Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name gimple-match.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/13.0.0 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../include/c++/11 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../include/c++/11/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../include/c++/11/backward -internal-isystem /usr/lib64/clang/13.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-error=format-diag -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -Wno-unused -fdeprecated-macro -fdebug-compilation-dir=/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-11-20-133755-20252-1/report-feZiLD.plist -x c++ gimple-match.c
1/* Generated automatically by the program `genmatch' from
2 a IL pattern matching and simplification description. */
3
4#include "gimple-match-head.c"
5
6bool
7gimple_nop_convert (tree t, tree *res_ops, tree (*valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
8{
9 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.c", 9
, __FUNCTION__))->typed.type)
;
10 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
11 {
12 case SSA_NAME:
13 if (gimple *_d1 = get_def (valueize, t))
14 {
15 if (gassign *_a1 = dyn_cast <gassign *> (_d1))
16 switch (gimple_assign_rhs_code (_a1))
17 {
18 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
19 {
20 tree _p0 = gimple_assign_rhs1 (_a1);
21 _p0 = do_valueize (valueize, _p0);
22 {
23/* #line 147 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
24 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
25/* #line 147 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
26 if (tree_nop_conversion_p (type, TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "gimple-match.c"
, 26, __FUNCTION__))->typed.type)
)
27)
28 {
29 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 145, __FILE__"gimple-match.c", __LINE__29);
30 {
31 res_ops[0] = captures[0];
32 return true;
33 }
34next_after_fail1:;
35 }
36 }
37 break;
38 }
39 case VIEW_CONVERT_EXPR:
40 {
41 tree _p0 = TREE_OPERAND (gimple_assign_rhs1 (_a1), 0)(*((const_cast<tree*> (tree_operand_check ((gimple_assign_rhs1
(_a1)), (0), "gimple-match.c", 41, __FUNCTION__)))))
;
42 if ((TREE_CODE (_p0)((enum tree_code) (_p0)->base.code) == SSA_NAME
43 || is_gimple_min_invariant (_p0)))
44 {
45 _p0 = do_valueize (valueize, _p0);
46 {
47/* #line 150 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
48 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
49/* #line 150 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
50 if (VECTOR_TYPE_P (type)(((enum tree_code) (type)->base.code) == VECTOR_TYPE) && VECTOR_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "gimple-match.c", 50, __FUNCTION__))->typed.type
))->base.code) == VECTOR_TYPE)
51 && known_eq (TYPE_VECTOR_SUBPARTS (type),(!maybe_ne (TYPE_VECTOR_SUBPARTS (type), TYPE_VECTOR_SUBPARTS
(((contains_struct_check ((captures[0]), (TS_TYPED), "gimple-match.c"
, 52, __FUNCTION__))->typed.type))))
52 TYPE_VECTOR_SUBPARTS (TREE_TYPE (captures[0])))(!maybe_ne (TYPE_VECTOR_SUBPARTS (type), TYPE_VECTOR_SUBPARTS
(((contains_struct_check ((captures[0]), (TS_TYPED), "gimple-match.c"
, 52, __FUNCTION__))->typed.type))))
53 && tree_nop_conversion_p (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "gimple-match.c"
, 53, __FUNCTION__))->typed.type)
, TREE_TYPE (TREE_TYPE (captures[0]))((contains_struct_check ((((contains_struct_check ((captures[
0]), (TS_TYPED), "gimple-match.c", 53, __FUNCTION__))->typed
.type)), (TS_TYPED), "gimple-match.c", 53, __FUNCTION__))->
typed.type)
)
54)
55 {
56 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 148, __FILE__"gimple-match.c", __LINE__56);
57 {
58 res_ops[0] = captures[0];
59 return true;
60 }
61next_after_fail2:;
62 }
63 }
64 }
65 break;
66 }
67 default:;
68 }
69 }
70 break;
71 default:;
72 }
73 return false;
74}
75
76bool
77gimple_power_of_two_cand (tree t, tree *res_ops, tree (*valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
78{
79 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.c", 79
, __FUNCTION__))->typed.type)
;
80 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
81 {
82 case SSA_NAME:
83 if (gimple *_d1 = get_def (valueize, t))
84 {
85 if (gassign *_a1 = dyn_cast <gassign *> (_d1))
86 switch (gimple_assign_rhs_code (_a1))
87 {
88 case LSHIFT_EXPR:
89 {
90 tree _p0 = gimple_assign_rhs1 (_a1);
91 _p0 = do_valueize (valueize, _p0);
92 tree _p1 = gimple_assign_rhs2 (_a1);
93 _p1 = do_valueize (valueize, _p1);
94 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
95 {
96 case INTEGER_CST:
97 {
98 {
99/* #line 656 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
100 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
101 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 656, __FILE__"gimple-match.c", __LINE__101);
102 {
103 res_ops[0] = captures[0];
104 return true;
105 }
106next_after_fail3:;
107 }
108 break;
109 }
110 default:;
111 }
112 break;
113 }
114 default:;
115 }
116 }
117 break;
118 case INTEGER_CST:
119 {
120 {
121/* #line 654 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
122 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
123 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 654, __FILE__"gimple-match.c", __LINE__123);
124 {
125 res_ops[0] = captures[0];
126 return true;
127 }
128next_after_fail4:;
129 }
130 break;
131 }
132 default:;
133 }
134 return false;
135}
136
137bool
138gimple_negate_expr_p (tree t, tree (*valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
139{
140 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.c", 140
, __FUNCTION__))->typed.type)
;
141 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
142 {
143 case SSA_NAME:
144 if (gimple *_d1 = get_def (valueize, t))
145 {
146 if (gassign *_a1 = dyn_cast <gassign *> (_d1))
147 switch (gimple_assign_rhs_code (_a1))
148 {
149 case NEGATE_EXPR:
150 {
151 tree _p0 = gimple_assign_rhs1 (_a1);
152 _p0 = do_valueize (valueize, _p0);
153 {
154/* #line 1520 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
155 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
156/* #line 1520 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
157 if (!TYPE_OVERFLOW_SANITIZED (type)((((enum tree_code) (type)->base.code) == ENUMERAL_TYPE ||
((enum tree_code) (type)->base.code) == BOOLEAN_TYPE || (
(enum tree_code) (type)->base.code) == INTEGER_TYPE) &&
!((((enum tree_code) (type)->base.code) == POINTER_TYPE ||
((enum tree_code) (type)->base.code) == REFERENCE_TYPE) ?
global_options.x_flag_wrapv_pointer : ((any_integral_type_check
((type), "gimple-match.c", 157, __FUNCTION__))->base.u.bits
.unsigned_flag || global_options.x_flag_wrapv)) && (global_options
.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
158)
159 {
160 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1519, __FILE__"gimple-match.c", __LINE__160);
161 {
162 return true;
163 }
164next_after_fail5:;
165 }
166 }
167 break;
168 }
169 case MINUS_EXPR:
170 {
171 tree _p0 = gimple_assign_rhs1 (_a1);
172 _p0 = do_valueize (valueize, _p0);
173 tree _p1 = gimple_assign_rhs2 (_a1);
174 _p1 = do_valueize (valueize, _p1);
175 {
176/* #line 1531 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
177 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
178/* #line 1531 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
179 if ((ANY_INTEGRAL_TYPE_P (type)((((enum tree_code) (type)->base.code) == ENUMERAL_TYPE ||
((enum tree_code) (type)->base.code) == BOOLEAN_TYPE || (
(enum tree_code) (type)->base.code) == INTEGER_TYPE) || ((
((enum tree_code) (type)->base.code) == COMPLEX_TYPE || ((
(enum tree_code) (type)->base.code) == VECTOR_TYPE)) &&
(((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "gimple-match.c", 179, __FUNCTION__))->typed.type))->
base.code) == ENUMERAL_TYPE || ((enum tree_code) (((contains_struct_check
((type), (TS_TYPED), "gimple-match.c", 179, __FUNCTION__))->
typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((type), (TS_TYPED), "gimple-match.c"
, 179, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)))
&& TYPE_OVERFLOW_WRAPS (type)((((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE) ? global_options
.x_flag_wrapv_pointer : ((any_integral_type_check ((type), "gimple-match.c"
, 179, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
)
180 || (FLOAT_TYPE_P (type)((((enum tree_code) (type)->base.code) == REAL_TYPE) || ((
((enum tree_code) (type)->base.code) == COMPLEX_TYPE || ((
(enum tree_code) (type)->base.code) == VECTOR_TYPE)) &&
(((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "gimple-match.c", 180, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE)))
181 && !HONOR_SIGN_DEPENDENT_ROUNDING (type)
182 && !HONOR_SIGNED_ZEROS (type))
183)
184 {
185 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1530, __FILE__"gimple-match.c", __LINE__185);
186 {
187 return true;
188 }
189next_after_fail6:;
190 }
191 }
192 break;
193 }
194 default:;
195 }
196 }
197 break;
198 case INTEGER_CST:
199 {
200 {
201/* #line 1512 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
202/* #line 1512 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
203 if ((INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
204 && TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "gimple-match.c", 204
, __FUNCTION__))->base.u.bits.unsigned_flag)
)
205 || (!TYPE_OVERFLOW_SANITIZED (type)((((enum tree_code) (type)->base.code) == ENUMERAL_TYPE ||
((enum tree_code) (type)->base.code) == BOOLEAN_TYPE || (
(enum tree_code) (type)->base.code) == INTEGER_TYPE) &&
!((((enum tree_code) (type)->base.code) == POINTER_TYPE ||
((enum tree_code) (type)->base.code) == REFERENCE_TYPE) ?
global_options.x_flag_wrapv_pointer : ((any_integral_type_check
((type), "gimple-match.c", 205, __FUNCTION__))->base.u.bits
.unsigned_flag || global_options.x_flag_wrapv)) && (global_options
.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
206 && may_negate_without_overflow_p (t))
207)
208 {
209 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1511, __FILE__"gimple-match.c", __LINE__209);
210 {
211 return true;
212 }
213next_after_fail7:;
214 }
215 }
216 break;
217 }
218 case FIXED_CST:
219 {
220 {
221/* #line 1517 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
222 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1517, __FILE__"gimple-match.c", __LINE__222);
223 {
224 return true;
225 }
226next_after_fail8:;
227 }
228 break;
229 }
230 case REAL_CST:
231 {
232 {
233/* #line 1523 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
234/* #line 1523 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
235 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (t))real_isneg (&((*((tree_check ((t), "gimple-match.c", 235,
__FUNCTION__, (REAL_CST)))->real_cst.real_cst_ptr))))
236)
237 {
238 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1522, __FILE__"gimple-match.c", __LINE__238);
239 {
240 return true;
241 }
242next_after_fail9:;
243 }
244 }
245 break;
246 }
247 case VECTOR_CST:
248 {
249 {
250/* #line 1528 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
251/* #line 1528 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
252 if (FLOAT_TYPE_P (TREE_TYPE (type))((((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "gimple-match.c", 252, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE) || ((((enum tree_code) (((contains_struct_check
((type), (TS_TYPED), "gimple-match.c", 252, __FUNCTION__))->
typed.type))->base.code) == COMPLEX_TYPE || (((enum tree_code
) (((contains_struct_check ((type), (TS_TYPED), "gimple-match.c"
, 252, __FUNCTION__))->typed.type))->base.code) == VECTOR_TYPE
)) && (((enum tree_code) (((contains_struct_check (((
(contains_struct_check ((type), (TS_TYPED), "gimple-match.c",
252, __FUNCTION__))->typed.type)), (TS_TYPED), "gimple-match.c"
, 252, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)))
|| TYPE_OVERFLOW_WRAPS (type)((((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE) ? global_options
.x_flag_wrapv_pointer : ((any_integral_type_check ((type), "gimple-match.c"
, 252, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
253)
254 {
255 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1527, __FILE__"gimple-match.c", __LINE__255);
256 {
257 return true;
258 }
259next_after_fail10:;
260 }
261 }
262 break;
263 }
264 default:;
265 }
266 return false;
267}
268
269bool
270gimple_truth_valued_p (tree t, tree (*valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
271{
272 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.c", 272
, __FUNCTION__))->typed.type)
;
273 {
274/* #line 1702 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
275 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
276/* #line 1702 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
277 if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "gimple-match.c", 277
, __FUNCTION__))->type_common.precision)
== 1
278)
279 {
280 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1701, __FILE__"gimple-match.c", __LINE__280);
281 {
282 return true;
283 }
284next_after_fail11:;
285 }
286 }
287 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
288 {
289 case SSA_NAME:
290 if (gimple *_d1 = get_def (valueize, t))
291 {
292 if (gassign *_a1 = dyn_cast <gassign *> (_d1))
293 switch (gimple_assign_rhs_code (_a1))
294 {
295 case LT_EXPR:
296 {
297 tree _p0 = gimple_assign_rhs1 (_a1);
298 _p0 = do_valueize (valueize, _p0);
299 tree _p1 = gimple_assign_rhs2 (_a1);
300 _p1 = do_valueize (valueize, _p1);
301 {
302/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
303 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
304 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__304);
305 {
306 return true;
307 }
308next_after_fail12:;
309 }
310 break;
311 }
312 case LE_EXPR:
313 {
314 tree _p0 = gimple_assign_rhs1 (_a1);
315 _p0 = do_valueize (valueize, _p0);
316 tree _p1 = gimple_assign_rhs2 (_a1);
317 _p1 = do_valueize (valueize, _p1);
318 {
319/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
320 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
321 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__321);
322 {
323 return true;
324 }
325next_after_fail13:;
326 }
327 break;
328 }
329 case EQ_EXPR:
330 {
331 tree _p0 = gimple_assign_rhs1 (_a1);
332 _p0 = do_valueize (valueize, _p0);
333 tree _p1 = gimple_assign_rhs2 (_a1);
334 _p1 = do_valueize (valueize, _p1);
335 if (tree_swap_operands_p (_p0, _p1))
336 std::swap (_p0, _p1);
337 {
338/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
339 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
340 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__340);
341 {
342 return true;
343 }
344next_after_fail14:;
345 }
346 break;
347 }
348 case NE_EXPR:
349 {
350 tree _p0 = gimple_assign_rhs1 (_a1);
351 _p0 = do_valueize (valueize, _p0);
352 tree _p1 = gimple_assign_rhs2 (_a1);
353 _p1 = do_valueize (valueize, _p1);
354 if (tree_swap_operands_p (_p0, _p1))
355 std::swap (_p0, _p1);
356 {
357/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
358 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
359 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__359);
360 {
361 return true;
362 }
363next_after_fail15:;
364 }
365 break;
366 }
367 case GE_EXPR:
368 {
369 tree _p0 = gimple_assign_rhs1 (_a1);
370 _p0 = do_valueize (valueize, _p0);
371 tree _p1 = gimple_assign_rhs2 (_a1);
372 _p1 = do_valueize (valueize, _p1);
373 {
374/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
375 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
376 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__376);
377 {
378 return true;
379 }
380next_after_fail16:;
381 }
382 break;
383 }
384 case GT_EXPR:
385 {
386 tree _p0 = gimple_assign_rhs1 (_a1);
387 _p0 = do_valueize (valueize, _p0);
388 tree _p1 = gimple_assign_rhs2 (_a1);
389 _p1 = do_valueize (valueize, _p1);
390 {
391/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
392 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
393 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__393);
394 {
395 return true;
396 }
397next_after_fail17:;
398 }
399 break;
400 }
401 case UNORDERED_EXPR:
402 {
403 tree _p0 = gimple_assign_rhs1 (_a1);
404 _p0 = do_valueize (valueize, _p0);
405 tree _p1 = gimple_assign_rhs2 (_a1);
406 _p1 = do_valueize (valueize, _p1);
407 if (tree_swap_operands_p (_p0, _p1))
408 std::swap (_p0, _p1);
409 {
410/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
411 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
412 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__412);
413 {
414 return true;
415 }
416next_after_fail18:;
417 }
418 break;
419 }
420 case ORDERED_EXPR:
421 {
422 tree _p0 = gimple_assign_rhs1 (_a1);
423 _p0 = do_valueize (valueize, _p0);
424 tree _p1 = gimple_assign_rhs2 (_a1);
425 _p1 = do_valueize (valueize, _p1);
426 if (tree_swap_operands_p (_p0, _p1))
427 std::swap (_p0, _p1);
428 {
429/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
430 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
431 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__431);
432 {
433 return true;
434 }
435next_after_fail19:;
436 }
437 break;
438 }
439 case UNLT_EXPR:
440 {
441 tree _p0 = gimple_assign_rhs1 (_a1);
442 _p0 = do_valueize (valueize, _p0);
443 tree _p1 = gimple_assign_rhs2 (_a1);
444 _p1 = do_valueize (valueize, _p1);
445 {
446/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
447 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
448 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__448);
449 {
450 return true;
451 }
452next_after_fail20:;
453 }
454 break;
455 }
456 case UNLE_EXPR:
457 {
458 tree _p0 = gimple_assign_rhs1 (_a1);
459 _p0 = do_valueize (valueize, _p0);
460 tree _p1 = gimple_assign_rhs2 (_a1);
461 _p1 = do_valueize (valueize, _p1);
462 {
463/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
464 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
465 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__465);
466 {
467 return true;
468 }
469next_after_fail21:;
470 }
471 break;
472 }
473 case UNGT_EXPR:
474 {
475 tree _p0 = gimple_assign_rhs1 (_a1);
476 _p0 = do_valueize (valueize, _p0);
477 tree _p1 = gimple_assign_rhs2 (_a1);
478 _p1 = do_valueize (valueize, _p1);
479 {
480/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
481 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
482 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__482);
483 {
484 return true;
485 }
486next_after_fail22:;
487 }
488 break;
489 }
490 case UNGE_EXPR:
491 {
492 tree _p0 = gimple_assign_rhs1 (_a1);
493 _p0 = do_valueize (valueize, _p0);
494 tree _p1 = gimple_assign_rhs2 (_a1);
495 _p1 = do_valueize (valueize, _p1);
496 {
497/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
498 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
499 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__499);
500 {
501 return true;
502 }
503next_after_fail23:;
504 }
505 break;
506 }
507 case UNEQ_EXPR:
508 {
509 tree _p0 = gimple_assign_rhs1 (_a1);
510 _p0 = do_valueize (valueize, _p0);
511 tree _p1 = gimple_assign_rhs2 (_a1);
512 _p1 = do_valueize (valueize, _p1);
513 if (tree_swap_operands_p (_p0, _p1))
514 std::swap (_p0, _p1);
515 {
516/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
517 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
518 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__518);
519 {
520 return true;
521 }
522next_after_fail24:;
523 }
524 break;
525 }
526 case LTGT_EXPR:
527 {
528 tree _p0 = gimple_assign_rhs1 (_a1);
529 _p0 = do_valueize (valueize, _p0);
530 tree _p1 = gimple_assign_rhs2 (_a1);
531 _p1 = do_valueize (valueize, _p1);
532 if (tree_swap_operands_p (_p0, _p1))
533 std::swap (_p0, _p1);
534 {
535/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
536 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
537 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__537);
538 {
539 return true;
540 }
541next_after_fail25:;
542 }
543 break;
544 }
545 case TRUTH_AND_EXPR:
546 {
547 tree _p0 = gimple_assign_rhs1 (_a1);
548 _p0 = do_valueize (valueize, _p0);
549 tree _p1 = gimple_assign_rhs2 (_a1);
550 _p1 = do_valueize (valueize, _p1);
551 if (tree_swap_operands_p (_p0, _p1))
552 std::swap (_p0, _p1);
553 {
554/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
555 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
556 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__556);
557 {
558 return true;
559 }
560next_after_fail26:;
561 }
562 break;
563 }
564 case TRUTH_ANDIF_EXPR:
565 {
566 tree _p0 = gimple_assign_rhs1 (_a1);
567 _p0 = do_valueize (valueize, _p0);
568 tree _p1 = gimple_assign_rhs2 (_a1);
569 _p1 = do_valueize (valueize, _p1);
570 {
571/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
572 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
573 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__573);
574 {
575 return true;
576 }
577next_after_fail27:;
578 }
579 break;
580 }
581 case TRUTH_OR_EXPR:
582 {
583 tree _p0 = gimple_assign_rhs1 (_a1);
584 _p0 = do_valueize (valueize, _p0);
585 tree _p1 = gimple_assign_rhs2 (_a1);
586 _p1 = do_valueize (valueize, _p1);
587 if (tree_swap_operands_p (_p0, _p1))
588 std::swap (_p0, _p1);
589 {
590/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
591 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
592 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__592);
593 {
594 return true;
595 }
596next_after_fail28:;
597 }
598 break;
599 }
600 case TRUTH_ORIF_EXPR:
601 {
602 tree _p0 = gimple_assign_rhs1 (_a1);
603 _p0 = do_valueize (valueize, _p0);
604 tree _p1 = gimple_assign_rhs2 (_a1);
605 _p1 = do_valueize (valueize, _p1);
606 {
607/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
608 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
609 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__609);
610 {
611 return true;
612 }
613next_after_fail29:;
614 }
615 break;
616 }
617 case TRUTH_XOR_EXPR:
618 {
619 tree _p0 = gimple_assign_rhs1 (_a1);
620 _p0 = do_valueize (valueize, _p0);
621 tree _p1 = gimple_assign_rhs2 (_a1);
622 _p1 = do_valueize (valueize, _p1);
623 if (tree_swap_operands_p (_p0, _p1))
624 std::swap (_p0, _p1);
625 {
626/* #line 1705 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
627 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
628 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1705, __FILE__"gimple-match.c", __LINE__628);
629 {
630 return true;
631 }
632next_after_fail30:;
633 }
634 break;
635 }
636 case TRUTH_NOT_EXPR:
637 {
638 tree _p0 = gimple_assign_rhs1 (_a1);
639 _p0 = do_valueize (valueize, _p0);
640 {
641/* #line 1707 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
642 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
643 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1707, __FILE__"gimple-match.c", __LINE__643);
644 {
645 return true;
646 }
647next_after_fail31:;
648 }
649 break;
650 }
651 default:;
652 }
653 }
654 break;
655 default:;
656 }
657 return false;
658}
659
660bool
661gimple_logical_inverted_value (tree t, tree *res_ops, tree (*valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
662{
663 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.c", 663
, __FUNCTION__))->typed.type)
;
664 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
665 {
666 case SSA_NAME:
667 if (gimple *_d1 = get_def (valueize, t))
668 {
669 if (gassign *_a1 = dyn_cast <gassign *> (_d1))
670 switch (gimple_assign_rhs_code (_a1))
671 {
672 case TRUTH_NOT_EXPR:
673 {
674 tree _p0 = gimple_assign_rhs1 (_a1);
675 _p0 = do_valueize (valueize, _p0);
676 {
677/* #line 1709 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
678 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
679 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1709, __FILE__"gimple-match.c", __LINE__679);
680 {
681 res_ops[0] = captures[0];
682 return true;
683 }
684next_after_fail32:;
685 }
686 break;
687 }
688 case BIT_NOT_EXPR:
689 {
690 tree _p0 = gimple_assign_rhs1 (_a1);
691 _p0 = do_valueize (valueize, _p0);
692 if (gimple_truth_valued_p (_p0, valueize))
693 {
694 {
695/* #line 1711 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
696 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
697 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1711, __FILE__"gimple-match.c", __LINE__697);
698 {
699 res_ops[0] = captures[0];
700 return true;
701 }
702next_after_fail33:;
703 }
704 }
705 break;
706 }
707 case EQ_EXPR:
708 {
709 tree _p0 = gimple_assign_rhs1 (_a1);
710 _p0 = do_valueize (valueize, _p0);
711 tree _p1 = gimple_assign_rhs2 (_a1);
712 _p1 = do_valueize (valueize, _p1);
713 if (tree_swap_operands_p (_p0, _p1))
714 std::swap (_p0, _p1);
715 if (integer_zerop (_p1))
716 {
717 {
718/* #line 1713 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
719 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
720 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1713, __FILE__"gimple-match.c", __LINE__720);
721 {
722 res_ops[0] = captures[0];
723 return true;
724 }
725next_after_fail34:;
726 }
727 }
728 break;
729 }
730 case NE_EXPR:
731 {
732 tree _p0 = gimple_assign_rhs1 (_a1);
733 _p0 = do_valueize (valueize, _p0);
734 tree _p1 = gimple_assign_rhs2 (_a1);
735 _p1 = do_valueize (valueize, _p1);
736 if (tree_swap_operands_p (_p0, _p1))
737 std::swap (_p0, _p1);
738 if (gimple_truth_valued_p (_p0, valueize))
739 {
740 if (integer_truep (_p1))
741 {
742 {
743/* #line 1715 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
744 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
745 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1715, __FILE__"gimple-match.c", __LINE__745);
746 {
747 res_ops[0] = captures[0];
748 return true;
749 }
750next_after_fail35:;
751 }
752 }
753 }
754 break;
755 }
756 case BIT_XOR_EXPR:
757 {
758 tree _p0 = gimple_assign_rhs1 (_a1);
759 _p0 = do_valueize (valueize, _p0);
760 tree _p1 = gimple_assign_rhs2 (_a1);
761 _p1 = do_valueize (valueize, _p1);
762 if (tree_swap_operands_p (_p0, _p1))
763 std::swap (_p0, _p1);
764 if (gimple_truth_valued_p (_p0, valueize))
765 {
766 if (integer_truep (_p1))
767 {
768 {
769/* #line 1717 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
770 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
771 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1717, __FILE__"gimple-match.c", __LINE__771);
772 {
773 res_ops[0] = captures[0];
774 return true;
775 }
776next_after_fail36:;
777 }
778 }
779 }
780 break;
781 }
782 default:;
783 }
784 }
785 break;
786 default:;
787 }
788 return false;
789}
790
791bool
792gimple_with_possible_nonzero_bits (tree t, tree (*valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
793{
794 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.c", 794
, __FUNCTION__))->typed.type)
;
Value stored to 'type' during its initialization is never read
795 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
796 {
797 case INTEGER_CST:
798 {
799 {
800/* #line 2056 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
801 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
802 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2056, __FILE__"gimple-match.c", __LINE__802);
803 {
804 return true;
805 }
806next_after_fail37:;
807 }
808 break;
809 }
810 case SSA_NAME:
811 {
812 {
813/* #line 2059 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
814 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
815/* #line 2059 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
816 if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "gimple-match.c", 816, __FUNCTION__))->typed.type
))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (((contains_struct_check
((captures[0]), (TS_TYPED), "gimple-match.c", 816, __FUNCTION__
))->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((captures[0]), (TS_TYPED), "gimple-match.c"
, 816, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
|| POINTER_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "gimple-match.c", 816, __FUNCTION__))->typed.type
))->base.code) == POINTER_TYPE || ((enum tree_code) (((contains_struct_check
((captures[0]), (TS_TYPED), "gimple-match.c", 816, __FUNCTION__
))->typed.type))->base.code) == REFERENCE_TYPE)
817)
818 {
819 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2058, __FILE__"gimple-match.c", __LINE__819);
820 {
821 return true;
822 }
823next_after_fail38:;
824 }
825 }
826 break;
827 }
828 default:;
829 }
830 return false;
831}
832
833bool
834gimple_with_possible_nonzero_bits2 (tree t, tree *res_ops, tree (*valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
835{
836 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.c", 836
, __FUNCTION__))->typed.type)
;
837 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
838 {
839 case SSA_NAME:
840 if (gimple *_d1 = get_def (valueize, t))
841 {
842 if (gassign *_a1 = dyn_cast <gassign *> (_d1))
843 switch (gimple_assign_rhs_code (_a1))
844 {
845 case BIT_AND_EXPR:
846 {
847 tree _p0 = gimple_assign_rhs1 (_a1);
848 _p0 = do_valueize (valueize, _p0);
849 tree _p1 = gimple_assign_rhs2 (_a1);
850 _p1 = do_valueize (valueize, _p1);
851 if (tree_swap_operands_p (_p0, _p1))
852 std::swap (_p0, _p1);
853 if (gimple_with_possible_nonzero_bits (_p0, valueize))
854 {
855 {
856/* #line 2063 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
857 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
858 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2063, __FILE__"gimple-match.c", __LINE__858);
859 {
860 res_ops[0] = captures[0];
861 return true;
862 }
863next_after_fail39:;
864 }
865 }
866 if (gimple_with_possible_nonzero_bits (_p1, valueize))
867 {
868 {
869/* #line 2063 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
870 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _p0 };
871 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2063, __FILE__"gimple-match.c", __LINE__871);
872 {
873 res_ops[0] = captures[0];
874 return true;
875 }
876next_after_fail40:;
877 }
878 }
879 break;
880 }
881 default:;
882 }
883 }
884 break;
885 default:;
886 }
887if (gimple_with_possible_nonzero_bits (t, valueize))
888 {
889 {
890/* #line 2061 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
891 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
892 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2061, __FILE__"gimple-match.c", __LINE__892);
893 {
894 res_ops[0] = captures[0];
895 return true;
896 }
897next_after_fail41:;
898 }
899 }
900 return false;
901}
902
903bool
904gimple_with_certain_nonzero_bits2 (tree t, tree *res_ops, tree (*valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
905{
906 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.c", 906
, __FUNCTION__))->typed.type)
;
907 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
908 {
909 case SSA_NAME:
910 if (gimple *_d1 = get_def (valueize, t))
911 {
912 if (gassign *_a1 = dyn_cast <gassign *> (_d1))
913 switch (gimple_assign_rhs_code (_a1))
914 {
915 case BIT_IOR_EXPR:
916 {
917 tree _p0 = gimple_assign_rhs1 (_a1);
918 _p0 = do_valueize (valueize, _p0);
919 tree _p1 = gimple_assign_rhs2 (_a1);
920 _p1 = do_valueize (valueize, _p1);
921 if (tree_swap_operands_p (_p0, _p1))
922 std::swap (_p0, _p1);
923 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
924 {
925 case INTEGER_CST:
926 {
927 {
928/* #line 2070 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
929 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _p0 };
930 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2070, __FILE__"gimple-match.c", __LINE__930);
931 {
932 res_ops[0] = captures[0];
933 return true;
934 }
935next_after_fail42:;
936 }
937 break;
938 }
939 default:;
940 }
941 break;
942 }
943 default:;
944 }
945 }
946 break;
947 case INTEGER_CST:
948 {
949 {
950/* #line 2068 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
951 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
952 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2068, __FILE__"gimple-match.c", __LINE__952);
953 {
954 res_ops[0] = captures[0];
955 return true;
956 }
957next_after_fail43:;
958 }
959 break;
960 }
961 default:;
962 }
963 return false;
964}
965
966bool
967gimple_min_value (tree t, tree (*valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
968{
969 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.c", 969
, __FUNCTION__))->typed.type)
;
970 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
971 {
972 case INTEGER_CST:
973 {
974 {
975/* #line 2231 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
976/* #line 2231 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
977 if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
978 && wi::eq_p (wi::to_wide (t), wi::min_value (type))
979)
980 {
981 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2230, __FILE__"gimple-match.c", __LINE__981);
982 {
983 return true;
984 }
985next_after_fail44:;
986 }
987 }
988 break;
989 }
990 default:;
991 }
992 return false;
993}
994
995bool
996gimple_max_value (tree t, tree (*valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
997{
998 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.c", 998
, __FUNCTION__))->typed.type)
;
999 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1000 {
1001 case INTEGER_CST:
1002 {
1003 {
1004/* #line 2236 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1005/* #line 2236 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1006 if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
1007 && wi::eq_p (wi::to_wide (t), wi::max_value (type))
1008)
1009 {
1010 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2235, __FILE__"gimple-match.c", __LINE__1010);
1011 {
1012 return true;
1013 }
1014next_after_fail45:;
1015 }
1016 }
1017 break;
1018 }
1019 default:;
1020 }
1021 return false;
1022}
1023
1024bool
1025gimple_compositional_complex (tree t, tree (*valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1026{
1027 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.c", 1027
, __FUNCTION__))->typed.type)
;
1028 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1029 {
1030 case SSA_NAME:
1031 if (gimple *_d1 = get_def (valueize, t))
1032 {
1033 if (gassign *_a1 = dyn_cast <gassign *> (_d1))
1034 switch (gimple_assign_rhs_code (_a1))
1035 {
1036 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1037 {
1038 tree _p0 = gimple_assign_rhs1 (_a1);
1039 _p0 = do_valueize (valueize, _p0);
1040 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
1041 {
1042 case SSA_NAME:
1043 if (gimple *_d2 = get_def (valueize, _p0))
1044 {
1045 if (gassign *_a2 = dyn_cast <gassign *> (_d2))
1046 switch (gimple_assign_rhs_code (_a2))
1047 {
1048 case COMPLEX_EXPR:
1049 {
1050 tree _q20 = gimple_assign_rhs1 (_a2);
1051 _q20 = do_valueize (valueize, _q20);
1052 tree _q21 = gimple_assign_rhs2 (_a2);
1053 _q21 = do_valueize (valueize, _q21);
1054 {
1055/* #line 3838 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1056 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q21 };
1057 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 3838, __FILE__"gimple-match.c", __LINE__1057);
1058 {
1059 return true;
1060 }
1061next_after_fail46:;
1062 }
1063 break;
1064 }
1065 default:;
1066 }
1067 }
1068 break;
1069 default:;
1070 }
1071 break;
1072 }
1073 case COMPLEX_EXPR:
1074 {
1075 tree _p0 = gimple_assign_rhs1 (_a1);
1076 _p0 = do_valueize (valueize, _p0);
1077 tree _p1 = gimple_assign_rhs2 (_a1);
1078 _p1 = do_valueize (valueize, _p1);
1079 {
1080/* #line 3838 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1081 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
1082 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 3838, __FILE__"gimple-match.c", __LINE__1082);
1083 {
1084 return true;
1085 }
1086next_after_fail47:;
1087 }
1088 break;
1089 }
1090 default:;
1091 }
1092 }
1093 break;
1094 default:;
1095 }
1096 return false;
1097}
1098
1099bool
1100gimple_nop_atomic_bit_test_and_p (tree t, tree *res_ops, tree (*valueize)(tree) ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1101{
1102 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "gimple-match.c", 1102
, __FUNCTION__))->typed.type)
;
1103 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1104 {
1105 case SSA_NAME:
1106 if (gimple *_d1 = get_def (valueize, t))
1107 {
1108 if (gassign *_a1 = dyn_cast <gassign *> (_d1))
1109 switch (gimple_assign_rhs_code (_a1))
1110 {
1111 case BIT_AND_EXPR:
1112 {
1113 tree _p0 = gimple_assign_rhs1 (_a1);
1114 _p0 = do_valueize (valueize, _p0);
1115 tree _p1 = gimple_assign_rhs2 (_a1);
1116 _p1 = do_valueize (valueize, _p1);
1117 if (tree_swap_operands_p (_p0, _p1))
1118 std::swap (_p0, _p1);
1119 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
1120 {
1121 case SSA_NAME:
1122 if (gimple *_d2 = get_def (valueize, _p0))
1123 {
1124 if (gcall *_c2 = dyn_cast <gcall *> (_d2))
1125 switch (gimple_call_combined_fn (_c2))
1126 {
1127 case CFN_BUILT_IN_ATOMIC_FETCH_OR_1:
1128 if (gimple_call_num_args (_c2) == 3)
1129 {
1130 tree _q20 = gimple_call_arg (_c2, 0);
1131 _q20 = do_valueize (valueize, _q20);
1132 tree _q21 = gimple_call_arg (_c2, 1);
1133 _q21 = do_valueize (valueize, _q21);
1134 tree _q22 = gimple_call_arg (_c2, 2);
1135 _q22 = do_valueize (valueize, _q22);
1136 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
1137 {
1138 case SSA_NAME:
1139 if (gimple *_d3 = get_def (valueize, _q21))
1140 {
1141 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
1142 switch (gimple_assign_rhs_code (_a3))
1143 {
1144 case LSHIFT_EXPR:
1145 {
1146 tree _q40 = gimple_assign_rhs1 (_a3);
1147 _q40 = do_valueize (valueize, _q40);
1148 tree _q41 = gimple_assign_rhs2 (_a3);
1149 _q41 = do_valueize (valueize, _q41);
1150 if (integer_onep (_q40))
1151 {
1152 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 1152, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
1153 {
1154 {
1155/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1156 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41, _q22 };
1157 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__1157);
1158 {
1159 res_ops[0] = captures[0];
1160 res_ops[1] = captures[0];
1161 res_ops[2] = captures[1];
1162 return true;
1163 }
1164next_after_fail48:;
1165 }
1166 }
1167 }
1168 break;
1169 }
1170 default:;
1171 }
1172 }
1173 break;
1174 case INTEGER_CST:
1175 {
1176 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1177 {
1178 case INTEGER_CST:
1179 {
1180 {
1181/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1182 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20, _q22 };
1183 {
1184/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1185 int ibit = tree_log2 (captures[0]);
1186 int ibit2 = tree_log2 (captures[1]);
1187/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1188 if (ibit == ibit2
1189 && ibit >= 0
1190)
1191 {
1192 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__1192);
1193 {
1194 res_ops[0] = captures[0];
1195 res_ops[1] = captures[1];
1196 res_ops[2] = captures[2];
1197 return true;
1198 }
1199next_after_fail49:;
1200 }
1201 }
1202 }
1203 break;
1204 }
1205 default:;
1206 }
1207 break;
1208 }
1209 default:;
1210 }
1211 }
1212 break;
1213 case CFN_BUILT_IN_ATOMIC_FETCH_OR_2:
1214 if (gimple_call_num_args (_c2) == 3)
1215 {
1216 tree _q20 = gimple_call_arg (_c2, 0);
1217 _q20 = do_valueize (valueize, _q20);
1218 tree _q21 = gimple_call_arg (_c2, 1);
1219 _q21 = do_valueize (valueize, _q21);
1220 tree _q22 = gimple_call_arg (_c2, 2);
1221 _q22 = do_valueize (valueize, _q22);
1222 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
1223 {
1224 case SSA_NAME:
1225 if (gimple *_d3 = get_def (valueize, _q21))
1226 {
1227 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
1228 switch (gimple_assign_rhs_code (_a3))
1229 {
1230 case LSHIFT_EXPR:
1231 {
1232 tree _q40 = gimple_assign_rhs1 (_a3);
1233 _q40 = do_valueize (valueize, _q40);
1234 tree _q41 = gimple_assign_rhs2 (_a3);
1235 _q41 = do_valueize (valueize, _q41);
1236 if (integer_onep (_q40))
1237 {
1238 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 1238, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
1239 {
1240 {
1241/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1242 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41, _q22 };
1243 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__1243);
1244 {
1245 res_ops[0] = captures[0];
1246 res_ops[1] = captures[0];
1247 res_ops[2] = captures[1];
1248 return true;
1249 }
1250next_after_fail50:;
1251 }
1252 }
1253 }
1254 break;
1255 }
1256 default:;
1257 }
1258 }
1259 break;
1260 case INTEGER_CST:
1261 {
1262 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1263 {
1264 case INTEGER_CST:
1265 {
1266 {
1267/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1268 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20, _q22 };
1269 {
1270/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1271 int ibit = tree_log2 (captures[0]);
1272 int ibit2 = tree_log2 (captures[1]);
1273/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1274 if (ibit == ibit2
1275 && ibit >= 0
1276)
1277 {
1278 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__1278);
1279 {
1280 res_ops[0] = captures[0];
1281 res_ops[1] = captures[1];
1282 res_ops[2] = captures[2];
1283 return true;
1284 }
1285next_after_fail51:;
1286 }
1287 }
1288 }
1289 break;
1290 }
1291 default:;
1292 }
1293 break;
1294 }
1295 default:;
1296 }
1297 }
1298 break;
1299 case CFN_BUILT_IN_ATOMIC_FETCH_OR_4:
1300 if (gimple_call_num_args (_c2) == 3)
1301 {
1302 tree _q20 = gimple_call_arg (_c2, 0);
1303 _q20 = do_valueize (valueize, _q20);
1304 tree _q21 = gimple_call_arg (_c2, 1);
1305 _q21 = do_valueize (valueize, _q21);
1306 tree _q22 = gimple_call_arg (_c2, 2);
1307 _q22 = do_valueize (valueize, _q22);
1308 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
1309 {
1310 case SSA_NAME:
1311 if (gimple *_d3 = get_def (valueize, _q21))
1312 {
1313 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
1314 switch (gimple_assign_rhs_code (_a3))
1315 {
1316 case LSHIFT_EXPR:
1317 {
1318 tree _q40 = gimple_assign_rhs1 (_a3);
1319 _q40 = do_valueize (valueize, _q40);
1320 tree _q41 = gimple_assign_rhs2 (_a3);
1321 _q41 = do_valueize (valueize, _q41);
1322 if (integer_onep (_q40))
1323 {
1324 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 1324, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
1325 {
1326 {
1327/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1328 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41, _q22 };
1329 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__1329);
1330 {
1331 res_ops[0] = captures[0];
1332 res_ops[1] = captures[0];
1333 res_ops[2] = captures[1];
1334 return true;
1335 }
1336next_after_fail52:;
1337 }
1338 }
1339 }
1340 break;
1341 }
1342 default:;
1343 }
1344 }
1345 break;
1346 case INTEGER_CST:
1347 {
1348 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1349 {
1350 case INTEGER_CST:
1351 {
1352 {
1353/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1354 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20, _q22 };
1355 {
1356/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1357 int ibit = tree_log2 (captures[0]);
1358 int ibit2 = tree_log2 (captures[1]);
1359/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1360 if (ibit == ibit2
1361 && ibit >= 0
1362)
1363 {
1364 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__1364);
1365 {
1366 res_ops[0] = captures[0];
1367 res_ops[1] = captures[1];
1368 res_ops[2] = captures[2];
1369 return true;
1370 }
1371next_after_fail53:;
1372 }
1373 }
1374 }
1375 break;
1376 }
1377 default:;
1378 }
1379 break;
1380 }
1381 default:;
1382 }
1383 }
1384 break;
1385 case CFN_BUILT_IN_ATOMIC_FETCH_OR_8:
1386 if (gimple_call_num_args (_c2) == 3)
1387 {
1388 tree _q20 = gimple_call_arg (_c2, 0);
1389 _q20 = do_valueize (valueize, _q20);
1390 tree _q21 = gimple_call_arg (_c2, 1);
1391 _q21 = do_valueize (valueize, _q21);
1392 tree _q22 = gimple_call_arg (_c2, 2);
1393 _q22 = do_valueize (valueize, _q22);
1394 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
1395 {
1396 case SSA_NAME:
1397 if (gimple *_d3 = get_def (valueize, _q21))
1398 {
1399 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
1400 switch (gimple_assign_rhs_code (_a3))
1401 {
1402 case LSHIFT_EXPR:
1403 {
1404 tree _q40 = gimple_assign_rhs1 (_a3);
1405 _q40 = do_valueize (valueize, _q40);
1406 tree _q41 = gimple_assign_rhs2 (_a3);
1407 _q41 = do_valueize (valueize, _q41);
1408 if (integer_onep (_q40))
1409 {
1410 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 1410, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
1411 {
1412 {
1413/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1414 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41, _q22 };
1415 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__1415);
1416 {
1417 res_ops[0] = captures[0];
1418 res_ops[1] = captures[0];
1419 res_ops[2] = captures[1];
1420 return true;
1421 }
1422next_after_fail54:;
1423 }
1424 }
1425 }
1426 break;
1427 }
1428 default:;
1429 }
1430 }
1431 break;
1432 case INTEGER_CST:
1433 {
1434 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1435 {
1436 case INTEGER_CST:
1437 {
1438 {
1439/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1440 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20, _q22 };
1441 {
1442/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1443 int ibit = tree_log2 (captures[0]);
1444 int ibit2 = tree_log2 (captures[1]);
1445/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1446 if (ibit == ibit2
1447 && ibit >= 0
1448)
1449 {
1450 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__1450);
1451 {
1452 res_ops[0] = captures[0];
1453 res_ops[1] = captures[1];
1454 res_ops[2] = captures[2];
1455 return true;
1456 }
1457next_after_fail55:;
1458 }
1459 }
1460 }
1461 break;
1462 }
1463 default:;
1464 }
1465 break;
1466 }
1467 default:;
1468 }
1469 }
1470 break;
1471 case CFN_BUILT_IN_ATOMIC_FETCH_OR_16:
1472 if (gimple_call_num_args (_c2) == 3)
1473 {
1474 tree _q20 = gimple_call_arg (_c2, 0);
1475 _q20 = do_valueize (valueize, _q20);
1476 tree _q21 = gimple_call_arg (_c2, 1);
1477 _q21 = do_valueize (valueize, _q21);
1478 tree _q22 = gimple_call_arg (_c2, 2);
1479 _q22 = do_valueize (valueize, _q22);
1480 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
1481 {
1482 case SSA_NAME:
1483 if (gimple *_d3 = get_def (valueize, _q21))
1484 {
1485 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
1486 switch (gimple_assign_rhs_code (_a3))
1487 {
1488 case LSHIFT_EXPR:
1489 {
1490 tree _q40 = gimple_assign_rhs1 (_a3);
1491 _q40 = do_valueize (valueize, _q40);
1492 tree _q41 = gimple_assign_rhs2 (_a3);
1493 _q41 = do_valueize (valueize, _q41);
1494 if (integer_onep (_q40))
1495 {
1496 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 1496, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
1497 {
1498 {
1499/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1500 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41, _q22 };
1501 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__1501);
1502 {
1503 res_ops[0] = captures[0];
1504 res_ops[1] = captures[0];
1505 res_ops[2] = captures[1];
1506 return true;
1507 }
1508next_after_fail56:;
1509 }
1510 }
1511 }
1512 break;
1513 }
1514 default:;
1515 }
1516 }
1517 break;
1518 case INTEGER_CST:
1519 {
1520 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1521 {
1522 case INTEGER_CST:
1523 {
1524 {
1525/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1526 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20, _q22 };
1527 {
1528/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1529 int ibit = tree_log2 (captures[0]);
1530 int ibit2 = tree_log2 (captures[1]);
1531/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1532 if (ibit == ibit2
1533 && ibit >= 0
1534)
1535 {
1536 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__1536);
1537 {
1538 res_ops[0] = captures[0];
1539 res_ops[1] = captures[1];
1540 res_ops[2] = captures[2];
1541 return true;
1542 }
1543next_after_fail57:;
1544 }
1545 }
1546 }
1547 break;
1548 }
1549 default:;
1550 }
1551 break;
1552 }
1553 default:;
1554 }
1555 }
1556 break;
1557 case CFN_BUILT_IN_ATOMIC_FETCH_XOR_1:
1558 if (gimple_call_num_args (_c2) == 3)
1559 {
1560 tree _q20 = gimple_call_arg (_c2, 0);
1561 _q20 = do_valueize (valueize, _q20);
1562 tree _q21 = gimple_call_arg (_c2, 1);
1563 _q21 = do_valueize (valueize, _q21);
1564 tree _q22 = gimple_call_arg (_c2, 2);
1565 _q22 = do_valueize (valueize, _q22);
1566 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
1567 {
1568 case SSA_NAME:
1569 if (gimple *_d3 = get_def (valueize, _q21))
1570 {
1571 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
1572 switch (gimple_assign_rhs_code (_a3))
1573 {
1574 case LSHIFT_EXPR:
1575 {
1576 tree _q40 = gimple_assign_rhs1 (_a3);
1577 _q40 = do_valueize (valueize, _q40);
1578 tree _q41 = gimple_assign_rhs2 (_a3);
1579 _q41 = do_valueize (valueize, _q41);
1580 if (integer_onep (_q40))
1581 {
1582 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 1582, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
1583 {
1584 {
1585/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1586 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41, _q22 };
1587 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__1587);
1588 {
1589 res_ops[0] = captures[0];
1590 res_ops[1] = captures[0];
1591 res_ops[2] = captures[1];
1592 return true;
1593 }
1594next_after_fail58:;
1595 }
1596 }
1597 }
1598 break;
1599 }
1600 default:;
1601 }
1602 }
1603 break;
1604 case INTEGER_CST:
1605 {
1606 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1607 {
1608 case INTEGER_CST:
1609 {
1610 {
1611/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1612 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20, _q22 };
1613 {
1614/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1615 int ibit = tree_log2 (captures[0]);
1616 int ibit2 = tree_log2 (captures[1]);
1617/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1618 if (ibit == ibit2
1619 && ibit >= 0
1620)
1621 {
1622 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__1622);
1623 {
1624 res_ops[0] = captures[0];
1625 res_ops[1] = captures[1];
1626 res_ops[2] = captures[2];
1627 return true;
1628 }
1629next_after_fail59:;
1630 }
1631 }
1632 }
1633 break;
1634 }
1635 default:;
1636 }
1637 break;
1638 }
1639 default:;
1640 }
1641 }
1642 break;
1643 case CFN_BUILT_IN_ATOMIC_FETCH_XOR_2:
1644 if (gimple_call_num_args (_c2) == 3)
1645 {
1646 tree _q20 = gimple_call_arg (_c2, 0);
1647 _q20 = do_valueize (valueize, _q20);
1648 tree _q21 = gimple_call_arg (_c2, 1);
1649 _q21 = do_valueize (valueize, _q21);
1650 tree _q22 = gimple_call_arg (_c2, 2);
1651 _q22 = do_valueize (valueize, _q22);
1652 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
1653 {
1654 case SSA_NAME:
1655 if (gimple *_d3 = get_def (valueize, _q21))
1656 {
1657 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
1658 switch (gimple_assign_rhs_code (_a3))
1659 {
1660 case LSHIFT_EXPR:
1661 {
1662 tree _q40 = gimple_assign_rhs1 (_a3);
1663 _q40 = do_valueize (valueize, _q40);
1664 tree _q41 = gimple_assign_rhs2 (_a3);
1665 _q41 = do_valueize (valueize, _q41);
1666 if (integer_onep (_q40))
1667 {
1668 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 1668, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
1669 {
1670 {
1671/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1672 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41, _q22 };
1673 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__1673);
1674 {
1675 res_ops[0] = captures[0];
1676 res_ops[1] = captures[0];
1677 res_ops[2] = captures[1];
1678 return true;
1679 }
1680next_after_fail60:;
1681 }
1682 }
1683 }
1684 break;
1685 }
1686 default:;
1687 }
1688 }
1689 break;
1690 case INTEGER_CST:
1691 {
1692 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1693 {
1694 case INTEGER_CST:
1695 {
1696 {
1697/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1698 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20, _q22 };
1699 {
1700/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1701 int ibit = tree_log2 (captures[0]);
1702 int ibit2 = tree_log2 (captures[1]);
1703/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1704 if (ibit == ibit2
1705 && ibit >= 0
1706)
1707 {
1708 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__1708);
1709 {
1710 res_ops[0] = captures[0];
1711 res_ops[1] = captures[1];
1712 res_ops[2] = captures[2];
1713 return true;
1714 }
1715next_after_fail61:;
1716 }
1717 }
1718 }
1719 break;
1720 }
1721 default:;
1722 }
1723 break;
1724 }
1725 default:;
1726 }
1727 }
1728 break;
1729 case CFN_BUILT_IN_ATOMIC_FETCH_XOR_4:
1730 if (gimple_call_num_args (_c2) == 3)
1731 {
1732 tree _q20 = gimple_call_arg (_c2, 0);
1733 _q20 = do_valueize (valueize, _q20);
1734 tree _q21 = gimple_call_arg (_c2, 1);
1735 _q21 = do_valueize (valueize, _q21);
1736 tree _q22 = gimple_call_arg (_c2, 2);
1737 _q22 = do_valueize (valueize, _q22);
1738 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
1739 {
1740 case SSA_NAME:
1741 if (gimple *_d3 = get_def (valueize, _q21))
1742 {
1743 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
1744 switch (gimple_assign_rhs_code (_a3))
1745 {
1746 case LSHIFT_EXPR:
1747 {
1748 tree _q40 = gimple_assign_rhs1 (_a3);
1749 _q40 = do_valueize (valueize, _q40);
1750 tree _q41 = gimple_assign_rhs2 (_a3);
1751 _q41 = do_valueize (valueize, _q41);
1752 if (integer_onep (_q40))
1753 {
1754 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 1754, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
1755 {
1756 {
1757/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1758 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41, _q22 };
1759 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__1759);
1760 {
1761 res_ops[0] = captures[0];
1762 res_ops[1] = captures[0];
1763 res_ops[2] = captures[1];
1764 return true;
1765 }
1766next_after_fail62:;
1767 }
1768 }
1769 }
1770 break;
1771 }
1772 default:;
1773 }
1774 }
1775 break;
1776 case INTEGER_CST:
1777 {
1778 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1779 {
1780 case INTEGER_CST:
1781 {
1782 {
1783/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1784 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20, _q22 };
1785 {
1786/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1787 int ibit = tree_log2 (captures[0]);
1788 int ibit2 = tree_log2 (captures[1]);
1789/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1790 if (ibit == ibit2
1791 && ibit >= 0
1792)
1793 {
1794 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__1794);
1795 {
1796 res_ops[0] = captures[0];
1797 res_ops[1] = captures[1];
1798 res_ops[2] = captures[2];
1799 return true;
1800 }
1801next_after_fail63:;
1802 }
1803 }
1804 }
1805 break;
1806 }
1807 default:;
1808 }
1809 break;
1810 }
1811 default:;
1812 }
1813 }
1814 break;
1815 case CFN_BUILT_IN_ATOMIC_FETCH_XOR_8:
1816 if (gimple_call_num_args (_c2) == 3)
1817 {
1818 tree _q20 = gimple_call_arg (_c2, 0);
1819 _q20 = do_valueize (valueize, _q20);
1820 tree _q21 = gimple_call_arg (_c2, 1);
1821 _q21 = do_valueize (valueize, _q21);
1822 tree _q22 = gimple_call_arg (_c2, 2);
1823 _q22 = do_valueize (valueize, _q22);
1824 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
1825 {
1826 case SSA_NAME:
1827 if (gimple *_d3 = get_def (valueize, _q21))
1828 {
1829 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
1830 switch (gimple_assign_rhs_code (_a3))
1831 {
1832 case LSHIFT_EXPR:
1833 {
1834 tree _q40 = gimple_assign_rhs1 (_a3);
1835 _q40 = do_valueize (valueize, _q40);
1836 tree _q41 = gimple_assign_rhs2 (_a3);
1837 _q41 = do_valueize (valueize, _q41);
1838 if (integer_onep (_q40))
1839 {
1840 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 1840, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
1841 {
1842 {
1843/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1844 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41, _q22 };
1845 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__1845);
1846 {
1847 res_ops[0] = captures[0];
1848 res_ops[1] = captures[0];
1849 res_ops[2] = captures[1];
1850 return true;
1851 }
1852next_after_fail64:;
1853 }
1854 }
1855 }
1856 break;
1857 }
1858 default:;
1859 }
1860 }
1861 break;
1862 case INTEGER_CST:
1863 {
1864 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1865 {
1866 case INTEGER_CST:
1867 {
1868 {
1869/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1870 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20, _q22 };
1871 {
1872/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1873 int ibit = tree_log2 (captures[0]);
1874 int ibit2 = tree_log2 (captures[1]);
1875/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1876 if (ibit == ibit2
1877 && ibit >= 0
1878)
1879 {
1880 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__1880);
1881 {
1882 res_ops[0] = captures[0];
1883 res_ops[1] = captures[1];
1884 res_ops[2] = captures[2];
1885 return true;
1886 }
1887next_after_fail65:;
1888 }
1889 }
1890 }
1891 break;
1892 }
1893 default:;
1894 }
1895 break;
1896 }
1897 default:;
1898 }
1899 }
1900 break;
1901 case CFN_BUILT_IN_ATOMIC_FETCH_XOR_16:
1902 if (gimple_call_num_args (_c2) == 3)
1903 {
1904 tree _q20 = gimple_call_arg (_c2, 0);
1905 _q20 = do_valueize (valueize, _q20);
1906 tree _q21 = gimple_call_arg (_c2, 1);
1907 _q21 = do_valueize (valueize, _q21);
1908 tree _q22 = gimple_call_arg (_c2, 2);
1909 _q22 = do_valueize (valueize, _q22);
1910 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
1911 {
1912 case SSA_NAME:
1913 if (gimple *_d3 = get_def (valueize, _q21))
1914 {
1915 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
1916 switch (gimple_assign_rhs_code (_a3))
1917 {
1918 case LSHIFT_EXPR:
1919 {
1920 tree _q40 = gimple_assign_rhs1 (_a3);
1921 _q40 = do_valueize (valueize, _q40);
1922 tree _q41 = gimple_assign_rhs2 (_a3);
1923 _q41 = do_valueize (valueize, _q41);
1924 if (integer_onep (_q40))
1925 {
1926 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 1926, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
1927 {
1928 {
1929/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1930 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41, _q22 };
1931 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__1931);
1932 {
1933 res_ops[0] = captures[0];
1934 res_ops[1] = captures[0];
1935 res_ops[2] = captures[1];
1936 return true;
1937 }
1938next_after_fail66:;
1939 }
1940 }
1941 }
1942 break;
1943 }
1944 default:;
1945 }
1946 }
1947 break;
1948 case INTEGER_CST:
1949 {
1950 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1951 {
1952 case INTEGER_CST:
1953 {
1954 {
1955/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1956 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20, _q22 };
1957 {
1958/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1959 int ibit = tree_log2 (captures[0]);
1960 int ibit2 = tree_log2 (captures[1]);
1961/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1962 if (ibit == ibit2
1963 && ibit >= 0
1964)
1965 {
1966 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__1966);
1967 {
1968 res_ops[0] = captures[0];
1969 res_ops[1] = captures[1];
1970 res_ops[2] = captures[2];
1971 return true;
1972 }
1973next_after_fail67:;
1974 }
1975 }
1976 }
1977 break;
1978 }
1979 default:;
1980 }
1981 break;
1982 }
1983 default:;
1984 }
1985 }
1986 break;
1987 case CFN_BUILT_IN_ATOMIC_XOR_FETCH_1:
1988 if (gimple_call_num_args (_c2) == 3)
1989 {
1990 tree _q20 = gimple_call_arg (_c2, 0);
1991 _q20 = do_valueize (valueize, _q20);
1992 tree _q21 = gimple_call_arg (_c2, 1);
1993 _q21 = do_valueize (valueize, _q21);
1994 tree _q22 = gimple_call_arg (_c2, 2);
1995 _q22 = do_valueize (valueize, _q22);
1996 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
1997 {
1998 case SSA_NAME:
1999 if (gimple *_d3 = get_def (valueize, _q21))
2000 {
2001 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
2002 switch (gimple_assign_rhs_code (_a3))
2003 {
2004 case LSHIFT_EXPR:
2005 {
2006 tree _q40 = gimple_assign_rhs1 (_a3);
2007 _q40 = do_valueize (valueize, _q40);
2008 tree _q41 = gimple_assign_rhs2 (_a3);
2009 _q41 = do_valueize (valueize, _q41);
2010 if (integer_onep (_q40))
2011 {
2012 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 2012, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
2013 {
2014 {
2015/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2016 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41, _q22 };
2017 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__2017);
2018 {
2019 res_ops[0] = captures[0];
2020 res_ops[1] = captures[0];
2021 res_ops[2] = captures[1];
2022 return true;
2023 }
2024next_after_fail68:;
2025 }
2026 }
2027 }
2028 break;
2029 }
2030 default:;
2031 }
2032 }
2033 break;
2034 case INTEGER_CST:
2035 {
2036 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2037 {
2038 case INTEGER_CST:
2039 {
2040 {
2041/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2042 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20, _q22 };
2043 {
2044/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2045 int ibit = tree_log2 (captures[0]);
2046 int ibit2 = tree_log2 (captures[1]);
2047/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2048 if (ibit == ibit2
2049 && ibit >= 0
2050)
2051 {
2052 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__2052);
2053 {
2054 res_ops[0] = captures[0];
2055 res_ops[1] = captures[1];
2056 res_ops[2] = captures[2];
2057 return true;
2058 }
2059next_after_fail69:;
2060 }
2061 }
2062 }
2063 break;
2064 }
2065 default:;
2066 }
2067 break;
2068 }
2069 default:;
2070 }
2071 }
2072 break;
2073 case CFN_BUILT_IN_ATOMIC_XOR_FETCH_2:
2074 if (gimple_call_num_args (_c2) == 3)
2075 {
2076 tree _q20 = gimple_call_arg (_c2, 0);
2077 _q20 = do_valueize (valueize, _q20);
2078 tree _q21 = gimple_call_arg (_c2, 1);
2079 _q21 = do_valueize (valueize, _q21);
2080 tree _q22 = gimple_call_arg (_c2, 2);
2081 _q22 = do_valueize (valueize, _q22);
2082 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
2083 {
2084 case SSA_NAME:
2085 if (gimple *_d3 = get_def (valueize, _q21))
2086 {
2087 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
2088 switch (gimple_assign_rhs_code (_a3))
2089 {
2090 case LSHIFT_EXPR:
2091 {
2092 tree _q40 = gimple_assign_rhs1 (_a3);
2093 _q40 = do_valueize (valueize, _q40);
2094 tree _q41 = gimple_assign_rhs2 (_a3);
2095 _q41 = do_valueize (valueize, _q41);
2096 if (integer_onep (_q40))
2097 {
2098 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 2098, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
2099 {
2100 {
2101/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2102 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41, _q22 };
2103 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__2103);
2104 {
2105 res_ops[0] = captures[0];
2106 res_ops[1] = captures[0];
2107 res_ops[2] = captures[1];
2108 return true;
2109 }
2110next_after_fail70:;
2111 }
2112 }
2113 }
2114 break;
2115 }
2116 default:;
2117 }
2118 }
2119 break;
2120 case INTEGER_CST:
2121 {
2122 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2123 {
2124 case INTEGER_CST:
2125 {
2126 {
2127/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2128 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20, _q22 };
2129 {
2130/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2131 int ibit = tree_log2 (captures[0]);
2132 int ibit2 = tree_log2 (captures[1]);
2133/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2134 if (ibit == ibit2
2135 && ibit >= 0
2136)
2137 {
2138 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__2138);
2139 {
2140 res_ops[0] = captures[0];
2141 res_ops[1] = captures[1];
2142 res_ops[2] = captures[2];
2143 return true;
2144 }
2145next_after_fail71:;
2146 }
2147 }
2148 }
2149 break;
2150 }
2151 default:;
2152 }
2153 break;
2154 }
2155 default:;
2156 }
2157 }
2158 break;
2159 case CFN_BUILT_IN_ATOMIC_XOR_FETCH_4:
2160 if (gimple_call_num_args (_c2) == 3)
2161 {
2162 tree _q20 = gimple_call_arg (_c2, 0);
2163 _q20 = do_valueize (valueize, _q20);
2164 tree _q21 = gimple_call_arg (_c2, 1);
2165 _q21 = do_valueize (valueize, _q21);
2166 tree _q22 = gimple_call_arg (_c2, 2);
2167 _q22 = do_valueize (valueize, _q22);
2168 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
2169 {
2170 case SSA_NAME:
2171 if (gimple *_d3 = get_def (valueize, _q21))
2172 {
2173 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
2174 switch (gimple_assign_rhs_code (_a3))
2175 {
2176 case LSHIFT_EXPR:
2177 {
2178 tree _q40 = gimple_assign_rhs1 (_a3);
2179 _q40 = do_valueize (valueize, _q40);
2180 tree _q41 = gimple_assign_rhs2 (_a3);
2181 _q41 = do_valueize (valueize, _q41);
2182 if (integer_onep (_q40))
2183 {
2184 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 2184, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
2185 {
2186 {
2187/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2188 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41, _q22 };
2189 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__2189);
2190 {
2191 res_ops[0] = captures[0];
2192 res_ops[1] = captures[0];
2193 res_ops[2] = captures[1];
2194 return true;
2195 }
2196next_after_fail72:;
2197 }
2198 }
2199 }
2200 break;
2201 }
2202 default:;
2203 }
2204 }
2205 break;
2206 case INTEGER_CST:
2207 {
2208 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2209 {
2210 case INTEGER_CST:
2211 {
2212 {
2213/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2214 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20, _q22 };
2215 {
2216/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2217 int ibit = tree_log2 (captures[0]);
2218 int ibit2 = tree_log2 (captures[1]);
2219/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2220 if (ibit == ibit2
2221 && ibit >= 0
2222)
2223 {
2224 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__2224);
2225 {
2226 res_ops[0] = captures[0];
2227 res_ops[1] = captures[1];
2228 res_ops[2] = captures[2];
2229 return true;
2230 }
2231next_after_fail73:;
2232 }
2233 }
2234 }
2235 break;
2236 }
2237 default:;
2238 }
2239 break;
2240 }
2241 default:;
2242 }
2243 }
2244 break;
2245 case CFN_BUILT_IN_ATOMIC_XOR_FETCH_8:
2246 if (gimple_call_num_args (_c2) == 3)
2247 {
2248 tree _q20 = gimple_call_arg (_c2, 0);
2249 _q20 = do_valueize (valueize, _q20);
2250 tree _q21 = gimple_call_arg (_c2, 1);
2251 _q21 = do_valueize (valueize, _q21);
2252 tree _q22 = gimple_call_arg (_c2, 2);
2253 _q22 = do_valueize (valueize, _q22);
2254 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
2255 {
2256 case SSA_NAME:
2257 if (gimple *_d3 = get_def (valueize, _q21))
2258 {
2259 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
2260 switch (gimple_assign_rhs_code (_a3))
2261 {
2262 case LSHIFT_EXPR:
2263 {
2264 tree _q40 = gimple_assign_rhs1 (_a3);
2265 _q40 = do_valueize (valueize, _q40);
2266 tree _q41 = gimple_assign_rhs2 (_a3);
2267 _q41 = do_valueize (valueize, _q41);
2268 if (integer_onep (_q40))
2269 {
2270 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 2270, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
2271 {
2272 {
2273/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2274 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41, _q22 };
2275 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__2275);
2276 {
2277 res_ops[0] = captures[0];
2278 res_ops[1] = captures[0];
2279 res_ops[2] = captures[1];
2280 return true;
2281 }
2282next_after_fail74:;
2283 }
2284 }
2285 }
2286 break;
2287 }
2288 default:;
2289 }
2290 }
2291 break;
2292 case INTEGER_CST:
2293 {
2294 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2295 {
2296 case INTEGER_CST:
2297 {
2298 {
2299/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2300 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20, _q22 };
2301 {
2302/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2303 int ibit = tree_log2 (captures[0]);
2304 int ibit2 = tree_log2 (captures[1]);
2305/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2306 if (ibit == ibit2
2307 && ibit >= 0
2308)
2309 {
2310 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__2310);
2311 {
2312 res_ops[0] = captures[0];
2313 res_ops[1] = captures[1];
2314 res_ops[2] = captures[2];
2315 return true;
2316 }
2317next_after_fail75:;
2318 }
2319 }
2320 }
2321 break;
2322 }
2323 default:;
2324 }
2325 break;
2326 }
2327 default:;
2328 }
2329 }
2330 break;
2331 case CFN_BUILT_IN_ATOMIC_XOR_FETCH_16:
2332 if (gimple_call_num_args (_c2) == 3)
2333 {
2334 tree _q20 = gimple_call_arg (_c2, 0);
2335 _q20 = do_valueize (valueize, _q20);
2336 tree _q21 = gimple_call_arg (_c2, 1);
2337 _q21 = do_valueize (valueize, _q21);
2338 tree _q22 = gimple_call_arg (_c2, 2);
2339 _q22 = do_valueize (valueize, _q22);
2340 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
2341 {
2342 case SSA_NAME:
2343 if (gimple *_d3 = get_def (valueize, _q21))
2344 {
2345 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
2346 switch (gimple_assign_rhs_code (_a3))
2347 {
2348 case LSHIFT_EXPR:
2349 {
2350 tree _q40 = gimple_assign_rhs1 (_a3);
2351 _q40 = do_valueize (valueize, _q40);
2352 tree _q41 = gimple_assign_rhs2 (_a3);
2353 _q41 = do_valueize (valueize, _q41);
2354 if (integer_onep (_q40))
2355 {
2356 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 2356, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
2357 {
2358 {
2359/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2360 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41, _q22 };
2361 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__2361);
2362 {
2363 res_ops[0] = captures[0];
2364 res_ops[1] = captures[0];
2365 res_ops[2] = captures[1];
2366 return true;
2367 }
2368next_after_fail76:;
2369 }
2370 }
2371 }
2372 break;
2373 }
2374 default:;
2375 }
2376 }
2377 break;
2378 case INTEGER_CST:
2379 {
2380 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2381 {
2382 case INTEGER_CST:
2383 {
2384 {
2385/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2386 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20, _q22 };
2387 {
2388/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2389 int ibit = tree_log2 (captures[0]);
2390 int ibit2 = tree_log2 (captures[1]);
2391/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2392 if (ibit == ibit2
2393 && ibit >= 0
2394)
2395 {
2396 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__2396);
2397 {
2398 res_ops[0] = captures[0];
2399 res_ops[1] = captures[1];
2400 res_ops[2] = captures[2];
2401 return true;
2402 }
2403next_after_fail77:;
2404 }
2405 }
2406 }
2407 break;
2408 }
2409 default:;
2410 }
2411 break;
2412 }
2413 default:;
2414 }
2415 }
2416 break;
2417 case CFN_BUILT_IN_SYNC_FETCH_AND_OR_1:
2418 if (gimple_call_num_args (_c2) == 2)
2419 {
2420 tree _q20 = gimple_call_arg (_c2, 0);
2421 _q20 = do_valueize (valueize, _q20);
2422 tree _q21 = gimple_call_arg (_c2, 1);
2423 _q21 = do_valueize (valueize, _q21);
2424 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
2425 {
2426 case SSA_NAME:
2427 if (gimple *_d3 = get_def (valueize, _q21))
2428 {
2429 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
2430 switch (gimple_assign_rhs_code (_a3))
2431 {
2432 case LSHIFT_EXPR:
2433 {
2434 tree _q40 = gimple_assign_rhs1 (_a3);
2435 _q40 = do_valueize (valueize, _q40);
2436 tree _q41 = gimple_assign_rhs2 (_a3);
2437 _q41 = do_valueize (valueize, _q41);
2438 if (integer_onep (_q40))
2439 {
2440 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 2440, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
2441 {
2442 {
2443/* #line 4058 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2444 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41 };
2445 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4058, __FILE__"gimple-match.c", __LINE__2445);
2446 {
2447 res_ops[0] = captures[0];
2448 res_ops[1] = captures[0];
2449 res_ops[2] = captures[1];
2450 return true;
2451 }
2452next_after_fail78:;
2453 }
2454 }
2455 }
2456 break;
2457 }
2458 default:;
2459 }
2460 }
2461 break;
2462 case INTEGER_CST:
2463 {
2464 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2465 {
2466 case INTEGER_CST:
2467 {
2468 {
2469/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2470 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20 };
2471 {
2472/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2473 int ibit = tree_log2 (captures[0]);
2474 int ibit2 = tree_log2 (captures[1]);
2475/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2476 if (ibit == ibit2
2477 && ibit >= 0
2478)
2479 {
2480 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__2480);
2481 {
2482 res_ops[0] = captures[0];
2483 res_ops[1] = captures[1];
2484 res_ops[2] = captures[2];
2485 return true;
2486 }
2487next_after_fail79:;
2488 }
2489 }
2490 }
2491 break;
2492 }
2493 default:;
2494 }
2495 break;
2496 }
2497 default:;
2498 }
2499 }
2500 break;
2501 case CFN_BUILT_IN_SYNC_FETCH_AND_OR_2:
2502 if (gimple_call_num_args (_c2) == 2)
2503 {
2504 tree _q20 = gimple_call_arg (_c2, 0);
2505 _q20 = do_valueize (valueize, _q20);
2506 tree _q21 = gimple_call_arg (_c2, 1);
2507 _q21 = do_valueize (valueize, _q21);
2508 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
2509 {
2510 case SSA_NAME:
2511 if (gimple *_d3 = get_def (valueize, _q21))
2512 {
2513 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
2514 switch (gimple_assign_rhs_code (_a3))
2515 {
2516 case LSHIFT_EXPR:
2517 {
2518 tree _q40 = gimple_assign_rhs1 (_a3);
2519 _q40 = do_valueize (valueize, _q40);
2520 tree _q41 = gimple_assign_rhs2 (_a3);
2521 _q41 = do_valueize (valueize, _q41);
2522 if (integer_onep (_q40))
2523 {
2524 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 2524, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
2525 {
2526 {
2527/* #line 4058 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2528 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41 };
2529 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4058, __FILE__"gimple-match.c", __LINE__2529);
2530 {
2531 res_ops[0] = captures[0];
2532 res_ops[1] = captures[0];
2533 res_ops[2] = captures[1];
2534 return true;
2535 }
2536next_after_fail80:;
2537 }
2538 }
2539 }
2540 break;
2541 }
2542 default:;
2543 }
2544 }
2545 break;
2546 case INTEGER_CST:
2547 {
2548 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2549 {
2550 case INTEGER_CST:
2551 {
2552 {
2553/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2554 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20 };
2555 {
2556/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2557 int ibit = tree_log2 (captures[0]);
2558 int ibit2 = tree_log2 (captures[1]);
2559/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2560 if (ibit == ibit2
2561 && ibit >= 0
2562)
2563 {
2564 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__2564);
2565 {
2566 res_ops[0] = captures[0];
2567 res_ops[1] = captures[1];
2568 res_ops[2] = captures[2];
2569 return true;
2570 }
2571next_after_fail81:;
2572 }
2573 }
2574 }
2575 break;
2576 }
2577 default:;
2578 }
2579 break;
2580 }
2581 default:;
2582 }
2583 }
2584 break;
2585 case CFN_BUILT_IN_SYNC_FETCH_AND_OR_4:
2586 if (gimple_call_num_args (_c2) == 2)
2587 {
2588 tree _q20 = gimple_call_arg (_c2, 0);
2589 _q20 = do_valueize (valueize, _q20);
2590 tree _q21 = gimple_call_arg (_c2, 1);
2591 _q21 = do_valueize (valueize, _q21);
2592 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
2593 {
2594 case SSA_NAME:
2595 if (gimple *_d3 = get_def (valueize, _q21))
2596 {
2597 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
2598 switch (gimple_assign_rhs_code (_a3))
2599 {
2600 case LSHIFT_EXPR:
2601 {
2602 tree _q40 = gimple_assign_rhs1 (_a3);
2603 _q40 = do_valueize (valueize, _q40);
2604 tree _q41 = gimple_assign_rhs2 (_a3);
2605 _q41 = do_valueize (valueize, _q41);
2606 if (integer_onep (_q40))
2607 {
2608 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 2608, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
2609 {
2610 {
2611/* #line 4058 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2612 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41 };
2613 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4058, __FILE__"gimple-match.c", __LINE__2613);
2614 {
2615 res_ops[0] = captures[0];
2616 res_ops[1] = captures[0];
2617 res_ops[2] = captures[1];
2618 return true;
2619 }
2620next_after_fail82:;
2621 }
2622 }
2623 }
2624 break;
2625 }
2626 default:;
2627 }
2628 }
2629 break;
2630 case INTEGER_CST:
2631 {
2632 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2633 {
2634 case INTEGER_CST:
2635 {
2636 {
2637/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2638 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20 };
2639 {
2640/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2641 int ibit = tree_log2 (captures[0]);
2642 int ibit2 = tree_log2 (captures[1]);
2643/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2644 if (ibit == ibit2
2645 && ibit >= 0
2646)
2647 {
2648 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__2648);
2649 {
2650 res_ops[0] = captures[0];
2651 res_ops[1] = captures[1];
2652 res_ops[2] = captures[2];
2653 return true;
2654 }
2655next_after_fail83:;
2656 }
2657 }
2658 }
2659 break;
2660 }
2661 default:;
2662 }
2663 break;
2664 }
2665 default:;
2666 }
2667 }
2668 break;
2669 case CFN_BUILT_IN_SYNC_FETCH_AND_OR_8:
2670 if (gimple_call_num_args (_c2) == 2)
2671 {
2672 tree _q20 = gimple_call_arg (_c2, 0);
2673 _q20 = do_valueize (valueize, _q20);
2674 tree _q21 = gimple_call_arg (_c2, 1);
2675 _q21 = do_valueize (valueize, _q21);
2676 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
2677 {
2678 case SSA_NAME:
2679 if (gimple *_d3 = get_def (valueize, _q21))
2680 {
2681 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
2682 switch (gimple_assign_rhs_code (_a3))
2683 {
2684 case LSHIFT_EXPR:
2685 {
2686 tree _q40 = gimple_assign_rhs1 (_a3);
2687 _q40 = do_valueize (valueize, _q40);
2688 tree _q41 = gimple_assign_rhs2 (_a3);
2689 _q41 = do_valueize (valueize, _q41);
2690 if (integer_onep (_q40))
2691 {
2692 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 2692, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
2693 {
2694 {
2695/* #line 4058 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2696 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41 };
2697 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4058, __FILE__"gimple-match.c", __LINE__2697);
2698 {
2699 res_ops[0] = captures[0];
2700 res_ops[1] = captures[0];
2701 res_ops[2] = captures[1];
2702 return true;
2703 }
2704next_after_fail84:;
2705 }
2706 }
2707 }
2708 break;
2709 }
2710 default:;
2711 }
2712 }
2713 break;
2714 case INTEGER_CST:
2715 {
2716 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2717 {
2718 case INTEGER_CST:
2719 {
2720 {
2721/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2722 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20 };
2723 {
2724/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2725 int ibit = tree_log2 (captures[0]);
2726 int ibit2 = tree_log2 (captures[1]);
2727/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2728 if (ibit == ibit2
2729 && ibit >= 0
2730)
2731 {
2732 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__2732);
2733 {
2734 res_ops[0] = captures[0];
2735 res_ops[1] = captures[1];
2736 res_ops[2] = captures[2];
2737 return true;
2738 }
2739next_after_fail85:;
2740 }
2741 }
2742 }
2743 break;
2744 }
2745 default:;
2746 }
2747 break;
2748 }
2749 default:;
2750 }
2751 }
2752 break;
2753 case CFN_BUILT_IN_SYNC_FETCH_AND_OR_16:
2754 if (gimple_call_num_args (_c2) == 2)
2755 {
2756 tree _q20 = gimple_call_arg (_c2, 0);
2757 _q20 = do_valueize (valueize, _q20);
2758 tree _q21 = gimple_call_arg (_c2, 1);
2759 _q21 = do_valueize (valueize, _q21);
2760 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
2761 {
2762 case SSA_NAME:
2763 if (gimple *_d3 = get_def (valueize, _q21))
2764 {
2765 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
2766 switch (gimple_assign_rhs_code (_a3))
2767 {
2768 case LSHIFT_EXPR:
2769 {
2770 tree _q40 = gimple_assign_rhs1 (_a3);
2771 _q40 = do_valueize (valueize, _q40);
2772 tree _q41 = gimple_assign_rhs2 (_a3);
2773 _q41 = do_valueize (valueize, _q41);
2774 if (integer_onep (_q40))
2775 {
2776 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 2776, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
2777 {
2778 {
2779/* #line 4058 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2780 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41 };
2781 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4058, __FILE__"gimple-match.c", __LINE__2781);
2782 {
2783 res_ops[0] = captures[0];
2784 res_ops[1] = captures[0];
2785 res_ops[2] = captures[1];
2786 return true;
2787 }
2788next_after_fail86:;
2789 }
2790 }
2791 }
2792 break;
2793 }
2794 default:;
2795 }
2796 }
2797 break;
2798 case INTEGER_CST:
2799 {
2800 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2801 {
2802 case INTEGER_CST:
2803 {
2804 {
2805/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2806 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20 };
2807 {
2808/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2809 int ibit = tree_log2 (captures[0]);
2810 int ibit2 = tree_log2 (captures[1]);
2811/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2812 if (ibit == ibit2
2813 && ibit >= 0
2814)
2815 {
2816 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__2816);
2817 {
2818 res_ops[0] = captures[0];
2819 res_ops[1] = captures[1];
2820 res_ops[2] = captures[2];
2821 return true;
2822 }
2823next_after_fail87:;
2824 }
2825 }
2826 }
2827 break;
2828 }
2829 default:;
2830 }
2831 break;
2832 }
2833 default:;
2834 }
2835 }
2836 break;
2837 case CFN_BUILT_IN_SYNC_FETCH_AND_XOR_1:
2838 if (gimple_call_num_args (_c2) == 2)
2839 {
2840 tree _q20 = gimple_call_arg (_c2, 0);
2841 _q20 = do_valueize (valueize, _q20);
2842 tree _q21 = gimple_call_arg (_c2, 1);
2843 _q21 = do_valueize (valueize, _q21);
2844 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
2845 {
2846 case SSA_NAME:
2847 if (gimple *_d3 = get_def (valueize, _q21))
2848 {
2849 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
2850 switch (gimple_assign_rhs_code (_a3))
2851 {
2852 case LSHIFT_EXPR:
2853 {
2854 tree _q40 = gimple_assign_rhs1 (_a3);
2855 _q40 = do_valueize (valueize, _q40);
2856 tree _q41 = gimple_assign_rhs2 (_a3);
2857 _q41 = do_valueize (valueize, _q41);
2858 if (integer_onep (_q40))
2859 {
2860 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 2860, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
2861 {
2862 {
2863/* #line 4058 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2864 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41 };
2865 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4058, __FILE__"gimple-match.c", __LINE__2865);
2866 {
2867 res_ops[0] = captures[0];
2868 res_ops[1] = captures[0];
2869 res_ops[2] = captures[1];
2870 return true;
2871 }
2872next_after_fail88:;
2873 }
2874 }
2875 }
2876 break;
2877 }
2878 default:;
2879 }
2880 }
2881 break;
2882 case INTEGER_CST:
2883 {
2884 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2885 {
2886 case INTEGER_CST:
2887 {
2888 {
2889/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2890 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20 };
2891 {
2892/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2893 int ibit = tree_log2 (captures[0]);
2894 int ibit2 = tree_log2 (captures[1]);
2895/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2896 if (ibit == ibit2
2897 && ibit >= 0
2898)
2899 {
2900 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__2900);
2901 {
2902 res_ops[0] = captures[0];
2903 res_ops[1] = captures[1];
2904 res_ops[2] = captures[2];
2905 return true;
2906 }
2907next_after_fail89:;
2908 }
2909 }
2910 }
2911 break;
2912 }
2913 default:;
2914 }
2915 break;
2916 }
2917 default:;
2918 }
2919 }
2920 break;
2921 case CFN_BUILT_IN_SYNC_FETCH_AND_XOR_2:
2922 if (gimple_call_num_args (_c2) == 2)
2923 {
2924 tree _q20 = gimple_call_arg (_c2, 0);
2925 _q20 = do_valueize (valueize, _q20);
2926 tree _q21 = gimple_call_arg (_c2, 1);
2927 _q21 = do_valueize (valueize, _q21);
2928 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
2929 {
2930 case SSA_NAME:
2931 if (gimple *_d3 = get_def (valueize, _q21))
2932 {
2933 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
2934 switch (gimple_assign_rhs_code (_a3))
2935 {
2936 case LSHIFT_EXPR:
2937 {
2938 tree _q40 = gimple_assign_rhs1 (_a3);
2939 _q40 = do_valueize (valueize, _q40);
2940 tree _q41 = gimple_assign_rhs2 (_a3);
2941 _q41 = do_valueize (valueize, _q41);
2942 if (integer_onep (_q40))
2943 {
2944 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 2944, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
2945 {
2946 {
2947/* #line 4058 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2948 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41 };
2949 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4058, __FILE__"gimple-match.c", __LINE__2949);
2950 {
2951 res_ops[0] = captures[0];
2952 res_ops[1] = captures[0];
2953 res_ops[2] = captures[1];
2954 return true;
2955 }
2956next_after_fail90:;
2957 }
2958 }
2959 }
2960 break;
2961 }
2962 default:;
2963 }
2964 }
2965 break;
2966 case INTEGER_CST:
2967 {
2968 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2969 {
2970 case INTEGER_CST:
2971 {
2972 {
2973/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2974 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20 };
2975 {
2976/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2977 int ibit = tree_log2 (captures[0]);
2978 int ibit2 = tree_log2 (captures[1]);
2979/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2980 if (ibit == ibit2
2981 && ibit >= 0
2982)
2983 {
2984 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__2984);
2985 {
2986 res_ops[0] = captures[0];
2987 res_ops[1] = captures[1];
2988 res_ops[2] = captures[2];
2989 return true;
2990 }
2991next_after_fail91:;
2992 }
2993 }
2994 }
2995 break;
2996 }
2997 default:;
2998 }
2999 break;
3000 }
3001 default:;
3002 }
3003 }
3004 break;
3005 case CFN_BUILT_IN_SYNC_FETCH_AND_XOR_4:
3006 if (gimple_call_num_args (_c2) == 2)
3007 {
3008 tree _q20 = gimple_call_arg (_c2, 0);
3009 _q20 = do_valueize (valueize, _q20);
3010 tree _q21 = gimple_call_arg (_c2, 1);
3011 _q21 = do_valueize (valueize, _q21);
3012 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
3013 {
3014 case SSA_NAME:
3015 if (gimple *_d3 = get_def (valueize, _q21))
3016 {
3017 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
3018 switch (gimple_assign_rhs_code (_a3))
3019 {
3020 case LSHIFT_EXPR:
3021 {
3022 tree _q40 = gimple_assign_rhs1 (_a3);
3023 _q40 = do_valueize (valueize, _q40);
3024 tree _q41 = gimple_assign_rhs2 (_a3);
3025 _q41 = do_valueize (valueize, _q41);
3026 if (integer_onep (_q40))
3027 {
3028 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 3028, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
3029 {
3030 {
3031/* #line 4058 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3032 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41 };
3033 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4058, __FILE__"gimple-match.c", __LINE__3033);
3034 {
3035 res_ops[0] = captures[0];
3036 res_ops[1] = captures[0];
3037 res_ops[2] = captures[1];
3038 return true;
3039 }
3040next_after_fail92:;
3041 }
3042 }
3043 }
3044 break;
3045 }
3046 default:;
3047 }
3048 }
3049 break;
3050 case INTEGER_CST:
3051 {
3052 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3053 {
3054 case INTEGER_CST:
3055 {
3056 {
3057/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3058 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20 };
3059 {
3060/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3061 int ibit = tree_log2 (captures[0]);
3062 int ibit2 = tree_log2 (captures[1]);
3063/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3064 if (ibit == ibit2
3065 && ibit >= 0
3066)
3067 {
3068 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__3068);
3069 {
3070 res_ops[0] = captures[0];
3071 res_ops[1] = captures[1];
3072 res_ops[2] = captures[2];
3073 return true;
3074 }
3075next_after_fail93:;
3076 }
3077 }
3078 }
3079 break;
3080 }
3081 default:;
3082 }
3083 break;
3084 }
3085 default:;
3086 }
3087 }
3088 break;
3089 case CFN_BUILT_IN_SYNC_FETCH_AND_XOR_8:
3090 if (gimple_call_num_args (_c2) == 2)
3091 {
3092 tree _q20 = gimple_call_arg (_c2, 0);
3093 _q20 = do_valueize (valueize, _q20);
3094 tree _q21 = gimple_call_arg (_c2, 1);
3095 _q21 = do_valueize (valueize, _q21);
3096 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
3097 {
3098 case SSA_NAME:
3099 if (gimple *_d3 = get_def (valueize, _q21))
3100 {
3101 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
3102 switch (gimple_assign_rhs_code (_a3))
3103 {
3104 case LSHIFT_EXPR:
3105 {
3106 tree _q40 = gimple_assign_rhs1 (_a3);
3107 _q40 = do_valueize (valueize, _q40);
3108 tree _q41 = gimple_assign_rhs2 (_a3);
3109 _q41 = do_valueize (valueize, _q41);
3110 if (integer_onep (_q40))
3111 {
3112 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 3112, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
3113 {
3114 {
3115/* #line 4058 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3116 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41 };
3117 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4058, __FILE__"gimple-match.c", __LINE__3117);
3118 {
3119 res_ops[0] = captures[0];
3120 res_ops[1] = captures[0];
3121 res_ops[2] = captures[1];
3122 return true;
3123 }
3124next_after_fail94:;
3125 }
3126 }
3127 }
3128 break;
3129 }
3130 default:;
3131 }
3132 }
3133 break;
3134 case INTEGER_CST:
3135 {
3136 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3137 {
3138 case INTEGER_CST:
3139 {
3140 {
3141/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3142 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20 };
3143 {
3144/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3145 int ibit = tree_log2 (captures[0]);
3146 int ibit2 = tree_log2 (captures[1]);
3147/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3148 if (ibit == ibit2
3149 && ibit >= 0
3150)
3151 {
3152 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__3152);
3153 {
3154 res_ops[0] = captures[0];
3155 res_ops[1] = captures[1];
3156 res_ops[2] = captures[2];
3157 return true;
3158 }
3159next_after_fail95:;
3160 }
3161 }
3162 }
3163 break;
3164 }
3165 default:;
3166 }
3167 break;
3168 }
3169 default:;
3170 }
3171 }
3172 break;
3173 case CFN_BUILT_IN_SYNC_FETCH_AND_XOR_16:
3174 if (gimple_call_num_args (_c2) == 2)
3175 {
3176 tree _q20 = gimple_call_arg (_c2, 0);
3177 _q20 = do_valueize (valueize, _q20);
3178 tree _q21 = gimple_call_arg (_c2, 1);
3179 _q21 = do_valueize (valueize, _q21);
3180 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
3181 {
3182 case SSA_NAME:
3183 if (gimple *_d3 = get_def (valueize, _q21))
3184 {
3185 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
3186 switch (gimple_assign_rhs_code (_a3))
3187 {
3188 case LSHIFT_EXPR:
3189 {
3190 tree _q40 = gimple_assign_rhs1 (_a3);
3191 _q40 = do_valueize (valueize, _q40);
3192 tree _q41 = gimple_assign_rhs2 (_a3);
3193 _q41 = do_valueize (valueize, _q41);
3194 if (integer_onep (_q40))
3195 {
3196 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 3196, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
3197 {
3198 {
3199/* #line 4058 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3200 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41 };
3201 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4058, __FILE__"gimple-match.c", __LINE__3201);
3202 {
3203 res_ops[0] = captures[0];
3204 res_ops[1] = captures[0];
3205 res_ops[2] = captures[1];
3206 return true;
3207 }
3208next_after_fail96:;
3209 }
3210 }
3211 }
3212 break;
3213 }
3214 default:;
3215 }
3216 }
3217 break;
3218 case INTEGER_CST:
3219 {
3220 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3221 {
3222 case INTEGER_CST:
3223 {
3224 {
3225/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3226 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20 };
3227 {
3228/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3229 int ibit = tree_log2 (captures[0]);
3230 int ibit2 = tree_log2 (captures[1]);
3231/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3232 if (ibit == ibit2
3233 && ibit >= 0
3234)
3235 {
3236 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__3236);
3237 {
3238 res_ops[0] = captures[0];
3239 res_ops[1] = captures[1];
3240 res_ops[2] = captures[2];
3241 return true;
3242 }
3243next_after_fail97:;
3244 }
3245 }
3246 }
3247 break;
3248 }
3249 default:;
3250 }
3251 break;
3252 }
3253 default:;
3254 }
3255 }
3256 break;
3257 case CFN_BUILT_IN_SYNC_XOR_AND_FETCH_1:
3258 if (gimple_call_num_args (_c2) == 2)
3259 {
3260 tree _q20 = gimple_call_arg (_c2, 0);
3261 _q20 = do_valueize (valueize, _q20);
3262 tree _q21 = gimple_call_arg (_c2, 1);
3263 _q21 = do_valueize (valueize, _q21);
3264 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
3265 {
3266 case SSA_NAME:
3267 if (gimple *_d3 = get_def (valueize, _q21))
3268 {
3269 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
3270 switch (gimple_assign_rhs_code (_a3))
3271 {
3272 case LSHIFT_EXPR:
3273 {
3274 tree _q40 = gimple_assign_rhs1 (_a3);
3275 _q40 = do_valueize (valueize, _q40);
3276 tree _q41 = gimple_assign_rhs2 (_a3);
3277 _q41 = do_valueize (valueize, _q41);
3278 if (integer_onep (_q40))
3279 {
3280 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 3280, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
3281 {
3282 {
3283/* #line 4058 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3284 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41 };
3285 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4058, __FILE__"gimple-match.c", __LINE__3285);
3286 {
3287 res_ops[0] = captures[0];
3288 res_ops[1] = captures[0];
3289 res_ops[2] = captures[1];
3290 return true;
3291 }
3292next_after_fail98:;
3293 }
3294 }
3295 }
3296 break;
3297 }
3298 default:;
3299 }
3300 }
3301 break;
3302 case INTEGER_CST:
3303 {
3304 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3305 {
3306 case INTEGER_CST:
3307 {
3308 {
3309/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3310 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20 };
3311 {
3312/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3313 int ibit = tree_log2 (captures[0]);
3314 int ibit2 = tree_log2 (captures[1]);
3315/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3316 if (ibit == ibit2
3317 && ibit >= 0
3318)
3319 {
3320 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__3320);
3321 {
3322 res_ops[0] = captures[0];
3323 res_ops[1] = captures[1];
3324 res_ops[2] = captures[2];
3325 return true;
3326 }
3327next_after_fail99:;
3328 }
3329 }
3330 }
3331 break;
3332 }
3333 default:;
3334 }
3335 break;
3336 }
3337 default:;
3338 }
3339 }
3340 break;
3341 case CFN_BUILT_IN_SYNC_XOR_AND_FETCH_2:
3342 if (gimple_call_num_args (_c2) == 2)
3343 {
3344 tree _q20 = gimple_call_arg (_c2, 0);
3345 _q20 = do_valueize (valueize, _q20);
3346 tree _q21 = gimple_call_arg (_c2, 1);
3347 _q21 = do_valueize (valueize, _q21);
3348 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
3349 {
3350 case SSA_NAME:
3351 if (gimple *_d3 = get_def (valueize, _q21))
3352 {
3353 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
3354 switch (gimple_assign_rhs_code (_a3))
3355 {
3356 case LSHIFT_EXPR:
3357 {
3358 tree _q40 = gimple_assign_rhs1 (_a3);
3359 _q40 = do_valueize (valueize, _q40);
3360 tree _q41 = gimple_assign_rhs2 (_a3);
3361 _q41 = do_valueize (valueize, _q41);
3362 if (integer_onep (_q40))
3363 {
3364 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 3364, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
3365 {
3366 {
3367/* #line 4058 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3368 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41 };
3369 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4058, __FILE__"gimple-match.c", __LINE__3369);
3370 {
3371 res_ops[0] = captures[0];
3372 res_ops[1] = captures[0];
3373 res_ops[2] = captures[1];
3374 return true;
3375 }
3376next_after_fail100:;
3377 }
3378 }
3379 }
3380 break;
3381 }
3382 default:;
3383 }
3384 }
3385 break;
3386 case INTEGER_CST:
3387 {
3388 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3389 {
3390 case INTEGER_CST:
3391 {
3392 {
3393/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3394 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20 };
3395 {
3396/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3397 int ibit = tree_log2 (captures[0]);
3398 int ibit2 = tree_log2 (captures[1]);
3399/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3400 if (ibit == ibit2
3401 && ibit >= 0
3402)
3403 {
3404 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__3404);
3405 {
3406 res_ops[0] = captures[0];
3407 res_ops[1] = captures[1];
3408 res_ops[2] = captures[2];
3409 return true;
3410 }
3411next_after_fail101:;
3412 }
3413 }
3414 }
3415 break;
3416 }
3417 default:;
3418 }
3419 break;
3420 }
3421 default:;
3422 }
3423 }
3424 break;
3425 case CFN_BUILT_IN_SYNC_XOR_AND_FETCH_4:
3426 if (gimple_call_num_args (_c2) == 2)
3427 {
3428 tree _q20 = gimple_call_arg (_c2, 0);
3429 _q20 = do_valueize (valueize, _q20);
3430 tree _q21 = gimple_call_arg (_c2, 1);
3431 _q21 = do_valueize (valueize, _q21);
3432 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
3433 {
3434 case SSA_NAME:
3435 if (gimple *_d3 = get_def (valueize, _q21))
3436 {
3437 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
3438 switch (gimple_assign_rhs_code (_a3))
3439 {
3440 case LSHIFT_EXPR:
3441 {
3442 tree _q40 = gimple_assign_rhs1 (_a3);
3443 _q40 = do_valueize (valueize, _q40);
3444 tree _q41 = gimple_assign_rhs2 (_a3);
3445 _q41 = do_valueize (valueize, _q41);
3446 if (integer_onep (_q40))
3447 {
3448 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 3448, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
3449 {
3450 {
3451/* #line 4058 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3452 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41 };
3453 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4058, __FILE__"gimple-match.c", __LINE__3453);
3454 {
3455 res_ops[0] = captures[0];
3456 res_ops[1] = captures[0];
3457 res_ops[2] = captures[1];
3458 return true;
3459 }
3460next_after_fail102:;
3461 }
3462 }
3463 }
3464 break;
3465 }
3466 default:;
3467 }
3468 }
3469 break;
3470 case INTEGER_CST:
3471 {
3472 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3473 {
3474 case INTEGER_CST:
3475 {
3476 {
3477/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3478 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20 };
3479 {
3480/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3481 int ibit = tree_log2 (captures[0]);
3482 int ibit2 = tree_log2 (captures[1]);
3483/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3484 if (ibit == ibit2
3485 && ibit >= 0
3486)
3487 {
3488 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__3488);
3489 {
3490 res_ops[0] = captures[0];
3491 res_ops[1] = captures[1];
3492 res_ops[2] = captures[2];
3493 return true;
3494 }
3495next_after_fail103:;
3496 }
3497 }
3498 }
3499 break;
3500 }
3501 default:;
3502 }
3503 break;
3504 }
3505 default:;
3506 }
3507 }
3508 break;
3509 case CFN_BUILT_IN_SYNC_XOR_AND_FETCH_8:
3510 if (gimple_call_num_args (_c2) == 2)
3511 {
3512 tree _q20 = gimple_call_arg (_c2, 0);
3513 _q20 = do_valueize (valueize, _q20);
3514 tree _q21 = gimple_call_arg (_c2, 1);
3515 _q21 = do_valueize (valueize, _q21);
3516 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
3517 {
3518 case SSA_NAME:
3519 if (gimple *_d3 = get_def (valueize, _q21))
3520 {
3521 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
3522 switch (gimple_assign_rhs_code (_a3))
3523 {
3524 case LSHIFT_EXPR:
3525 {
3526 tree _q40 = gimple_assign_rhs1 (_a3);
3527 _q40 = do_valueize (valueize, _q40);
3528 tree _q41 = gimple_assign_rhs2 (_a3);
3529 _q41 = do_valueize (valueize, _q41);
3530 if (integer_onep (_q40))
3531 {
3532 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 3532, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
3533 {
3534 {
3535/* #line 4058 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3536 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41 };
3537 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4058, __FILE__"gimple-match.c", __LINE__3537);
3538 {
3539 res_ops[0] = captures[0];
3540 res_ops[1] = captures[0];
3541 res_ops[2] = captures[1];
3542 return true;
3543 }
3544next_after_fail104:;
3545 }
3546 }
3547 }
3548 break;
3549 }
3550 default:;
3551 }
3552 }
3553 break;
3554 case INTEGER_CST:
3555 {
3556 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3557 {
3558 case INTEGER_CST:
3559 {
3560 {
3561/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3562 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20 };
3563 {
3564/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3565 int ibit = tree_log2 (captures[0]);
3566 int ibit2 = tree_log2 (captures[1]);
3567/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3568 if (ibit == ibit2
3569 && ibit >= 0
3570)
3571 {
3572 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__3572);
3573 {
3574 res_ops[0] = captures[0];
3575 res_ops[1] = captures[1];
3576 res_ops[2] = captures[2];
3577 return true;
3578 }
3579next_after_fail105:;
3580 }
3581 }
3582 }
3583 break;
3584 }
3585 default:;
3586 }
3587 break;
3588 }
3589 default:;
3590 }
3591 }
3592 break;
3593 case CFN_BUILT_IN_SYNC_XOR_AND_FETCH_16:
3594 if (gimple_call_num_args (_c2) == 2)
3595 {
3596 tree _q20 = gimple_call_arg (_c2, 0);
3597 _q20 = do_valueize (valueize, _q20);
3598 tree _q21 = gimple_call_arg (_c2, 1);
3599 _q21 = do_valueize (valueize, _q21);
3600 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
3601 {
3602 case SSA_NAME:
3603 if (gimple *_d3 = get_def (valueize, _q21))
3604 {
3605 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
3606 switch (gimple_assign_rhs_code (_a3))
3607 {
3608 case LSHIFT_EXPR:
3609 {
3610 tree _q40 = gimple_assign_rhs1 (_a3);
3611 _q40 = do_valueize (valueize, _q40);
3612 tree _q41 = gimple_assign_rhs2 (_a3);
3613 _q41 = do_valueize (valueize, _q41);
3614 if (integer_onep (_q40))
3615 {
3616 if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 3616, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
3617 {
3618 {
3619/* #line 4058 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3620 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p0, _q20, _q40, _q41 };
3621 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4058, __FILE__"gimple-match.c", __LINE__3621);
3622 {
3623 res_ops[0] = captures[0];
3624 res_ops[1] = captures[0];
3625 res_ops[2] = captures[1];
3626 return true;
3627 }
3628next_after_fail106:;
3629 }
3630 }
3631 }
3632 break;
3633 }
3634 default:;
3635 }
3636 }
3637 break;
3638 case INTEGER_CST:
3639 {
3640 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3641 {
3642 case INTEGER_CST:
3643 {
3644 {
3645/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3646 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q21, _p1, _p0, _q20 };
3647 {
3648/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3649 int ibit = tree_log2 (captures[0]);
3650 int ibit2 = tree_log2 (captures[1]);
3651/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3652 if (ibit == ibit2
3653 && ibit >= 0
3654)
3655 {
3656 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__3656);
3657 {
3658 res_ops[0] = captures[0];
3659 res_ops[1] = captures[1];
3660 res_ops[2] = captures[2];
3661 return true;
3662 }
3663next_after_fail107:;
3664 }
3665 }
3666 }
3667 break;
3668 }
3669 default:;
3670 }
3671 break;
3672 }
3673 default:;
3674 }
3675 }
3676 break;
3677 default:;
3678 }
3679 }
3680 break;
3681 default:;
3682 }
3683 {
3684 tree _p0_pops[1];
3685 if (gimple_nop_convert (_p0, _p0_pops, valueize))
3686 {
3687 tree _q20 = _p0_pops[0];
3688 switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
3689 {
3690 case SSA_NAME:
3691 if (gimple *_d2 = get_def (valueize, _q20))
3692 {
3693 if (gcall *_c2 = dyn_cast <gcall *> (_d2))
3694 switch (gimple_call_combined_fn (_c2))
3695 {
3696 case CFN_BUILT_IN_ATOMIC_FETCH_OR_1:
3697 if (gimple_call_num_args (_c2) == 3)
3698 {
3699 tree _q30 = gimple_call_arg (_c2, 0);
3700 _q30 = do_valueize (valueize, _q30);
3701 tree _q31 = gimple_call_arg (_c2, 1);
3702 _q31 = do_valueize (valueize, _q31);
3703 tree _q32 = gimple_call_arg (_c2, 2);
3704 _q32 = do_valueize (valueize, _q32);
3705 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
3706 {
3707 case INTEGER_CST:
3708 {
3709 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3710 {
3711 case INTEGER_CST:
3712 {
3713 {
3714/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3715 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
3716 {
3717/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3718 int ibit = tree_log2 (captures[0]);
3719 int ibit2 = tree_log2 (captures[1]);
3720/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3721 if (ibit == ibit2
3722 && ibit >= 0
3723)
3724 {
3725 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__3725);
3726 {
3727 res_ops[0] = captures[0];
3728 res_ops[1] = captures[1];
3729 res_ops[2] = captures[2];
3730 return true;
3731 }
3732next_after_fail108:;
3733 }
3734 }
3735 }
3736 break;
3737 }
3738 default:;
3739 }
3740 break;
3741 }
3742 default:;
3743 }
3744 {
3745 tree _q31_pops[1];
3746 if (gimple_nop_convert (_q31, _q31_pops, valueize))
3747 {
3748 tree _q50 = _q31_pops[0];
3749 switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
3750 {
3751 case SSA_NAME:
3752 if (gimple *_d3 = get_def (valueize, _q50))
3753 {
3754 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
3755 switch (gimple_assign_rhs_code (_a3))
3756 {
3757 case LSHIFT_EXPR:
3758 {
3759 tree _q60 = gimple_assign_rhs1 (_a3);
3760 _q60 = do_valueize (valueize, _q60);
3761 tree _q61 = gimple_assign_rhs2 (_a3);
3762 _q61 = do_valueize (valueize, _q61);
3763 if (integer_onep (_q60))
3764 {
3765 if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 3765, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
3766 {
3767 {
3768/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3769 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
3770 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__3770);
3771 {
3772 res_ops[0] = captures[0];
3773 res_ops[1] = captures[0];
3774 res_ops[2] = captures[1];
3775 return true;
3776 }
3777next_after_fail109:;
3778 }
3779 }
3780 }
3781 break;
3782 }
3783 default:;
3784 }
3785 }
3786 break;
3787 default:;
3788 }
3789}
3790 }
3791 }
3792 break;
3793 case CFN_BUILT_IN_ATOMIC_FETCH_OR_2:
3794 if (gimple_call_num_args (_c2) == 3)
3795 {
3796 tree _q30 = gimple_call_arg (_c2, 0);
3797 _q30 = do_valueize (valueize, _q30);
3798 tree _q31 = gimple_call_arg (_c2, 1);
3799 _q31 = do_valueize (valueize, _q31);
3800 tree _q32 = gimple_call_arg (_c2, 2);
3801 _q32 = do_valueize (valueize, _q32);
3802 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
3803 {
3804 case INTEGER_CST:
3805 {
3806 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3807 {
3808 case INTEGER_CST:
3809 {
3810 {
3811/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3812 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
3813 {
3814/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3815 int ibit = tree_log2 (captures[0]);
3816 int ibit2 = tree_log2 (captures[1]);
3817/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3818 if (ibit == ibit2
3819 && ibit >= 0
3820)
3821 {
3822 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__3822);
3823 {
3824 res_ops[0] = captures[0];
3825 res_ops[1] = captures[1];
3826 res_ops[2] = captures[2];
3827 return true;
3828 }
3829next_after_fail110:;
3830 }
3831 }
3832 }
3833 break;
3834 }
3835 default:;
3836 }
3837 break;
3838 }
3839 default:;
3840 }
3841 {
3842 tree _q31_pops[1];
3843 if (gimple_nop_convert (_q31, _q31_pops, valueize))
3844 {
3845 tree _q50 = _q31_pops[0];
3846 switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
3847 {
3848 case SSA_NAME:
3849 if (gimple *_d3 = get_def (valueize, _q50))
3850 {
3851 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
3852 switch (gimple_assign_rhs_code (_a3))
3853 {
3854 case LSHIFT_EXPR:
3855 {
3856 tree _q60 = gimple_assign_rhs1 (_a3);
3857 _q60 = do_valueize (valueize, _q60);
3858 tree _q61 = gimple_assign_rhs2 (_a3);
3859 _q61 = do_valueize (valueize, _q61);
3860 if (integer_onep (_q60))
3861 {
3862 if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 3862, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
3863 {
3864 {
3865/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3866 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
3867 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__3867);
3868 {
3869 res_ops[0] = captures[0];
3870 res_ops[1] = captures[0];
3871 res_ops[2] = captures[1];
3872 return true;
3873 }
3874next_after_fail111:;
3875 }
3876 }
3877 }
3878 break;
3879 }
3880 default:;
3881 }
3882 }
3883 break;
3884 default:;
3885 }
3886}
3887 }
3888 }
3889 break;
3890 case CFN_BUILT_IN_ATOMIC_FETCH_OR_4:
3891 if (gimple_call_num_args (_c2) == 3)
3892 {
3893 tree _q30 = gimple_call_arg (_c2, 0);
3894 _q30 = do_valueize (valueize, _q30);
3895 tree _q31 = gimple_call_arg (_c2, 1);
3896 _q31 = do_valueize (valueize, _q31);
3897 tree _q32 = gimple_call_arg (_c2, 2);
3898 _q32 = do_valueize (valueize, _q32);
3899 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
3900 {
3901 case INTEGER_CST:
3902 {
3903 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3904 {
3905 case INTEGER_CST:
3906 {
3907 {
3908/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3909 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
3910 {
3911/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3912 int ibit = tree_log2 (captures[0]);
3913 int ibit2 = tree_log2 (captures[1]);
3914/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3915 if (ibit == ibit2
3916 && ibit >= 0
3917)
3918 {
3919 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__3919);
3920 {
3921 res_ops[0] = captures[0];
3922 res_ops[1] = captures[1];
3923 res_ops[2] = captures[2];
3924 return true;
3925 }
3926next_after_fail112:;
3927 }
3928 }
3929 }
3930 break;
3931 }
3932 default:;
3933 }
3934 break;
3935 }
3936 default:;
3937 }
3938 {
3939 tree _q31_pops[1];
3940 if (gimple_nop_convert (_q31, _q31_pops, valueize))
3941 {
3942 tree _q50 = _q31_pops[0];
3943 switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
3944 {
3945 case SSA_NAME:
3946 if (gimple *_d3 = get_def (valueize, _q50))
3947 {
3948 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
3949 switch (gimple_assign_rhs_code (_a3))
3950 {
3951 case LSHIFT_EXPR:
3952 {
3953 tree _q60 = gimple_assign_rhs1 (_a3);
3954 _q60 = do_valueize (valueize, _q60);
3955 tree _q61 = gimple_assign_rhs2 (_a3);
3956 _q61 = do_valueize (valueize, _q61);
3957 if (integer_onep (_q60))
3958 {
3959 if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 3959, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
3960 {
3961 {
3962/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3963 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
3964 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__3964);
3965 {
3966 res_ops[0] = captures[0];
3967 res_ops[1] = captures[0];
3968 res_ops[2] = captures[1];
3969 return true;
3970 }
3971next_after_fail113:;
3972 }
3973 }
3974 }
3975 break;
3976 }
3977 default:;
3978 }
3979 }
3980 break;
3981 default:;
3982 }
3983}
3984 }
3985 }
3986 break;
3987 case CFN_BUILT_IN_ATOMIC_FETCH_OR_8:
3988 if (gimple_call_num_args (_c2) == 3)
3989 {
3990 tree _q30 = gimple_call_arg (_c2, 0);
3991 _q30 = do_valueize (valueize, _q30);
3992 tree _q31 = gimple_call_arg (_c2, 1);
3993 _q31 = do_valueize (valueize, _q31);
3994 tree _q32 = gimple_call_arg (_c2, 2);
3995 _q32 = do_valueize (valueize, _q32);
3996 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
3997 {
3998 case INTEGER_CST:
3999 {
4000 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4001 {
4002 case INTEGER_CST:
4003 {
4004 {
4005/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4006 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
4007 {
4008/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4009 int ibit = tree_log2 (captures[0]);
4010 int ibit2 = tree_log2 (captures[1]);
4011/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4012 if (ibit == ibit2
4013 && ibit >= 0
4014)
4015 {
4016 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__4016);
4017 {
4018 res_ops[0] = captures[0];
4019 res_ops[1] = captures[1];
4020 res_ops[2] = captures[2];
4021 return true;
4022 }
4023next_after_fail114:;
4024 }
4025 }
4026 }
4027 break;
4028 }
4029 default:;
4030 }
4031 break;
4032 }
4033 default:;
4034 }
4035 {
4036 tree _q31_pops[1];
4037 if (gimple_nop_convert (_q31, _q31_pops, valueize))
4038 {
4039 tree _q50 = _q31_pops[0];
4040 switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
4041 {
4042 case SSA_NAME:
4043 if (gimple *_d3 = get_def (valueize, _q50))
4044 {
4045 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
4046 switch (gimple_assign_rhs_code (_a3))
4047 {
4048 case LSHIFT_EXPR:
4049 {
4050 tree _q60 = gimple_assign_rhs1 (_a3);
4051 _q60 = do_valueize (valueize, _q60);
4052 tree _q61 = gimple_assign_rhs2 (_a3);
4053 _q61 = do_valueize (valueize, _q61);
4054 if (integer_onep (_q60))
4055 {
4056 if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 4056, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
4057 {
4058 {
4059/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4060 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
4061 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__4061);
4062 {
4063 res_ops[0] = captures[0];
4064 res_ops[1] = captures[0];
4065 res_ops[2] = captures[1];
4066 return true;
4067 }
4068next_after_fail115:;
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_FETCH_OR_16:
4085 if (gimple_call_num_args (_c2) == 3)
4086 {
4087 tree _q30 = gimple_call_arg (_c2, 0);
4088 _q30 = do_valueize (valueize, _q30);
4089 tree _q31 = gimple_call_arg (_c2, 1);
4090 _q31 = do_valueize (valueize, _q31);
4091 tree _q32 = gimple_call_arg (_c2, 2);
4092 _q32 = do_valueize (valueize, _q32);
4093 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4094 {
4095 case INTEGER_CST:
4096 {
4097 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4098 {
4099 case INTEGER_CST:
4100 {
4101 {
4102/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4103 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
4104 {
4105/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4106 int ibit = tree_log2 (captures[0]);
4107 int ibit2 = tree_log2 (captures[1]);
4108/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4109 if (ibit == ibit2
4110 && ibit >= 0
4111)
4112 {
4113 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__4113);
4114 {
4115 res_ops[0] = captures[0];
4116 res_ops[1] = captures[1];
4117 res_ops[2] = captures[2];
4118 return true;
4119 }
4120next_after_fail116:;
4121 }
4122 }
4123 }
4124 break;
4125 }
4126 default:;
4127 }
4128 break;
4129 }
4130 default:;
4131 }
4132 {
4133 tree _q31_pops[1];
4134 if (gimple_nop_convert (_q31, _q31_pops, valueize))
4135 {
4136 tree _q50 = _q31_pops[0];
4137 switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
4138 {
4139 case SSA_NAME:
4140 if (gimple *_d3 = get_def (valueize, _q50))
4141 {
4142 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
4143 switch (gimple_assign_rhs_code (_a3))
4144 {
4145 case LSHIFT_EXPR:
4146 {
4147 tree _q60 = gimple_assign_rhs1 (_a3);
4148 _q60 = do_valueize (valueize, _q60);
4149 tree _q61 = gimple_assign_rhs2 (_a3);
4150 _q61 = do_valueize (valueize, _q61);
4151 if (integer_onep (_q60))
4152 {
4153 if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 4153, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
4154 {
4155 {
4156/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4157 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
4158 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __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 }
4165next_after_fail117:;
4166 }
4167 }
4168 }
4169 break;
4170 }
4171 default:;
4172 }
4173 }
4174 break;
4175 default:;
4176 }
4177}
4178 }
4179 }
4180 break;
4181 case CFN_BUILT_IN_ATOMIC_FETCH_XOR_1:
4182 if (gimple_call_num_args (_c2) == 3)
4183 {
4184 tree _q30 = gimple_call_arg (_c2, 0);
4185 _q30 = do_valueize (valueize, _q30);
4186 tree _q31 = gimple_call_arg (_c2, 1);
4187 _q31 = do_valueize (valueize, _q31);
4188 tree _q32 = gimple_call_arg (_c2, 2);
4189 _q32 = do_valueize (valueize, _q32);
4190 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4191 {
4192 case INTEGER_CST:
4193 {
4194 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4195 {
4196 case INTEGER_CST:
4197 {
4198 {
4199/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4200 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
4201 {
4202/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4203 int ibit = tree_log2 (captures[0]);
4204 int ibit2 = tree_log2 (captures[1]);
4205/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4206 if (ibit == ibit2
4207 && ibit >= 0
4208)
4209 {
4210 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__4210);
4211 {
4212 res_ops[0] = captures[0];
4213 res_ops[1] = captures[1];
4214 res_ops[2] = captures[2];
4215 return true;
4216 }
4217next_after_fail118:;
4218 }
4219 }
4220 }
4221 break;
4222 }
4223 default:;
4224 }
4225 break;
4226 }
4227 default:;
4228 }
4229 {
4230 tree _q31_pops[1];
4231 if (gimple_nop_convert (_q31, _q31_pops, valueize))
4232 {
4233 tree _q50 = _q31_pops[0];
4234 switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
4235 {
4236 case SSA_NAME:
4237 if (gimple *_d3 = get_def (valueize, _q50))
4238 {
4239 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
4240 switch (gimple_assign_rhs_code (_a3))
4241 {
4242 case LSHIFT_EXPR:
4243 {
4244 tree _q60 = gimple_assign_rhs1 (_a3);
4245 _q60 = do_valueize (valueize, _q60);
4246 tree _q61 = gimple_assign_rhs2 (_a3);
4247 _q61 = do_valueize (valueize, _q61);
4248 if (integer_onep (_q60))
4249 {
4250 if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 4250, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
4251 {
4252 {
4253/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4254 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
4255 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__4255);
4256 {
4257 res_ops[0] = captures[0];
4258 res_ops[1] = captures[0];
4259 res_ops[2] = captures[1];
4260 return true;
4261 }
4262next_after_fail119:;
4263 }
4264 }
4265 }
4266 break;
4267 }
4268 default:;
4269 }
4270 }
4271 break;
4272 default:;
4273 }
4274}
4275 }
4276 }
4277 break;
4278 case CFN_BUILT_IN_ATOMIC_FETCH_XOR_2:
4279 if (gimple_call_num_args (_c2) == 3)
4280 {
4281 tree _q30 = gimple_call_arg (_c2, 0);
4282 _q30 = do_valueize (valueize, _q30);
4283 tree _q31 = gimple_call_arg (_c2, 1);
4284 _q31 = do_valueize (valueize, _q31);
4285 tree _q32 = gimple_call_arg (_c2, 2);
4286 _q32 = do_valueize (valueize, _q32);
4287 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4288 {
4289 case INTEGER_CST:
4290 {
4291 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4292 {
4293 case INTEGER_CST:
4294 {
4295 {
4296/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4297 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
4298 {
4299/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4300 int ibit = tree_log2 (captures[0]);
4301 int ibit2 = tree_log2 (captures[1]);
4302/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4303 if (ibit == ibit2
4304 && ibit >= 0
4305)
4306 {
4307 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__4307);
4308 {
4309 res_ops[0] = captures[0];
4310 res_ops[1] = captures[1];
4311 res_ops[2] = captures[2];
4312 return true;
4313 }
4314next_after_fail120:;
4315 }
4316 }
4317 }
4318 break;
4319 }
4320 default:;
4321 }
4322 break;
4323 }
4324 default:;
4325 }
4326 {
4327 tree _q31_pops[1];
4328 if (gimple_nop_convert (_q31, _q31_pops, valueize))
4329 {
4330 tree _q50 = _q31_pops[0];
4331 switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
4332 {
4333 case SSA_NAME:
4334 if (gimple *_d3 = get_def (valueize, _q50))
4335 {
4336 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
4337 switch (gimple_assign_rhs_code (_a3))
4338 {
4339 case LSHIFT_EXPR:
4340 {
4341 tree _q60 = gimple_assign_rhs1 (_a3);
4342 _q60 = do_valueize (valueize, _q60);
4343 tree _q61 = gimple_assign_rhs2 (_a3);
4344 _q61 = do_valueize (valueize, _q61);
4345 if (integer_onep (_q60))
4346 {
4347 if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 4347, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
4348 {
4349 {
4350/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4351 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
4352 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__4352);
4353 {
4354 res_ops[0] = captures[0];
4355 res_ops[1] = captures[0];
4356 res_ops[2] = captures[1];
4357 return true;
4358 }
4359next_after_fail121:;
4360 }
4361 }
4362 }
4363 break;
4364 }
4365 default:;
4366 }
4367 }
4368 break;
4369 default:;
4370 }
4371}
4372 }
4373 }
4374 break;
4375 case CFN_BUILT_IN_ATOMIC_FETCH_XOR_4:
4376 if (gimple_call_num_args (_c2) == 3)
4377 {
4378 tree _q30 = gimple_call_arg (_c2, 0);
4379 _q30 = do_valueize (valueize, _q30);
4380 tree _q31 = gimple_call_arg (_c2, 1);
4381 _q31 = do_valueize (valueize, _q31);
4382 tree _q32 = gimple_call_arg (_c2, 2);
4383 _q32 = do_valueize (valueize, _q32);
4384 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4385 {
4386 case INTEGER_CST:
4387 {
4388 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4389 {
4390 case INTEGER_CST:
4391 {
4392 {
4393/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4394 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
4395 {
4396/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4397 int ibit = tree_log2 (captures[0]);
4398 int ibit2 = tree_log2 (captures[1]);
4399/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4400 if (ibit == ibit2
4401 && ibit >= 0
4402)
4403 {
4404 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__4404);
4405 {
4406 res_ops[0] = captures[0];
4407 res_ops[1] = captures[1];
4408 res_ops[2] = captures[2];
4409 return true;
4410 }
4411next_after_fail122:;
4412 }
4413 }
4414 }
4415 break;
4416 }
4417 default:;
4418 }
4419 break;
4420 }
4421 default:;
4422 }
4423 {
4424 tree _q31_pops[1];
4425 if (gimple_nop_convert (_q31, _q31_pops, valueize))
4426 {
4427 tree _q50 = _q31_pops[0];
4428 switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
4429 {
4430 case SSA_NAME:
4431 if (gimple *_d3 = get_def (valueize, _q50))
4432 {
4433 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
4434 switch (gimple_assign_rhs_code (_a3))
4435 {
4436 case LSHIFT_EXPR:
4437 {
4438 tree _q60 = gimple_assign_rhs1 (_a3);
4439 _q60 = do_valueize (valueize, _q60);
4440 tree _q61 = gimple_assign_rhs2 (_a3);
4441 _q61 = do_valueize (valueize, _q61);
4442 if (integer_onep (_q60))
4443 {
4444 if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 4444, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
4445 {
4446 {
4447/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4448 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
4449 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__4449);
4450 {
4451 res_ops[0] = captures[0];
4452 res_ops[1] = captures[0];
4453 res_ops[2] = captures[1];
4454 return true;
4455 }
4456next_after_fail123:;
4457 }
4458 }
4459 }
4460 break;
4461 }
4462 default:;
4463 }
4464 }
4465 break;
4466 default:;
4467 }
4468}
4469 }
4470 }
4471 break;
4472 case CFN_BUILT_IN_ATOMIC_FETCH_XOR_8:
4473 if (gimple_call_num_args (_c2) == 3)
4474 {
4475 tree _q30 = gimple_call_arg (_c2, 0);
4476 _q30 = do_valueize (valueize, _q30);
4477 tree _q31 = gimple_call_arg (_c2, 1);
4478 _q31 = do_valueize (valueize, _q31);
4479 tree _q32 = gimple_call_arg (_c2, 2);
4480 _q32 = do_valueize (valueize, _q32);
4481 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4482 {
4483 case INTEGER_CST:
4484 {
4485 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4486 {
4487 case INTEGER_CST:
4488 {
4489 {
4490/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4491 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
4492 {
4493/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4494 int ibit = tree_log2 (captures[0]);
4495 int ibit2 = tree_log2 (captures[1]);
4496/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4497 if (ibit == ibit2
4498 && ibit >= 0
4499)
4500 {
4501 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__4501);
4502 {
4503 res_ops[0] = captures[0];
4504 res_ops[1] = captures[1];
4505 res_ops[2] = captures[2];
4506 return true;
4507 }
4508next_after_fail124:;
4509 }
4510 }
4511 }
4512 break;
4513 }
4514 default:;
4515 }
4516 break;
4517 }
4518 default:;
4519 }
4520 {
4521 tree _q31_pops[1];
4522 if (gimple_nop_convert (_q31, _q31_pops, valueize))
4523 {
4524 tree _q50 = _q31_pops[0];
4525 switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
4526 {
4527 case SSA_NAME:
4528 if (gimple *_d3 = get_def (valueize, _q50))
4529 {
4530 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
4531 switch (gimple_assign_rhs_code (_a3))
4532 {
4533 case LSHIFT_EXPR:
4534 {
4535 tree _q60 = gimple_assign_rhs1 (_a3);
4536 _q60 = do_valueize (valueize, _q60);
4537 tree _q61 = gimple_assign_rhs2 (_a3);
4538 _q61 = do_valueize (valueize, _q61);
4539 if (integer_onep (_q60))
4540 {
4541 if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 4541, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
4542 {
4543 {
4544/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4545 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
4546 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__4546);
4547 {
4548 res_ops[0] = captures[0];
4549 res_ops[1] = captures[0];
4550 res_ops[2] = captures[1];
4551 return true;
4552 }
4553next_after_fail125:;
4554 }
4555 }
4556 }
4557 break;
4558 }
4559 default:;
4560 }
4561 }
4562 break;
4563 default:;
4564 }
4565}
4566 }
4567 }
4568 break;
4569 case CFN_BUILT_IN_ATOMIC_FETCH_XOR_16:
4570 if (gimple_call_num_args (_c2) == 3)
4571 {
4572 tree _q30 = gimple_call_arg (_c2, 0);
4573 _q30 = do_valueize (valueize, _q30);
4574 tree _q31 = gimple_call_arg (_c2, 1);
4575 _q31 = do_valueize (valueize, _q31);
4576 tree _q32 = gimple_call_arg (_c2, 2);
4577 _q32 = do_valueize (valueize, _q32);
4578 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4579 {
4580 case INTEGER_CST:
4581 {
4582 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4583 {
4584 case INTEGER_CST:
4585 {
4586 {
4587/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4588 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
4589 {
4590/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4591 int ibit = tree_log2 (captures[0]);
4592 int ibit2 = tree_log2 (captures[1]);
4593/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4594 if (ibit == ibit2
4595 && ibit >= 0
4596)
4597 {
4598 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__4598);
4599 {
4600 res_ops[0] = captures[0];
4601 res_ops[1] = captures[1];
4602 res_ops[2] = captures[2];
4603 return true;
4604 }
4605next_after_fail126:;
4606 }
4607 }
4608 }
4609 break;
4610 }
4611 default:;
4612 }
4613 break;
4614 }
4615 default:;
4616 }
4617 {
4618 tree _q31_pops[1];
4619 if (gimple_nop_convert (_q31, _q31_pops, valueize))
4620 {
4621 tree _q50 = _q31_pops[0];
4622 switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
4623 {
4624 case SSA_NAME:
4625 if (gimple *_d3 = get_def (valueize, _q50))
4626 {
4627 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
4628 switch (gimple_assign_rhs_code (_a3))
4629 {
4630 case LSHIFT_EXPR:
4631 {
4632 tree _q60 = gimple_assign_rhs1 (_a3);
4633 _q60 = do_valueize (valueize, _q60);
4634 tree _q61 = gimple_assign_rhs2 (_a3);
4635 _q61 = do_valueize (valueize, _q61);
4636 if (integer_onep (_q60))
4637 {
4638 if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 4638, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
4639 {
4640 {
4641/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4642 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
4643 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__4643);
4644 {
4645 res_ops[0] = captures[0];
4646 res_ops[1] = captures[0];
4647 res_ops[2] = captures[1];
4648 return true;
4649 }
4650next_after_fail127:;
4651 }
4652 }
4653 }
4654 break;
4655 }
4656 default:;
4657 }
4658 }
4659 break;
4660 default:;
4661 }
4662}
4663 }
4664 }
4665 break;
4666 case CFN_BUILT_IN_ATOMIC_XOR_FETCH_1:
4667 if (gimple_call_num_args (_c2) == 3)
4668 {
4669 tree _q30 = gimple_call_arg (_c2, 0);
4670 _q30 = do_valueize (valueize, _q30);
4671 tree _q31 = gimple_call_arg (_c2, 1);
4672 _q31 = do_valueize (valueize, _q31);
4673 tree _q32 = gimple_call_arg (_c2, 2);
4674 _q32 = do_valueize (valueize, _q32);
4675 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4676 {
4677 case INTEGER_CST:
4678 {
4679 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4680 {
4681 case INTEGER_CST:
4682 {
4683 {
4684/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4685 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
4686 {
4687/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4688 int ibit = tree_log2 (captures[0]);
4689 int ibit2 = tree_log2 (captures[1]);
4690/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4691 if (ibit == ibit2
4692 && ibit >= 0
4693)
4694 {
4695 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__4695);
4696 {
4697 res_ops[0] = captures[0];
4698 res_ops[1] = captures[1];
4699 res_ops[2] = captures[2];
4700 return true;
4701 }
4702next_after_fail128:;
4703 }
4704 }
4705 }
4706 break;
4707 }
4708 default:;
4709 }
4710 break;
4711 }
4712 default:;
4713 }
4714 {
4715 tree _q31_pops[1];
4716 if (gimple_nop_convert (_q31, _q31_pops, valueize))
4717 {
4718 tree _q50 = _q31_pops[0];
4719 switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
4720 {
4721 case SSA_NAME:
4722 if (gimple *_d3 = get_def (valueize, _q50))
4723 {
4724 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
4725 switch (gimple_assign_rhs_code (_a3))
4726 {
4727 case LSHIFT_EXPR:
4728 {
4729 tree _q60 = gimple_assign_rhs1 (_a3);
4730 _q60 = do_valueize (valueize, _q60);
4731 tree _q61 = gimple_assign_rhs2 (_a3);
4732 _q61 = do_valueize (valueize, _q61);
4733 if (integer_onep (_q60))
4734 {
4735 if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 4735, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
4736 {
4737 {
4738/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4739 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
4740 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__4740);
4741 {
4742 res_ops[0] = captures[0];
4743 res_ops[1] = captures[0];
4744 res_ops[2] = captures[1];
4745 return true;
4746 }
4747next_after_fail129:;
4748 }
4749 }
4750 }
4751 break;
4752 }
4753 default:;
4754 }
4755 }
4756 break;
4757 default:;
4758 }
4759}
4760 }
4761 }
4762 break;
4763 case CFN_BUILT_IN_ATOMIC_XOR_FETCH_2:
4764 if (gimple_call_num_args (_c2) == 3)
4765 {
4766 tree _q30 = gimple_call_arg (_c2, 0);
4767 _q30 = do_valueize (valueize, _q30);
4768 tree _q31 = gimple_call_arg (_c2, 1);
4769 _q31 = do_valueize (valueize, _q31);
4770 tree _q32 = gimple_call_arg (_c2, 2);
4771 _q32 = do_valueize (valueize, _q32);
4772 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4773 {
4774 case INTEGER_CST:
4775 {
4776 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4777 {
4778 case INTEGER_CST:
4779 {
4780 {
4781/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4782 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
4783 {
4784/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4785 int ibit = tree_log2 (captures[0]);
4786 int ibit2 = tree_log2 (captures[1]);
4787/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4788 if (ibit == ibit2
4789 && ibit >= 0
4790)
4791 {
4792 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__4792);
4793 {
4794 res_ops[0] = captures[0];
4795 res_ops[1] = captures[1];
4796 res_ops[2] = captures[2];
4797 return true;
4798 }
4799next_after_fail130:;
4800 }
4801 }
4802 }
4803 break;
4804 }
4805 default:;
4806 }
4807 break;
4808 }
4809 default:;
4810 }
4811 {
4812 tree _q31_pops[1];
4813 if (gimple_nop_convert (_q31, _q31_pops, valueize))
4814 {
4815 tree _q50 = _q31_pops[0];
4816 switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
4817 {
4818 case SSA_NAME:
4819 if (gimple *_d3 = get_def (valueize, _q50))
4820 {
4821 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
4822 switch (gimple_assign_rhs_code (_a3))
4823 {
4824 case LSHIFT_EXPR:
4825 {
4826 tree _q60 = gimple_assign_rhs1 (_a3);
4827 _q60 = do_valueize (valueize, _q60);
4828 tree _q61 = gimple_assign_rhs2 (_a3);
4829 _q61 = do_valueize (valueize, _q61);
4830 if (integer_onep (_q60))
4831 {
4832 if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 4832, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
4833 {
4834 {
4835/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4836 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
4837 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__4837);
4838 {
4839 res_ops[0] = captures[0];
4840 res_ops[1] = captures[0];
4841 res_ops[2] = captures[1];
4842 return true;
4843 }
4844next_after_fail131:;
4845 }
4846 }
4847 }
4848 break;
4849 }
4850 default:;
4851 }
4852 }
4853 break;
4854 default:;
4855 }
4856}
4857 }
4858 }
4859 break;
4860 case CFN_BUILT_IN_ATOMIC_XOR_FETCH_4:
4861 if (gimple_call_num_args (_c2) == 3)
4862 {
4863 tree _q30 = gimple_call_arg (_c2, 0);
4864 _q30 = do_valueize (valueize, _q30);
4865 tree _q31 = gimple_call_arg (_c2, 1);
4866 _q31 = do_valueize (valueize, _q31);
4867 tree _q32 = gimple_call_arg (_c2, 2);
4868 _q32 = do_valueize (valueize, _q32);
4869 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4870 {
4871 case INTEGER_CST:
4872 {
4873 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4874 {
4875 case INTEGER_CST:
4876 {
4877 {
4878/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4879 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
4880 {
4881/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4882 int ibit = tree_log2 (captures[0]);
4883 int ibit2 = tree_log2 (captures[1]);
4884/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4885 if (ibit == ibit2
4886 && ibit >= 0
4887)
4888 {
4889 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__4889);
4890 {
4891 res_ops[0] = captures[0];
4892 res_ops[1] = captures[1];
4893 res_ops[2] = captures[2];
4894 return true;
4895 }
4896next_after_fail132:;
4897 }
4898 }
4899 }
4900 break;
4901 }
4902 default:;
4903 }
4904 break;
4905 }
4906 default:;
4907 }
4908 {
4909 tree _q31_pops[1];
4910 if (gimple_nop_convert (_q31, _q31_pops, valueize))
4911 {
4912 tree _q50 = _q31_pops[0];
4913 switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
4914 {
4915 case SSA_NAME:
4916 if (gimple *_d3 = get_def (valueize, _q50))
4917 {
4918 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
4919 switch (gimple_assign_rhs_code (_a3))
4920 {
4921 case LSHIFT_EXPR:
4922 {
4923 tree _q60 = gimple_assign_rhs1 (_a3);
4924 _q60 = do_valueize (valueize, _q60);
4925 tree _q61 = gimple_assign_rhs2 (_a3);
4926 _q61 = do_valueize (valueize, _q61);
4927 if (integer_onep (_q60))
4928 {
4929 if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 4929, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
4930 {
4931 {
4932/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4933 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
4934 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__4934);
4935 {
4936 res_ops[0] = captures[0];
4937 res_ops[1] = captures[0];
4938 res_ops[2] = captures[1];
4939 return true;
4940 }
4941next_after_fail133:;
4942 }
4943 }
4944 }
4945 break;
4946 }
4947 default:;
4948 }
4949 }
4950 break;
4951 default:;
4952 }
4953}
4954 }
4955 }
4956 break;
4957 case CFN_BUILT_IN_ATOMIC_XOR_FETCH_8:
4958 if (gimple_call_num_args (_c2) == 3)
4959 {
4960 tree _q30 = gimple_call_arg (_c2, 0);
4961 _q30 = do_valueize (valueize, _q30);
4962 tree _q31 = gimple_call_arg (_c2, 1);
4963 _q31 = do_valueize (valueize, _q31);
4964 tree _q32 = gimple_call_arg (_c2, 2);
4965 _q32 = do_valueize (valueize, _q32);
4966 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
4967 {
4968 case INTEGER_CST:
4969 {
4970 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
4971 {
4972 case INTEGER_CST:
4973 {
4974 {
4975/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4976 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
4977 {
4978/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4979 int ibit = tree_log2 (captures[0]);
4980 int ibit2 = tree_log2 (captures[1]);
4981/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4982 if (ibit == ibit2
4983 && ibit >= 0
4984)
4985 {
4986 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__4986);
4987 {
4988 res_ops[0] = captures[0];
4989 res_ops[1] = captures[1];
4990 res_ops[2] = captures[2];
4991 return true;
4992 }
4993next_after_fail134:;
4994 }
4995 }
4996 }
4997 break;
4998 }
4999 default:;
5000 }
5001 break;
5002 }
5003 default:;
5004 }
5005 {
5006 tree _q31_pops[1];
5007 if (gimple_nop_convert (_q31, _q31_pops, valueize))
5008 {
5009 tree _q50 = _q31_pops[0];
5010 switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
5011 {
5012 case SSA_NAME:
5013 if (gimple *_d3 = get_def (valueize, _q50))
5014 {
5015 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
5016 switch (gimple_assign_rhs_code (_a3))
5017 {
5018 case LSHIFT_EXPR:
5019 {
5020 tree _q60 = gimple_assign_rhs1 (_a3);
5021 _q60 = do_valueize (valueize, _q60);
5022 tree _q61 = gimple_assign_rhs2 (_a3);
5023 _q61 = do_valueize (valueize, _q61);
5024 if (integer_onep (_q60))
5025 {
5026 if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 5026, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
5027 {
5028 {
5029/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5030 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
5031 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__5031);
5032 {
5033 res_ops[0] = captures[0];
5034 res_ops[1] = captures[0];
5035 res_ops[2] = captures[1];
5036 return true;
5037 }
5038next_after_fail135:;
5039 }
5040 }
5041 }
5042 break;
5043 }
5044 default:;
5045 }
5046 }
5047 break;
5048 default:;
5049 }
5050}
5051 }
5052 }
5053 break;
5054 case CFN_BUILT_IN_ATOMIC_XOR_FETCH_16:
5055 if (gimple_call_num_args (_c2) == 3)
5056 {
5057 tree _q30 = gimple_call_arg (_c2, 0);
5058 _q30 = do_valueize (valueize, _q30);
5059 tree _q31 = gimple_call_arg (_c2, 1);
5060 _q31 = do_valueize (valueize, _q31);
5061 tree _q32 = gimple_call_arg (_c2, 2);
5062 _q32 = do_valueize (valueize, _q32);
5063 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5064 {
5065 case INTEGER_CST:
5066 {
5067 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5068 {
5069 case INTEGER_CST:
5070 {
5071 {
5072/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5073 tree captures[5] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30, _q32 };
5074 {
5075/* #line 4035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5076 int ibit = tree_log2 (captures[0]);
5077 int ibit2 = tree_log2 (captures[1]);
5078/* #line 4039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5079 if (ibit == ibit2
5080 && ibit >= 0
5081)
5082 {
5083 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4032, __FILE__"gimple-match.c", __LINE__5083);
5084 {
5085 res_ops[0] = captures[0];
5086 res_ops[1] = captures[1];
5087 res_ops[2] = captures[2];
5088 return true;
5089 }
5090next_after_fail136:;
5091 }
5092 }
5093 }
5094 break;
5095 }
5096 default:;
5097 }
5098 break;
5099 }
5100 default:;
5101 }
5102 {
5103 tree _q31_pops[1];
5104 if (gimple_nop_convert (_q31, _q31_pops, valueize))
5105 {
5106 tree _q50 = _q31_pops[0];
5107 switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
5108 {
5109 case SSA_NAME:
5110 if (gimple *_d3 = get_def (valueize, _q50))
5111 {
5112 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
5113 switch (gimple_assign_rhs_code (_a3))
5114 {
5115 case LSHIFT_EXPR:
5116 {
5117 tree _q60 = gimple_assign_rhs1 (_a3);
5118 _q60 = do_valueize (valueize, _q60);
5119 tree _q61 = gimple_assign_rhs2 (_a3);
5120 _q61 = do_valueize (valueize, _q61);
5121 if (integer_onep (_q60))
5122 {
5123 if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "gimple-match.c", 5123, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
5124 {
5125 {
5126/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5127 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q50, _p0, _q30, _q60, _q61, _q32 };
5128 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__5128);
5129 {
5130 res_ops[0] = captures[0];
5131 res_ops[1] = captures[0];
5132 res_ops[2] = captures[1];
5133 return true;
5134 }
5135next_after_fail137:;
5136 }
5137 }
5138 }
5139 break;
5140 }
5141 default:;
5142 }
5143 }
5144 break;
5145 default:;
5146 }
5147}
5148 }
5149 }
5150 break;
5151 case CFN_BUILT_IN_SYNC_FETCH_AND_OR_1:
5152 if (gimple_call_num_args (_c2) == 2)
5153 {
5154 tree _q30 = gimple_call_arg (_c2, 0);
5155 _q30 = do_valueize (valueize, _q30);
5156 tree _q31 = gimple_call_arg (_c2, 1);
5157 _q31 = do_valueize (valueize, _q31);
5158 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5159 {
5160 case INTEGER_CST:
5161 {
5162 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5163 {
5164 case INTEGER_CST:
5165 {
5166 {
5167/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5168 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5169 {
5170/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5171 int ibit = tree_log2 (captures[0]);
5172 int ibit2 = tree_log2 (captures[1]);
5173/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5174 if (ibit == ibit2
5175 && ibit >= 0
5176)
5177 {
5178 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__5178);
5179 {
5180 res_ops[0] = captures[0];
5181 res_ops[1] = captures[1];
5182 res_ops[2] = captures[2];
5183 return true;
5184 }
5185next_after_fail138:;
5186 }
5187 }
5188 }
5189 break;
5190 }
5191 default:;
5192 }
5193 break;
5194 }
5195 default:;
5196 }
5197 }
5198 break;
5199 case CFN_BUILT_IN_SYNC_FETCH_AND_OR_2:
5200 if (gimple_call_num_args (_c2) == 2)
5201 {
5202 tree _q30 = gimple_call_arg (_c2, 0);
5203 _q30 = do_valueize (valueize, _q30);
5204 tree _q31 = gimple_call_arg (_c2, 1);
5205 _q31 = do_valueize (valueize, _q31);
5206 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5207 {
5208 case INTEGER_CST:
5209 {
5210 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5211 {
5212 case INTEGER_CST:
5213 {
5214 {
5215/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5216 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5217 {
5218/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5219 int ibit = tree_log2 (captures[0]);
5220 int ibit2 = tree_log2 (captures[1]);
5221/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5222 if (ibit == ibit2
5223 && ibit >= 0
5224)
5225 {
5226 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__5226);
5227 {
5228 res_ops[0] = captures[0];
5229 res_ops[1] = captures[1];
5230 res_ops[2] = captures[2];
5231 return true;
5232 }
5233next_after_fail139:;
5234 }
5235 }
5236 }
5237 break;
5238 }
5239 default:;
5240 }
5241 break;
5242 }
5243 default:;
5244 }
5245 }
5246 break;
5247 case CFN_BUILT_IN_SYNC_FETCH_AND_OR_4:
5248 if (gimple_call_num_args (_c2) == 2)
5249 {
5250 tree _q30 = gimple_call_arg (_c2, 0);
5251 _q30 = do_valueize (valueize, _q30);
5252 tree _q31 = gimple_call_arg (_c2, 1);
5253 _q31 = do_valueize (valueize, _q31);
5254 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5255 {
5256 case INTEGER_CST:
5257 {
5258 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5259 {
5260 case INTEGER_CST:
5261 {
5262 {
5263/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5264 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5265 {
5266/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5267 int ibit = tree_log2 (captures[0]);
5268 int ibit2 = tree_log2 (captures[1]);
5269/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5270 if (ibit == ibit2
5271 && ibit >= 0
5272)
5273 {
5274 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__5274);
5275 {
5276 res_ops[0] = captures[0];
5277 res_ops[1] = captures[1];
5278 res_ops[2] = captures[2];
5279 return true;
5280 }
5281next_after_fail140:;
5282 }
5283 }
5284 }
5285 break;
5286 }
5287 default:;
5288 }
5289 break;
5290 }
5291 default:;
5292 }
5293 }
5294 break;
5295 case CFN_BUILT_IN_SYNC_FETCH_AND_OR_8:
5296 if (gimple_call_num_args (_c2) == 2)
5297 {
5298 tree _q30 = gimple_call_arg (_c2, 0);
5299 _q30 = do_valueize (valueize, _q30);
5300 tree _q31 = gimple_call_arg (_c2, 1);
5301 _q31 = do_valueize (valueize, _q31);
5302 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5303 {
5304 case INTEGER_CST:
5305 {
5306 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5307 {
5308 case INTEGER_CST:
5309 {
5310 {
5311/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5312 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5313 {
5314/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5315 int ibit = tree_log2 (captures[0]);
5316 int ibit2 = tree_log2 (captures[1]);
5317/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5318 if (ibit == ibit2
5319 && ibit >= 0
5320)
5321 {
5322 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__5322);
5323 {
5324 res_ops[0] = captures[0];
5325 res_ops[1] = captures[1];
5326 res_ops[2] = captures[2];
5327 return true;
5328 }
5329next_after_fail141:;
5330 }
5331 }
5332 }
5333 break;
5334 }
5335 default:;
5336 }
5337 break;
5338 }
5339 default:;
5340 }
5341 }
5342 break;
5343 case CFN_BUILT_IN_SYNC_FETCH_AND_OR_16:
5344 if (gimple_call_num_args (_c2) == 2)
5345 {
5346 tree _q30 = gimple_call_arg (_c2, 0);
5347 _q30 = do_valueize (valueize, _q30);
5348 tree _q31 = gimple_call_arg (_c2, 1);
5349 _q31 = do_valueize (valueize, _q31);
5350 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5351 {
5352 case INTEGER_CST:
5353 {
5354 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5355 {
5356 case INTEGER_CST:
5357 {
5358 {
5359/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5360 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5361 {
5362/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5363 int ibit = tree_log2 (captures[0]);
5364 int ibit2 = tree_log2 (captures[1]);
5365/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5366 if (ibit == ibit2
5367 && ibit >= 0
5368)
5369 {
5370 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__5370);
5371 {
5372 res_ops[0] = captures[0];
5373 res_ops[1] = captures[1];
5374 res_ops[2] = captures[2];
5375 return true;
5376 }
5377next_after_fail142:;
5378 }
5379 }
5380 }
5381 break;
5382 }
5383 default:;
5384 }
5385 break;
5386 }
5387 default:;
5388 }
5389 }
5390 break;
5391 case CFN_BUILT_IN_SYNC_FETCH_AND_XOR_1:
5392 if (gimple_call_num_args (_c2) == 2)
5393 {
5394 tree _q30 = gimple_call_arg (_c2, 0);
5395 _q30 = do_valueize (valueize, _q30);
5396 tree _q31 = gimple_call_arg (_c2, 1);
5397 _q31 = do_valueize (valueize, _q31);
5398 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5399 {
5400 case INTEGER_CST:
5401 {
5402 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5403 {
5404 case INTEGER_CST:
5405 {
5406 {
5407/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5408 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5409 {
5410/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5411 int ibit = tree_log2 (captures[0]);
5412 int ibit2 = tree_log2 (captures[1]);
5413/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5414 if (ibit == ibit2
5415 && ibit >= 0
5416)
5417 {
5418 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__5418);
5419 {
5420 res_ops[0] = captures[0];
5421 res_ops[1] = captures[1];
5422 res_ops[2] = captures[2];
5423 return true;
5424 }
5425next_after_fail143:;
5426 }
5427 }
5428 }
5429 break;
5430 }
5431 default:;
5432 }
5433 break;
5434 }
5435 default:;
5436 }
5437 }
5438 break;
5439 case CFN_BUILT_IN_SYNC_FETCH_AND_XOR_2:
5440 if (gimple_call_num_args (_c2) == 2)
5441 {
5442 tree _q30 = gimple_call_arg (_c2, 0);
5443 _q30 = do_valueize (valueize, _q30);
5444 tree _q31 = gimple_call_arg (_c2, 1);
5445 _q31 = do_valueize (valueize, _q31);
5446 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5447 {
5448 case INTEGER_CST:
5449 {
5450 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5451 {
5452 case INTEGER_CST:
5453 {
5454 {
5455/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5456 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5457 {
5458/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5459 int ibit = tree_log2 (captures[0]);
5460 int ibit2 = tree_log2 (captures[1]);
5461/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5462 if (ibit == ibit2
5463 && ibit >= 0
5464)
5465 {
5466 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__5466);
5467 {
5468 res_ops[0] = captures[0];
5469 res_ops[1] = captures[1];
5470 res_ops[2] = captures[2];
5471 return true;
5472 }
5473next_after_fail144:;
5474 }
5475 }
5476 }
5477 break;
5478 }
5479 default:;
5480 }
5481 break;
5482 }
5483 default:;
5484 }
5485 }
5486 break;
5487 case CFN_BUILT_IN_SYNC_FETCH_AND_XOR_4:
5488 if (gimple_call_num_args (_c2) == 2)
5489 {
5490 tree _q30 = gimple_call_arg (_c2, 0);
5491 _q30 = do_valueize (valueize, _q30);
5492 tree _q31 = gimple_call_arg (_c2, 1);
5493 _q31 = do_valueize (valueize, _q31);
5494 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5495 {
5496 case INTEGER_CST:
5497 {
5498 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5499 {
5500 case INTEGER_CST:
5501 {
5502 {
5503/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5504 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5505 {
5506/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5507 int ibit = tree_log2 (captures[0]);
5508 int ibit2 = tree_log2 (captures[1]);
5509/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5510 if (ibit == ibit2
5511 && ibit >= 0
5512)
5513 {
5514 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__5514);
5515 {
5516 res_ops[0] = captures[0];
5517 res_ops[1] = captures[1];
5518 res_ops[2] = captures[2];
5519 return true;
5520 }
5521next_after_fail145:;
5522 }
5523 }
5524 }
5525 break;
5526 }
5527 default:;
5528 }
5529 break;
5530 }
5531 default:;
5532 }
5533 }
5534 break;
5535 case CFN_BUILT_IN_SYNC_FETCH_AND_XOR_8:
5536 if (gimple_call_num_args (_c2) == 2)
5537 {
5538 tree _q30 = gimple_call_arg (_c2, 0);
5539 _q30 = do_valueize (valueize, _q30);
5540 tree _q31 = gimple_call_arg (_c2, 1);
5541 _q31 = do_valueize (valueize, _q31);
5542 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5543 {
5544 case INTEGER_CST:
5545 {
5546 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5547 {
5548 case INTEGER_CST:
5549 {
5550 {
5551/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5552 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5553 {
5554/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5555 int ibit = tree_log2 (captures[0]);
5556 int ibit2 = tree_log2 (captures[1]);
5557/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5558 if (ibit == ibit2
5559 && ibit >= 0
5560)
5561 {
5562 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__5562);
5563 {
5564 res_ops[0] = captures[0];
5565 res_ops[1] = captures[1];
5566 res_ops[2] = captures[2];
5567 return true;
5568 }
5569next_after_fail146:;
5570 }
5571 }
5572 }
5573 break;
5574 }
5575 default:;
5576 }
5577 break;
5578 }
5579 default:;
5580 }
5581 }
5582 break;
5583 case CFN_BUILT_IN_SYNC_FETCH_AND_XOR_16:
5584 if (gimple_call_num_args (_c2) == 2)
5585 {
5586 tree _q30 = gimple_call_arg (_c2, 0);
5587 _q30 = do_valueize (valueize, _q30);
5588 tree _q31 = gimple_call_arg (_c2, 1);
5589 _q31 = do_valueize (valueize, _q31);
5590 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5591 {
5592 case INTEGER_CST:
5593 {
5594 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5595 {
5596 case INTEGER_CST:
5597 {
5598 {
5599/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5600 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5601 {
5602/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5603 int ibit = tree_log2 (captures[0]);
5604 int ibit2 = tree_log2 (captures[1]);
5605/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5606 if (ibit == ibit2
5607 && ibit >= 0
5608)
5609 {
5610 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__5610);
5611 {
5612 res_ops[0] = captures[0];
5613 res_ops[1] = captures[1];
5614 res_ops[2] = captures[2];
5615 return true;
5616 }
5617next_after_fail147:;
5618 }
5619 }
5620 }
5621 break;
5622 }
5623 default:;
5624 }
5625 break;
5626 }
5627 default:;
5628 }
5629 }
5630 break;
5631 case CFN_BUILT_IN_SYNC_XOR_AND_FETCH_1:
5632 if (gimple_call_num_args (_c2) == 2)
5633 {
5634 tree _q30 = gimple_call_arg (_c2, 0);
5635 _q30 = do_valueize (valueize, _q30);
5636 tree _q31 = gimple_call_arg (_c2, 1);
5637 _q31 = do_valueize (valueize, _q31);
5638 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5639 {
5640 case INTEGER_CST:
5641 {
5642 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5643 {
5644 case INTEGER_CST:
5645 {
5646 {
5647/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5648 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5649 {
5650/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5651 int ibit = tree_log2 (captures[0]);
5652 int ibit2 = tree_log2 (captures[1]);
5653/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5654 if (ibit == ibit2
5655 && ibit >= 0
5656)
5657 {
5658 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__5658);
5659 {
5660 res_ops[0] = captures[0];
5661 res_ops[1] = captures[1];
5662 res_ops[2] = captures[2];
5663 return true;
5664 }
5665next_after_fail148:;
5666 }
5667 }
5668 }
5669 break;
5670 }
5671 default:;
5672 }
5673 break;
5674 }
5675 default:;
5676 }
5677 }
5678 break;
5679 case CFN_BUILT_IN_SYNC_XOR_AND_FETCH_2:
5680 if (gimple_call_num_args (_c2) == 2)
5681 {
5682 tree _q30 = gimple_call_arg (_c2, 0);
5683 _q30 = do_valueize (valueize, _q30);
5684 tree _q31 = gimple_call_arg (_c2, 1);
5685 _q31 = do_valueize (valueize, _q31);
5686 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5687 {
5688 case INTEGER_CST:
5689 {
5690 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5691 {
5692 case INTEGER_CST:
5693 {
5694 {
5695/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5696 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5697 {
5698/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5699 int ibit = tree_log2 (captures[0]);
5700 int ibit2 = tree_log2 (captures[1]);
5701/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5702 if (ibit == ibit2
5703 && ibit >= 0
5704)
5705 {
5706 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__5706);
5707 {
5708 res_ops[0] = captures[0];
5709 res_ops[1] = captures[1];
5710 res_ops[2] = captures[2];
5711 return true;
5712 }
5713next_after_fail149:;
5714 }
5715 }
5716 }
5717 break;
5718 }
5719 default:;
5720 }
5721 break;
5722 }
5723 default:;
5724 }
5725 }
5726 break;
5727 case CFN_BUILT_IN_SYNC_XOR_AND_FETCH_4:
5728 if (gimple_call_num_args (_c2) == 2)
5729 {
5730 tree _q30 = gimple_call_arg (_c2, 0);
5731 _q30 = do_valueize (valueize, _q30);
5732 tree _q31 = gimple_call_arg (_c2, 1);
5733 _q31 = do_valueize (valueize, _q31);
5734 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5735 {
5736 case INTEGER_CST:
5737 {
5738 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5739 {
5740 case INTEGER_CST:
5741 {
5742 {
5743/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5744 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5745 {
5746/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5747 int ibit = tree_log2 (captures[0]);
5748 int ibit2 = tree_log2 (captures[1]);
5749/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5750 if (ibit == ibit2
5751 && ibit >= 0
5752)
5753 {
5754 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__5754);
5755 {
5756 res_ops[0] = captures[0];
5757 res_ops[1] = captures[1];
5758 res_ops[2] = captures[2];
5759 return true;
5760 }
5761next_after_fail150:;
5762 }
5763 }
5764 }
5765 break;
5766 }
5767 default:;
5768 }
5769 break;
5770 }
5771 default:;
5772 }
5773 }
5774 break;
5775 case CFN_BUILT_IN_SYNC_XOR_AND_FETCH_8:
5776 if (gimple_call_num_args (_c2) == 2)
5777 {
5778 tree _q30 = gimple_call_arg (_c2, 0);
5779 _q30 = do_valueize (valueize, _q30);
5780 tree _q31 = gimple_call_arg (_c2, 1);
5781 _q31 = do_valueize (valueize, _q31);
5782 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5783 {
5784 case INTEGER_CST:
5785 {
5786 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5787 {
5788 case INTEGER_CST:
5789 {
5790 {
5791/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5792 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5793 {
5794/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5795 int ibit = tree_log2 (captures[0]);
5796 int ibit2 = tree_log2 (captures[1]);
5797/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5798 if (ibit == ibit2
5799 && ibit >= 0
5800)
5801 {
5802 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__5802);
5803 {
5804 res_ops[0] = captures[0];
5805 res_ops[1] = captures[1];
5806 res_ops[2] = captures[2];
5807 return true;
5808 }
5809next_after_fail151:;
5810 }
5811 }
5812 }
5813 break;
5814 }
5815 default:;
5816 }
5817 break;
5818 }
5819 default:;
5820 }
5821 }
5822 break;
5823 case CFN_BUILT_IN_SYNC_XOR_AND_FETCH_16:
5824 if (gimple_call_num_args (_c2) == 2)
5825 {
5826 tree _q30 = gimple_call_arg (_c2, 0);
5827 _q30 = do_valueize (valueize, _q30);
5828 tree _q31 = gimple_call_arg (_c2, 1);
5829 _q31 = do_valueize (valueize, _q31);
5830 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5831 {
5832 case INTEGER_CST:
5833 {
5834 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5835 {
5836 case INTEGER_CST:
5837 {
5838 {
5839/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5840 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q31, _p1, _p0, _q30 };
5841 {
5842/* #line 4045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5843 int ibit = tree_log2 (captures[0]);
5844 int ibit2 = tree_log2 (captures[1]);
5845/* #line 4049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5846 if (ibit == ibit2
5847 && ibit >= 0
5848)
5849 {
5850 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4042, __FILE__"gimple-match.c", __LINE__5850);
5851 {
5852 res_ops[0] = captures[0];
5853 res_ops[1] = captures[1];
5854 res_ops[2] = captures[2];
5855 return true;
5856 }
5857next_after_fail152:;
5858 }
5859 }
5860 }
5861 break;
5862 }
5863 default:;
5864 }
5865 break;
5866 }
5867 default:;
5868 }
5869 }
5870 break;
5871 default:;
5872 }
5873 }
5874 break;
5875 default:;
5876 }
5877}
5878 }
5879 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
5880 {
5881 case SSA_NAME:
5882 if (gimple *_d2 = get_def (valueize, _p1))
5883 {
5884 if (gcall *_c2 = dyn_cast <gcall *> (_d2))
5885 switch (gimple_call_combined_fn (_c2))
5886 {
5887 case CFN_BUILT_IN_ATOMIC_FETCH_OR_1:
5888 if (gimple_call_num_args (_c2) == 3)
5889 {
5890 tree _q30 = gimple_call_arg (_c2, 0);
5891 _q30 = do_valueize (valueize, _q30);
5892 tree _q31 = gimple_call_arg (_c2, 1);
5893 _q31 = do_valueize (valueize, _q31);
5894 tree _q32 = gimple_call_arg (_c2, 2);
5895 _q32 = do_valueize (valueize, _q32);
5896 if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)((non_type_check ((_q31), "gimple-match.c", 5896, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5897 {
5898 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5899 {
5900 case SSA_NAME:
5901 if (gimple *_d3 = get_def (valueize, _q31))
5902 {
5903 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
5904 switch (gimple_assign_rhs_code (_a3))
5905 {
5906 case LSHIFT_EXPR:
5907 {
5908 tree _q60 = gimple_assign_rhs1 (_a3);
5909 _q60 = do_valueize (valueize, _q60);
5910 tree _q61 = gimple_assign_rhs2 (_a3);
5911 _q61 = do_valueize (valueize, _q61);
5912 if (integer_onep (_q60))
5913 {
5914 {
5915/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5916 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1, _q30, _q60, _q61, _q32 };
5917 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__5917);
5918 {
5919 res_ops[0] = captures[0];
5920 res_ops[1] = captures[0];
5921 res_ops[2] = captures[1];
5922 return true;
5923 }
5924next_after_fail153:;
5925 }
5926 }
5927 break;
5928 }
5929 default:;
5930 }
5931 }
5932 break;
5933 default:;
5934 }
5935 }
5936 }
5937 break;
5938 case CFN_BUILT_IN_ATOMIC_FETCH_OR_2:
5939 if (gimple_call_num_args (_c2) == 3)
5940 {
5941 tree _q30 = gimple_call_arg (_c2, 0);
5942 _q30 = do_valueize (valueize, _q30);
5943 tree _q31 = gimple_call_arg (_c2, 1);
5944 _q31 = do_valueize (valueize, _q31);
5945 tree _q32 = gimple_call_arg (_c2, 2);
5946 _q32 = do_valueize (valueize, _q32);
5947 if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)((non_type_check ((_q31), "gimple-match.c", 5947, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5948 {
5949 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
5950 {
5951 case SSA_NAME:
5952 if (gimple *_d3 = get_def (valueize, _q31))
5953 {
5954 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
5955 switch (gimple_assign_rhs_code (_a3))
5956 {
5957 case LSHIFT_EXPR:
5958 {
5959 tree _q60 = gimple_assign_rhs1 (_a3);
5960 _q60 = do_valueize (valueize, _q60);
5961 tree _q61 = gimple_assign_rhs2 (_a3);
5962 _q61 = do_valueize (valueize, _q61);
5963 if (integer_onep (_q60))
5964 {
5965 {
5966/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5967 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1, _q30, _q60, _q61, _q32 };
5968 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__5968);
5969 {
5970 res_ops[0] = captures[0];
5971 res_ops[1] = captures[0];
5972 res_ops[2] = captures[1];
5973 return true;
5974 }
5975next_after_fail154:;
5976 }
5977 }
5978 break;
5979 }
5980 default:;
5981 }
5982 }
5983 break;
5984 default:;
5985 }
5986 }
5987 }
5988 break;
5989 case CFN_BUILT_IN_ATOMIC_FETCH_OR_4:
5990 if (gimple_call_num_args (_c2) == 3)
5991 {
5992 tree _q30 = gimple_call_arg (_c2, 0);
5993 _q30 = do_valueize (valueize, _q30);
5994 tree _q31 = gimple_call_arg (_c2, 1);
5995 _q31 = do_valueize (valueize, _q31);
5996 tree _q32 = gimple_call_arg (_c2, 2);
5997 _q32 = do_valueize (valueize, _q32);
5998 if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)((non_type_check ((_q31), "gimple-match.c", 5998, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5999 {
6000 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
6001 {
6002 case SSA_NAME:
6003 if (gimple *_d3 = get_def (valueize, _q31))
6004 {
6005 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
6006 switch (gimple_assign_rhs_code (_a3))
6007 {
6008 case LSHIFT_EXPR:
6009 {
6010 tree _q60 = gimple_assign_rhs1 (_a3);
6011 _q60 = do_valueize (valueize, _q60);
6012 tree _q61 = gimple_assign_rhs2 (_a3);
6013 _q61 = do_valueize (valueize, _q61);
6014 if (integer_onep (_q60))
6015 {
6016 {
6017/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
6018 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1, _q30, _q60, _q61, _q32 };
6019 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__6019);
6020 {
6021 res_ops[0] = captures[0];
6022 res_ops[1] = captures[0];
6023 res_ops[2] = captures[1];
6024 return true;
6025 }
6026next_after_fail155:;
6027 }
6028 }
6029 break;
6030 }
6031 default:;
6032 }
6033 }
6034 break;
6035 default:;
6036 }
6037 }
6038 }
6039 break;
6040 case CFN_BUILT_IN_ATOMIC_FETCH_OR_8:
6041 if (gimple_call_num_args (_c2) == 3)
6042 {
6043 tree _q30 = gimple_call_arg (_c2, 0);
6044 _q30 = do_valueize (valueize, _q30);
6045 tree _q31 = gimple_call_arg (_c2, 1);
6046 _q31 = do_valueize (valueize, _q31);
6047 tree _q32 = gimple_call_arg (_c2, 2);
6048 _q32 = do_valueize (valueize, _q32);
6049 if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)((non_type_check ((_q31), "gimple-match.c", 6049, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6050 {
6051 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
6052 {
6053 case SSA_NAME:
6054 if (gimple *_d3 = get_def (valueize, _q31))
6055 {
6056 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
6057 switch (gimple_assign_rhs_code (_a3))
6058 {
6059 case LSHIFT_EXPR:
6060 {
6061 tree _q60 = gimple_assign_rhs1 (_a3);
6062 _q60 = do_valueize (valueize, _q60);
6063 tree _q61 = gimple_assign_rhs2 (_a3);
6064 _q61 = do_valueize (valueize, _q61);
6065 if (integer_onep (_q60))
6066 {
6067 {
6068/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
6069 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1, _q30, _q60, _q61, _q32 };
6070 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__6070);
6071 {
6072 res_ops[0] = captures[0];
6073 res_ops[1] = captures[0];
6074 res_ops[2] = captures[1];
6075 return true;
6076 }
6077next_after_fail156:;
6078 }
6079 }
6080 break;
6081 }
6082 default:;
6083 }
6084 }
6085 break;
6086 default:;
6087 }
6088 }
6089 }
6090 break;
6091 case CFN_BUILT_IN_ATOMIC_FETCH_OR_16:
6092 if (gimple_call_num_args (_c2) == 3)
6093 {
6094 tree _q30 = gimple_call_arg (_c2, 0);
6095 _q30 = do_valueize (valueize, _q30);
6096 tree _q31 = gimple_call_arg (_c2, 1);
6097 _q31 = do_valueize (valueize, _q31);
6098 tree _q32 = gimple_call_arg (_c2, 2);
6099 _q32 = do_valueize (valueize, _q32);
6100 if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)((non_type_check ((_q31), "gimple-match.c", 6100, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6101 {
6102 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
6103 {
6104 case SSA_NAME:
6105 if (gimple *_d3 = get_def (valueize, _q31))
6106 {
6107 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
6108 switch (gimple_assign_rhs_code (_a3))
6109 {
6110 case LSHIFT_EXPR:
6111 {
6112 tree _q60 = gimple_assign_rhs1 (_a3);
6113 _q60 = do_valueize (valueize, _q60);
6114 tree _q61 = gimple_assign_rhs2 (_a3);
6115 _q61 = do_valueize (valueize, _q61);
6116 if (integer_onep (_q60))
6117 {
6118 {
6119/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
6120 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1, _q30, _q60, _q61, _q32 };
6121 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__6121);
6122 {
6123 res_ops[0] = captures[0];
6124 res_ops[1] = captures[0];
6125 res_ops[2] = captures[1];
6126 return true;
6127 }
6128next_after_fail157:;
6129 }
6130 }
6131 break;
6132 }
6133 default:;
6134 }
6135 }
6136 break;
6137 default:;
6138 }
6139 }
6140 }
6141 break;
6142 case CFN_BUILT_IN_ATOMIC_FETCH_XOR_1:
6143 if (gimple_call_num_args (_c2) == 3)
6144 {
6145 tree _q30 = gimple_call_arg (_c2, 0);
6146 _q30 = do_valueize (valueize, _q30);
6147 tree _q31 = gimple_call_arg (_c2, 1);
6148 _q31 = do_valueize (valueize, _q31);
6149 tree _q32 = gimple_call_arg (_c2, 2);
6150 _q32 = do_valueize (valueize, _q32);
6151 if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)((non_type_check ((_q31), "gimple-match.c", 6151, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6152 {
6153 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
6154 {
6155 case SSA_NAME:
6156 if (gimple *_d3 = get_def (valueize, _q31))
6157 {
6158 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
6159 switch (gimple_assign_rhs_code (_a3))
6160 {
6161 case LSHIFT_EXPR:
6162 {
6163 tree _q60 = gimple_assign_rhs1 (_a3);
6164 _q60 = do_valueize (valueize, _q60);
6165 tree _q61 = gimple_assign_rhs2 (_a3);
6166 _q61 = do_valueize (valueize, _q61);
6167 if (integer_onep (_q60))
6168 {
6169 {
6170/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
6171 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1, _q30, _q60, _q61, _q32 };
6172 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__6172);
6173 {
6174 res_ops[0] = captures[0];
6175 res_ops[1] = captures[0];
6176 res_ops[2] = captures[1];
6177 return true;
6178 }
6179next_after_fail158:;
6180 }
6181 }
6182 break;
6183 }
6184 default:;
6185 }
6186 }
6187 break;
6188 default:;
6189 }
6190 }
6191 }
6192 break;
6193 case CFN_BUILT_IN_ATOMIC_FETCH_XOR_2:
6194 if (gimple_call_num_args (_c2) == 3)
6195 {
6196 tree _q30 = gimple_call_arg (_c2, 0);
6197 _q30 = do_valueize (valueize, _q30);
6198 tree _q31 = gimple_call_arg (_c2, 1);
6199 _q31 = do_valueize (valueize, _q31);
6200 tree _q32 = gimple_call_arg (_c2, 2);
6201 _q32 = do_valueize (valueize, _q32);
6202 if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)((non_type_check ((_q31), "gimple-match.c", 6202, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6203 {
6204 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
6205 {
6206 case SSA_NAME:
6207 if (gimple *_d3 = get_def (valueize, _q31))
6208 {
6209 if (gassign *_a3 = dyn_cast <gassign *> (_d3))
6210 switch (gimple_assign_rhs_code (_a3))
6211 {
6212 case LSHIFT_EXPR:
6213 {
6214 tree _q60 = gimple_assign_rhs1 (_a3);
6215 _q60 = do_valueize (valueize, _q60);
6216 tree _q61 = gimple_assign_rhs2 (_a3);
6217 _q61 = do_valueize (valueize, _q61);
6218 if (integer_onep (_q60))
6219 {
6220 {
6221/* #line 4052 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
6222 tree captures[6] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1, _q30, _q60, _q61, _q32 };
6223 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4052, __FILE__"gimple-match.c", __LINE__6223);
6224 {
6225 res_ops[0] = captures[0];
6226 res_ops[1] = captures[0];
6227 res_ops[2