gimple-match.cc

Bug Summary

File:	objdir/gcc/gimple-match.cc
Warning:	line 827, column 14 Value stored to 'type' during its initialization is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-suse-linux -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name gimple-match.cc -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 -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/15.0.7 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/backward -internal-isystem /usr/lib64/clang/15.0.7/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -Wno-unused -fdeprecated-macro -fdebug-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2023-03-27-141847-20772-1/report-wBaWF9.plist -x c++ gimple-match.cc

1	/* Generated automatically by the program `genmatch' from
2	a IL pattern matching and simplification description. */
3
4	#include "gimple-match-head.cc"
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.cc", 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 148 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
24	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
25	/* #line 148 "/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.cc" , 26, __FUNCTION__))->typed.type))
27	)
28	{
29	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 146, __FILE__"gimple-match.cc", __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.cc", 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 151 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
48	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
49	/* #line 151 "/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.cc", 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.cc" , 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.cc" , 52, __FUNCTION__))->typed.type))))
53	&& tree_nop_conversion_p (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "gimple-match.cc" , 53, __FUNCTION__))->typed.type), TREE_TYPE (TREE_TYPE (captures[0]))((contains_struct_check ((((contains_struct_check ((captures[ 0]), (TS_TYPED), "gimple-match.cc", 53, __FUNCTION__))->typed .type)), (TS_TYPED), "gimple-match.cc", 53, __FUNCTION__))-> typed.type))
54	)
55	{
56	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 149, __FILE__"gimple-match.cc", __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.cc", 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 798 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
100	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
101	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 798, __FILE__"gimple-match.cc", __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 796 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
122	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
123	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 796, __FILE__"gimple-match.cc", __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.cc", 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 1686 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
155	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
156	/* #line 1686 "/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.cc", 157, __FUNCTION__))->base.u.bits .unsigned_flag \|\| global_options.x_flag_wrapv)) && (global_options .x_flag_sanitize & SANITIZE_SI_OVERFLOW))
158	)
159	{
160	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1685, __FILE__"gimple-match.cc", __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 1697 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
177	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
178	/* #line 1697 "/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.cc", 179, __FUNCTION__))->typed.type))-> base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) (((contains_struct_check ((type), (TS_TYPED), "gimple-match.cc", 179, __FUNCTION__))-> typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code ) (((contains_struct_check ((type), (TS_TYPED), "gimple-match.cc" , 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.cc" , 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.cc", 180, __FUNCTION__))->typed.type))-> base.code) == REAL_TYPE)))
181	&& !HONOR_SIGN_DEPENDENT_ROUNDING (type)
182	&& !HONOR_SIGNED_ZEROS (type))
183	)
184	{
185	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1696, __FILE__"gimple-match.cc", __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 1678 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
202	/* #line 1678 "/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.cc", 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.cc", 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 (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1677, __FILE__"gimple-match.cc", __LINE__209);
210	{
211	return true;
212	}
213	next_after_fail7:;
214	}
215	}
216	break;
217	}
218	case FIXED_CST:
219	{
220	{
221	/* #line 1683 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
222	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1683, __FILE__"gimple-match.cc", __LINE__222);
223	{
224	return true;
225	}
226	next_after_fail8:;
227	}
228	break;
229	}
230	case REAL_CST:
231	{
232	{
233	/* #line 1689 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
234	/* #line 1689 "/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.cc" , 235, __FUNCTION__, (REAL_CST)))->real_cst.value))))
236	)
237	{
238	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1688, __FILE__"gimple-match.cc", __LINE__238);
239	{
240	return true;
241	}
242	next_after_fail9:;
243	}
244	}
245	break;
246	}
247	case VECTOR_CST:
248	{
249	{
250	/* #line 1694 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
251	/* #line 1694 "/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.cc", 252, __FUNCTION__))->typed.type))-> base.code) == REAL_TYPE) \|\| ((((enum tree_code) (((contains_struct_check ((type), (TS_TYPED), "gimple-match.cc", 252, __FUNCTION__))-> typed.type))->base.code) == COMPLEX_TYPE \|\| (((enum tree_code ) (((contains_struct_check ((type), (TS_TYPED), "gimple-match.cc" , 252, __FUNCTION__))->typed.type))->base.code) == VECTOR_TYPE )) && (((enum tree_code) (((contains_struct_check ((( (contains_struct_check ((type), (TS_TYPED), "gimple-match.cc" , 252, __FUNCTION__))->typed.type)), (TS_TYPED), "gimple-match.cc" , 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.cc" , 252, __FUNCTION__))->base.u.bits.unsigned_flag \|\| global_options .x_flag_wrapv))
253	)
254	{
255	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1693, __FILE__"gimple-match.cc", __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.cc", 272 , __FUNCTION__))->typed.type);
273	{
274	/* #line 1885 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
275	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
276	/* #line 1885 "/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.cc", 277 , __FUNCTION__))->type_common.precision) == 1
278	)
279	{
280	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1884, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
303	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
304	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
320	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
321	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
339	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
340	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
358	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
359	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
375	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
376	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
392	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
393	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
411	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
412	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
430	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
431	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
447	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
448	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
464	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
465	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
481	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
482	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
498	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
499	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
517	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
518	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
536	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
537	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
555	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
556	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
572	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
573	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
591	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
592	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
608	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
609	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
627	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
628	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"gimple-match.cc", __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 1890 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
642	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
643	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1890, __FILE__"gimple-match.cc", __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.cc", 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 1892 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
678	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
679	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1892, __FILE__"gimple-match.cc", __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 1894 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
696	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
697	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1894, __FILE__"gimple-match.cc", __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 1896 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
719	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
720	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1896, __FILE__"gimple-match.cc", __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 1898 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
744	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
745	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1898, __FILE__"gimple-match.cc", __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 1900 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
770	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
771	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1900, __FILE__"gimple-match.cc", __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_zero_one_valued_p (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.cc", 794 , __FUNCTION__))->typed.type);
795	{
796	/* #line 1925 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
797	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
798	/* #line 1925 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
799	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) && tree_nonzero_bits (captures[0]) == 1
800	)
801	{
802	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1924, __FILE__"gimple-match.cc", __LINE__802);
803	{
804	return true;
805	}
806	next_after_fail37:;
807	}
808	}
809	if (gimple_truth_valued_p (t, valueize))
810	{
811	{
812	/* #line 1927 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
813	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
814	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1927, __FILE__"gimple-match.cc", __LINE__814);
815	{
816	return true;
817	}
818	next_after_fail38:;
819	}
820	}
821	return false;
822	}
823
824	bool
825	gimple_with_possible_nonzero_bits (tree t, tree (*valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
826	{
827	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.cc", 827 , __FUNCTION__))->typed.type);
	Value stored to 'type' during its initialization is never read
828	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
829	{
830	case INTEGER_CST:
831	{
832	{
833	/* #line 2402 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
834	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
835	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2402, __FILE__"gimple-match.cc", __LINE__835);
836	{
837	return true;
838	}
839	next_after_fail39:;
840	}
841	break;
842	}
843	case SSA_NAME:
844	{
845	{
846	/* #line 2405 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
847	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
848	/* #line 2405 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
849	if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 849, __FUNCTION__))->typed.type ))->base.code) == ENUMERAL_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[0]), (TS_TYPED), "gimple-match.cc", 849, __FUNCTION__ ))->typed.type))->base.code) == BOOLEAN_TYPE \|\| ((enum tree_code ) (((contains_struct_check ((captures[0]), (TS_TYPED), "gimple-match.cc" , 849, __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.cc", 849, __FUNCTION__))->typed.type ))->base.code) == POINTER_TYPE \|\| ((enum tree_code) (((contains_struct_check ((captures[0]), (TS_TYPED), "gimple-match.cc", 849, __FUNCTION__ ))->typed.type))->base.code) == REFERENCE_TYPE)
850	)
851	{
852	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2404, __FILE__"gimple-match.cc", __LINE__852);
853	{
854	return true;
855	}
856	next_after_fail40:;
857	}
858	}
859	break;
860	}
861	default:;
862	}
863	return false;
864	}
865
866	bool
867	gimple_with_possible_nonzero_bits2 (tree t, tree res_ops, tree (valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
868	{
869	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.cc", 869 , __FUNCTION__))->typed.type);
870	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
871	{
872	case SSA_NAME:
873	if (gimple *_d1 = get_def (valueize, t))
874	{
875	if (gassign _a1 = dyn_cast <gassign > (_d1))
876	switch (gimple_assign_rhs_code (_a1))
877	{
878	case BIT_AND_EXPR:
879	{
880	tree _p0 = gimple_assign_rhs1 (_a1);
881	_p0 = do_valueize (valueize, _p0);
882	tree _p1 = gimple_assign_rhs2 (_a1);
883	_p1 = do_valueize (valueize, _p1);
884	if (tree_swap_operands_p (_p0, _p1))
885	std::swap (_p0, _p1);
886	if (gimple_with_possible_nonzero_bits (_p0, valueize))
887	{
888	{
889	/* #line 2409 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
890	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
891	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2409, __FILE__"gimple-match.cc", __LINE__891);
892	{
893	res_ops[0] = captures[0];
894	return true;
895	}
896	next_after_fail41:;
897	}
898	}
899	if (gimple_with_possible_nonzero_bits (_p1, valueize))
900	{
901	{
902	/* #line 2409 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
903	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _p0 };
904	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2409, __FILE__"gimple-match.cc", __LINE__904);
905	{
906	res_ops[0] = captures[0];
907	return true;
908	}
909	next_after_fail42:;
910	}
911	}
912	break;
913	}
914	default:;
915	}
916	}
917	break;
918	default:;
919	}
920	if (gimple_with_possible_nonzero_bits (t, valueize))
921	{
922	{
923	/* #line 2407 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
924	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
925	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2407, __FILE__"gimple-match.cc", __LINE__925);
926	{
927	res_ops[0] = captures[0];
928	return true;
929	}
930	next_after_fail43:;
931	}
932	}
933	return false;
934	}
935
936	bool
937	gimple_with_certain_nonzero_bits2 (tree t, tree res_ops, tree (valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
938	{
939	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.cc", 939 , __FUNCTION__))->typed.type);
940	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
941	{
942	case SSA_NAME:
943	if (gimple *_d1 = get_def (valueize, t))
944	{
945	if (gassign _a1 = dyn_cast <gassign > (_d1))
946	switch (gimple_assign_rhs_code (_a1))
947	{
948	case BIT_IOR_EXPR:
949	{
950	tree _p0 = gimple_assign_rhs1 (_a1);
951	_p0 = do_valueize (valueize, _p0);
952	tree _p1 = gimple_assign_rhs2 (_a1);
953	_p1 = do_valueize (valueize, _p1);
954	if (tree_swap_operands_p (_p0, _p1))
955	std::swap (_p0, _p1);
956	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
957	{
958	case INTEGER_CST:
959	{
960	{
961	/* #line 2416 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
962	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _p0 };
963	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2416, __FILE__"gimple-match.cc", __LINE__963);
964	{
965	res_ops[0] = captures[0];
966	return true;
967	}
968	next_after_fail44:;
969	}
970	break;
971	}
972	default:;
973	}
974	break;
975	}
976	default:;
977	}
978	}
979	break;
980	case INTEGER_CST:
981	{
982	{
983	/* #line 2414 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
984	tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
985	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2414, __FILE__"gimple-match.cc", __LINE__985);
986	{
987	res_ops[0] = captures[0];
988	return true;
989	}
990	next_after_fail45:;
991	}
992	break;
993	}
994	default:;
995	}
996	return false;
997	}
998
999	bool
1000	gimple_min_value (tree t, tree (*valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1001	{
1002	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.cc", 1002 , __FUNCTION__))->typed.type);
1003	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1004	{
1005	case INTEGER_CST:
1006	{
1007	{
1008	/* #line 2585 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1009	/* #line 2585 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1010	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)
1011	&& wi::eq_p (wi::to_wide (t), wi::min_value (type))
1012	)
1013	{
1014	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2584, __FILE__"gimple-match.cc", __LINE__1014);
1015	{
1016	return true;
1017	}
1018	next_after_fail46:;
1019	}
1020	}
1021	break;
1022	}
1023	default:;
1024	}
1025	return false;
1026	}
1027
1028	bool
1029	gimple_max_value (tree t, tree (*valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1030	{
1031	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.cc", 1031 , __FUNCTION__))->typed.type);
1032	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1033	{
1034	case INTEGER_CST:
1035	{
1036	{
1037	/* #line 2590 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1038	/* #line 2590 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1039	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)
1040	&& wi::eq_p (wi::to_wide (t), wi::max_value (type))
1041	)
1042	{
1043	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2589, __FILE__"gimple-match.cc", __LINE__1043);
1044	{
1045	return true;
1046	}
1047	next_after_fail47:;
1048	}
1049	}
1050	break;
1051	}
1052	default:;
1053	}
1054	return false;
1055	}
1056
1057	bool
1058	gimple_compositional_complex (tree t, tree (*valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1059	{
1060	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.cc", 1060 , __FUNCTION__))->typed.type);
1061	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1062	{
1063	case SSA_NAME:
1064	if (gimple *_d1 = get_def (valueize, t))
1065	{
1066	if (gassign _a1 = dyn_cast <gassign > (_d1))
1067	switch (gimple_assign_rhs_code (_a1))
1068	{
1069	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1070	{
1071	tree _p0 = gimple_assign_rhs1 (_a1);
1072	_p0 = do_valueize (valueize, _p0);
1073	switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
1074	{
1075	case SSA_NAME:
1076	if (gimple *_d2 = get_def (valueize, _p0))
1077	{
1078	if (gassign _a2 = dyn_cast <gassign > (_d2))
1079	switch (gimple_assign_rhs_code (_a2))
1080	{
1081	case COMPLEX_EXPR:
1082	{
1083	tree _q20 = gimple_assign_rhs1 (_a2);
1084	_q20 = do_valueize (valueize, _q20);
1085	tree _q21 = gimple_assign_rhs2 (_a2);
1086	_q21 = do_valueize (valueize, _q21);
1087	{
1088	/* #line 4271 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1089	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q21 };
1090	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4271, __FILE__"gimple-match.cc", __LINE__1090);
1091	{
1092	return true;
1093	}
1094	next_after_fail48:;
1095	}
1096	break;
1097	}
1098	default:;
1099	}
1100	}
1101	break;
1102	default:;
1103	}
1104	break;
1105	}
1106	case COMPLEX_EXPR:
1107	{
1108	tree _p0 = gimple_assign_rhs1 (_a1);
1109	_p0 = do_valueize (valueize, _p0);
1110	tree _p1 = gimple_assign_rhs2 (_a1);
1111	_p1 = do_valueize (valueize, _p1);
1112	{
1113	/* #line 4271 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1114	tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
1115	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4271, __FILE__"gimple-match.cc", __LINE__1115);
1116	{
1117	return true;
1118	}
1119	next_after_fail49:;
1120	}
1121	break;
1122	}
1123	default:;
1124	}
1125	}
1126	break;
1127	default:;
1128	}
1129	return false;
1130	}
1131
1132	bool
1133	gimple_nop_atomic_bit_test_and_p (tree t, tree res_ops, tree (valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1134	{
1135	const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.cc", 1135 , __FUNCTION__))->typed.type);
1136	switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1137	{
1138	case SSA_NAME:
1139	if (gimple *_d1 = get_def (valueize, t))
1140	{
1141	if (gassign _a1 = dyn_cast <gassign > (_d1))
1142	switch (gimple_assign_rhs_code (_a1))
1143	{
1144	case BIT_AND_EXPR:
1145	{
1146	tree _p0 = gimple_assign_rhs1 (_a1);
1147	_p0 = do_valueize (valueize, _p0);
1148	tree _p1 = gimple_assign_rhs2 (_a1);
1149	_p1 = do_valueize (valueize, _p1);
1150	if (tree_swap_operands_p (_p0, _p1))
1151	std::swap (_p0, _p1);
1152	switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
1153	{
1154	case SSA_NAME:
1155	if (gimple *_d2 = get_def (valueize, _p0))
1156	{
1157	if (gassign _a2 = dyn_cast <gassign > (_d2))
1158	switch (gimple_assign_rhs_code (_a2))
1159	{
1160	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1161	{
1162	tree _q20 = gimple_assign_rhs1 (_a2);
1163	_q20 = do_valueize (valueize, _q20);
1164	switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
1165	{
1166	case SSA_NAME:
1167	if (gimple *_d3 = get_def (valueize, _q20))
1168	{
1169	if (gcall _c3 = dyn_cast <gcall > (_d3))
1170	switch (gimple_call_combined_fn (_c3))
1171	{
1172	case CFN_BUILT_IN_ATOMIC_FETCH_OR_1:
1173	if (gimple_call_num_args (_c3) == 3)
1174	{
1175	tree _q30 = gimple_call_arg (_c3, 0);
1176	_q30 = do_valueize (valueize, _q30);
1177	tree _q31 = gimple_call_arg (_c3, 1);
1178	_q31 = do_valueize (valueize, _q31);
1179	tree _q32 = gimple_call_arg (_c3, 2);
1180	_q32 = do_valueize (valueize, _q32);
1181	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
1182	{
1183	case SSA_NAME:
1184	if (gimple *_d4 = get_def (valueize, _q31))
1185	{
1186	if (gassign _a4 = dyn_cast <gassign > (_d4))
1187	switch (gimple_assign_rhs_code (_a4))
1188	{
1189	case LSHIFT_EXPR:
1190	{
1191	tree _q50 = gimple_assign_rhs1 (_a4);
1192	_q50 = do_valueize (valueize, _q50);
1193	tree _q51 = gimple_assign_rhs2 (_a4);
1194	_q51 = do_valueize (valueize, _q51);
1195	if (integer_onep (_q50))
1196	{
1197	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1198	{
1199	case SSA_NAME:
1200	if (gimple *_d5 = get_def (valueize, _p1))
1201	{
1202	if (gassign _a5 = dyn_cast <gassign > (_d5))
1203	switch (gimple_assign_rhs_code (_a5))
1204	{
1205	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1206	{
1207	tree _q90 = gimple_assign_rhs1 (_a5);
1208	_q90 = do_valueize (valueize, _q90);
1209	if ((_q90 == _q31 && ! TREE_SIDE_EFFECTS (_q90)((non_type_check ((_q90), "gimple-match.cc", 1209, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q90, _q31, 0) && types_match (_q90, _q31)))
1210	{
1211	{
1212	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1213	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
1214	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1215	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 1215 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 1215, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 1215, __FUNCTION__))-> type_common.precision)
1216	)
1217	{
1218	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__1218);
1219	{
1220	res_ops[0] = captures[0];
1221	res_ops[1] = captures[0];
1222	res_ops[2] = captures[1];
1223	return true;
1224	}
1225	next_after_fail50:;
1226	}
1227	}
1228	}
1229	break;
1230	}
1231	default:;
1232	}
1233	}
1234	break;
1235	default:;
1236	}
1237	if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 1237, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
1238	{
1239	{
1240	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1241	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
1242	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1243	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 1243 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 1243, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 1243, __FUNCTION__))-> type_common.precision)
1244	)
1245	{
1246	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__1246);
1247	{
1248	res_ops[0] = captures[0];
1249	res_ops[1] = captures[0];
1250	res_ops[2] = captures[1];
1251	return true;
1252	}
1253	next_after_fail51:;
1254	}
1255	}
1256	}
1257	}
1258	break;
1259	}
1260	default:;
1261	}
1262	}
1263	break;
1264	case INTEGER_CST:
1265	{
1266	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1267	{
1268	case INTEGER_CST:
1269	{
1270	{
1271	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1272	tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
1273	{
1274	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1275	int ibit = tree_log2 (captures[0]);
1276	int ibit2 = tree_log2 (captures[1]);
1277	/* #line 4470 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1278	if (ibit == ibit2
1279	&& ibit >= 0
1280	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 1280 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 1280, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 1280, __FUNCTION__))-> type_common.precision)
1281	)
1282	{
1283	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4463, __FILE__"gimple-match.cc", __LINE__1283);
1284	{
1285	res_ops[0] = captures[0];
1286	res_ops[1] = captures[1];
1287	res_ops[2] = captures[2];
1288	return true;
1289	}
1290	next_after_fail52:;
1291	}
1292	}
1293	}
1294	break;
1295	}
1296	default:;
1297	}
1298	break;
1299	}
1300	default:;
1301	}
1302	{
1303	tree _q31_pops[1];
1304	if (gimple_nop_convert (_q31, _q31_pops, valueize))
1305	{
1306	tree _q50 = _q31_pops[0];
1307	switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
1308	{
1309	case SSA_NAME:
1310	if (gimple *_d4 = get_def (valueize, _q50))
1311	{
1312	if (gassign _a4 = dyn_cast <gassign > (_d4))
1313	switch (gimple_assign_rhs_code (_a4))
1314	{
1315	case LSHIFT_EXPR:
1316	{
1317	tree _q60 = gimple_assign_rhs1 (_a4);
1318	_q60 = do_valueize (valueize, _q60);
1319	tree _q61 = gimple_assign_rhs2 (_a4);
1320	_q61 = do_valueize (valueize, _q61);
1321	if (integer_onep (_q60))
1322	{
1323	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1324	{
1325	case SSA_NAME:
1326	if (gimple *_d5 = get_def (valueize, _p1))
1327	{
1328	if (gassign _a5 = dyn_cast <gassign > (_d5))
1329	switch (gimple_assign_rhs_code (_a5))
1330	{
1331	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1332	{
1333	tree _q100 = gimple_assign_rhs1 (_a5);
1334	_q100 = do_valueize (valueize, _q100);
1335	if ((_q100 == _q50 && ! TREE_SIDE_EFFECTS (_q100)((non_type_check ((_q100), "gimple-match.cc", 1335, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q100, _q50, 0) && types_match (_q100, _q50)))
1336	{
1337	{
1338	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1339	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
1340	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1341	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 1341 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 1341, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 1341, __FUNCTION__))-> type_common.precision)
1342	)
1343	{
1344	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__1344);
1345	{
1346	res_ops[0] = captures[0];
1347	res_ops[1] = captures[0];
1348	res_ops[2] = captures[1];
1349	return true;
1350	}
1351	next_after_fail53:;
1352	}
1353	}
1354	}
1355	break;
1356	}
1357	default:;
1358	}
1359	}
1360	break;
1361	default:;
1362	}
1363	if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 1363, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
1364	{
1365	{
1366	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1367	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
1368	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1369	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 1369 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 1369, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 1369, __FUNCTION__))-> type_common.precision)
1370	)
1371	{
1372	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__1372);
1373	{
1374	res_ops[0] = captures[0];
1375	res_ops[1] = captures[0];
1376	res_ops[2] = captures[1];
1377	return true;
1378	}
1379	next_after_fail54:;
1380	}
1381	}
1382	}
1383	}
1384	break;
1385	}
1386	default:;
1387	}
1388	}
1389	break;
1390	default:;
1391	}
1392	}
1393	}
1394	}
1395	break;
1396	case CFN_BUILT_IN_ATOMIC_FETCH_OR_2:
1397	if (gimple_call_num_args (_c3) == 3)
1398	{
1399	tree _q30 = gimple_call_arg (_c3, 0);
1400	_q30 = do_valueize (valueize, _q30);
1401	tree _q31 = gimple_call_arg (_c3, 1);
1402	_q31 = do_valueize (valueize, _q31);
1403	tree _q32 = gimple_call_arg (_c3, 2);
1404	_q32 = do_valueize (valueize, _q32);
1405	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
1406	{
1407	case SSA_NAME:
1408	if (gimple *_d4 = get_def (valueize, _q31))
1409	{
1410	if (gassign _a4 = dyn_cast <gassign > (_d4))
1411	switch (gimple_assign_rhs_code (_a4))
1412	{
1413	case LSHIFT_EXPR:
1414	{
1415	tree _q50 = gimple_assign_rhs1 (_a4);
1416	_q50 = do_valueize (valueize, _q50);
1417	tree _q51 = gimple_assign_rhs2 (_a4);
1418	_q51 = do_valueize (valueize, _q51);
1419	if (integer_onep (_q50))
1420	{
1421	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1422	{
1423	case SSA_NAME:
1424	if (gimple *_d5 = get_def (valueize, _p1))
1425	{
1426	if (gassign _a5 = dyn_cast <gassign > (_d5))
1427	switch (gimple_assign_rhs_code (_a5))
1428	{
1429	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1430	{
1431	tree _q90 = gimple_assign_rhs1 (_a5);
1432	_q90 = do_valueize (valueize, _q90);
1433	if ((_q90 == _q31 && ! TREE_SIDE_EFFECTS (_q90)((non_type_check ((_q90), "gimple-match.cc", 1433, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q90, _q31, 0) && types_match (_q90, _q31)))
1434	{
1435	{
1436	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1437	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
1438	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1439	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 1439 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 1439, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 1439, __FUNCTION__))-> type_common.precision)
1440	)
1441	{
1442	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__1442);
1443	{
1444	res_ops[0] = captures[0];
1445	res_ops[1] = captures[0];
1446	res_ops[2] = captures[1];
1447	return true;
1448	}
1449	next_after_fail55:;
1450	}
1451	}
1452	}
1453	break;
1454	}
1455	default:;
1456	}
1457	}
1458	break;
1459	default:;
1460	}
1461	if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 1461, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
1462	{
1463	{
1464	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1465	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
1466	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1467	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 1467 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 1467, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 1467, __FUNCTION__))-> type_common.precision)
1468	)
1469	{
1470	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__1470);
1471	{
1472	res_ops[0] = captures[0];
1473	res_ops[1] = captures[0];
1474	res_ops[2] = captures[1];
1475	return true;
1476	}
1477	next_after_fail56:;
1478	}
1479	}
1480	}
1481	}
1482	break;
1483	}
1484	default:;
1485	}
1486	}
1487	break;
1488	case INTEGER_CST:
1489	{
1490	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1491	{
1492	case INTEGER_CST:
1493	{
1494	{
1495	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1496	tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
1497	{
1498	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1499	int ibit = tree_log2 (captures[0]);
1500	int ibit2 = tree_log2 (captures[1]);
1501	/* #line 4470 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1502	if (ibit == ibit2
1503	&& ibit >= 0
1504	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 1504 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 1504, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 1504, __FUNCTION__))-> type_common.precision)
1505	)
1506	{
1507	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4463, __FILE__"gimple-match.cc", __LINE__1507);
1508	{
1509	res_ops[0] = captures[0];
1510	res_ops[1] = captures[1];
1511	res_ops[2] = captures[2];
1512	return true;
1513	}
1514	next_after_fail57:;
1515	}
1516	}
1517	}
1518	break;
1519	}
1520	default:;
1521	}
1522	break;
1523	}
1524	default:;
1525	}
1526	{
1527	tree _q31_pops[1];
1528	if (gimple_nop_convert (_q31, _q31_pops, valueize))
1529	{
1530	tree _q50 = _q31_pops[0];
1531	switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
1532	{
1533	case SSA_NAME:
1534	if (gimple *_d4 = get_def (valueize, _q50))
1535	{
1536	if (gassign _a4 = dyn_cast <gassign > (_d4))
1537	switch (gimple_assign_rhs_code (_a4))
1538	{
1539	case LSHIFT_EXPR:
1540	{
1541	tree _q60 = gimple_assign_rhs1 (_a4);
1542	_q60 = do_valueize (valueize, _q60);
1543	tree _q61 = gimple_assign_rhs2 (_a4);
1544	_q61 = do_valueize (valueize, _q61);
1545	if (integer_onep (_q60))
1546	{
1547	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1548	{
1549	case SSA_NAME:
1550	if (gimple *_d5 = get_def (valueize, _p1))
1551	{
1552	if (gassign _a5 = dyn_cast <gassign > (_d5))
1553	switch (gimple_assign_rhs_code (_a5))
1554	{
1555	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1556	{
1557	tree _q100 = gimple_assign_rhs1 (_a5);
1558	_q100 = do_valueize (valueize, _q100);
1559	if ((_q100 == _q50 && ! TREE_SIDE_EFFECTS (_q100)((non_type_check ((_q100), "gimple-match.cc", 1559, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q100, _q50, 0) && types_match (_q100, _q50)))
1560	{
1561	{
1562	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1563	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
1564	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1565	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 1565 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 1565, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 1565, __FUNCTION__))-> type_common.precision)
1566	)
1567	{
1568	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__1568);
1569	{
1570	res_ops[0] = captures[0];
1571	res_ops[1] = captures[0];
1572	res_ops[2] = captures[1];
1573	return true;
1574	}
1575	next_after_fail58:;
1576	}
1577	}
1578	}
1579	break;
1580	}
1581	default:;
1582	}
1583	}
1584	break;
1585	default:;
1586	}
1587	if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 1587, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
1588	{
1589	{
1590	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1591	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
1592	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1593	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 1593 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 1593, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 1593, __FUNCTION__))-> type_common.precision)
1594	)
1595	{
1596	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__1596);
1597	{
1598	res_ops[0] = captures[0];
1599	res_ops[1] = captures[0];
1600	res_ops[2] = captures[1];
1601	return true;
1602	}
1603	next_after_fail59:;
1604	}
1605	}
1606	}
1607	}
1608	break;
1609	}
1610	default:;
1611	}
1612	}
1613	break;
1614	default:;
1615	}
1616	}
1617	}
1618	}
1619	break;
1620	case CFN_BUILT_IN_ATOMIC_FETCH_OR_4:
1621	if (gimple_call_num_args (_c3) == 3)
1622	{
1623	tree _q30 = gimple_call_arg (_c3, 0);
1624	_q30 = do_valueize (valueize, _q30);
1625	tree _q31 = gimple_call_arg (_c3, 1);
1626	_q31 = do_valueize (valueize, _q31);
1627	tree _q32 = gimple_call_arg (_c3, 2);
1628	_q32 = do_valueize (valueize, _q32);
1629	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
1630	{
1631	case SSA_NAME:
1632	if (gimple *_d4 = get_def (valueize, _q31))
1633	{
1634	if (gassign _a4 = dyn_cast <gassign > (_d4))
1635	switch (gimple_assign_rhs_code (_a4))
1636	{
1637	case LSHIFT_EXPR:
1638	{
1639	tree _q50 = gimple_assign_rhs1 (_a4);
1640	_q50 = do_valueize (valueize, _q50);
1641	tree _q51 = gimple_assign_rhs2 (_a4);
1642	_q51 = do_valueize (valueize, _q51);
1643	if (integer_onep (_q50))
1644	{
1645	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1646	{
1647	case SSA_NAME:
1648	if (gimple *_d5 = get_def (valueize, _p1))
1649	{
1650	if (gassign _a5 = dyn_cast <gassign > (_d5))
1651	switch (gimple_assign_rhs_code (_a5))
1652	{
1653	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1654	{
1655	tree _q90 = gimple_assign_rhs1 (_a5);
1656	_q90 = do_valueize (valueize, _q90);
1657	if ((_q90 == _q31 && ! TREE_SIDE_EFFECTS (_q90)((non_type_check ((_q90), "gimple-match.cc", 1657, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q90, _q31, 0) && types_match (_q90, _q31)))
1658	{
1659	{
1660	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1661	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
1662	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1663	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 1663 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 1663, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 1663, __FUNCTION__))-> type_common.precision)
1664	)
1665	{
1666	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__1666);
1667	{
1668	res_ops[0] = captures[0];
1669	res_ops[1] = captures[0];
1670	res_ops[2] = captures[1];
1671	return true;
1672	}
1673	next_after_fail60:;
1674	}
1675	}
1676	}
1677	break;
1678	}
1679	default:;
1680	}
1681	}
1682	break;
1683	default:;
1684	}
1685	if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 1685, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
1686	{
1687	{
1688	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1689	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
1690	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1691	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 1691 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 1691, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 1691, __FUNCTION__))-> type_common.precision)
1692	)
1693	{
1694	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__1694);
1695	{
1696	res_ops[0] = captures[0];
1697	res_ops[1] = captures[0];
1698	res_ops[2] = captures[1];
1699	return true;
1700	}
1701	next_after_fail61:;
1702	}
1703	}
1704	}
1705	}
1706	break;
1707	}
1708	default:;
1709	}
1710	}
1711	break;
1712	case INTEGER_CST:
1713	{
1714	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1715	{
1716	case INTEGER_CST:
1717	{
1718	{
1719	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1720	tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
1721	{
1722	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1723	int ibit = tree_log2 (captures[0]);
1724	int ibit2 = tree_log2 (captures[1]);
1725	/* #line 4470 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1726	if (ibit == ibit2
1727	&& ibit >= 0
1728	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 1728 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 1728, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 1728, __FUNCTION__))-> type_common.precision)
1729	)
1730	{
1731	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4463, __FILE__"gimple-match.cc", __LINE__1731);
1732	{
1733	res_ops[0] = captures[0];
1734	res_ops[1] = captures[1];
1735	res_ops[2] = captures[2];
1736	return true;
1737	}
1738	next_after_fail62:;
1739	}
1740	}
1741	}
1742	break;
1743	}
1744	default:;
1745	}
1746	break;
1747	}
1748	default:;
1749	}
1750	{
1751	tree _q31_pops[1];
1752	if (gimple_nop_convert (_q31, _q31_pops, valueize))
1753	{
1754	tree _q50 = _q31_pops[0];
1755	switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
1756	{
1757	case SSA_NAME:
1758	if (gimple *_d4 = get_def (valueize, _q50))
1759	{
1760	if (gassign _a4 = dyn_cast <gassign > (_d4))
1761	switch (gimple_assign_rhs_code (_a4))
1762	{
1763	case LSHIFT_EXPR:
1764	{
1765	tree _q60 = gimple_assign_rhs1 (_a4);
1766	_q60 = do_valueize (valueize, _q60);
1767	tree _q61 = gimple_assign_rhs2 (_a4);
1768	_q61 = do_valueize (valueize, _q61);
1769	if (integer_onep (_q60))
1770	{
1771	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1772	{
1773	case SSA_NAME:
1774	if (gimple *_d5 = get_def (valueize, _p1))
1775	{
1776	if (gassign _a5 = dyn_cast <gassign > (_d5))
1777	switch (gimple_assign_rhs_code (_a5))
1778	{
1779	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1780	{
1781	tree _q100 = gimple_assign_rhs1 (_a5);
1782	_q100 = do_valueize (valueize, _q100);
1783	if ((_q100 == _q50 && ! TREE_SIDE_EFFECTS (_q100)((non_type_check ((_q100), "gimple-match.cc", 1783, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q100, _q50, 0) && types_match (_q100, _q50)))
1784	{
1785	{
1786	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1787	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
1788	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1789	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 1789 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 1789, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 1789, __FUNCTION__))-> type_common.precision)
1790	)
1791	{
1792	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__1792);
1793	{
1794	res_ops[0] = captures[0];
1795	res_ops[1] = captures[0];
1796	res_ops[2] = captures[1];
1797	return true;
1798	}
1799	next_after_fail63:;
1800	}
1801	}
1802	}
1803	break;
1804	}
1805	default:;
1806	}
1807	}
1808	break;
1809	default:;
1810	}
1811	if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 1811, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
1812	{
1813	{
1814	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1815	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
1816	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1817	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 1817 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 1817, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 1817, __FUNCTION__))-> type_common.precision)
1818	)
1819	{
1820	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__1820);
1821	{
1822	res_ops[0] = captures[0];
1823	res_ops[1] = captures[0];
1824	res_ops[2] = captures[1];
1825	return true;
1826	}
1827	next_after_fail64:;
1828	}
1829	}
1830	}
1831	}
1832	break;
1833	}
1834	default:;
1835	}
1836	}
1837	break;
1838	default:;
1839	}
1840	}
1841	}
1842	}
1843	break;
1844	case CFN_BUILT_IN_ATOMIC_FETCH_OR_8:
1845	if (gimple_call_num_args (_c3) == 3)
1846	{
1847	tree _q30 = gimple_call_arg (_c3, 0);
1848	_q30 = do_valueize (valueize, _q30);
1849	tree _q31 = gimple_call_arg (_c3, 1);
1850	_q31 = do_valueize (valueize, _q31);
1851	tree _q32 = gimple_call_arg (_c3, 2);
1852	_q32 = do_valueize (valueize, _q32);
1853	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
1854	{
1855	case SSA_NAME:
1856	if (gimple *_d4 = get_def (valueize, _q31))
1857	{
1858	if (gassign _a4 = dyn_cast <gassign > (_d4))
1859	switch (gimple_assign_rhs_code (_a4))
1860	{
1861	case LSHIFT_EXPR:
1862	{
1863	tree _q50 = gimple_assign_rhs1 (_a4);
1864	_q50 = do_valueize (valueize, _q50);
1865	tree _q51 = gimple_assign_rhs2 (_a4);
1866	_q51 = do_valueize (valueize, _q51);
1867	if (integer_onep (_q50))
1868	{
1869	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1870	{
1871	case SSA_NAME:
1872	if (gimple *_d5 = get_def (valueize, _p1))
1873	{
1874	if (gassign _a5 = dyn_cast <gassign > (_d5))
1875	switch (gimple_assign_rhs_code (_a5))
1876	{
1877	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1878	{
1879	tree _q90 = gimple_assign_rhs1 (_a5);
1880	_q90 = do_valueize (valueize, _q90);
1881	if ((_q90 == _q31 && ! TREE_SIDE_EFFECTS (_q90)((non_type_check ((_q90), "gimple-match.cc", 1881, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q90, _q31, 0) && types_match (_q90, _q31)))
1882	{
1883	{
1884	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1885	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
1886	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1887	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 1887 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 1887, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 1887, __FUNCTION__))-> type_common.precision)
1888	)
1889	{
1890	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__1890);
1891	{
1892	res_ops[0] = captures[0];
1893	res_ops[1] = captures[0];
1894	res_ops[2] = captures[1];
1895	return true;
1896	}
1897	next_after_fail65:;
1898	}
1899	}
1900	}
1901	break;
1902	}
1903	default:;
1904	}
1905	}
1906	break;
1907	default:;
1908	}
1909	if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 1909, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
1910	{
1911	{
1912	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1913	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
1914	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1915	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 1915 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 1915, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 1915, __FUNCTION__))-> type_common.precision)
1916	)
1917	{
1918	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__1918);
1919	{
1920	res_ops[0] = captures[0];
1921	res_ops[1] = captures[0];
1922	res_ops[2] = captures[1];
1923	return true;
1924	}
1925	next_after_fail66:;
1926	}
1927	}
1928	}
1929	}
1930	break;
1931	}
1932	default:;
1933	}
1934	}
1935	break;
1936	case INTEGER_CST:
1937	{
1938	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1939	{
1940	case INTEGER_CST:
1941	{
1942	{
1943	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1944	tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
1945	{
1946	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1947	int ibit = tree_log2 (captures[0]);
1948	int ibit2 = tree_log2 (captures[1]);
1949	/* #line 4470 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1950	if (ibit == ibit2
1951	&& ibit >= 0
1952	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 1952 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 1952, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 1952, __FUNCTION__))-> type_common.precision)
1953	)
1954	{
1955	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4463, __FILE__"gimple-match.cc", __LINE__1955);
1956	{
1957	res_ops[0] = captures[0];
1958	res_ops[1] = captures[1];
1959	res_ops[2] = captures[2];
1960	return true;
1961	}
1962	next_after_fail67:;
1963	}
1964	}
1965	}
1966	break;
1967	}
1968	default:;
1969	}
1970	break;
1971	}
1972	default:;
1973	}
1974	{
1975	tree _q31_pops[1];
1976	if (gimple_nop_convert (_q31, _q31_pops, valueize))
1977	{
1978	tree _q50 = _q31_pops[0];
1979	switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
1980	{
1981	case SSA_NAME:
1982	if (gimple *_d4 = get_def (valueize, _q50))
1983	{
1984	if (gassign _a4 = dyn_cast <gassign > (_d4))
1985	switch (gimple_assign_rhs_code (_a4))
1986	{
1987	case LSHIFT_EXPR:
1988	{
1989	tree _q60 = gimple_assign_rhs1 (_a4);
1990	_q60 = do_valueize (valueize, _q60);
1991	tree _q61 = gimple_assign_rhs2 (_a4);
1992	_q61 = do_valueize (valueize, _q61);
1993	if (integer_onep (_q60))
1994	{
1995	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1996	{
1997	case SSA_NAME:
1998	if (gimple *_d5 = get_def (valueize, _p1))
1999	{
2000	if (gassign _a5 = dyn_cast <gassign > (_d5))
2001	switch (gimple_assign_rhs_code (_a5))
2002	{
2003	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2004	{
2005	tree _q100 = gimple_assign_rhs1 (_a5);
2006	_q100 = do_valueize (valueize, _q100);
2007	if ((_q100 == _q50 && ! TREE_SIDE_EFFECTS (_q100)((non_type_check ((_q100), "gimple-match.cc", 2007, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q100, _q50, 0) && types_match (_q100, _q50)))
2008	{
2009	{
2010	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2011	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
2012	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2013	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2013 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2013, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2013, __FUNCTION__))-> type_common.precision)
2014	)
2015	{
2016	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__2016);
2017	{
2018	res_ops[0] = captures[0];
2019	res_ops[1] = captures[0];
2020	res_ops[2] = captures[1];
2021	return true;
2022	}
2023	next_after_fail68:;
2024	}
2025	}
2026	}
2027	break;
2028	}
2029	default:;
2030	}
2031	}
2032	break;
2033	default:;
2034	}
2035	if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 2035, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
2036	{
2037	{
2038	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2039	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
2040	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2041	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2041 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2041, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2041, __FUNCTION__))-> type_common.precision)
2042	)
2043	{
2044	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__2044);
2045	{
2046	res_ops[0] = captures[0];
2047	res_ops[1] = captures[0];
2048	res_ops[2] = captures[1];
2049	return true;
2050	}
2051	next_after_fail69:;
2052	}
2053	}
2054	}
2055	}
2056	break;
2057	}
2058	default:;
2059	}
2060	}
2061	break;
2062	default:;
2063	}
2064	}
2065	}
2066	}
2067	break;
2068	case CFN_BUILT_IN_ATOMIC_FETCH_OR_16:
2069	if (gimple_call_num_args (_c3) == 3)
2070	{
2071	tree _q30 = gimple_call_arg (_c3, 0);
2072	_q30 = do_valueize (valueize, _q30);
2073	tree _q31 = gimple_call_arg (_c3, 1);
2074	_q31 = do_valueize (valueize, _q31);
2075	tree _q32 = gimple_call_arg (_c3, 2);
2076	_q32 = do_valueize (valueize, _q32);
2077	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
2078	{
2079	case SSA_NAME:
2080	if (gimple *_d4 = get_def (valueize, _q31))
2081	{
2082	if (gassign _a4 = dyn_cast <gassign > (_d4))
2083	switch (gimple_assign_rhs_code (_a4))
2084	{
2085	case LSHIFT_EXPR:
2086	{
2087	tree _q50 = gimple_assign_rhs1 (_a4);
2088	_q50 = do_valueize (valueize, _q50);
2089	tree _q51 = gimple_assign_rhs2 (_a4);
2090	_q51 = do_valueize (valueize, _q51);
2091	if (integer_onep (_q50))
2092	{
2093	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2094	{
2095	case SSA_NAME:
2096	if (gimple *_d5 = get_def (valueize, _p1))
2097	{
2098	if (gassign _a5 = dyn_cast <gassign > (_d5))
2099	switch (gimple_assign_rhs_code (_a5))
2100	{
2101	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2102	{
2103	tree _q90 = gimple_assign_rhs1 (_a5);
2104	_q90 = do_valueize (valueize, _q90);
2105	if ((_q90 == _q31 && ! TREE_SIDE_EFFECTS (_q90)((non_type_check ((_q90), "gimple-match.cc", 2105, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q90, _q31, 0) && types_match (_q90, _q31)))
2106	{
2107	{
2108	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2109	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
2110	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2111	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2111 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2111, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2111, __FUNCTION__))-> type_common.precision)
2112	)
2113	{
2114	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__2114);
2115	{
2116	res_ops[0] = captures[0];
2117	res_ops[1] = captures[0];
2118	res_ops[2] = captures[1];
2119	return true;
2120	}
2121	next_after_fail70:;
2122	}
2123	}
2124	}
2125	break;
2126	}
2127	default:;
2128	}
2129	}
2130	break;
2131	default:;
2132	}
2133	if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 2133, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
2134	{
2135	{
2136	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2137	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
2138	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2139	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2139 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2139, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2139, __FUNCTION__))-> type_common.precision)
2140	)
2141	{
2142	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__2142);
2143	{
2144	res_ops[0] = captures[0];
2145	res_ops[1] = captures[0];
2146	res_ops[2] = captures[1];
2147	return true;
2148	}
2149	next_after_fail71:;
2150	}
2151	}
2152	}
2153	}
2154	break;
2155	}
2156	default:;
2157	}
2158	}
2159	break;
2160	case INTEGER_CST:
2161	{
2162	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2163	{
2164	case INTEGER_CST:
2165	{
2166	{
2167	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2168	tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
2169	{
2170	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2171	int ibit = tree_log2 (captures[0]);
2172	int ibit2 = tree_log2 (captures[1]);
2173	/* #line 4470 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2174	if (ibit == ibit2
2175	&& ibit >= 0
2176	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2176 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2176, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2176, __FUNCTION__))-> type_common.precision)
2177	)
2178	{
2179	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4463, __FILE__"gimple-match.cc", __LINE__2179);
2180	{
2181	res_ops[0] = captures[0];
2182	res_ops[1] = captures[1];
2183	res_ops[2] = captures[2];
2184	return true;
2185	}
2186	next_after_fail72:;
2187	}
2188	}
2189	}
2190	break;
2191	}
2192	default:;
2193	}
2194	break;
2195	}
2196	default:;
2197	}
2198	{
2199	tree _q31_pops[1];
2200	if (gimple_nop_convert (_q31, _q31_pops, valueize))
2201	{
2202	tree _q50 = _q31_pops[0];
2203	switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
2204	{
2205	case SSA_NAME:
2206	if (gimple *_d4 = get_def (valueize, _q50))
2207	{
2208	if (gassign _a4 = dyn_cast <gassign > (_d4))
2209	switch (gimple_assign_rhs_code (_a4))
2210	{
2211	case LSHIFT_EXPR:
2212	{
2213	tree _q60 = gimple_assign_rhs1 (_a4);
2214	_q60 = do_valueize (valueize, _q60);
2215	tree _q61 = gimple_assign_rhs2 (_a4);
2216	_q61 = do_valueize (valueize, _q61);
2217	if (integer_onep (_q60))
2218	{
2219	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2220	{
2221	case SSA_NAME:
2222	if (gimple *_d5 = get_def (valueize, _p1))
2223	{
2224	if (gassign _a5 = dyn_cast <gassign > (_d5))
2225	switch (gimple_assign_rhs_code (_a5))
2226	{
2227	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2228	{
2229	tree _q100 = gimple_assign_rhs1 (_a5);
2230	_q100 = do_valueize (valueize, _q100);
2231	if ((_q100 == _q50 && ! TREE_SIDE_EFFECTS (_q100)((non_type_check ((_q100), "gimple-match.cc", 2231, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q100, _q50, 0) && types_match (_q100, _q50)))
2232	{
2233	{
2234	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2235	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
2236	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2237	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2237 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2237, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2237, __FUNCTION__))-> type_common.precision)
2238	)
2239	{
2240	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__2240);
2241	{
2242	res_ops[0] = captures[0];
2243	res_ops[1] = captures[0];
2244	res_ops[2] = captures[1];
2245	return true;
2246	}
2247	next_after_fail73:;
2248	}
2249	}
2250	}
2251	break;
2252	}
2253	default:;
2254	}
2255	}
2256	break;
2257	default:;
2258	}
2259	if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 2259, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
2260	{
2261	{
2262	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2263	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
2264	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2265	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2265 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2265, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2265, __FUNCTION__))-> type_common.precision)
2266	)
2267	{
2268	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__2268);
2269	{
2270	res_ops[0] = captures[0];
2271	res_ops[1] = captures[0];
2272	res_ops[2] = captures[1];
2273	return true;
2274	}
2275	next_after_fail74:;
2276	}
2277	}
2278	}
2279	}
2280	break;
2281	}
2282	default:;
2283	}
2284	}
2285	break;
2286	default:;
2287	}
2288	}
2289	}
2290	}
2291	break;
2292	case CFN_BUILT_IN_ATOMIC_FETCH_XOR_1:
2293	if (gimple_call_num_args (_c3) == 3)
2294	{
2295	tree _q30 = gimple_call_arg (_c3, 0);
2296	_q30 = do_valueize (valueize, _q30);
2297	tree _q31 = gimple_call_arg (_c3, 1);
2298	_q31 = do_valueize (valueize, _q31);
2299	tree _q32 = gimple_call_arg (_c3, 2);
2300	_q32 = do_valueize (valueize, _q32);
2301	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
2302	{
2303	case SSA_NAME:
2304	if (gimple *_d4 = get_def (valueize, _q31))
2305	{
2306	if (gassign _a4 = dyn_cast <gassign > (_d4))
2307	switch (gimple_assign_rhs_code (_a4))
2308	{
2309	case LSHIFT_EXPR:
2310	{
2311	tree _q50 = gimple_assign_rhs1 (_a4);
2312	_q50 = do_valueize (valueize, _q50);
2313	tree _q51 = gimple_assign_rhs2 (_a4);
2314	_q51 = do_valueize (valueize, _q51);
2315	if (integer_onep (_q50))
2316	{
2317	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2318	{
2319	case SSA_NAME:
2320	if (gimple *_d5 = get_def (valueize, _p1))
2321	{
2322	if (gassign _a5 = dyn_cast <gassign > (_d5))
2323	switch (gimple_assign_rhs_code (_a5))
2324	{
2325	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2326	{
2327	tree _q90 = gimple_assign_rhs1 (_a5);
2328	_q90 = do_valueize (valueize, _q90);
2329	if ((_q90 == _q31 && ! TREE_SIDE_EFFECTS (_q90)((non_type_check ((_q90), "gimple-match.cc", 2329, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q90, _q31, 0) && types_match (_q90, _q31)))
2330	{
2331	{
2332	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2333	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
2334	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2335	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2335 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2335, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2335, __FUNCTION__))-> type_common.precision)
2336	)
2337	{
2338	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__2338);
2339	{
2340	res_ops[0] = captures[0];
2341	res_ops[1] = captures[0];
2342	res_ops[2] = captures[1];
2343	return true;
2344	}
2345	next_after_fail75:;
2346	}
2347	}
2348	}
2349	break;
2350	}
2351	default:;
2352	}
2353	}
2354	break;
2355	default:;
2356	}
2357	if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 2357, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
2358	{
2359	{
2360	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2361	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
2362	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2363	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2363 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2363, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2363, __FUNCTION__))-> type_common.precision)
2364	)
2365	{
2366	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__2366);
2367	{
2368	res_ops[0] = captures[0];
2369	res_ops[1] = captures[0];
2370	res_ops[2] = captures[1];
2371	return true;
2372	}
2373	next_after_fail76:;
2374	}
2375	}
2376	}
2377	}
2378	break;
2379	}
2380	default:;
2381	}
2382	}
2383	break;
2384	case INTEGER_CST:
2385	{
2386	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2387	{
2388	case INTEGER_CST:
2389	{
2390	{
2391	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2392	tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
2393	{
2394	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2395	int ibit = tree_log2 (captures[0]);
2396	int ibit2 = tree_log2 (captures[1]);
2397	/* #line 4470 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2398	if (ibit == ibit2
2399	&& ibit >= 0
2400	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2400 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2400, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2400, __FUNCTION__))-> type_common.precision)
2401	)
2402	{
2403	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4463, __FILE__"gimple-match.cc", __LINE__2403);
2404	{
2405	res_ops[0] = captures[0];
2406	res_ops[1] = captures[1];
2407	res_ops[2] = captures[2];
2408	return true;
2409	}
2410	next_after_fail77:;
2411	}
2412	}
2413	}
2414	break;
2415	}
2416	default:;
2417	}
2418	break;
2419	}
2420	default:;
2421	}
2422	{
2423	tree _q31_pops[1];
2424	if (gimple_nop_convert (_q31, _q31_pops, valueize))
2425	{
2426	tree _q50 = _q31_pops[0];
2427	switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
2428	{
2429	case SSA_NAME:
2430	if (gimple *_d4 = get_def (valueize, _q50))
2431	{
2432	if (gassign _a4 = dyn_cast <gassign > (_d4))
2433	switch (gimple_assign_rhs_code (_a4))
2434	{
2435	case LSHIFT_EXPR:
2436	{
2437	tree _q60 = gimple_assign_rhs1 (_a4);
2438	_q60 = do_valueize (valueize, _q60);
2439	tree _q61 = gimple_assign_rhs2 (_a4);
2440	_q61 = do_valueize (valueize, _q61);
2441	if (integer_onep (_q60))
2442	{
2443	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2444	{
2445	case SSA_NAME:
2446	if (gimple *_d5 = get_def (valueize, _p1))
2447	{
2448	if (gassign _a5 = dyn_cast <gassign > (_d5))
2449	switch (gimple_assign_rhs_code (_a5))
2450	{
2451	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2452	{
2453	tree _q100 = gimple_assign_rhs1 (_a5);
2454	_q100 = do_valueize (valueize, _q100);
2455	if ((_q100 == _q50 && ! TREE_SIDE_EFFECTS (_q100)((non_type_check ((_q100), "gimple-match.cc", 2455, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q100, _q50, 0) && types_match (_q100, _q50)))
2456	{
2457	{
2458	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2459	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
2460	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2461	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2461 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2461, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2461, __FUNCTION__))-> type_common.precision)
2462	)
2463	{
2464	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__2464);
2465	{
2466	res_ops[0] = captures[0];
2467	res_ops[1] = captures[0];
2468	res_ops[2] = captures[1];
2469	return true;
2470	}
2471	next_after_fail78:;
2472	}
2473	}
2474	}
2475	break;
2476	}
2477	default:;
2478	}
2479	}
2480	break;
2481	default:;
2482	}
2483	if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 2483, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
2484	{
2485	{
2486	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2487	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
2488	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2489	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2489 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2489, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2489, __FUNCTION__))-> type_common.precision)
2490	)
2491	{
2492	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__2492);
2493	{
2494	res_ops[0] = captures[0];
2495	res_ops[1] = captures[0];
2496	res_ops[2] = captures[1];
2497	return true;
2498	}
2499	next_after_fail79:;
2500	}
2501	}
2502	}
2503	}
2504	break;
2505	}
2506	default:;
2507	}
2508	}
2509	break;
2510	default:;
2511	}
2512	}
2513	}
2514	}
2515	break;
2516	case CFN_BUILT_IN_ATOMIC_FETCH_XOR_2:
2517	if (gimple_call_num_args (_c3) == 3)
2518	{
2519	tree _q30 = gimple_call_arg (_c3, 0);
2520	_q30 = do_valueize (valueize, _q30);
2521	tree _q31 = gimple_call_arg (_c3, 1);
2522	_q31 = do_valueize (valueize, _q31);
2523	tree _q32 = gimple_call_arg (_c3, 2);
2524	_q32 = do_valueize (valueize, _q32);
2525	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
2526	{
2527	case SSA_NAME:
2528	if (gimple *_d4 = get_def (valueize, _q31))
2529	{
2530	if (gassign _a4 = dyn_cast <gassign > (_d4))
2531	switch (gimple_assign_rhs_code (_a4))
2532	{
2533	case LSHIFT_EXPR:
2534	{
2535	tree _q50 = gimple_assign_rhs1 (_a4);
2536	_q50 = do_valueize (valueize, _q50);
2537	tree _q51 = gimple_assign_rhs2 (_a4);
2538	_q51 = do_valueize (valueize, _q51);
2539	if (integer_onep (_q50))
2540	{
2541	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2542	{
2543	case SSA_NAME:
2544	if (gimple *_d5 = get_def (valueize, _p1))
2545	{
2546	if (gassign _a5 = dyn_cast <gassign > (_d5))
2547	switch (gimple_assign_rhs_code (_a5))
2548	{
2549	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2550	{
2551	tree _q90 = gimple_assign_rhs1 (_a5);
2552	_q90 = do_valueize (valueize, _q90);
2553	if ((_q90 == _q31 && ! TREE_SIDE_EFFECTS (_q90)((non_type_check ((_q90), "gimple-match.cc", 2553, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q90, _q31, 0) && types_match (_q90, _q31)))
2554	{
2555	{
2556	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2557	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
2558	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2559	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2559 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2559, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2559, __FUNCTION__))-> type_common.precision)
2560	)
2561	{
2562	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__2562);
2563	{
2564	res_ops[0] = captures[0];
2565	res_ops[1] = captures[0];
2566	res_ops[2] = captures[1];
2567	return true;
2568	}
2569	next_after_fail80:;
2570	}
2571	}
2572	}
2573	break;
2574	}
2575	default:;
2576	}
2577	}
2578	break;
2579	default:;
2580	}
2581	if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 2581, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
2582	{
2583	{
2584	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2585	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
2586	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2587	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2587 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2587, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2587, __FUNCTION__))-> type_common.precision)
2588	)
2589	{
2590	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__2590);
2591	{
2592	res_ops[0] = captures[0];
2593	res_ops[1] = captures[0];
2594	res_ops[2] = captures[1];
2595	return true;
2596	}
2597	next_after_fail81:;
2598	}
2599	}
2600	}
2601	}
2602	break;
2603	}
2604	default:;
2605	}
2606	}
2607	break;
2608	case INTEGER_CST:
2609	{
2610	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2611	{
2612	case INTEGER_CST:
2613	{
2614	{
2615	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2616	tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
2617	{
2618	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2619	int ibit = tree_log2 (captures[0]);
2620	int ibit2 = tree_log2 (captures[1]);
2621	/* #line 4470 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2622	if (ibit == ibit2
2623	&& ibit >= 0
2624	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2624 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2624, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2624, __FUNCTION__))-> type_common.precision)
2625	)
2626	{
2627	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4463, __FILE__"gimple-match.cc", __LINE__2627);
2628	{
2629	res_ops[0] = captures[0];
2630	res_ops[1] = captures[1];
2631	res_ops[2] = captures[2];
2632	return true;
2633	}
2634	next_after_fail82:;
2635	}
2636	}
2637	}
2638	break;
2639	}
2640	default:;
2641	}
2642	break;
2643	}
2644	default:;
2645	}
2646	{
2647	tree _q31_pops[1];
2648	if (gimple_nop_convert (_q31, _q31_pops, valueize))
2649	{
2650	tree _q50 = _q31_pops[0];
2651	switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
2652	{
2653	case SSA_NAME:
2654	if (gimple *_d4 = get_def (valueize, _q50))
2655	{
2656	if (gassign _a4 = dyn_cast <gassign > (_d4))
2657	switch (gimple_assign_rhs_code (_a4))
2658	{
2659	case LSHIFT_EXPR:
2660	{
2661	tree _q60 = gimple_assign_rhs1 (_a4);
2662	_q60 = do_valueize (valueize, _q60);
2663	tree _q61 = gimple_assign_rhs2 (_a4);
2664	_q61 = do_valueize (valueize, _q61);
2665	if (integer_onep (_q60))
2666	{
2667	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2668	{
2669	case SSA_NAME:
2670	if (gimple *_d5 = get_def (valueize, _p1))
2671	{
2672	if (gassign _a5 = dyn_cast <gassign > (_d5))
2673	switch (gimple_assign_rhs_code (_a5))
2674	{
2675	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2676	{
2677	tree _q100 = gimple_assign_rhs1 (_a5);
2678	_q100 = do_valueize (valueize, _q100);
2679	if ((_q100 == _q50 && ! TREE_SIDE_EFFECTS (_q100)((non_type_check ((_q100), "gimple-match.cc", 2679, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q100, _q50, 0) && types_match (_q100, _q50)))
2680	{
2681	{
2682	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2683	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
2684	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2685	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2685 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2685, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2685, __FUNCTION__))-> type_common.precision)
2686	)
2687	{
2688	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__2688);
2689	{
2690	res_ops[0] = captures[0];
2691	res_ops[1] = captures[0];
2692	res_ops[2] = captures[1];
2693	return true;
2694	}
2695	next_after_fail83:;
2696	}
2697	}
2698	}
2699	break;
2700	}
2701	default:;
2702	}
2703	}
2704	break;
2705	default:;
2706	}
2707	if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 2707, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
2708	{
2709	{
2710	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2711	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
2712	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2713	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2713 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2713, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2713, __FUNCTION__))-> type_common.precision)
2714	)
2715	{
2716	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__2716);
2717	{
2718	res_ops[0] = captures[0];
2719	res_ops[1] = captures[0];
2720	res_ops[2] = captures[1];
2721	return true;
2722	}
2723	next_after_fail84:;
2724	}
2725	}
2726	}
2727	}
2728	break;
2729	}
2730	default:;
2731	}
2732	}
2733	break;
2734	default:;
2735	}
2736	}
2737	}
2738	}
2739	break;
2740	case CFN_BUILT_IN_ATOMIC_FETCH_XOR_4:
2741	if (gimple_call_num_args (_c3) == 3)
2742	{
2743	tree _q30 = gimple_call_arg (_c3, 0);
2744	_q30 = do_valueize (valueize, _q30);
2745	tree _q31 = gimple_call_arg (_c3, 1);
2746	_q31 = do_valueize (valueize, _q31);
2747	tree _q32 = gimple_call_arg (_c3, 2);
2748	_q32 = do_valueize (valueize, _q32);
2749	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
2750	{
2751	case SSA_NAME:
2752	if (gimple *_d4 = get_def (valueize, _q31))
2753	{
2754	if (gassign _a4 = dyn_cast <gassign > (_d4))
2755	switch (gimple_assign_rhs_code (_a4))
2756	{
2757	case LSHIFT_EXPR:
2758	{
2759	tree _q50 = gimple_assign_rhs1 (_a4);
2760	_q50 = do_valueize (valueize, _q50);
2761	tree _q51 = gimple_assign_rhs2 (_a4);
2762	_q51 = do_valueize (valueize, _q51);
2763	if (integer_onep (_q50))
2764	{
2765	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2766	{
2767	case SSA_NAME:
2768	if (gimple *_d5 = get_def (valueize, _p1))
2769	{
2770	if (gassign _a5 = dyn_cast <gassign > (_d5))
2771	switch (gimple_assign_rhs_code (_a5))
2772	{
2773	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2774	{
2775	tree _q90 = gimple_assign_rhs1 (_a5);
2776	_q90 = do_valueize (valueize, _q90);
2777	if ((_q90 == _q31 && ! TREE_SIDE_EFFECTS (_q90)((non_type_check ((_q90), "gimple-match.cc", 2777, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q90, _q31, 0) && types_match (_q90, _q31)))
2778	{
2779	{
2780	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2781	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
2782	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2783	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2783 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2783, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2783, __FUNCTION__))-> type_common.precision)
2784	)
2785	{
2786	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__2786);
2787	{
2788	res_ops[0] = captures[0];
2789	res_ops[1] = captures[0];
2790	res_ops[2] = captures[1];
2791	return true;
2792	}
2793	next_after_fail85:;
2794	}
2795	}
2796	}
2797	break;
2798	}
2799	default:;
2800	}
2801	}
2802	break;
2803	default:;
2804	}
2805	if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 2805, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
2806	{
2807	{
2808	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2809	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
2810	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2811	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2811 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2811, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2811, __FUNCTION__))-> type_common.precision)
2812	)
2813	{
2814	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__2814);
2815	{
2816	res_ops[0] = captures[0];
2817	res_ops[1] = captures[0];
2818	res_ops[2] = captures[1];
2819	return true;
2820	}
2821	next_after_fail86:;
2822	}
2823	}
2824	}
2825	}
2826	break;
2827	}
2828	default:;
2829	}
2830	}
2831	break;
2832	case INTEGER_CST:
2833	{
2834	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2835	{
2836	case INTEGER_CST:
2837	{
2838	{
2839	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2840	tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
2841	{
2842	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2843	int ibit = tree_log2 (captures[0]);
2844	int ibit2 = tree_log2 (captures[1]);
2845	/* #line 4470 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2846	if (ibit == ibit2
2847	&& ibit >= 0
2848	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2848 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2848, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2848, __FUNCTION__))-> type_common.precision)
2849	)
2850	{
2851	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4463, __FILE__"gimple-match.cc", __LINE__2851);
2852	{
2853	res_ops[0] = captures[0];
2854	res_ops[1] = captures[1];
2855	res_ops[2] = captures[2];
2856	return true;
2857	}
2858	next_after_fail87:;
2859	}
2860	}
2861	}
2862	break;
2863	}
2864	default:;
2865	}
2866	break;
2867	}
2868	default:;
2869	}
2870	{
2871	tree _q31_pops[1];
2872	if (gimple_nop_convert (_q31, _q31_pops, valueize))
2873	{
2874	tree _q50 = _q31_pops[0];
2875	switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
2876	{
2877	case SSA_NAME:
2878	if (gimple *_d4 = get_def (valueize, _q50))
2879	{
2880	if (gassign _a4 = dyn_cast <gassign > (_d4))
2881	switch (gimple_assign_rhs_code (_a4))
2882	{
2883	case LSHIFT_EXPR:
2884	{
2885	tree _q60 = gimple_assign_rhs1 (_a4);
2886	_q60 = do_valueize (valueize, _q60);
2887	tree _q61 = gimple_assign_rhs2 (_a4);
2888	_q61 = do_valueize (valueize, _q61);
2889	if (integer_onep (_q60))
2890	{
2891	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2892	{
2893	case SSA_NAME:
2894	if (gimple *_d5 = get_def (valueize, _p1))
2895	{
2896	if (gassign _a5 = dyn_cast <gassign > (_d5))
2897	switch (gimple_assign_rhs_code (_a5))
2898	{
2899	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2900	{
2901	tree _q100 = gimple_assign_rhs1 (_a5);
2902	_q100 = do_valueize (valueize, _q100);
2903	if ((_q100 == _q50 && ! TREE_SIDE_EFFECTS (_q100)((non_type_check ((_q100), "gimple-match.cc", 2903, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q100, _q50, 0) && types_match (_q100, _q50)))
2904	{
2905	{
2906	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2907	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
2908	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2909	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2909 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2909, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2909, __FUNCTION__))-> type_common.precision)
2910	)
2911	{
2912	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__2912);
2913	{
2914	res_ops[0] = captures[0];
2915	res_ops[1] = captures[0];
2916	res_ops[2] = captures[1];
2917	return true;
2918	}
2919	next_after_fail88:;
2920	}
2921	}
2922	}
2923	break;
2924	}
2925	default:;
2926	}
2927	}
2928	break;
2929	default:;
2930	}
2931	if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 2931, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
2932	{
2933	{
2934	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2935	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
2936	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2937	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 2937 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 2937, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 2937, __FUNCTION__))-> type_common.precision)
2938	)
2939	{
2940	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__2940);
2941	{
2942	res_ops[0] = captures[0];
2943	res_ops[1] = captures[0];
2944	res_ops[2] = captures[1];
2945	return true;
2946	}
2947	next_after_fail89:;
2948	}
2949	}
2950	}
2951	}
2952	break;
2953	}
2954	default:;
2955	}
2956	}
2957	break;
2958	default:;
2959	}
2960	}
2961	}
2962	}
2963	break;
2964	case CFN_BUILT_IN_ATOMIC_FETCH_XOR_8:
2965	if (gimple_call_num_args (_c3) == 3)
2966	{
2967	tree _q30 = gimple_call_arg (_c3, 0);
2968	_q30 = do_valueize (valueize, _q30);
2969	tree _q31 = gimple_call_arg (_c3, 1);
2970	_q31 = do_valueize (valueize, _q31);
2971	tree _q32 = gimple_call_arg (_c3, 2);
2972	_q32 = do_valueize (valueize, _q32);
2973	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
2974	{
2975	case SSA_NAME:
2976	if (gimple *_d4 = get_def (valueize, _q31))
2977	{
2978	if (gassign _a4 = dyn_cast <gassign > (_d4))
2979	switch (gimple_assign_rhs_code (_a4))
2980	{
2981	case LSHIFT_EXPR:
2982	{
2983	tree _q50 = gimple_assign_rhs1 (_a4);
2984	_q50 = do_valueize (valueize, _q50);
2985	tree _q51 = gimple_assign_rhs2 (_a4);
2986	_q51 = do_valueize (valueize, _q51);
2987	if (integer_onep (_q50))
2988	{
2989	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2990	{
2991	case SSA_NAME:
2992	if (gimple *_d5 = get_def (valueize, _p1))
2993	{
2994	if (gassign _a5 = dyn_cast <gassign > (_d5))
2995	switch (gimple_assign_rhs_code (_a5))
2996	{
2997	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2998	{
2999	tree _q90 = gimple_assign_rhs1 (_a5);
3000	_q90 = do_valueize (valueize, _q90);
3001	if ((_q90 == _q31 && ! TREE_SIDE_EFFECTS (_q90)((non_type_check ((_q90), "gimple-match.cc", 3001, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q90, _q31, 0) && types_match (_q90, _q31)))
3002	{
3003	{
3004	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3005	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
3006	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3007	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3007 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3007, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3007, __FUNCTION__))-> type_common.precision)
3008	)
3009	{
3010	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__3010);
3011	{
3012	res_ops[0] = captures[0];
3013	res_ops[1] = captures[0];
3014	res_ops[2] = captures[1];
3015	return true;
3016	}
3017	next_after_fail90:;
3018	}
3019	}
3020	}
3021	break;
3022	}
3023	default:;
3024	}
3025	}
3026	break;
3027	default:;
3028	}
3029	if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 3029, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
3030	{
3031	{
3032	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3033	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
3034	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3035	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3035 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3035, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3035, __FUNCTION__))-> type_common.precision)
3036	)
3037	{
3038	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__3038);
3039	{
3040	res_ops[0] = captures[0];
3041	res_ops[1] = captures[0];
3042	res_ops[2] = captures[1];
3043	return true;
3044	}
3045	next_after_fail91:;
3046	}
3047	}
3048	}
3049	}
3050	break;
3051	}
3052	default:;
3053	}
3054	}
3055	break;
3056	case INTEGER_CST:
3057	{
3058	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3059	{
3060	case INTEGER_CST:
3061	{
3062	{
3063	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3064	tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
3065	{
3066	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3067	int ibit = tree_log2 (captures[0]);
3068	int ibit2 = tree_log2 (captures[1]);
3069	/* #line 4470 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3070	if (ibit == ibit2
3071	&& ibit >= 0
3072	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3072 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3072, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3072, __FUNCTION__))-> type_common.precision)
3073	)
3074	{
3075	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4463, __FILE__"gimple-match.cc", __LINE__3075);
3076	{
3077	res_ops[0] = captures[0];
3078	res_ops[1] = captures[1];
3079	res_ops[2] = captures[2];
3080	return true;
3081	}
3082	next_after_fail92:;
3083	}
3084	}
3085	}
3086	break;
3087	}
3088	default:;
3089	}
3090	break;
3091	}
3092	default:;
3093	}
3094	{
3095	tree _q31_pops[1];
3096	if (gimple_nop_convert (_q31, _q31_pops, valueize))
3097	{
3098	tree _q50 = _q31_pops[0];
3099	switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
3100	{
3101	case SSA_NAME:
3102	if (gimple *_d4 = get_def (valueize, _q50))
3103	{
3104	if (gassign _a4 = dyn_cast <gassign > (_d4))
3105	switch (gimple_assign_rhs_code (_a4))
3106	{
3107	case LSHIFT_EXPR:
3108	{
3109	tree _q60 = gimple_assign_rhs1 (_a4);
3110	_q60 = do_valueize (valueize, _q60);
3111	tree _q61 = gimple_assign_rhs2 (_a4);
3112	_q61 = do_valueize (valueize, _q61);
3113	if (integer_onep (_q60))
3114	{
3115	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3116	{
3117	case SSA_NAME:
3118	if (gimple *_d5 = get_def (valueize, _p1))
3119	{
3120	if (gassign _a5 = dyn_cast <gassign > (_d5))
3121	switch (gimple_assign_rhs_code (_a5))
3122	{
3123	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
3124	{
3125	tree _q100 = gimple_assign_rhs1 (_a5);
3126	_q100 = do_valueize (valueize, _q100);
3127	if ((_q100 == _q50 && ! TREE_SIDE_EFFECTS (_q100)((non_type_check ((_q100), "gimple-match.cc", 3127, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q100, _q50, 0) && types_match (_q100, _q50)))
3128	{
3129	{
3130	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3131	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
3132	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3133	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3133 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3133, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3133, __FUNCTION__))-> type_common.precision)
3134	)
3135	{
3136	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__3136);
3137	{
3138	res_ops[0] = captures[0];
3139	res_ops[1] = captures[0];
3140	res_ops[2] = captures[1];
3141	return true;
3142	}
3143	next_after_fail93:;
3144	}
3145	}
3146	}
3147	break;
3148	}
3149	default:;
3150	}
3151	}
3152	break;
3153	default:;
3154	}
3155	if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 3155, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
3156	{
3157	{
3158	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3159	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
3160	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3161	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3161 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3161, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3161, __FUNCTION__))-> type_common.precision)
3162	)
3163	{
3164	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__3164);
3165	{
3166	res_ops[0] = captures[0];
3167	res_ops[1] = captures[0];
3168	res_ops[2] = captures[1];
3169	return true;
3170	}
3171	next_after_fail94:;
3172	}
3173	}
3174	}
3175	}
3176	break;
3177	}
3178	default:;
3179	}
3180	}
3181	break;
3182	default:;
3183	}
3184	}
3185	}
3186	}
3187	break;
3188	case CFN_BUILT_IN_ATOMIC_FETCH_XOR_16:
3189	if (gimple_call_num_args (_c3) == 3)
3190	{
3191	tree _q30 = gimple_call_arg (_c3, 0);
3192	_q30 = do_valueize (valueize, _q30);
3193	tree _q31 = gimple_call_arg (_c3, 1);
3194	_q31 = do_valueize (valueize, _q31);
3195	tree _q32 = gimple_call_arg (_c3, 2);
3196	_q32 = do_valueize (valueize, _q32);
3197	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
3198	{
3199	case SSA_NAME:
3200	if (gimple *_d4 = get_def (valueize, _q31))
3201	{
3202	if (gassign _a4 = dyn_cast <gassign > (_d4))
3203	switch (gimple_assign_rhs_code (_a4))
3204	{
3205	case LSHIFT_EXPR:
3206	{
3207	tree _q50 = gimple_assign_rhs1 (_a4);
3208	_q50 = do_valueize (valueize, _q50);
3209	tree _q51 = gimple_assign_rhs2 (_a4);
3210	_q51 = do_valueize (valueize, _q51);
3211	if (integer_onep (_q50))
3212	{
3213	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3214	{
3215	case SSA_NAME:
3216	if (gimple *_d5 = get_def (valueize, _p1))
3217	{
3218	if (gassign _a5 = dyn_cast <gassign > (_d5))
3219	switch (gimple_assign_rhs_code (_a5))
3220	{
3221	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
3222	{
3223	tree _q90 = gimple_assign_rhs1 (_a5);
3224	_q90 = do_valueize (valueize, _q90);
3225	if ((_q90 == _q31 && ! TREE_SIDE_EFFECTS (_q90)((non_type_check ((_q90), "gimple-match.cc", 3225, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q90, _q31, 0) && types_match (_q90, _q31)))
3226	{
3227	{
3228	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3229	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
3230	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3231	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3231 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3231, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3231, __FUNCTION__))-> type_common.precision)
3232	)
3233	{
3234	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__3234);
3235	{
3236	res_ops[0] = captures[0];
3237	res_ops[1] = captures[0];
3238	res_ops[2] = captures[1];
3239	return true;
3240	}
3241	next_after_fail95:;
3242	}
3243	}
3244	}
3245	break;
3246	}
3247	default:;
3248	}
3249	}
3250	break;
3251	default:;
3252	}
3253	if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 3253, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
3254	{
3255	{
3256	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3257	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
3258	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3259	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3259 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3259, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3259, __FUNCTION__))-> type_common.precision)
3260	)
3261	{
3262	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__3262);
3263	{
3264	res_ops[0] = captures[0];
3265	res_ops[1] = captures[0];
3266	res_ops[2] = captures[1];
3267	return true;
3268	}
3269	next_after_fail96:;
3270	}
3271	}
3272	}
3273	}
3274	break;
3275	}
3276	default:;
3277	}
3278	}
3279	break;
3280	case INTEGER_CST:
3281	{
3282	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3283	{
3284	case INTEGER_CST:
3285	{
3286	{
3287	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3288	tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
3289	{
3290	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3291	int ibit = tree_log2 (captures[0]);
3292	int ibit2 = tree_log2 (captures[1]);
3293	/* #line 4470 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3294	if (ibit == ibit2
3295	&& ibit >= 0
3296	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3296 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3296, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3296, __FUNCTION__))-> type_common.precision)
3297	)
3298	{
3299	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4463, __FILE__"gimple-match.cc", __LINE__3299);
3300	{
3301	res_ops[0] = captures[0];
3302	res_ops[1] = captures[1];
3303	res_ops[2] = captures[2];
3304	return true;
3305	}
3306	next_after_fail97:;
3307	}
3308	}
3309	}
3310	break;
3311	}
3312	default:;
3313	}
3314	break;
3315	}
3316	default:;
3317	}
3318	{
3319	tree _q31_pops[1];
3320	if (gimple_nop_convert (_q31, _q31_pops, valueize))
3321	{
3322	tree _q50 = _q31_pops[0];
3323	switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
3324	{
3325	case SSA_NAME:
3326	if (gimple *_d4 = get_def (valueize, _q50))
3327	{
3328	if (gassign _a4 = dyn_cast <gassign > (_d4))
3329	switch (gimple_assign_rhs_code (_a4))
3330	{
3331	case LSHIFT_EXPR:
3332	{
3333	tree _q60 = gimple_assign_rhs1 (_a4);
3334	_q60 = do_valueize (valueize, _q60);
3335	tree _q61 = gimple_assign_rhs2 (_a4);
3336	_q61 = do_valueize (valueize, _q61);
3337	if (integer_onep (_q60))
3338	{
3339	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3340	{
3341	case SSA_NAME:
3342	if (gimple *_d5 = get_def (valueize, _p1))
3343	{
3344	if (gassign _a5 = dyn_cast <gassign > (_d5))
3345	switch (gimple_assign_rhs_code (_a5))
3346	{
3347	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
3348	{
3349	tree _q100 = gimple_assign_rhs1 (_a5);
3350	_q100 = do_valueize (valueize, _q100);
3351	if ((_q100 == _q50 && ! TREE_SIDE_EFFECTS (_q100)((non_type_check ((_q100), "gimple-match.cc", 3351, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q100, _q50, 0) && types_match (_q100, _q50)))
3352	{
3353	{
3354	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3355	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
3356	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3357	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3357 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3357, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3357, __FUNCTION__))-> type_common.precision)
3358	)
3359	{
3360	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__3360);
3361	{
3362	res_ops[0] = captures[0];
3363	res_ops[1] = captures[0];
3364	res_ops[2] = captures[1];
3365	return true;
3366	}
3367	next_after_fail98:;
3368	}
3369	}
3370	}
3371	break;
3372	}
3373	default:;
3374	}
3375	}
3376	break;
3377	default:;
3378	}
3379	if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 3379, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
3380	{
3381	{
3382	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3383	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
3384	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3385	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3385 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3385, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3385, __FUNCTION__))-> type_common.precision)
3386	)
3387	{
3388	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__3388);
3389	{
3390	res_ops[0] = captures[0];
3391	res_ops[1] = captures[0];
3392	res_ops[2] = captures[1];
3393	return true;
3394	}
3395	next_after_fail99:;
3396	}
3397	}
3398	}
3399	}
3400	break;
3401	}
3402	default:;
3403	}
3404	}
3405	break;
3406	default:;
3407	}
3408	}
3409	}
3410	}
3411	break;
3412	case CFN_BUILT_IN_ATOMIC_XOR_FETCH_1:
3413	if (gimple_call_num_args (_c3) == 3)
3414	{
3415	tree _q30 = gimple_call_arg (_c3, 0);
3416	_q30 = do_valueize (valueize, _q30);
3417	tree _q31 = gimple_call_arg (_c3, 1);
3418	_q31 = do_valueize (valueize, _q31);
3419	tree _q32 = gimple_call_arg (_c3, 2);
3420	_q32 = do_valueize (valueize, _q32);
3421	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
3422	{
3423	case SSA_NAME:
3424	if (gimple *_d4 = get_def (valueize, _q31))
3425	{
3426	if (gassign _a4 = dyn_cast <gassign > (_d4))
3427	switch (gimple_assign_rhs_code (_a4))
3428	{
3429	case LSHIFT_EXPR:
3430	{
3431	tree _q50 = gimple_assign_rhs1 (_a4);
3432	_q50 = do_valueize (valueize, _q50);
3433	tree _q51 = gimple_assign_rhs2 (_a4);
3434	_q51 = do_valueize (valueize, _q51);
3435	if (integer_onep (_q50))
3436	{
3437	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3438	{
3439	case SSA_NAME:
3440	if (gimple *_d5 = get_def (valueize, _p1))
3441	{
3442	if (gassign _a5 = dyn_cast <gassign > (_d5))
3443	switch (gimple_assign_rhs_code (_a5))
3444	{
3445	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
3446	{
3447	tree _q90 = gimple_assign_rhs1 (_a5);
3448	_q90 = do_valueize (valueize, _q90);
3449	if ((_q90 == _q31 && ! TREE_SIDE_EFFECTS (_q90)((non_type_check ((_q90), "gimple-match.cc", 3449, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q90, _q31, 0) && types_match (_q90, _q31)))
3450	{
3451	{
3452	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3453	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
3454	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3455	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3455 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3455, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3455, __FUNCTION__))-> type_common.precision)
3456	)
3457	{
3458	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__3458);
3459	{
3460	res_ops[0] = captures[0];
3461	res_ops[1] = captures[0];
3462	res_ops[2] = captures[1];
3463	return true;
3464	}
3465	next_after_fail100:;
3466	}
3467	}
3468	}
3469	break;
3470	}
3471	default:;
3472	}
3473	}
3474	break;
3475	default:;
3476	}
3477	if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 3477, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
3478	{
3479	{
3480	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3481	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
3482	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3483	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3483 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3483, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3483, __FUNCTION__))-> type_common.precision)
3484	)
3485	{
3486	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__3486);
3487	{
3488	res_ops[0] = captures[0];
3489	res_ops[1] = captures[0];
3490	res_ops[2] = captures[1];
3491	return true;
3492	}
3493	next_after_fail101:;
3494	}
3495	}
3496	}
3497	}
3498	break;
3499	}
3500	default:;
3501	}
3502	}
3503	break;
3504	case INTEGER_CST:
3505	{
3506	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3507	{
3508	case INTEGER_CST:
3509	{
3510	{
3511	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3512	tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
3513	{
3514	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3515	int ibit = tree_log2 (captures[0]);
3516	int ibit2 = tree_log2 (captures[1]);
3517	/* #line 4470 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3518	if (ibit == ibit2
3519	&& ibit >= 0
3520	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3520 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3520, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3520, __FUNCTION__))-> type_common.precision)
3521	)
3522	{
3523	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4463, __FILE__"gimple-match.cc", __LINE__3523);
3524	{
3525	res_ops[0] = captures[0];
3526	res_ops[1] = captures[1];
3527	res_ops[2] = captures[2];
3528	return true;
3529	}
3530	next_after_fail102:;
3531	}
3532	}
3533	}
3534	break;
3535	}
3536	default:;
3537	}
3538	break;
3539	}
3540	default:;
3541	}
3542	{
3543	tree _q31_pops[1];
3544	if (gimple_nop_convert (_q31, _q31_pops, valueize))
3545	{
3546	tree _q50 = _q31_pops[0];
3547	switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
3548	{
3549	case SSA_NAME:
3550	if (gimple *_d4 = get_def (valueize, _q50))
3551	{
3552	if (gassign _a4 = dyn_cast <gassign > (_d4))
3553	switch (gimple_assign_rhs_code (_a4))
3554	{
3555	case LSHIFT_EXPR:
3556	{
3557	tree _q60 = gimple_assign_rhs1 (_a4);
3558	_q60 = do_valueize (valueize, _q60);
3559	tree _q61 = gimple_assign_rhs2 (_a4);
3560	_q61 = do_valueize (valueize, _q61);
3561	if (integer_onep (_q60))
3562	{
3563	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3564	{
3565	case SSA_NAME:
3566	if (gimple *_d5 = get_def (valueize, _p1))
3567	{
3568	if (gassign _a5 = dyn_cast <gassign > (_d5))
3569	switch (gimple_assign_rhs_code (_a5))
3570	{
3571	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
3572	{
3573	tree _q100 = gimple_assign_rhs1 (_a5);
3574	_q100 = do_valueize (valueize, _q100);
3575	if ((_q100 == _q50 && ! TREE_SIDE_EFFECTS (_q100)((non_type_check ((_q100), "gimple-match.cc", 3575, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q100, _q50, 0) && types_match (_q100, _q50)))
3576	{
3577	{
3578	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3579	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
3580	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3581	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3581 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3581, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3581, __FUNCTION__))-> type_common.precision)
3582	)
3583	{
3584	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__3584);
3585	{
3586	res_ops[0] = captures[0];
3587	res_ops[1] = captures[0];
3588	res_ops[2] = captures[1];
3589	return true;
3590	}
3591	next_after_fail103:;
3592	}
3593	}
3594	}
3595	break;
3596	}
3597	default:;
3598	}
3599	}
3600	break;
3601	default:;
3602	}
3603	if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 3603, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
3604	{
3605	{
3606	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3607	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
3608	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3609	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3609 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3609, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3609, __FUNCTION__))-> type_common.precision)
3610	)
3611	{
3612	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__3612);
3613	{
3614	res_ops[0] = captures[0];
3615	res_ops[1] = captures[0];
3616	res_ops[2] = captures[1];
3617	return true;
3618	}
3619	next_after_fail104:;
3620	}
3621	}
3622	}
3623	}
3624	break;
3625	}
3626	default:;
3627	}
3628	}
3629	break;
3630	default:;
3631	}
3632	}
3633	}
3634	}
3635	break;
3636	case CFN_BUILT_IN_ATOMIC_XOR_FETCH_2:
3637	if (gimple_call_num_args (_c3) == 3)
3638	{
3639	tree _q30 = gimple_call_arg (_c3, 0);
3640	_q30 = do_valueize (valueize, _q30);
3641	tree _q31 = gimple_call_arg (_c3, 1);
3642	_q31 = do_valueize (valueize, _q31);
3643	tree _q32 = gimple_call_arg (_c3, 2);
3644	_q32 = do_valueize (valueize, _q32);
3645	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
3646	{
3647	case SSA_NAME:
3648	if (gimple *_d4 = get_def (valueize, _q31))
3649	{
3650	if (gassign _a4 = dyn_cast <gassign > (_d4))
3651	switch (gimple_assign_rhs_code (_a4))
3652	{
3653	case LSHIFT_EXPR:
3654	{
3655	tree _q50 = gimple_assign_rhs1 (_a4);
3656	_q50 = do_valueize (valueize, _q50);
3657	tree _q51 = gimple_assign_rhs2 (_a4);
3658	_q51 = do_valueize (valueize, _q51);
3659	if (integer_onep (_q50))
3660	{
3661	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3662	{
3663	case SSA_NAME:
3664	if (gimple *_d5 = get_def (valueize, _p1))
3665	{
3666	if (gassign _a5 = dyn_cast <gassign > (_d5))
3667	switch (gimple_assign_rhs_code (_a5))
3668	{
3669	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
3670	{
3671	tree _q90 = gimple_assign_rhs1 (_a5);
3672	_q90 = do_valueize (valueize, _q90);
3673	if ((_q90 == _q31 && ! TREE_SIDE_EFFECTS (_q90)((non_type_check ((_q90), "gimple-match.cc", 3673, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q90, _q31, 0) && types_match (_q90, _q31)))
3674	{
3675	{
3676	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3677	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
3678	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3679	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3679 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3679, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3679, __FUNCTION__))-> type_common.precision)
3680	)
3681	{
3682	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__3682);
3683	{
3684	res_ops[0] = captures[0];
3685	res_ops[1] = captures[0];
3686	res_ops[2] = captures[1];
3687	return true;
3688	}
3689	next_after_fail105:;
3690	}
3691	}
3692	}
3693	break;
3694	}
3695	default:;
3696	}
3697	}
3698	break;
3699	default:;
3700	}
3701	if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 3701, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
3702	{
3703	{
3704	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3705	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
3706	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3707	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3707 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3707, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3707, __FUNCTION__))-> type_common.precision)
3708	)
3709	{
3710	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__3710);
3711	{
3712	res_ops[0] = captures[0];
3713	res_ops[1] = captures[0];
3714	res_ops[2] = captures[1];
3715	return true;
3716	}
3717	next_after_fail106:;
3718	}
3719	}
3720	}
3721	}
3722	break;
3723	}
3724	default:;
3725	}
3726	}
3727	break;
3728	case INTEGER_CST:
3729	{
3730	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3731	{
3732	case INTEGER_CST:
3733	{
3734	{
3735	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3736	tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
3737	{
3738	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3739	int ibit = tree_log2 (captures[0]);
3740	int ibit2 = tree_log2 (captures[1]);
3741	/* #line 4470 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3742	if (ibit == ibit2
3743	&& ibit >= 0
3744	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3744 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3744, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3744, __FUNCTION__))-> type_common.precision)
3745	)
3746	{
3747	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4463, __FILE__"gimple-match.cc", __LINE__3747);
3748	{
3749	res_ops[0] = captures[0];
3750	res_ops[1] = captures[1];
3751	res_ops[2] = captures[2];
3752	return true;
3753	}
3754	next_after_fail107:;
3755	}
3756	}
3757	}
3758	break;
3759	}
3760	default:;
3761	}
3762	break;
3763	}
3764	default:;
3765	}
3766	{
3767	tree _q31_pops[1];
3768	if (gimple_nop_convert (_q31, _q31_pops, valueize))
3769	{
3770	tree _q50 = _q31_pops[0];
3771	switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
3772	{
3773	case SSA_NAME:
3774	if (gimple *_d4 = get_def (valueize, _q50))
3775	{
3776	if (gassign _a4 = dyn_cast <gassign > (_d4))
3777	switch (gimple_assign_rhs_code (_a4))
3778	{
3779	case LSHIFT_EXPR:
3780	{
3781	tree _q60 = gimple_assign_rhs1 (_a4);
3782	_q60 = do_valueize (valueize, _q60);
3783	tree _q61 = gimple_assign_rhs2 (_a4);
3784	_q61 = do_valueize (valueize, _q61);
3785	if (integer_onep (_q60))
3786	{
3787	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3788	{
3789	case SSA_NAME:
3790	if (gimple *_d5 = get_def (valueize, _p1))
3791	{
3792	if (gassign _a5 = dyn_cast <gassign > (_d5))
3793	switch (gimple_assign_rhs_code (_a5))
3794	{
3795	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
3796	{
3797	tree _q100 = gimple_assign_rhs1 (_a5);
3798	_q100 = do_valueize (valueize, _q100);
3799	if ((_q100 == _q50 && ! TREE_SIDE_EFFECTS (_q100)((non_type_check ((_q100), "gimple-match.cc", 3799, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q100, _q50, 0) && types_match (_q100, _q50)))
3800	{
3801	{
3802	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3803	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
3804	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3805	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3805 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3805, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3805, __FUNCTION__))-> type_common.precision)
3806	)
3807	{
3808	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__3808);
3809	{
3810	res_ops[0] = captures[0];
3811	res_ops[1] = captures[0];
3812	res_ops[2] = captures[1];
3813	return true;
3814	}
3815	next_after_fail108:;
3816	}
3817	}
3818	}
3819	break;
3820	}
3821	default:;
3822	}
3823	}
3824	break;
3825	default:;
3826	}
3827	if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 3827, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
3828	{
3829	{
3830	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3831	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
3832	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3833	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3833 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3833, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3833, __FUNCTION__))-> type_common.precision)
3834	)
3835	{
3836	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__3836);
3837	{
3838	res_ops[0] = captures[0];
3839	res_ops[1] = captures[0];
3840	res_ops[2] = captures[1];
3841	return true;
3842	}
3843	next_after_fail109:;
3844	}
3845	}
3846	}
3847	}
3848	break;
3849	}
3850	default:;
3851	}
3852	}
3853	break;
3854	default:;
3855	}
3856	}
3857	}
3858	}
3859	break;
3860	case CFN_BUILT_IN_ATOMIC_XOR_FETCH_4:
3861	if (gimple_call_num_args (_c3) == 3)
3862	{
3863	tree _q30 = gimple_call_arg (_c3, 0);
3864	_q30 = do_valueize (valueize, _q30);
3865	tree _q31 = gimple_call_arg (_c3, 1);
3866	_q31 = do_valueize (valueize, _q31);
3867	tree _q32 = gimple_call_arg (_c3, 2);
3868	_q32 = do_valueize (valueize, _q32);
3869	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
3870	{
3871	case SSA_NAME:
3872	if (gimple *_d4 = get_def (valueize, _q31))
3873	{
3874	if (gassign _a4 = dyn_cast <gassign > (_d4))
3875	switch (gimple_assign_rhs_code (_a4))
3876	{
3877	case LSHIFT_EXPR:
3878	{
3879	tree _q50 = gimple_assign_rhs1 (_a4);
3880	_q50 = do_valueize (valueize, _q50);
3881	tree _q51 = gimple_assign_rhs2 (_a4);
3882	_q51 = do_valueize (valueize, _q51);
3883	if (integer_onep (_q50))
3884	{
3885	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3886	{
3887	case SSA_NAME:
3888	if (gimple *_d5 = get_def (valueize, _p1))
3889	{
3890	if (gassign _a5 = dyn_cast <gassign > (_d5))
3891	switch (gimple_assign_rhs_code (_a5))
3892	{
3893	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
3894	{
3895	tree _q90 = gimple_assign_rhs1 (_a5);
3896	_q90 = do_valueize (valueize, _q90);
3897	if ((_q90 == _q31 && ! TREE_SIDE_EFFECTS (_q90)((non_type_check ((_q90), "gimple-match.cc", 3897, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q90, _q31, 0) && types_match (_q90, _q31)))
3898	{
3899	{
3900	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3901	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
3902	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3903	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3903 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3903, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3903, __FUNCTION__))-> type_common.precision)
3904	)
3905	{
3906	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__3906);
3907	{
3908	res_ops[0] = captures[0];
3909	res_ops[1] = captures[0];
3910	res_ops[2] = captures[1];
3911	return true;
3912	}
3913	next_after_fail110:;
3914	}
3915	}
3916	}
3917	break;
3918	}
3919	default:;
3920	}
3921	}
3922	break;
3923	default:;
3924	}
3925	if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 3925, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
3926	{
3927	{
3928	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3929	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
3930	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3931	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3931 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3931, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3931, __FUNCTION__))-> type_common.precision)
3932	)
3933	{
3934	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__3934);
3935	{
3936	res_ops[0] = captures[0];
3937	res_ops[1] = captures[0];
3938	res_ops[2] = captures[1];
3939	return true;
3940	}
3941	next_after_fail111:;
3942	}
3943	}
3944	}
3945	}
3946	break;
3947	}
3948	default:;
3949	}
3950	}
3951	break;
3952	case INTEGER_CST:
3953	{
3954	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3955	{
3956	case INTEGER_CST:
3957	{
3958	{
3959	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3960	tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
3961	{
3962	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3963	int ibit = tree_log2 (captures[0]);
3964	int ibit2 = tree_log2 (captures[1]);
3965	/* #line 4470 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3966	if (ibit == ibit2
3967	&& ibit >= 0
3968	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 3968 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 3968, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 3968, __FUNCTION__))-> type_common.precision)
3969	)
3970	{
3971	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4463, __FILE__"gimple-match.cc", __LINE__3971);
3972	{
3973	res_ops[0] = captures[0];
3974	res_ops[1] = captures[1];
3975	res_ops[2] = captures[2];
3976	return true;
3977	}
3978	next_after_fail112:;
3979	}
3980	}
3981	}
3982	break;
3983	}
3984	default:;
3985	}
3986	break;
3987	}
3988	default:;
3989	}
3990	{
3991	tree _q31_pops[1];
3992	if (gimple_nop_convert (_q31, _q31_pops, valueize))
3993	{
3994	tree _q50 = _q31_pops[0];
3995	switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
3996	{
3997	case SSA_NAME:
3998	if (gimple *_d4 = get_def (valueize, _q50))
3999	{
4000	if (gassign _a4 = dyn_cast <gassign > (_d4))
4001	switch (gimple_assign_rhs_code (_a4))
4002	{
4003	case LSHIFT_EXPR:
4004	{
4005	tree _q60 = gimple_assign_rhs1 (_a4);
4006	_q60 = do_valueize (valueize, _q60);
4007	tree _q61 = gimple_assign_rhs2 (_a4);
4008	_q61 = do_valueize (valueize, _q61);
4009	if (integer_onep (_q60))
4010	{
4011	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4012	{
4013	case SSA_NAME:
4014	if (gimple *_d5 = get_def (valueize, _p1))
4015	{
4016	if (gassign _a5 = dyn_cast <gassign > (_d5))
4017	switch (gimple_assign_rhs_code (_a5))
4018	{
4019	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
4020	{
4021	tree _q100 = gimple_assign_rhs1 (_a5);
4022	_q100 = do_valueize (valueize, _q100);
4023	if ((_q100 == _q50 && ! TREE_SIDE_EFFECTS (_q100)((non_type_check ((_q100), "gimple-match.cc", 4023, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q100, _q50, 0) && types_match (_q100, _q50)))
4024	{
4025	{
4026	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4027	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
4028	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4029	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4029 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4029, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4029, __FUNCTION__))-> type_common.precision)
4030	)
4031	{
4032	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__4032);
4033	{
4034	res_ops[0] = captures[0];
4035	res_ops[1] = captures[0];
4036	res_ops[2] = captures[1];
4037	return true;
4038	}
4039	next_after_fail113:;
4040	}
4041	}
4042	}
4043	break;
4044	}
4045	default:;
4046	}
4047	}
4048	break;
4049	default:;
4050	}
4051	if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 4051, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
4052	{
4053	{
4054	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4055	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
4056	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4057	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4057 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4057, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4057, __FUNCTION__))-> type_common.precision)
4058	)
4059	{
4060	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__4060);
4061	{
4062	res_ops[0] = captures[0];
4063	res_ops[1] = captures[0];
4064	res_ops[2] = captures[1];
4065	return true;
4066	}
4067	next_after_fail114:;
4068	}
4069	}
4070	}
4071	}
4072	break;
4073	}
4074	default:;
4075	}
4076	}
4077	break;
4078	default:;
4079	}
4080	}
4081	}
4082	}
4083	break;
4084	case CFN_BUILT_IN_ATOMIC_XOR_FETCH_8:
4085	if (gimple_call_num_args (_c3) == 3)
4086	{
4087	tree _q30 = gimple_call_arg (_c3, 0);
4088	_q30 = do_valueize (valueize, _q30);
4089	tree _q31 = gimple_call_arg (_c3, 1);
4090	_q31 = do_valueize (valueize, _q31);
4091	tree _q32 = gimple_call_arg (_c3, 2);
4092	_q32 = do_valueize (valueize, _q32);
4093	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4094	{
4095	case SSA_NAME:
4096	if (gimple *_d4 = get_def (valueize, _q31))
4097	{
4098	if (gassign _a4 = dyn_cast <gassign > (_d4))
4099	switch (gimple_assign_rhs_code (_a4))
4100	{
4101	case LSHIFT_EXPR:
4102	{
4103	tree _q50 = gimple_assign_rhs1 (_a4);
4104	_q50 = do_valueize (valueize, _q50);
4105	tree _q51 = gimple_assign_rhs2 (_a4);
4106	_q51 = do_valueize (valueize, _q51);
4107	if (integer_onep (_q50))
4108	{
4109	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4110	{
4111	case SSA_NAME:
4112	if (gimple *_d5 = get_def (valueize, _p1))
4113	{
4114	if (gassign _a5 = dyn_cast <gassign > (_d5))
4115	switch (gimple_assign_rhs_code (_a5))
4116	{
4117	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
4118	{
4119	tree _q90 = gimple_assign_rhs1 (_a5);
4120	_q90 = do_valueize (valueize, _q90);
4121	if ((_q90 == _q31 && ! TREE_SIDE_EFFECTS (_q90)((non_type_check ((_q90), "gimple-match.cc", 4121, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q90, _q31, 0) && types_match (_q90, _q31)))
4122	{
4123	{
4124	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4125	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
4126	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4127	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4127 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4127, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4127, __FUNCTION__))-> type_common.precision)
4128	)
4129	{
4130	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__4130);
4131	{
4132	res_ops[0] = captures[0];
4133	res_ops[1] = captures[0];
4134	res_ops[2] = captures[1];
4135	return true;
4136	}
4137	next_after_fail115:;
4138	}
4139	}
4140	}
4141	break;
4142	}
4143	default:;
4144	}
4145	}
4146	break;
4147	default:;
4148	}
4149	if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 4149, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
4150	{
4151	{
4152	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4153	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
4154	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4155	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4155 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4155, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4155, __FUNCTION__))-> type_common.precision)
4156	)
4157	{
4158	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__4158);
4159	{
4160	res_ops[0] = captures[0];
4161	res_ops[1] = captures[0];
4162	res_ops[2] = captures[1];
4163	return true;
4164	}
4165	next_after_fail116:;
4166	}
4167	}
4168	}
4169	}
4170	break;
4171	}
4172	default:;
4173	}
4174	}
4175	break;
4176	case INTEGER_CST:
4177	{
4178	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4179	{
4180	case INTEGER_CST:
4181	{
4182	{
4183	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4184	tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
4185	{
4186	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4187	int ibit = tree_log2 (captures[0]);
4188	int ibit2 = tree_log2 (captures[1]);
4189	/* #line 4470 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4190	if (ibit == ibit2
4191	&& ibit >= 0
4192	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4192 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4192, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4192, __FUNCTION__))-> type_common.precision)
4193	)
4194	{
4195	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4463, __FILE__"gimple-match.cc", __LINE__4195);
4196	{
4197	res_ops[0] = captures[0];
4198	res_ops[1] = captures[1];
4199	res_ops[2] = captures[2];
4200	return true;
4201	}
4202	next_after_fail117:;
4203	}
4204	}
4205	}
4206	break;
4207	}
4208	default:;
4209	}
4210	break;
4211	}
4212	default:;
4213	}
4214	{
4215	tree _q31_pops[1];
4216	if (gimple_nop_convert (_q31, _q31_pops, valueize))
4217	{
4218	tree _q50 = _q31_pops[0];
4219	switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
4220	{
4221	case SSA_NAME:
4222	if (gimple *_d4 = get_def (valueize, _q50))
4223	{
4224	if (gassign _a4 = dyn_cast <gassign > (_d4))
4225	switch (gimple_assign_rhs_code (_a4))
4226	{
4227	case LSHIFT_EXPR:
4228	{
4229	tree _q60 = gimple_assign_rhs1 (_a4);
4230	_q60 = do_valueize (valueize, _q60);
4231	tree _q61 = gimple_assign_rhs2 (_a4);
4232	_q61 = do_valueize (valueize, _q61);
4233	if (integer_onep (_q60))
4234	{
4235	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4236	{
4237	case SSA_NAME:
4238	if (gimple *_d5 = get_def (valueize, _p1))
4239	{
4240	if (gassign _a5 = dyn_cast <gassign > (_d5))
4241	switch (gimple_assign_rhs_code (_a5))
4242	{
4243	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
4244	{
4245	tree _q100 = gimple_assign_rhs1 (_a5);
4246	_q100 = do_valueize (valueize, _q100);
4247	if ((_q100 == _q50 && ! TREE_SIDE_EFFECTS (_q100)((non_type_check ((_q100), "gimple-match.cc", 4247, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q100, _q50, 0) && types_match (_q100, _q50)))
4248	{
4249	{
4250	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4251	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
4252	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4253	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4253 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4253, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4253, __FUNCTION__))-> type_common.precision)
4254	)
4255	{
4256	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__4256);
4257	{
4258	res_ops[0] = captures[0];
4259	res_ops[1] = captures[0];
4260	res_ops[2] = captures[1];
4261	return true;
4262	}
4263	next_after_fail118:;
4264	}
4265	}
4266	}
4267	break;
4268	}
4269	default:;
4270	}
4271	}
4272	break;
4273	default:;
4274	}
4275	if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 4275, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
4276	{
4277	{
4278	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4279	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
4280	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4281	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4281 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4281, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4281, __FUNCTION__))-> type_common.precision)
4282	)
4283	{
4284	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__4284);
4285	{
4286	res_ops[0] = captures[0];
4287	res_ops[1] = captures[0];
4288	res_ops[2] = captures[1];
4289	return true;
4290	}
4291	next_after_fail119:;
4292	}
4293	}
4294	}
4295	}
4296	break;
4297	}
4298	default:;
4299	}
4300	}
4301	break;
4302	default:;
4303	}
4304	}
4305	}
4306	}
4307	break;
4308	case CFN_BUILT_IN_ATOMIC_XOR_FETCH_16:
4309	if (gimple_call_num_args (_c3) == 3)
4310	{
4311	tree _q30 = gimple_call_arg (_c3, 0);
4312	_q30 = do_valueize (valueize, _q30);
4313	tree _q31 = gimple_call_arg (_c3, 1);
4314	_q31 = do_valueize (valueize, _q31);
4315	tree _q32 = gimple_call_arg (_c3, 2);
4316	_q32 = do_valueize (valueize, _q32);
4317	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4318	{
4319	case SSA_NAME:
4320	if (gimple *_d4 = get_def (valueize, _q31))
4321	{
4322	if (gassign _a4 = dyn_cast <gassign > (_d4))
4323	switch (gimple_assign_rhs_code (_a4))
4324	{
4325	case LSHIFT_EXPR:
4326	{
4327	tree _q50 = gimple_assign_rhs1 (_a4);
4328	_q50 = do_valueize (valueize, _q50);
4329	tree _q51 = gimple_assign_rhs2 (_a4);
4330	_q51 = do_valueize (valueize, _q51);
4331	if (integer_onep (_q50))
4332	{
4333	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4334	{
4335	case SSA_NAME:
4336	if (gimple *_d5 = get_def (valueize, _p1))
4337	{
4338	if (gassign _a5 = dyn_cast <gassign > (_d5))
4339	switch (gimple_assign_rhs_code (_a5))
4340	{
4341	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
4342	{
4343	tree _q90 = gimple_assign_rhs1 (_a5);
4344	_q90 = do_valueize (valueize, _q90);
4345	if ((_q90 == _q31 && ! TREE_SIDE_EFFECTS (_q90)((non_type_check ((_q90), "gimple-match.cc", 4345, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q90, _q31, 0) && types_match (_q90, _q31)))
4346	{
4347	{
4348	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4349	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
4350	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4351	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4351 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4351, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4351, __FUNCTION__))-> type_common.precision)
4352	)
4353	{
4354	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__4354);
4355	{
4356	res_ops[0] = captures[0];
4357	res_ops[1] = captures[0];
4358	res_ops[2] = captures[1];
4359	return true;
4360	}
4361	next_after_fail120:;
4362	}
4363	}
4364	}
4365	break;
4366	}
4367	default:;
4368	}
4369	}
4370	break;
4371	default:;
4372	}
4373	if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 4373, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
4374	{
4375	{
4376	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4377	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p0, _q30, _q50, _q51, _q32 };
4378	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4379	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4379 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4379, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4379, __FUNCTION__))-> type_common.precision)
4380	)
4381	{
4382	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__4382);
4383	{
4384	res_ops[0] = captures[0];
4385	res_ops[1] = captures[0];
4386	res_ops[2] = captures[1];
4387	return true;
4388	}
4389	next_after_fail121:;
4390	}
4391	}
4392	}
4393	}
4394	break;
4395	}
4396	default:;
4397	}
4398	}
4399	break;
4400	case INTEGER_CST:
4401	{
4402	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4403	{
4404	case INTEGER_CST:
4405	{
4406	{
4407	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4408	tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
4409	{
4410	/* #line 4466 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4411	int ibit = tree_log2 (captures[0]);
4412	int ibit2 = tree_log2 (captures[1]);
4413	/* #line 4470 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4414	if (ibit == ibit2
4415	&& ibit >= 0
4416	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4416 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4416, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4416, __FUNCTION__))-> type_common.precision)
4417	)
4418	{
4419	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4463, __FILE__"gimple-match.cc", __LINE__4419);
4420	{
4421	res_ops[0] = captures[0];
4422	res_ops[1] = captures[1];
4423	res_ops[2] = captures[2];
4424	return true;
4425	}
4426	next_after_fail122:;
4427	}
4428	}
4429	}
4430	break;
4431	}
4432	default:;
4433	}
4434	break;
4435	}
4436	default:;
4437	}
4438	{
4439	tree _q31_pops[1];
4440	if (gimple_nop_convert (_q31, _q31_pops, valueize))
4441	{
4442	tree _q50 = _q31_pops[0];
4443	switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
4444	{
4445	case SSA_NAME:
4446	if (gimple *_d4 = get_def (valueize, _q50))
4447	{
4448	if (gassign _a4 = dyn_cast <gassign > (_d4))
4449	switch (gimple_assign_rhs_code (_a4))
4450	{
4451	case LSHIFT_EXPR:
4452	{
4453	tree _q60 = gimple_assign_rhs1 (_a4);
4454	_q60 = do_valueize (valueize, _q60);
4455	tree _q61 = gimple_assign_rhs2 (_a4);
4456	_q61 = do_valueize (valueize, _q61);
4457	if (integer_onep (_q60))
4458	{
4459	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4460	{
4461	case SSA_NAME:
4462	if (gimple *_d5 = get_def (valueize, _p1))
4463	{
4464	if (gassign _a5 = dyn_cast <gassign > (_d5))
4465	switch (gimple_assign_rhs_code (_a5))
4466	{
4467	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
4468	{
4469	tree _q100 = gimple_assign_rhs1 (_a5);
4470	_q100 = do_valueize (valueize, _q100);
4471	if ((_q100 == _q50 && ! TREE_SIDE_EFFECTS (_q100)((non_type_check ((_q100), "gimple-match.cc", 4471, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q100, _q50, 0) && types_match (_q100, _q50)))
4472	{
4473	{
4474	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4475	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
4476	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4477	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4477 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4477, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4477, __FUNCTION__))-> type_common.precision)
4478	)
4479	{
4480	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__4480);
4481	{
4482	res_ops[0] = captures[0];
4483	res_ops[1] = captures[0];
4484	res_ops[2] = captures[1];
4485	return true;
4486	}
4487	next_after_fail123:;
4488	}
4489	}
4490	}
4491	break;
4492	}
4493	default:;
4494	}
4495	}
4496	break;
4497	default:;
4498	}
4499	if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.cc", 4499, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
4500	{
4501	{
4502	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4503	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
4504	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4505	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4505 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4505, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4505, __FUNCTION__))-> type_common.precision)
4506	)
4507	{
4508	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__4508);
4509	{
4510	res_ops[0] = captures[0];
4511	res_ops[1] = captures[0];
4512	res_ops[2] = captures[1];
4513	return true;
4514	}
4515	next_after_fail124:;
4516	}
4517	}
4518	}
4519	}
4520	break;
4521	}
4522	default:;
4523	}
4524	}
4525	break;
4526	default:;
4527	}
4528	}
4529	}
4530	}
4531	break;
4532	case CFN_BUILT_IN_SYNC_FETCH_AND_OR_1:
4533	if (gimple_call_num_args (_c3) == 2)
4534	{
4535	tree _q30 = gimple_call_arg (_c3, 0);
4536	_q30 = do_valueize (valueize, _q30);
4537	tree _q31 = gimple_call_arg (_c3, 1);
4538	_q31 = do_valueize (valueize, _q31);
4539	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4540	{
4541	case INTEGER_CST:
4542	{
4543	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4544	{
4545	case INTEGER_CST:
4546	{
4547	{
4548	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4549	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
4550	{
4551	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4552	int ibit = tree_log2 (captures[0]);
4553	int ibit2 = tree_log2 (captures[1]);
4554	/* #line 4481 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4555	if (ibit == ibit2
4556	&& ibit >= 0
4557	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4557 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4557, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4557, __FUNCTION__))-> type_common.precision)
4558	)
4559	{
4560	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4474, __FILE__"gimple-match.cc", __LINE__4560);
4561	{
4562	res_ops[0] = captures[0];
4563	res_ops[1] = captures[1];
4564	res_ops[2] = captures[2];
4565	return true;
4566	}
4567	next_after_fail125:;
4568	}
4569	}
4570	}
4571	break;
4572	}
4573	default:;
4574	}
4575	break;
4576	}
4577	default:;
4578	}
4579	}
4580	break;
4581	case CFN_BUILT_IN_SYNC_FETCH_AND_OR_2:
4582	if (gimple_call_num_args (_c3) == 2)
4583	{
4584	tree _q30 = gimple_call_arg (_c3, 0);
4585	_q30 = do_valueize (valueize, _q30);
4586	tree _q31 = gimple_call_arg (_c3, 1);
4587	_q31 = do_valueize (valueize, _q31);
4588	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4589	{
4590	case INTEGER_CST:
4591	{
4592	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4593	{
4594	case INTEGER_CST:
4595	{
4596	{
4597	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4598	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
4599	{
4600	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4601	int ibit = tree_log2 (captures[0]);
4602	int ibit2 = tree_log2 (captures[1]);
4603	/* #line 4481 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4604	if (ibit == ibit2
4605	&& ibit >= 0
4606	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4606 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4606, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4606, __FUNCTION__))-> type_common.precision)
4607	)
4608	{
4609	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4474, __FILE__"gimple-match.cc", __LINE__4609);
4610	{
4611	res_ops[0] = captures[0];
4612	res_ops[1] = captures[1];
4613	res_ops[2] = captures[2];
4614	return true;
4615	}
4616	next_after_fail126:;
4617	}
4618	}
4619	}
4620	break;
4621	}
4622	default:;
4623	}
4624	break;
4625	}
4626	default:;
4627	}
4628	}
4629	break;
4630	case CFN_BUILT_IN_SYNC_FETCH_AND_OR_4:
4631	if (gimple_call_num_args (_c3) == 2)
4632	{
4633	tree _q30 = gimple_call_arg (_c3, 0);
4634	_q30 = do_valueize (valueize, _q30);
4635	tree _q31 = gimple_call_arg (_c3, 1);
4636	_q31 = do_valueize (valueize, _q31);
4637	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4638	{
4639	case INTEGER_CST:
4640	{
4641	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4642	{
4643	case INTEGER_CST:
4644	{
4645	{
4646	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4647	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
4648	{
4649	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4650	int ibit = tree_log2 (captures[0]);
4651	int ibit2 = tree_log2 (captures[1]);
4652	/* #line 4481 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4653	if (ibit == ibit2
4654	&& ibit >= 0
4655	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4655 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4655, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4655, __FUNCTION__))-> type_common.precision)
4656	)
4657	{
4658	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4474, __FILE__"gimple-match.cc", __LINE__4658);
4659	{
4660	res_ops[0] = captures[0];
4661	res_ops[1] = captures[1];
4662	res_ops[2] = captures[2];
4663	return true;
4664	}
4665	next_after_fail127:;
4666	}
4667	}
4668	}
4669	break;
4670	}
4671	default:;
4672	}
4673	break;
4674	}
4675	default:;
4676	}
4677	}
4678	break;
4679	case CFN_BUILT_IN_SYNC_FETCH_AND_OR_8:
4680	if (gimple_call_num_args (_c3) == 2)
4681	{
4682	tree _q30 = gimple_call_arg (_c3, 0);
4683	_q30 = do_valueize (valueize, _q30);
4684	tree _q31 = gimple_call_arg (_c3, 1);
4685	_q31 = do_valueize (valueize, _q31);
4686	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4687	{
4688	case INTEGER_CST:
4689	{
4690	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4691	{
4692	case INTEGER_CST:
4693	{
4694	{
4695	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4696	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
4697	{
4698	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4699	int ibit = tree_log2 (captures[0]);
4700	int ibit2 = tree_log2 (captures[1]);
4701	/* #line 4481 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4702	if (ibit == ibit2
4703	&& ibit >= 0
4704	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4704 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4704, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4704, __FUNCTION__))-> type_common.precision)
4705	)
4706	{
4707	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4474, __FILE__"gimple-match.cc", __LINE__4707);
4708	{
4709	res_ops[0] = captures[0];
4710	res_ops[1] = captures[1];
4711	res_ops[2] = captures[2];
4712	return true;
4713	}
4714	next_after_fail128:;
4715	}
4716	}
4717	}
4718	break;
4719	}
4720	default:;
4721	}
4722	break;
4723	}
4724	default:;
4725	}
4726	}
4727	break;
4728	case CFN_BUILT_IN_SYNC_FETCH_AND_OR_16:
4729	if (gimple_call_num_args (_c3) == 2)
4730	{
4731	tree _q30 = gimple_call_arg (_c3, 0);
4732	_q30 = do_valueize (valueize, _q30);
4733	tree _q31 = gimple_call_arg (_c3, 1);
4734	_q31 = do_valueize (valueize, _q31);
4735	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4736	{
4737	case INTEGER_CST:
4738	{
4739	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4740	{
4741	case INTEGER_CST:
4742	{
4743	{
4744	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4745	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
4746	{
4747	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4748	int ibit = tree_log2 (captures[0]);
4749	int ibit2 = tree_log2 (captures[1]);
4750	/* #line 4481 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4751	if (ibit == ibit2
4752	&& ibit >= 0
4753	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4753 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4753, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4753, __FUNCTION__))-> type_common.precision)
4754	)
4755	{
4756	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4474, __FILE__"gimple-match.cc", __LINE__4756);
4757	{
4758	res_ops[0] = captures[0];
4759	res_ops[1] = captures[1];
4760	res_ops[2] = captures[2];
4761	return true;
4762	}
4763	next_after_fail129:;
4764	}
4765	}
4766	}
4767	break;
4768	}
4769	default:;
4770	}
4771	break;
4772	}
4773	default:;
4774	}
4775	}
4776	break;
4777	case CFN_BUILT_IN_SYNC_FETCH_AND_XOR_1:
4778	if (gimple_call_num_args (_c3) == 2)
4779	{
4780	tree _q30 = gimple_call_arg (_c3, 0);
4781	_q30 = do_valueize (valueize, _q30);
4782	tree _q31 = gimple_call_arg (_c3, 1);
4783	_q31 = do_valueize (valueize, _q31);
4784	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4785	{
4786	case INTEGER_CST:
4787	{
4788	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4789	{
4790	case INTEGER_CST:
4791	{
4792	{
4793	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4794	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
4795	{
4796	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4797	int ibit = tree_log2 (captures[0]);
4798	int ibit2 = tree_log2 (captures[1]);
4799	/* #line 4481 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4800	if (ibit == ibit2
4801	&& ibit >= 0
4802	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4802 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4802, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4802, __FUNCTION__))-> type_common.precision)
4803	)
4804	{
4805	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4474, __FILE__"gimple-match.cc", __LINE__4805);
4806	{
4807	res_ops[0] = captures[0];
4808	res_ops[1] = captures[1];
4809	res_ops[2] = captures[2];
4810	return true;
4811	}
4812	next_after_fail130:;
4813	}
4814	}
4815	}
4816	break;
4817	}
4818	default:;
4819	}
4820	break;
4821	}
4822	default:;
4823	}
4824	}
4825	break;
4826	case CFN_BUILT_IN_SYNC_FETCH_AND_XOR_2:
4827	if (gimple_call_num_args (_c3) == 2)
4828	{
4829	tree _q30 = gimple_call_arg (_c3, 0);
4830	_q30 = do_valueize (valueize, _q30);
4831	tree _q31 = gimple_call_arg (_c3, 1);
4832	_q31 = do_valueize (valueize, _q31);
4833	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4834	{
4835	case INTEGER_CST:
4836	{
4837	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4838	{
4839	case INTEGER_CST:
4840	{
4841	{
4842	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4843	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
4844	{
4845	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4846	int ibit = tree_log2 (captures[0]);
4847	int ibit2 = tree_log2 (captures[1]);
4848	/* #line 4481 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4849	if (ibit == ibit2
4850	&& ibit >= 0
4851	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4851 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4851, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4851, __FUNCTION__))-> type_common.precision)
4852	)
4853	{
4854	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4474, __FILE__"gimple-match.cc", __LINE__4854);
4855	{
4856	res_ops[0] = captures[0];
4857	res_ops[1] = captures[1];
4858	res_ops[2] = captures[2];
4859	return true;
4860	}
4861	next_after_fail131:;
4862	}
4863	}
4864	}
4865	break;
4866	}
4867	default:;
4868	}
4869	break;
4870	}
4871	default:;
4872	}
4873	}
4874	break;
4875	case CFN_BUILT_IN_SYNC_FETCH_AND_XOR_4:
4876	if (gimple_call_num_args (_c3) == 2)
4877	{
4878	tree _q30 = gimple_call_arg (_c3, 0);
4879	_q30 = do_valueize (valueize, _q30);
4880	tree _q31 = gimple_call_arg (_c3, 1);
4881	_q31 = do_valueize (valueize, _q31);
4882	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4883	{
4884	case INTEGER_CST:
4885	{
4886	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4887	{
4888	case INTEGER_CST:
4889	{
4890	{
4891	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4892	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
4893	{
4894	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4895	int ibit = tree_log2 (captures[0]);
4896	int ibit2 = tree_log2 (captures[1]);
4897	/* #line 4481 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4898	if (ibit == ibit2
4899	&& ibit >= 0
4900	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4900 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4900, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4900, __FUNCTION__))-> type_common.precision)
4901	)
4902	{
4903	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4474, __FILE__"gimple-match.cc", __LINE__4903);
4904	{
4905	res_ops[0] = captures[0];
4906	res_ops[1] = captures[1];
4907	res_ops[2] = captures[2];
4908	return true;
4909	}
4910	next_after_fail132:;
4911	}
4912	}
4913	}
4914	break;
4915	}
4916	default:;
4917	}
4918	break;
4919	}
4920	default:;
4921	}
4922	}
4923	break;
4924	case CFN_BUILT_IN_SYNC_FETCH_AND_XOR_8:
4925	if (gimple_call_num_args (_c3) == 2)
4926	{
4927	tree _q30 = gimple_call_arg (_c3, 0);
4928	_q30 = do_valueize (valueize, _q30);
4929	tree _q31 = gimple_call_arg (_c3, 1);
4930	_q31 = do_valueize (valueize, _q31);
4931	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4932	{
4933	case INTEGER_CST:
4934	{
4935	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4936	{
4937	case INTEGER_CST:
4938	{
4939	{
4940	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4941	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
4942	{
4943	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4944	int ibit = tree_log2 (captures[0]);
4945	int ibit2 = tree_log2 (captures[1]);
4946	/* #line 4481 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4947	if (ibit == ibit2
4948	&& ibit >= 0
4949	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4949 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4949, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4949, __FUNCTION__))-> type_common.precision)
4950	)
4951	{
4952	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4474, __FILE__"gimple-match.cc", __LINE__4952);
4953	{
4954	res_ops[0] = captures[0];
4955	res_ops[1] = captures[1];
4956	res_ops[2] = captures[2];
4957	return true;
4958	}
4959	next_after_fail133:;
4960	}
4961	}
4962	}
4963	break;
4964	}
4965	default:;
4966	}
4967	break;
4968	}
4969	default:;
4970	}
4971	}
4972	break;
4973	case CFN_BUILT_IN_SYNC_FETCH_AND_XOR_16:
4974	if (gimple_call_num_args (_c3) == 2)
4975	{
4976	tree _q30 = gimple_call_arg (_c3, 0);
4977	_q30 = do_valueize (valueize, _q30);
4978	tree _q31 = gimple_call_arg (_c3, 1);
4979	_q31 = do_valueize (valueize, _q31);
4980	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4981	{
4982	case INTEGER_CST:
4983	{
4984	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4985	{
4986	case INTEGER_CST:
4987	{
4988	{
4989	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4990	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
4991	{
4992	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4993	int ibit = tree_log2 (captures[0]);
4994	int ibit2 = tree_log2 (captures[1]);
4995	/* #line 4481 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4996	if (ibit == ibit2
4997	&& ibit >= 0
4998	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 4998 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 4998, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 4998, __FUNCTION__))-> type_common.precision)
4999	)
5000	{
5001	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4474, __FILE__"gimple-match.cc", __LINE__5001);
5002	{
5003	res_ops[0] = captures[0];
5004	res_ops[1] = captures[1];
5005	res_ops[2] = captures[2];
5006	return true;
5007	}
5008	next_after_fail134:;
5009	}
5010	}
5011	}
5012	break;
5013	}
5014	default:;
5015	}
5016	break;
5017	}
5018	default:;
5019	}
5020	}
5021	break;
5022	case CFN_BUILT_IN_SYNC_XOR_AND_FETCH_1:
5023	if (gimple_call_num_args (_c3) == 2)
5024	{
5025	tree _q30 = gimple_call_arg (_c3, 0);
5026	_q30 = do_valueize (valueize, _q30);
5027	tree _q31 = gimple_call_arg (_c3, 1);
5028	_q31 = do_valueize (valueize, _q31);
5029	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5030	{
5031	case INTEGER_CST:
5032	{
5033	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5034	{
5035	case INTEGER_CST:
5036	{
5037	{
5038	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5039	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5040	{
5041	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5042	int ibit = tree_log2 (captures[0]);
5043	int ibit2 = tree_log2 (captures[1]);
5044	/* #line 4481 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5045	if (ibit == ibit2
5046	&& ibit >= 0
5047	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 5047 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 5047, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 5047, __FUNCTION__))-> type_common.precision)
5048	)
5049	{
5050	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4474, __FILE__"gimple-match.cc", __LINE__5050);
5051	{
5052	res_ops[0] = captures[0];
5053	res_ops[1] = captures[1];
5054	res_ops[2] = captures[2];
5055	return true;
5056	}
5057	next_after_fail135:;
5058	}
5059	}
5060	}
5061	break;
5062	}
5063	default:;
5064	}
5065	break;
5066	}
5067	default:;
5068	}
5069	}
5070	break;
5071	case CFN_BUILT_IN_SYNC_XOR_AND_FETCH_2:
5072	if (gimple_call_num_args (_c3) == 2)
5073	{
5074	tree _q30 = gimple_call_arg (_c3, 0);
5075	_q30 = do_valueize (valueize, _q30);
5076	tree _q31 = gimple_call_arg (_c3, 1);
5077	_q31 = do_valueize (valueize, _q31);
5078	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5079	{
5080	case INTEGER_CST:
5081	{
5082	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5083	{
5084	case INTEGER_CST:
5085	{
5086	{
5087	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5088	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5089	{
5090	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5091	int ibit = tree_log2 (captures[0]);
5092	int ibit2 = tree_log2 (captures[1]);
5093	/* #line 4481 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5094	if (ibit == ibit2
5095	&& ibit >= 0
5096	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 5096 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 5096, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 5096, __FUNCTION__))-> type_common.precision)
5097	)
5098	{
5099	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4474, __FILE__"gimple-match.cc", __LINE__5099);
5100	{
5101	res_ops[0] = captures[0];
5102	res_ops[1] = captures[1];
5103	res_ops[2] = captures[2];
5104	return true;
5105	}
5106	next_after_fail136:;
5107	}
5108	}
5109	}
5110	break;
5111	}
5112	default:;
5113	}
5114	break;
5115	}
5116	default:;
5117	}
5118	}
5119	break;
5120	case CFN_BUILT_IN_SYNC_XOR_AND_FETCH_4:
5121	if (gimple_call_num_args (_c3) == 2)
5122	{
5123	tree _q30 = gimple_call_arg (_c3, 0);
5124	_q30 = do_valueize (valueize, _q30);
5125	tree _q31 = gimple_call_arg (_c3, 1);
5126	_q31 = do_valueize (valueize, _q31);
5127	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5128	{
5129	case INTEGER_CST:
5130	{
5131	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5132	{
5133	case INTEGER_CST:
5134	{
5135	{
5136	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5137	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5138	{
5139	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5140	int ibit = tree_log2 (captures[0]);
5141	int ibit2 = tree_log2 (captures[1]);
5142	/* #line 4481 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5143	if (ibit == ibit2
5144	&& ibit >= 0
5145	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 5145 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 5145, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 5145, __FUNCTION__))-> type_common.precision)
5146	)
5147	{
5148	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4474, __FILE__"gimple-match.cc", __LINE__5148);
5149	{
5150	res_ops[0] = captures[0];
5151	res_ops[1] = captures[1];
5152	res_ops[2] = captures[2];
5153	return true;
5154	}
5155	next_after_fail137:;
5156	}
5157	}
5158	}
5159	break;
5160	}
5161	default:;
5162	}
5163	break;
5164	}
5165	default:;
5166	}
5167	}
5168	break;
5169	case CFN_BUILT_IN_SYNC_XOR_AND_FETCH_8:
5170	if (gimple_call_num_args (_c3) == 2)
5171	{
5172	tree _q30 = gimple_call_arg (_c3, 0);
5173	_q30 = do_valueize (valueize, _q30);
5174	tree _q31 = gimple_call_arg (_c3, 1);
5175	_q31 = do_valueize (valueize, _q31);
5176	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5177	{
5178	case INTEGER_CST:
5179	{
5180	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5181	{
5182	case INTEGER_CST:
5183	{
5184	{
5185	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5186	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5187	{
5188	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5189	int ibit = tree_log2 (captures[0]);
5190	int ibit2 = tree_log2 (captures[1]);
5191	/* #line 4481 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5192	if (ibit == ibit2
5193	&& ibit >= 0
5194	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 5194 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 5194, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 5194, __FUNCTION__))-> type_common.precision)
5195	)
5196	{
5197	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4474, __FILE__"gimple-match.cc", __LINE__5197);
5198	{
5199	res_ops[0] = captures[0];
5200	res_ops[1] = captures[1];
5201	res_ops[2] = captures[2];
5202	return true;
5203	}
5204	next_after_fail138:;
5205	}
5206	}
5207	}
5208	break;
5209	}
5210	default:;
5211	}
5212	break;
5213	}
5214	default:;
5215	}
5216	}
5217	break;
5218	case CFN_BUILT_IN_SYNC_XOR_AND_FETCH_16:
5219	if (gimple_call_num_args (_c3) == 2)
5220	{
5221	tree _q30 = gimple_call_arg (_c3, 0);
5222	_q30 = do_valueize (valueize, _q30);
5223	tree _q31 = gimple_call_arg (_c3, 1);
5224	_q31 = do_valueize (valueize, _q31);
5225	switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5226	{
5227	case INTEGER_CST:
5228	{
5229	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5230	{
5231	case INTEGER_CST:
5232	{
5233	{
5234	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5235	tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5236	{
5237	/* #line 4477 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5238	int ibit = tree_log2 (captures[0]);
5239	int ibit2 = tree_log2 (captures[1]);
5240	/* #line 4481 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5241	if (ibit == ibit2
5242	&& ibit >= 0
5243	&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 5243 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 5243, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 5243, __FUNCTION__))-> type_common.precision)
5244	)
5245	{
5246	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4474, __FILE__"gimple-match.cc", __LINE__5246);
5247	{
5248	res_ops[0] = captures[0];
5249	res_ops[1] = captures[1];
5250	res_ops[2] = captures[2];
5251	return true;
5252	}
5253	next_after_fail139:;
5254	}
5255	}
5256	}
5257	break;
5258	}
5259	default:;
5260	}
5261	break;
5262	}
5263	default:;
5264	}
5265	}
5266	break;
5267	default:;
5268	}
5269	}
5270	break;
5271	default:;
5272	}
5273	switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5274	{
5275	case SSA_NAME:
5276	if (gimple *_d3 = get_def (valueize, _p1))
5277	{
5278	if (gassign _a3 = dyn_cast <gassign > (_d3))
5279	switch (gimple_assign_rhs_code (_a3))
5280	{
5281	CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
5282	{
5283	tree _q40 = gimple_assign_rhs1 (_a3);
5284	_q40 = do_valueize (valueize, _q40);
5285	switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
5286	{
5287	case SSA_NAME:
5288	if (gimple *_d4 = get_def (valueize, _q40))
5289	{
5290	if (gcall _c4 = dyn_cast <gcall > (_d4))
5291	switch (gimple_call_combined_fn (_c4))
5292	{
5293	case CFN_BUILT_IN_ATOMIC_FETCH_OR_1:
5294	if (gimple_call_num_args (_c4) == 3)
5295	{
5296	tree _q50 = gimple_call_arg (_c4, 0);
5297	_q50 = do_valueize (valueize, _q50);
5298	tree _q51 = gimple_call_arg (_c4, 1);
5299	_q51 = do_valueize (valueize, _q51);
5300	tree _q52 = gimple_call_arg (_c4, 2);
5301	_q52 = do_valueize (valueize, _q52);
5302	{
5303	tree _q51_pops[1];
5304	if (gimple_nop_convert (_q51, _q51_pops, valueize))
5305	{
5306	tree _q70 = _q51_pops[0];
5307	if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)((non_type_check ((_q70), "gimple-match.cc", 5307, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
5308	{
5309	switch (TREE_CODE (_q70)((enum tree_code) (_q70)->base.code))
5310	{
5311	case SSA_NAME:
5312	if (gimple *_d5 = get_def (valueize, _q70))
5313	{
5314	if (gassign _a5 = dyn_cast <gassign > (_d5))
5315	switch (gimple_assign_rhs_code (_a5))
5316	{
5317	case LSHIFT_EXPR:
5318	{
5319	tree _q90 = gimple_assign_rhs1 (_a5);
5320	_q90 = do_valueize (valueize, _q90);
5321	tree _q91 = gimple_assign_rhs2 (_a5);
5322	_q91 = do_valueize (valueize, _q91);
5323	if (integer_onep (_q90))
5324	{
5325	{
5326	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5327	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _p1, _q50, _q90, _q91, _q52 };
5328	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5329	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 5329 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 5329, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 5329, __FUNCTION__))-> type_common.precision)
5330	)
5331	{
5332	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__5332);
5333	{
5334	res_ops[0] = captures[0];
5335	res_ops[1] = captures[0];
5336	res_ops[2] = captures[1];
5337	return true;
5338	}
5339	next_after_fail140:;
5340	}
5341	}
5342	}
5343	break;
5344	}
5345	default:;
5346	}
5347	}
5348	break;
5349	default:;
5350	}
5351	}
5352	}
5353	}
5354	if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)((non_type_check ((_q51), "gimple-match.cc", 5354, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5355	{
5356	switch (TREE_CODE (_q51)((enum tree_code) (_q51)->base.code))
5357	{
5358	case SSA_NAME:
5359	if (gimple *_d5 = get_def (valueize, _q51))
5360	{
5361	if (gassign _a5 = dyn_cast <gassign > (_d5))
5362	switch (gimple_assign_rhs_code (_a5))
5363	{
5364	case LSHIFT_EXPR:
5365	{
5366	tree _q80 = gimple_assign_rhs1 (_a5);
5367	_q80 = do_valueize (valueize, _q80);
5368	tree _q81 = gimple_assign_rhs2 (_a5);
5369	_q81 = do_valueize (valueize, _q81);
5370	if (integer_onep (_q80))
5371	{
5372	{
5373	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5374	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _p1, _q50, _q80, _q81, _q52 };
5375	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5376	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 5376 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 5376, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 5376, __FUNCTION__))-> type_common.precision)
5377	)
5378	{
5379	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__5379);
5380	{
5381	res_ops[0] = captures[0];
5382	res_ops[1] = captures[0];
5383	res_ops[2] = captures[1];
5384	return true;
5385	}
5386	next_after_fail141:;
5387	}
5388	}
5389	}
5390	break;
5391	}
5392	default:;
5393	}
5394	}
5395	break;
5396	default:;
5397	}
5398	}
5399	}
5400	break;
5401	case CFN_BUILT_IN_ATOMIC_FETCH_OR_2:
5402	if (gimple_call_num_args (_c4) == 3)
5403	{
5404	tree _q50 = gimple_call_arg (_c4, 0);
5405	_q50 = do_valueize (valueize, _q50);
5406	tree _q51 = gimple_call_arg (_c4, 1);
5407	_q51 = do_valueize (valueize, _q51);
5408	tree _q52 = gimple_call_arg (_c4, 2);
5409	_q52 = do_valueize (valueize, _q52);
5410	{
5411	tree _q51_pops[1];
5412	if (gimple_nop_convert (_q51, _q51_pops, valueize))
5413	{
5414	tree _q70 = _q51_pops[0];
5415	if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)((non_type_check ((_q70), "gimple-match.cc", 5415, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
5416	{
5417	switch (TREE_CODE (_q70)((enum tree_code) (_q70)->base.code))
5418	{
5419	case SSA_NAME:
5420	if (gimple *_d5 = get_def (valueize, _q70))
5421	{
5422	if (gassign _a5 = dyn_cast <gassign > (_d5))
5423	switch (gimple_assign_rhs_code (_a5))
5424	{
5425	case LSHIFT_EXPR:
5426	{
5427	tree _q90 = gimple_assign_rhs1 (_a5);
5428	_q90 = do_valueize (valueize, _q90);
5429	tree _q91 = gimple_assign_rhs2 (_a5);
5430	_q91 = do_valueize (valueize, _q91);
5431	if (integer_onep (_q90))
5432	{
5433	{
5434	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5435	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _p1, _q50, _q90, _q91, _q52 };
5436	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5437	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 5437 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 5437, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 5437, __FUNCTION__))-> type_common.precision)
5438	)
5439	{
5440	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__5440);
5441	{
5442	res_ops[0] = captures[0];
5443	res_ops[1] = captures[0];
5444	res_ops[2] = captures[1];
5445	return true;
5446	}
5447	next_after_fail142:;
5448	}
5449	}
5450	}
5451	break;
5452	}
5453	default:;
5454	}
5455	}
5456	break;
5457	default:;
5458	}
5459	}
5460	}
5461	}
5462	if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)((non_type_check ((_q51), "gimple-match.cc", 5462, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5463	{
5464	switch (TREE_CODE (_q51)((enum tree_code) (_q51)->base.code))
5465	{
5466	case SSA_NAME:
5467	if (gimple *_d5 = get_def (valueize, _q51))
5468	{
5469	if (gassign _a5 = dyn_cast <gassign > (_d5))
5470	switch (gimple_assign_rhs_code (_a5))
5471	{
5472	case LSHIFT_EXPR:
5473	{
5474	tree _q80 = gimple_assign_rhs1 (_a5);
5475	_q80 = do_valueize (valueize, _q80);
5476	tree _q81 = gimple_assign_rhs2 (_a5);
5477	_q81 = do_valueize (valueize, _q81);
5478	if (integer_onep (_q80))
5479	{
5480	{
5481	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5482	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _p1, _q50, _q80, _q81, _q52 };
5483	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5484	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 5484 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 5484, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 5484, __FUNCTION__))-> type_common.precision)
5485	)
5486	{
5487	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__5487);
5488	{
5489	res_ops[0] = captures[0];
5490	res_ops[1] = captures[0];
5491	res_ops[2] = captures[1];
5492	return true;
5493	}
5494	next_after_fail143:;
5495	}
5496	}
5497	}
5498	break;
5499	}
5500	default:;
5501	}
5502	}
5503	break;
5504	default:;
5505	}
5506	}
5507	}
5508	break;
5509	case CFN_BUILT_IN_ATOMIC_FETCH_OR_4:
5510	if (gimple_call_num_args (_c4) == 3)
5511	{
5512	tree _q50 = gimple_call_arg (_c4, 0);
5513	_q50 = do_valueize (valueize, _q50);
5514	tree _q51 = gimple_call_arg (_c4, 1);
5515	_q51 = do_valueize (valueize, _q51);
5516	tree _q52 = gimple_call_arg (_c4, 2);
5517	_q52 = do_valueize (valueize, _q52);
5518	{
5519	tree _q51_pops[1];
5520	if (gimple_nop_convert (_q51, _q51_pops, valueize))
5521	{
5522	tree _q70 = _q51_pops[0];
5523	if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)((non_type_check ((_q70), "gimple-match.cc", 5523, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
5524	{
5525	switch (TREE_CODE (_q70)((enum tree_code) (_q70)->base.code))
5526	{
5527	case SSA_NAME:
5528	if (gimple *_d5 = get_def (valueize, _q70))
5529	{
5530	if (gassign _a5 = dyn_cast <gassign > (_d5))
5531	switch (gimple_assign_rhs_code (_a5))
5532	{
5533	case LSHIFT_EXPR:
5534	{
5535	tree _q90 = gimple_assign_rhs1 (_a5);
5536	_q90 = do_valueize (valueize, _q90);
5537	tree _q91 = gimple_assign_rhs2 (_a5);
5538	_q91 = do_valueize (valueize, _q91);
5539	if (integer_onep (_q90))
5540	{
5541	{
5542	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5543	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _p1, _q50, _q90, _q91, _q52 };
5544	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5545	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 5545 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 5545, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 5545, __FUNCTION__))-> type_common.precision)
5546	)
5547	{
5548	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__5548);
5549	{
5550	res_ops[0] = captures[0];
5551	res_ops[1] = captures[0];
5552	res_ops[2] = captures[1];
5553	return true;
5554	}
5555	next_after_fail144:;
5556	}
5557	}
5558	}
5559	break;
5560	}
5561	default:;
5562	}
5563	}
5564	break;
5565	default:;
5566	}
5567	}
5568	}
5569	}
5570	if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)((non_type_check ((_q51), "gimple-match.cc", 5570, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5571	{
5572	switch (TREE_CODE (_q51)((enum tree_code) (_q51)->base.code))
5573	{
5574	case SSA_NAME:
5575	if (gimple *_d5 = get_def (valueize, _q51))
5576	{
5577	if (gassign _a5 = dyn_cast <gassign > (_d5))
5578	switch (gimple_assign_rhs_code (_a5))
5579	{
5580	case LSHIFT_EXPR:
5581	{
5582	tree _q80 = gimple_assign_rhs1 (_a5);
5583	_q80 = do_valueize (valueize, _q80);
5584	tree _q81 = gimple_assign_rhs2 (_a5);
5585	_q81 = do_valueize (valueize, _q81);
5586	if (integer_onep (_q80))
5587	{
5588	{
5589	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5590	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _p1, _q50, _q80, _q81, _q52 };
5591	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5592	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 5592 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 5592, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 5592, __FUNCTION__))-> type_common.precision)
5593	)
5594	{
5595	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__5595);
5596	{
5597	res_ops[0] = captures[0];
5598	res_ops[1] = captures[0];
5599	res_ops[2] = captures[1];
5600	return true;
5601	}
5602	next_after_fail145:;
5603	}
5604	}
5605	}
5606	break;
5607	}
5608	default:;
5609	}
5610	}
5611	break;
5612	default:;
5613	}
5614	}
5615	}
5616	break;
5617	case CFN_BUILT_IN_ATOMIC_FETCH_OR_8:
5618	if (gimple_call_num_args (_c4) == 3)
5619	{
5620	tree _q50 = gimple_call_arg (_c4, 0);
5621	_q50 = do_valueize (valueize, _q50);
5622	tree _q51 = gimple_call_arg (_c4, 1);
5623	_q51 = do_valueize (valueize, _q51);
5624	tree _q52 = gimple_call_arg (_c4, 2);
5625	_q52 = do_valueize (valueize, _q52);
5626	{
5627	tree _q51_pops[1];
5628	if (gimple_nop_convert (_q51, _q51_pops, valueize))
5629	{
5630	tree _q70 = _q51_pops[0];
5631	if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)((non_type_check ((_q70), "gimple-match.cc", 5631, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
5632	{
5633	switch (TREE_CODE (_q70)((enum tree_code) (_q70)->base.code))
5634	{
5635	case SSA_NAME:
5636	if (gimple *_d5 = get_def (valueize, _q70))
5637	{
5638	if (gassign _a5 = dyn_cast <gassign > (_d5))
5639	switch (gimple_assign_rhs_code (_a5))
5640	{
5641	case LSHIFT_EXPR:
5642	{
5643	tree _q90 = gimple_assign_rhs1 (_a5);
5644	_q90 = do_valueize (valueize, _q90);
5645	tree _q91 = gimple_assign_rhs2 (_a5);
5646	_q91 = do_valueize (valueize, _q91);
5647	if (integer_onep (_q90))
5648	{
5649	{
5650	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5651	tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _p1, _q50, _q90, _q91, _q52 };
5652	/* #line 4490 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5653	if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.cc", 5653 , __FUNCTION__))->type_common.precision) <= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), ( TS_TYPED), "gimple-match.cc", 5653, __FUNCTION__))->typed. type)), (tcc_type), "gimple-match.cc", 5653, __FUNCTION__))-> type_common.precision)
5654	)
5655	{
5656	if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING )), 0))) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4485, __FILE__"gimple-match.cc", __LINE__5656);
5657	{
5658	res_ops[0] = captures[0];
5659	res_ops[1] = captures[0];
5660	res_ops[2] = captures[1];
5661	return true;
5662	}
5663	next_after_fail146:;
5664	}
5665	}
5666	}
5667	break;
5668	}
5669	default:;
5670	}
5671	}
5672	break;
5673	default:;
5674	}
5675	}
5676	}
5677	}
5678	if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)((non_type_check ((_q51), "gimple-match.cc", 5678, __FUNCTION__ ))->base.side_effects_flag)) \|\| (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5679	{
5680	switch (TREE_CODE (_q51)((enum tree_code) (_q51)->base.code))
5681	{
5682	case SSA_NAME:
5683	if (gimple *_d5 = get_def (valueize, _q51))
5684	{
5685	if (gassign _a5 = dyn_cast <gassign > (_d5))
5686	switch (gimple_assign_rhs_code (_a5))
5687	{
5688	case LSHIFT_EXPR:
5689	{
5690	tree _q80 = gimple_assign_rhs1 (_a5);
5691	_q80 = do_valueize (valueize, _q80);
5692	tree _q81 = gimple_assign_rhs2 (_a5);
5693	_q81 = do_valueize (valueize, _q81);
5694	if (integer_onep (_q80))