Line data Source code
1 : /* Generated automatically by the program `genmatch' from
2 : a IL pattern matching and simplification description. */
3 : #pragma GCC diagnostic push
4 : #pragma GCC diagnostic ignored "-Wunused-variable"
5 : #pragma GCC diagnostic ignored "-Wunused-function"
6 :
7 : #include "generic-match-auto.h"
8 :
9 : bool
10 129912779 : tree_negate_expr_p (tree t)
11 : {
12 129912779 : const tree type = TREE_TYPE (t);
13 129912779 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 129912779 : if (TREE_SIDE_EFFECTS (t)) return false;
15 124960330 : switch (TREE_CODE (t))
16 : {
17 7610840 : case INTEGER_CST:
18 7610840 : {
19 7610840 : {
20 7610840 : if ((INTEGRAL_TYPE_P (type)
21 7610840 : && TYPE_UNSIGNED (type))
22 9783404 : || (!TYPE_OVERFLOW_SANITIZED (type)
23 2169822 : && may_negate_without_overflow_p (t))
24 : )
25 : {
26 7594958 : {
27 7594958 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 14, __FILE__, __LINE__, false);
28 7594958 : return true;
29 : }
30 : }
31 : }
32 : break;
33 : }
34 0 : case FIXED_CST:
35 0 : {
36 0 : {
37 0 : {
38 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 15, __FILE__, __LINE__, false);
39 : return true;
40 : }
41 : }
42 403883 : break;
43 : }
44 403883 : case NEGATE_EXPR:
45 403883 : {
46 403883 : tree _p0 = TREE_OPERAND (t, 0);
47 403883 : {
48 403883 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
49 403883 : if (!TYPE_OVERFLOW_SANITIZED (type)
50 : )
51 : {
52 403863 : {
53 403863 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 16, __FILE__, __LINE__, false);
54 403863 : return true;
55 : }
56 : }
57 : }
58 : break;
59 : }
60 733673 : case REAL_CST:
61 733673 : {
62 733673 : {
63 733673 : if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (t))
64 : )
65 : {
66 639 : {
67 639 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 17, __FILE__, __LINE__, false);
68 639 : return true;
69 : }
70 : }
71 : }
72 : break;
73 : }
74 450 : case VECTOR_CST:
75 450 : {
76 450 : {
77 450 : if (FLOAT_TYPE_P (TREE_TYPE (type)) || TYPE_OVERFLOW_WRAPS (type)
78 : )
79 : {
80 329 : {
81 329 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 18, __FILE__, __LINE__, false);
82 329 : return true;
83 : }
84 : }
85 : }
86 : break;
87 : }
88 1220814 : case MINUS_EXPR:
89 1220814 : {
90 1220814 : tree _p0 = TREE_OPERAND (t, 0);
91 1220814 : tree _p1 = TREE_OPERAND (t, 1);
92 1220814 : {
93 1220814 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
94 1220814 : if ((ANY_INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_WRAPS (type))
95 2124213 : || (FLOAT_TYPE_P (type)
96 640083 : && !HONOR_SIGN_DEPENDENT_ROUNDING (type)
97 640083 : && !HONOR_SIGNED_ZEROS (type))
98 : )
99 : {
100 317988 : {
101 317988 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 19, __FILE__, __LINE__, false);
102 317988 : return true;
103 : }
104 : }
105 : }
106 902826 : break;
107 : }
108 : default:;
109 : }
110 : return false;
111 : }
112 :
113 : bool
114 0 : tree_double_value_p (tree t)
115 : {
116 0 : const tree type = TREE_TYPE (t);
117 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
118 0 : if (TREE_SIDE_EFFECTS (t)) return false;
119 0 : {
120 0 : tree captures[1] ATTRIBUTE_UNUSED = { t };
121 0 : if (TYPE_MAIN_VARIANT (TREE_TYPE (captures[0])) == double_type_node
122 : )
123 : {
124 0 : {
125 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 44, __FILE__, __LINE__, false);
126 0 : return true;
127 : }
128 : }
129 : }
130 : return false;
131 : }
132 :
133 : tree
134 0 : generic_simplify_6 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
135 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
136 : {
137 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
138 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail77;
139 0 : {
140 0 : tree res_op0;
141 0 : {
142 0 : tree _o1[2], _r1;
143 0 : _o1[0] = captures[1];
144 0 : _o1[1] = captures[2];
145 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
146 0 : res_op0 = _r1;
147 : }
148 0 : tree _r;
149 0 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
150 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 54, __FILE__, __LINE__, true);
151 : return _r;
152 : }
153 0 : next_after_fail77:;
154 0 : return NULL_TREE;
155 : }
156 :
157 : tree
158 223445 : generic_simplify_15 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
159 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
160 : const enum tree_code ARG_UNUSED (op))
161 : {
162 223445 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
163 223445 : {
164 223445 : bool wascmp;
165 223445 : if (types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
166 223445 : && bitwise_inverted_equal_p (captures[0], captures[1], wascmp)
167 : )
168 : {
169 47 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail90;
170 47 : {
171 47 : tree res_op0;
172 47 : res_op0 = wascmp
173 47 : ? constant_boolean_node (true, type)
174 40 : : build_all_ones_cst (TREE_TYPE (captures[0]));
175 47 : tree _r;
176 47 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
177 47 : if (TREE_SIDE_EFFECTS (captures[0]))
178 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
179 47 : if (TREE_SIDE_EFFECTS (captures[1]))
180 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
181 47 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 63, __FILE__, __LINE__, true);
182 47 : return _r;
183 : }
184 0 : next_after_fail90:;
185 : }
186 : }
187 223398 : return NULL_TREE;
188 : }
189 :
190 : tree
191 11 : generic_simplify_24 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
192 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
193 : {
194 11 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
195 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail99;
196 11 : {
197 11 : tree res_op0;
198 11 : res_op0 = captures[0];
199 11 : tree _r;
200 11 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
201 11 : if (TREE_SIDE_EFFECTS (captures[2]))
202 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
203 11 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 72, __FILE__, __LINE__, true);
204 : return _r;
205 : }
206 0 : next_after_fail99:;
207 0 : return NULL_TREE;
208 : }
209 :
210 : tree
211 0 : generic_simplify_31 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
212 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
213 : {
214 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
215 0 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[1]))
216 0 : && tree_nop_conversion_p (type, TREE_TYPE (captures[2]))
217 : )
218 : {
219 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail106;
220 0 : {
221 0 : tree res_op0;
222 0 : {
223 0 : tree _o1[1], _r1;
224 0 : _o1[0] = captures[1];
225 0 : if (TREE_TYPE (_o1[0]) != type)
226 : {
227 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
228 : }
229 : else
230 : _r1 = _o1[0];
231 0 : res_op0 = _r1;
232 : }
233 0 : tree res_op1;
234 0 : {
235 0 : tree _o1[1], _r1;
236 0 : _o1[0] = captures[2];
237 0 : if (TREE_TYPE (_o1[0]) != type)
238 : {
239 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
240 : }
241 : else
242 : _r1 = _o1[0];
243 0 : res_op1 = _r1;
244 : }
245 0 : tree _r;
246 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
247 0 : if (TREE_SIDE_EFFECTS (captures[0]))
248 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
249 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 79, __FILE__, __LINE__, true);
250 0 : return _r;
251 : }
252 0 : next_after_fail106:;
253 : }
254 : return NULL_TREE;
255 : }
256 :
257 : tree
258 0 : generic_simplify_40 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
259 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
260 : const enum tree_code ARG_UNUSED (op))
261 : {
262 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
263 0 : if (INTEGRAL_TYPE_P (type)
264 0 : && operand_equal_p (captures[2], captures[6], 0)
265 0 : && (tree_nonzero_bits (captures[0]) & tree_nonzero_bits (captures[4])) == 0
266 : )
267 : {
268 0 : {
269 0 : tree t = type;
270 0 : if (!TYPE_OVERFLOW_WRAPS (t))
271 0 : t = unsigned_type_for (t);
272 0 : wide_int c = wi::add (wi::to_wide (captures[3]), wi::to_wide (captures[7]));
273 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail117;
274 0 : if (TREE_SIDE_EFFECTS (captures[7])) goto next_after_fail117;
275 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail117;
276 0 : {
277 0 : tree res_op0;
278 0 : {
279 0 : tree _o1[2], _r1;
280 0 : {
281 0 : tree _o2[1], _r2;
282 0 : _o2[0] = captures[2];
283 0 : if (TREE_TYPE (_o2[0]) != t)
284 : {
285 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, t, _o2[0]);
286 : }
287 : else
288 : _r2 = _o2[0];
289 0 : _o1[0] = _r2;
290 : }
291 0 : _o1[1] = wide_int_to_tree (t, c);
292 0 : _r1 = fold_build2_loc (loc, MULT_EXPR, t, _o1[0], _o1[1]);
293 0 : res_op0 = _r1;
294 : }
295 0 : tree _r;
296 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
297 0 : if (TREE_SIDE_EFFECTS (captures[6]))
298 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[6]), _r);
299 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 88, __FILE__, __LINE__, true);
300 0 : return _r;
301 : }
302 0 : next_after_fail117:;
303 0 : }
304 : }
305 : return NULL_TREE;
306 : }
307 :
308 : tree
309 18 : generic_simplify_51 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
310 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
311 : const enum tree_code ARG_UNUSED (cmp))
312 : {
313 18 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
314 36 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
315 18 : && !TYPE_UNSIGNED (TREE_TYPE (captures[1]))
316 36 : && types_match (TREE_TYPE (captures[1]), TREE_TYPE (captures[3]))
317 : )
318 : {
319 18 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail130;
320 18 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail130;
321 18 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail130;
322 18 : {
323 18 : tree res_op0;
324 18 : {
325 18 : tree _o1[2], _r1;
326 18 : _o1[0] = captures[1];
327 18 : _o1[1] = captures[3];
328 18 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
329 18 : res_op0 = _r1;
330 : }
331 18 : tree res_op1;
332 18 : res_op1 = build_zero_cst (TREE_TYPE (captures[1]));
333 18 : tree _r;
334 18 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
335 18 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 98, __FILE__, __LINE__, true);
336 18 : return _r;
337 : }
338 : next_after_fail130:;
339 : }
340 : return NULL_TREE;
341 : }
342 :
343 : tree
344 46116 : generic_simplify_61 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
345 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
346 : {
347 46116 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
348 46116 : if (!TYPE_SATURATING (type)
349 : )
350 : {
351 46116 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
352 92162 : && !FIXED_POINT_TYPE_P (type)
353 : )
354 : {
355 46046 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail142;
356 46046 : {
357 46046 : tree res_op0;
358 46046 : res_op0 = captures[0];
359 46046 : tree _r;
360 46046 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
361 46046 : if (TREE_SIDE_EFFECTS (captures[1]))
362 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
363 46046 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 110, __FILE__, __LINE__, true);
364 46046 : return _r;
365 : }
366 0 : next_after_fail142:;
367 : }
368 : }
369 : return NULL_TREE;
370 : }
371 :
372 : tree
373 6831678 : generic_simplify_68 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
374 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
375 : const enum tree_code ARG_UNUSED (op))
376 : {
377 6831678 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
378 6831678 : if (!TYPE_SATURATING (type)
379 : )
380 : {
381 6831678 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
382 13280721 : && !FIXED_POINT_TYPE_P (type)
383 : )
384 : {
385 6449043 : if (INTEGRAL_TYPE_P (type)
386 6448751 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
387 5186946 : && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (captures[0]))
388 4344616 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
389 3800700 : && !TYPE_OVERFLOW_TRAPS (type)
390 10249743 : && !TYPE_OVERFLOW_SANITIZED (type)
391 : )
392 : {
393 3800429 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail157;
394 3800429 : {
395 3800429 : tree res_op0;
396 3800429 : {
397 3800429 : tree _o1[2], _r1;
398 3800429 : _o1[0] = captures[0];
399 3800429 : _o1[1] = captures[1];
400 3800429 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
401 3800429 : if (EXPR_P (_r1))
402 3785997 : goto next_after_fail157;
403 14432 : res_op0 = _r1;
404 : }
405 14432 : tree _r;
406 14432 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
407 14432 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 125, __FILE__, __LINE__, true);
408 14432 : return _r;
409 : }
410 : next_after_fail157:;
411 : }
412 : }
413 : }
414 : return NULL_TREE;
415 : }
416 :
417 : tree
418 56 : generic_simplify_78 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
419 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
420 : const enum tree_code ARG_UNUSED (cmp),
421 : const enum tree_code ARG_UNUSED (icmp),
422 : const enum tree_code ARG_UNUSED (ncmp))
423 : {
424 56 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
425 56 : if (TYPE_PRECISION (type) > 1
426 56 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
427 : )
428 : {
429 0 : {
430 0 : enum tree_code ic = invert_tree_comparison
431 0 : (cmp, HONOR_NANS (captures[1]));
432 0 : tree cmptype = TREE_TYPE (captures[0]);
433 0 : if (ic == icmp
434 : )
435 : {
436 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail168;
437 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail168;
438 0 : {
439 0 : tree res_op0;
440 0 : {
441 0 : tree _o1[1], _r1;
442 0 : {
443 0 : tree _o2[2], _r2;
444 0 : _o2[0] = captures[1];
445 0 : _o2[1] = captures[2];
446 0 : _r2 = fold_build2_loc (loc, icmp, cmptype, _o2[0], _o2[1]);
447 0 : _o1[0] = _r2;
448 : }
449 0 : if (TREE_TYPE (_o1[0]) != type)
450 : {
451 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
452 : }
453 : else
454 : _r1 = _o1[0];
455 0 : res_op0 = _r1;
456 : }
457 0 : tree _r;
458 0 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
459 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 136, __FILE__, __LINE__, true);
460 0 : return _r;
461 : }
462 : next_after_fail168:;
463 : }
464 : else
465 : {
466 0 : if (ic == ncmp
467 : )
468 : {
469 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail169;
470 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail169;
471 0 : {
472 0 : tree res_op0;
473 0 : {
474 0 : tree _o1[1], _r1;
475 0 : {
476 0 : tree _o2[2], _r2;
477 0 : _o2[0] = captures[1];
478 0 : _o2[1] = captures[2];
479 0 : _r2 = fold_build2_loc (loc, ncmp, cmptype, _o2[0], _o2[1]);
480 0 : _o1[0] = _r2;
481 : }
482 0 : if (TREE_TYPE (_o1[0]) != type)
483 : {
484 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
485 : }
486 : else
487 : _r1 = _o1[0];
488 0 : res_op0 = _r1;
489 : }
490 0 : tree _r;
491 0 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
492 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 137, __FILE__, __LINE__, true);
493 0 : return _r;
494 : }
495 : next_after_fail169:;
496 : }
497 : }
498 : }
499 : }
500 : return NULL_TREE;
501 : }
502 :
503 : tree
504 5 : generic_simplify_92 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
505 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
506 : {
507 5 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
508 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail183;
509 5 : {
510 5 : tree res_op0;
511 5 : res_op0 = captures[1];
512 5 : tree res_op1;
513 5 : {
514 5 : tree _o1[1], _r1;
515 5 : _o1[0] = captures[2];
516 5 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
517 5 : res_op1 = _r1;
518 : }
519 5 : tree _r;
520 5 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
521 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 151, __FILE__, __LINE__, true);
522 : return _r;
523 : }
524 0 : next_after_fail183:;
525 0 : return NULL_TREE;
526 : }
527 :
528 : tree
529 339 : generic_simplify_99 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
530 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
531 : {
532 339 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
533 339 : if (!TYPE_SATURATING (type)
534 : )
535 : {
536 339 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
537 678 : && !FIXED_POINT_TYPE_P (type)
538 : )
539 : {
540 339 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail192;
541 339 : {
542 339 : tree res_op0;
543 339 : res_op0 = captures[1];
544 339 : tree _r;
545 339 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
546 339 : if (TREE_SIDE_EFFECTS (captures[0]))
547 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
548 339 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 159, __FILE__, __LINE__, true);
549 339 : return _r;
550 : }
551 0 : next_after_fail192:;
552 : }
553 : }
554 : return NULL_TREE;
555 : }
556 :
557 : tree
558 155389 : generic_simplify_105 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
559 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
560 : {
561 155389 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
562 155389 : if (!TYPE_SATURATING (type)
563 : )
564 : {
565 155389 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
566 310778 : && !FIXED_POINT_TYPE_P (type)
567 : )
568 : {
569 155389 : if (INTEGRAL_TYPE_P (type)
570 155389 : && TYPE_OVERFLOW_UNDEFINED (type)
571 67 : && element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
572 155456 : && element_precision (type) <= element_precision (TREE_TYPE (captures[2]))
573 : )
574 : {
575 67 : {
576 67 : tree utype = unsigned_type_for (type);
577 67 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail201;
578 67 : {
579 67 : tree res_op0;
580 67 : {
581 67 : tree _o1[2], _r1;
582 67 : {
583 67 : tree _o2[1], _r2;
584 67 : _o2[0] = captures[1];
585 67 : if (TREE_TYPE (_o2[0]) != utype)
586 : {
587 52 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
588 : }
589 : else
590 : _r2 = _o2[0];
591 67 : _o1[0] = _r2;
592 : }
593 67 : {
594 67 : tree _o2[1], _r2;
595 67 : _o2[0] = captures[2];
596 67 : if (TREE_TYPE (_o2[0]) != utype)
597 : {
598 52 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
599 : }
600 : else
601 : _r2 = _o2[0];
602 67 : _o1[1] = _r2;
603 : }
604 67 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
605 67 : res_op0 = _r1;
606 : }
607 67 : tree _r;
608 67 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
609 67 : if (TREE_SIDE_EFFECTS (captures[3]))
610 2 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
611 67 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 168, __FILE__, __LINE__, true);
612 67 : return _r;
613 : }
614 0 : next_after_fail201:;
615 : }
616 : }
617 : else
618 : {
619 155322 : if (((element_precision (type) <= element_precision (TREE_TYPE (captures[1])))
620 155322 : == (element_precision (type) <= element_precision (TREE_TYPE (captures[2]))))
621 155322 : && (element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
622 53 : || (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
623 53 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
624 53 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
625 53 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))))
626 : )
627 : {
628 138657 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail202;
629 138657 : {
630 138657 : tree res_op0;
631 138657 : {
632 138657 : tree _o1[1], _r1;
633 138657 : _o1[0] = captures[1];
634 138657 : if (TREE_TYPE (_o1[0]) != type)
635 : {
636 138657 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
637 : }
638 : else
639 : _r1 = _o1[0];
640 138657 : res_op0 = _r1;
641 : }
642 138657 : tree res_op1;
643 138657 : {
644 138657 : tree _o1[1], _r1;
645 138657 : _o1[0] = captures[2];
646 138657 : if (TREE_TYPE (_o1[0]) != type)
647 : {
648 138657 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
649 : }
650 : else
651 : _r1 = _o1[0];
652 138657 : res_op1 = _r1;
653 : }
654 138657 : tree _r;
655 138657 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
656 138657 : if (TREE_SIDE_EFFECTS (captures[3]))
657 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
658 138657 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 169, __FILE__, __LINE__, true);
659 138657 : return _r;
660 : }
661 0 : next_after_fail202:;
662 : }
663 : }
664 : }
665 : }
666 : return NULL_TREE;
667 : }
668 :
669 : tree
670 93 : generic_simplify_133 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
671 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
672 : const enum tree_code ARG_UNUSED (op),
673 : const enum tree_code ARG_UNUSED (rop))
674 : {
675 93 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
676 93 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[0]))
677 93 : && element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
678 : )
679 : {
680 61 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail230;
681 61 : {
682 61 : tree res_op0;
683 61 : {
684 61 : tree _o1[2], _r1;
685 61 : {
686 61 : tree _o2[1], _r2;
687 61 : _o2[0] = captures[0];
688 61 : if (TREE_TYPE (_o2[0]) != type)
689 : {
690 1 : _r2 = fold_build1_loc (loc, NOP_EXPR, type, _o2[0]);
691 : }
692 : else
693 : _r2 = _o2[0];
694 61 : _o1[0] = _r2;
695 : }
696 61 : {
697 61 : tree _o2[1], _r2;
698 61 : _o2[0] = captures[1];
699 61 : if (TREE_TYPE (_o2[0]) != type)
700 : {
701 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, type, _o2[0]);
702 : }
703 : else
704 : _r2 = _o2[0];
705 61 : _o1[1] = _r2;
706 : }
707 61 : _r1 = fold_build2_loc (loc, rop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
708 61 : res_op0 = _r1;
709 : }
710 61 : tree _r;
711 61 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
712 61 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 192, __FILE__, __LINE__, true);
713 61 : return _r;
714 : }
715 0 : next_after_fail230:;
716 : }
717 : return NULL_TREE;
718 : }
719 :
720 : tree
721 2 : generic_simplify_146 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
722 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
723 : const enum tree_code ARG_UNUSED (bitop),
724 : const enum tree_code ARG_UNUSED (rbitop))
725 : {
726 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
727 2 : if (bitop == BIT_AND_EXPR
728 : )
729 : {
730 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail247;
731 1 : {
732 1 : tree _r;
733 1 : _r = build_zero_cst (type);
734 1 : if (TREE_SIDE_EFFECTS (captures[0]))
735 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
736 1 : if (TREE_SIDE_EFFECTS (captures[1]))
737 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
738 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 199, __FILE__, __LINE__, true);
739 1 : return _r;
740 : }
741 0 : next_after_fail247:;
742 : }
743 : else
744 : {
745 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail248;
746 1 : {
747 1 : tree _r;
748 1 : _r = build_minus_one_cst (type);
749 1 : if (TREE_SIDE_EFFECTS (captures[0]))
750 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
751 1 : if (TREE_SIDE_EFFECTS (captures[1]))
752 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
753 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 200, __FILE__, __LINE__, true);
754 1 : return _r;
755 : }
756 0 : next_after_fail248:;
757 : }
758 : return NULL_TREE;
759 : }
760 :
761 : tree
762 0 : generic_simplify_156 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
763 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
764 : {
765 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
766 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
767 0 : && TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))
768 : )
769 : {
770 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail261;
771 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail261;
772 0 : {
773 0 : tree res_op0;
774 0 : res_op0 = captures[3];
775 0 : tree res_op1;
776 0 : {
777 0 : tree _o1[2], _r1;
778 0 : _o1[0] = captures[1];
779 0 : _o1[1] = build_int_cst (TREE_TYPE (captures[1]), 1);
780 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
781 0 : res_op1 = _r1;
782 : }
783 0 : tree _r;
784 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
785 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 210, __FILE__, __LINE__, true);
786 0 : return _r;
787 : }
788 : next_after_fail261:;
789 : }
790 : return NULL_TREE;
791 : }
792 :
793 : tree
794 0 : generic_simplify_165 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
795 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
796 : const enum tree_code ARG_UNUSED (eqne))
797 : {
798 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
799 0 : if (eqne == EQ_EXPR
800 : )
801 : {
802 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail288;
803 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail288;
804 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail288;
805 0 : {
806 0 : tree _r;
807 0 : _r = captures[0];
808 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 228, __FILE__, __LINE__, true);
809 0 : return _r;
810 : }
811 : next_after_fail288:;
812 : }
813 : else
814 : {
815 0 : if (eqne == NE_EXPR
816 : )
817 : {
818 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail289;
819 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail289;
820 0 : {
821 0 : tree _r;
822 0 : _r = constant_boolean_node (true, type);
823 0 : if (TREE_SIDE_EFFECTS (captures[2]))
824 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
825 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 229, __FILE__, __LINE__, true);
826 0 : return _r;
827 : }
828 : next_after_fail289:;
829 : }
830 : }
831 : return NULL_TREE;
832 : }
833 :
834 : tree
835 0 : generic_simplify_173 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
836 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
837 : {
838 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
839 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail310;
840 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail310;
841 0 : {
842 0 : tree _r;
843 0 : _r = captures[1];
844 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 231, __FILE__, __LINE__, true);
845 : return _r;
846 : }
847 : next_after_fail310:;
848 : return NULL_TREE;
849 : }
850 :
851 : tree
852 0 : generic_simplify_177 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
853 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
854 : const combined_fn ARG_UNUSED (COPYSIGN_ALL))
855 : {
856 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
857 0 : if (!tree_expr_maybe_nan_p (captures[0]) && !HONOR_SIGNED_ZEROS (type)
858 : )
859 : {
860 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail314;
861 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail314;
862 0 : {
863 0 : tree res_op0;
864 0 : res_op0 = captures[0];
865 0 : tree _r;
866 0 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
867 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 235, __FILE__, __LINE__, true);
868 0 : return _r;
869 : }
870 : next_after_fail314:;
871 : }
872 : return NULL_TREE;
873 : }
874 :
875 : tree
876 0 : generic_simplify_180 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
877 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
878 : const combined_fn ARG_UNUSED (COPYSIGN_ALL))
879 : {
880 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
881 0 : if (!tree_expr_maybe_nan_p (captures[0]) && !HONOR_SIGNED_ZEROS (type)
882 : )
883 : {
884 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail317;
885 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail317;
886 0 : {
887 0 : tree res_op0;
888 0 : {
889 0 : tree _o1[1], _r1;
890 0 : _o1[0] = captures[0];
891 0 : _r1 = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
892 0 : res_op0 = _r1;
893 : }
894 0 : tree _r;
895 0 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
896 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 236, __FILE__, __LINE__, true);
897 0 : return _r;
898 : }
899 : next_after_fail317:;
900 : }
901 : return NULL_TREE;
902 : }
903 :
904 : tree
905 6 : generic_simplify_186 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
906 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
907 : {
908 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
909 6 : if (INTEGRAL_TYPE_P (type)
910 6 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
911 12 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
912 : )
913 : {
914 6 : if (TYPE_UNSIGNED (type)
915 : )
916 : {
917 5 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail323;
918 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail323;
919 5 : {
920 5 : tree res_op0;
921 5 : res_op0 = captures[0];
922 5 : tree _r;
923 5 : _r = fold_build1_loc (loc, ABSU_EXPR, type, res_op0);
924 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 241, __FILE__, __LINE__, true);
925 5 : return _r;
926 : }
927 : next_after_fail323:;
928 : }
929 : else
930 : {
931 1 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail324;
932 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail324;
933 1 : {
934 1 : tree res_op0;
935 1 : res_op0 = captures[0];
936 1 : tree _r;
937 1 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
938 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 242, __FILE__, __LINE__, true);
939 1 : return _r;
940 : }
941 : next_after_fail324:;
942 : }
943 : }
944 : return NULL_TREE;
945 : }
946 :
947 : tree
948 40511 : generic_simplify_192 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
949 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
950 : {
951 40511 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
952 40511 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail331;
953 40511 : {
954 40511 : tree res_op0;
955 40511 : res_op0 = captures[0];
956 40511 : tree _r;
957 40511 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
958 40511 : if (TREE_SIDE_EFFECTS (captures[2]))
959 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
960 40511 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 246, __FILE__, __LINE__, true);
961 : return _r;
962 : }
963 0 : next_after_fail331:;
964 0 : return NULL_TREE;
965 : }
966 :
967 : tree
968 8 : generic_simplify_197 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
969 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
970 : const combined_fn ARG_UNUSED (POW))
971 : {
972 8 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
973 8 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
974 : )
975 : {
976 8 : if (!TREE_OVERFLOW (captures[2])
977 : )
978 : {
979 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail337;
980 8 : {
981 8 : tree res_op0;
982 8 : res_op0 = captures[0];
983 8 : tree res_op1;
984 8 : {
985 8 : tree _o1[2], _r1;
986 8 : _o1[0] = captures[2];
987 8 : _o1[1] = build_one_cst (type);
988 8 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
989 8 : res_op1 = _r1;
990 : }
991 8 : tree _r;
992 8 : _r = maybe_build_call_expr_loc (loc, POW, type, 2, res_op0, res_op1);
993 8 : if (!_r)
994 0 : goto next_after_fail337;
995 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 252, __FILE__, __LINE__, true);
996 8 : return _r;
997 : }
998 : next_after_fail337:;
999 : }
1000 : }
1001 : return NULL_TREE;
1002 : }
1003 :
1004 : tree
1005 20163 : generic_simplify_204 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1006 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1007 : const enum tree_code ARG_UNUSED (cmp),
1008 : const enum tree_code ARG_UNUSED (mod))
1009 : {
1010 20163 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1011 20163 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1012 : )
1013 : {
1014 20163 : {
1015 20163 : tree utype = unsigned_type_for (TREE_TYPE (captures[0]));
1016 20163 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail344;
1017 20163 : {
1018 20163 : tree res_op0;
1019 20163 : {
1020 20163 : tree _o1[2], _r1;
1021 20163 : {
1022 20163 : tree _o2[1], _r2;
1023 20163 : _o2[0] = captures[0];
1024 20163 : if (TREE_TYPE (_o2[0]) != utype)
1025 : {
1026 20163 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
1027 : }
1028 : else
1029 : _r2 = _o2[0];
1030 20163 : _o1[0] = _r2;
1031 : }
1032 20163 : {
1033 20163 : tree _o2[1], _r2;
1034 20163 : _o2[0] = captures[1];
1035 20163 : if (TREE_TYPE (_o2[0]) != utype)
1036 : {
1037 20163 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
1038 : }
1039 : else
1040 : _r2 = _o2[0];
1041 20163 : _o1[1] = _r2;
1042 : }
1043 20163 : _r1 = fold_build2_loc (loc, mod, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1044 20163 : res_op0 = _r1;
1045 : }
1046 20163 : tree res_op1;
1047 20163 : {
1048 20163 : tree _o1[1], _r1;
1049 20163 : _o1[0] = captures[2];
1050 20163 : if (TREE_TYPE (_o1[0]) != utype)
1051 : {
1052 20163 : _r1 = fold_build1_loc (loc, NOP_EXPR, utype, _o1[0]);
1053 : }
1054 : else
1055 : _r1 = _o1[0];
1056 20163 : res_op1 = _r1;
1057 : }
1058 20163 : tree _r;
1059 20163 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1060 20163 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 259, __FILE__, __LINE__, true);
1061 20163 : return _r;
1062 : }
1063 0 : next_after_fail344:;
1064 : }
1065 : }
1066 : return NULL_TREE;
1067 : }
1068 :
1069 : tree
1070 7411 : generic_simplify_217 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1071 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1072 : const enum tree_code ARG_UNUSED (op))
1073 : {
1074 7411 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1075 7411 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail373;
1076 7411 : {
1077 7411 : tree res_op0;
1078 7411 : res_op0 = captures[1];
1079 7411 : tree res_op1;
1080 7411 : res_op1 = captures[2];
1081 7411 : tree _r;
1082 7411 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1083 7411 : if (TREE_SIDE_EFFECTS (captures[0]))
1084 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1085 7411 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 287, __FILE__, __LINE__, true);
1086 : return _r;
1087 : }
1088 0 : next_after_fail373:;
1089 0 : return NULL_TREE;
1090 : }
1091 :
1092 : tree
1093 6 : generic_simplify_224 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1094 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1095 : const enum tree_code ARG_UNUSED (neeq))
1096 : {
1097 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1098 6 : {
1099 6 : poly_int64 diff; tree inner_type = TREE_TYPE (captures[1]);
1100 6 : if (ptr_difference_const (captures[0], captures[2], &diff)
1101 : )
1102 : {
1103 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail380;
1104 0 : {
1105 0 : tree res_op0;
1106 0 : {
1107 0 : tree _o1[2], _r1;
1108 0 : _o1[0] = build_int_cst_type (inner_type, diff);
1109 0 : _o1[1] = captures[1];
1110 0 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1111 0 : res_op0 = _r1;
1112 : }
1113 0 : tree res_op1;
1114 0 : res_op1 = captures[3];
1115 0 : tree _r;
1116 0 : _r = fold_build2_loc (loc, neeq, type, res_op0, res_op1);
1117 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1118 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1119 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1120 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1121 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 293, __FILE__, __LINE__, true);
1122 0 : return _r;
1123 : }
1124 0 : next_after_fail380:;
1125 : }
1126 : }
1127 6 : return NULL_TREE;
1128 : }
1129 :
1130 : tree
1131 13 : generic_simplify_234 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1132 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1133 : const enum tree_code ARG_UNUSED (cmp))
1134 : {
1135 13 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1136 13 : if (tree_fits_shwi_p (captures[3])
1137 13 : && tree_to_shwi (captures[3]) > 0
1138 26 : && tree_to_shwi (captures[3]) < TYPE_PRECISION (TREE_TYPE (captures[2]))
1139 : )
1140 : {
1141 13 : if (tree_to_shwi (captures[3]) > wi::ctz (wi::to_wide (captures[5]))
1142 : )
1143 : {
1144 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail393;
1145 0 : {
1146 0 : tree _r;
1147 0 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1148 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1149 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1150 0 : if (TREE_SIDE_EFFECTS (captures[3]))
1151 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
1152 0 : if (TREE_SIDE_EFFECTS (captures[4]))
1153 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
1154 0 : if (TREE_SIDE_EFFECTS (captures[5]))
1155 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
1156 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 306, __FILE__, __LINE__, true);
1157 0 : return _r;
1158 : }
1159 0 : next_after_fail393:;
1160 : }
1161 : else
1162 : {
1163 13 : {
1164 13 : wide_int c1 = wi::to_wide (captures[3]);
1165 13 : wide_int c2 = wi::lrshift (wi::to_wide (captures[4]), c1);
1166 13 : wide_int c3 = wi::lrshift (wi::to_wide (captures[5]), c1);
1167 13 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail394;
1168 13 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail394;
1169 13 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail394;
1170 13 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail394;
1171 13 : {
1172 13 : tree res_op0;
1173 13 : {
1174 13 : tree _o1[2], _r1;
1175 13 : _o1[0] = captures[2];
1176 13 : _o1[1] = wide_int_to_tree (TREE_TYPE (captures[2]), c2);
1177 13 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1178 13 : res_op0 = _r1;
1179 : }
1180 13 : tree res_op1;
1181 13 : res_op1 = wide_int_to_tree (TREE_TYPE (captures[2]), c3);
1182 13 : tree _r;
1183 13 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1184 13 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 307, __FILE__, __LINE__, true);
1185 13 : return _r;
1186 : }
1187 0 : next_after_fail394:;
1188 13 : }
1189 : }
1190 : }
1191 : return NULL_TREE;
1192 : }
1193 :
1194 : tree
1195 92774 : generic_simplify_247 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1196 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1197 : const enum tree_code ARG_UNUSED (cmp))
1198 : {
1199 92774 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1200 92774 : if (single_use (captures[0])
1201 : )
1202 : {
1203 92774 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail416;
1204 92774 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail416;
1205 92774 : {
1206 92774 : tree res_op0;
1207 92774 : res_op0 = captures[1];
1208 92774 : tree res_op1;
1209 92774 : res_op1 = captures[2];
1210 92774 : tree _r;
1211 92774 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1212 92774 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 329, __FILE__, __LINE__, true);
1213 92774 : return _r;
1214 : }
1215 : next_after_fail416:;
1216 : }
1217 : return NULL_TREE;
1218 : }
1219 :
1220 : tree
1221 926187 : generic_simplify_254 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1222 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1223 : const enum tree_code ARG_UNUSED (cmp),
1224 : const enum tree_code ARG_UNUSED (scmp))
1225 : {
1226 926187 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1227 926187 : if (single_use (captures[0])
1228 926187 : && (TREE_CODE (captures[2]) == INTEGER_CST || TREE_CODE (captures[2]) == VECTOR_CST)
1229 : )
1230 : {
1231 926187 : {
1232 926187 : tree otype = TREE_TYPE (captures[2]);
1233 926187 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail428;
1234 926187 : {
1235 926187 : tree res_op0;
1236 926187 : {
1237 926187 : tree _o1[1], _r1;
1238 926187 : _o1[0] = captures[1];
1239 926187 : if (TREE_TYPE (_o1[0]) != otype)
1240 : {
1241 195 : _r1 = fold_build1_loc (loc, NOP_EXPR, otype, _o1[0]);
1242 : }
1243 : else
1244 : _r1 = _o1[0];
1245 926187 : res_op0 = _r1;
1246 : }
1247 926187 : tree res_op1;
1248 926187 : {
1249 926187 : tree _o1[1], _r1;
1250 926187 : _o1[0] = captures[2];
1251 926187 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
1252 926187 : res_op1 = _r1;
1253 : }
1254 926187 : tree _r;
1255 926187 : _r = fold_build2_loc (loc, scmp, type, res_op0, res_op1);
1256 926187 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 340, __FILE__, __LINE__, true);
1257 926187 : return _r;
1258 : }
1259 0 : next_after_fail428:;
1260 : }
1261 : }
1262 : return NULL_TREE;
1263 : }
1264 :
1265 : tree
1266 1255 : generic_simplify_261 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1267 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1268 : const enum tree_code ARG_UNUSED (cmp),
1269 : const enum tree_code ARG_UNUSED (icmp))
1270 : {
1271 1255 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1272 1255 : if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1273 1255 : && ! DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1274 : )
1275 : {
1276 1255 : {
1277 1255 : format_helper fmt (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (captures[0]))));
1278 1255 : tree type1 = TREE_TYPE (captures[1]);
1279 1255 : bool type1_signed_p = TYPE_SIGN (type1) == SIGNED;
1280 1255 : tree type2 = TREE_TYPE (captures[2]);
1281 1255 : bool type2_signed_p = TYPE_SIGN (type2) == SIGNED;
1282 1255 : if (fmt.can_represent_integral_type_p (type1)
1283 1255 : && fmt.can_represent_integral_type_p (type2)
1284 : )
1285 : {
1286 229 : if (cmp == ORDERED_EXPR || cmp == UNORDERED_EXPR
1287 : )
1288 : {
1289 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail467;
1290 0 : {
1291 0 : tree _r;
1292 0 : _r = constant_boolean_node (cmp == ORDERED_EXPR, type);
1293 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1294 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1295 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1296 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1297 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 378, __FILE__, __LINE__, true);
1298 183 : return _r;
1299 : }
1300 0 : next_after_fail467:;
1301 : }
1302 : else
1303 : {
1304 229 : if (TYPE_PRECISION (type1) > TYPE_PRECISION (type2)
1305 229 : && type1_signed_p >= type2_signed_p
1306 : )
1307 : {
1308 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail468;
1309 0 : {
1310 0 : tree res_op0;
1311 0 : res_op0 = captures[1];
1312 0 : tree res_op1;
1313 0 : {
1314 0 : tree _o1[1], _r1;
1315 0 : _o1[0] = captures[2];
1316 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
1317 : {
1318 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
1319 : }
1320 : else
1321 : _r1 = _o1[0];
1322 0 : res_op1 = _r1;
1323 : }
1324 0 : tree _r;
1325 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
1326 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 379, __FILE__, __LINE__, true);
1327 0 : return _r;
1328 : }
1329 0 : next_after_fail468:;
1330 : }
1331 : else
1332 : {
1333 229 : if (TYPE_PRECISION (type1) < TYPE_PRECISION (type2)
1334 229 : && type1_signed_p <= type2_signed_p
1335 : )
1336 : {
1337 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail469;
1338 7 : {
1339 7 : tree res_op0;
1340 7 : {
1341 7 : tree _o1[1], _r1;
1342 7 : _o1[0] = captures[1];
1343 7 : if (TREE_TYPE (_o1[0]) != type2)
1344 : {
1345 7 : _r1 = fold_build1_loc (loc, NOP_EXPR, type2, _o1[0]);
1346 : }
1347 : else
1348 : _r1 = _o1[0];
1349 7 : res_op0 = _r1;
1350 : }
1351 7 : tree res_op1;
1352 7 : res_op1 = captures[2];
1353 7 : tree _r;
1354 7 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
1355 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 380, __FILE__, __LINE__, true);
1356 7 : return _r;
1357 : }
1358 0 : next_after_fail469:;
1359 : }
1360 : else
1361 : {
1362 222 : if (TYPE_PRECISION (type1) == TYPE_PRECISION (type2)
1363 222 : && type1_signed_p == type2_signed_p
1364 : )
1365 : {
1366 176 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail470;
1367 176 : {
1368 176 : tree res_op0;
1369 176 : res_op0 = captures[1];
1370 176 : tree res_op1;
1371 176 : {
1372 176 : tree _o1[1], _r1;
1373 176 : _o1[0] = captures[2];
1374 176 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
1375 : {
1376 1 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
1377 : }
1378 : else
1379 : _r1 = _o1[0];
1380 176 : res_op1 = _r1;
1381 : }
1382 176 : tree _r;
1383 176 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
1384 176 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 381, __FILE__, __LINE__, true);
1385 176 : return _r;
1386 : }
1387 0 : next_after_fail470:;
1388 : }
1389 : }
1390 : }
1391 : }
1392 : }
1393 : }
1394 : }
1395 : return NULL_TREE;
1396 : }
1397 :
1398 : tree
1399 0 : generic_simplify_273 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1400 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1401 : const enum tree_code ARG_UNUSED (cmp))
1402 : {
1403 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1404 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
1405 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1406 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1407 0 : && TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (TREE_TYPE (captures[2]))
1408 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (TREE_TYPE (captures[1]))
1409 0 : && !wi::neg_p (wi::to_wide (captures[3]))
1410 : )
1411 : {
1412 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail505;
1413 0 : {
1414 0 : tree res_op0;
1415 0 : {
1416 0 : tree _o1[2], _r1;
1417 0 : _o1[0] = captures[2];
1418 0 : {
1419 0 : tree _o2[1], _r2;
1420 0 : {
1421 0 : tree _o3[1], _r3;
1422 0 : _o3[0] = captures[3];
1423 0 : _r3 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o3[0]), _o3[0]);
1424 0 : _o2[0] = _r3;
1425 : }
1426 0 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
1427 : {
1428 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
1429 : }
1430 : else
1431 : _r2 = _o2[0];
1432 0 : _o1[1] = _r2;
1433 : }
1434 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1435 0 : res_op0 = _r1;
1436 : }
1437 0 : tree res_op1;
1438 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[2]));
1439 0 : tree _r;
1440 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1441 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 408, __FILE__, __LINE__, true);
1442 0 : return _r;
1443 : }
1444 0 : next_after_fail505:;
1445 : }
1446 : return NULL_TREE;
1447 : }
1448 :
1449 : tree
1450 806996 : generic_simplify_280 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1451 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1452 : const enum tree_code ARG_UNUSED (cmp),
1453 : const enum tree_code ARG_UNUSED (ncmp))
1454 : {
1455 806996 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1456 1550638 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1457 806996 : && type_has_mode_precision_p (TREE_TYPE (captures[1]))
1458 805700 : && element_precision (captures[0]) >= element_precision (captures[1])
1459 1613992 : && wi::only_sign_bit_p (wi::to_wide (captures[2]), element_precision (captures[1]))
1460 : )
1461 : {
1462 12969 : {
1463 12969 : tree stype = signed_type_for (TREE_TYPE (captures[1]));
1464 12969 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail512;
1465 12969 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail512;
1466 12969 : {
1467 12969 : tree res_op0;
1468 12969 : {
1469 12969 : tree _o1[1], _r1;
1470 12969 : _o1[0] = captures[1];
1471 12969 : if (TREE_TYPE (_o1[0]) != stype)
1472 : {
1473 12756 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
1474 : }
1475 : else
1476 : _r1 = _o1[0];
1477 12969 : res_op0 = _r1;
1478 : }
1479 12969 : tree res_op1;
1480 12969 : res_op1 = build_zero_cst (stype);
1481 12969 : tree _r;
1482 12969 : _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
1483 12969 : if (TREE_SIDE_EFFECTS (captures[2]))
1484 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1485 12969 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 414, __FILE__, __LINE__, true);
1486 12969 : return _r;
1487 : }
1488 : next_after_fail512:;
1489 : }
1490 : }
1491 : return NULL_TREE;
1492 : }
1493 :
1494 : tree
1495 2 : generic_simplify_290 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1496 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1497 : const enum tree_code ARG_UNUSED (cmp))
1498 : {
1499 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1500 4 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
1501 2 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1502 2 : && TYPE_UNSIGNED (TREE_TYPE (captures[2]))
1503 2 : && (TYPE_PRECISION (TREE_TYPE (captures[1]))
1504 2 : >= 2 * TYPE_PRECISION (TREE_TYPE (captures[2])))
1505 2 : && tree_fits_uhwi_p (captures[4])
1506 2 : && tree_to_uhwi (captures[4]) == TYPE_PRECISION (TREE_TYPE (captures[2]))
1507 2 : && types_match (captures[2], captures[3])
1508 2 : && type_has_mode_precision_p (TREE_TYPE (captures[2]))
1509 6 : && (optab_handler (umulv4_optab, TYPE_MODE (TREE_TYPE (captures[2])))
1510 : != CODE_FOR_nothing)
1511 : )
1512 : {
1513 2 : {
1514 2 : tree t = TREE_TYPE (captures[2]), cpx = build_complex_type (t);
1515 2 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail540;
1516 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail540;
1517 2 : {
1518 2 : tree res_op0;
1519 2 : {
1520 2 : tree _o1[1], _r1;
1521 2 : {
1522 2 : tree _o2[2], _r2;
1523 2 : _o2[0] = captures[2];
1524 2 : _o2[1] = captures[3];
1525 2 : _r2 = maybe_build_call_expr_loc (loc, CFN_MUL_OVERFLOW, cpx, 2, _o2[0], _o2[1]);
1526 2 : if (!_r2)
1527 0 : goto next_after_fail540;
1528 2 : _o1[0] = _r2;
1529 : }
1530 2 : _r1 = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
1531 2 : res_op0 = _r1;
1532 : }
1533 2 : tree res_op1;
1534 2 : res_op1 = build_zero_cst (t);
1535 2 : tree _r;
1536 2 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1537 2 : if (TREE_SIDE_EFFECTS (captures[4]))
1538 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
1539 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 433, __FILE__, __LINE__, true);
1540 2 : return _r;
1541 : }
1542 : next_after_fail540:;
1543 : }
1544 : }
1545 : return NULL_TREE;
1546 : }
1547 :
1548 : tree
1549 366 : generic_simplify_293 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1550 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1551 : const enum tree_code ARG_UNUSED (op),
1552 : const enum tree_code ARG_UNUSED (cmp),
1553 : const combined_fn ARG_UNUSED (clz))
1554 : {
1555 366 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1556 366 : if (!sanitize_flags_p (SANITIZE_BUILTIN)
1557 366 : || (cfun && (cfun->curr_properties & PROP_ssa) != 0)
1558 : )
1559 : {
1560 302 : if (integer_zerop (captures[2]) && single_use (captures[0])
1561 : )
1562 : {
1563 59 : {
1564 59 : tree stype = signed_type_for (TREE_TYPE (captures[1]));
1565 59 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail552;
1566 59 : {
1567 59 : tree res_op0;
1568 59 : {
1569 59 : tree _o1[1], _r1;
1570 59 : _o1[0] = captures[1];
1571 59 : if (TREE_TYPE (_o1[0]) != stype)
1572 : {
1573 59 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
1574 : }
1575 : else
1576 : _r1 = _o1[0];
1577 59 : res_op0 = _r1;
1578 : }
1579 59 : tree res_op1;
1580 59 : res_op1 = build_zero_cst (stype);
1581 59 : tree _r;
1582 59 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1583 59 : if (TREE_SIDE_EFFECTS (captures[2]))
1584 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1585 59 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 445, __FILE__, __LINE__, true);
1586 59 : return _r;
1587 : }
1588 0 : next_after_fail552:;
1589 : }
1590 : }
1591 : else
1592 : {
1593 243 : if (wi::to_wide (captures[2]) == TYPE_PRECISION (TREE_TYPE (captures[1])) - 1
1594 : )
1595 : {
1596 79 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail553;
1597 79 : {
1598 79 : tree res_op0;
1599 79 : res_op0 = captures[1];
1600 79 : tree res_op1;
1601 79 : res_op1 = build_one_cst (TREE_TYPE (captures[1]));
1602 79 : tree _r;
1603 79 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1604 79 : if (TREE_SIDE_EFFECTS (captures[2]))
1605 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1606 79 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 446, __FILE__, __LINE__, true);
1607 79 : return _r;
1608 : }
1609 0 : next_after_fail553:;
1610 : }
1611 : }
1612 : }
1613 : return NULL_TREE;
1614 : }
1615 :
1616 : tree
1617 0 : generic_simplify_296 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1618 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1619 : const enum tree_code ARG_UNUSED (op))
1620 : {
1621 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1622 0 : {
1623 0 : HOST_WIDE_INT zero_val = tree_to_shwi (captures[2]);
1624 0 : tree type0 = TREE_TYPE (captures[1]);
1625 0 : int prec = TYPE_PRECISION (type0);
1626 0 : if (prec <= MAX_FIXED_MODE_SIZE
1627 : )
1628 : {
1629 0 : if (tree_int_cst_sgn (captures[3]) < 0 || wi::to_widest (captures[3]) >= prec
1630 : )
1631 : {
1632 0 : if (zero_val != wi::to_widest (captures[3])
1633 : )
1634 : {
1635 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail558;
1636 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail558;
1637 0 : {
1638 0 : tree _r;
1639 0 : _r = constant_boolean_node (op == EQ_EXPR ? false : true, type);
1640 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1641 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1642 0 : if (TREE_SIDE_EFFECTS (captures[3]))
1643 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
1644 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 451, __FILE__, __LINE__, true);
1645 0 : return _r;
1646 : }
1647 0 : next_after_fail558:;
1648 : }
1649 : }
1650 : else
1651 : {
1652 0 : if (zero_val < 0 || zero_val >= prec
1653 : )
1654 : {
1655 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail559;
1656 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail559;
1657 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail559;
1658 0 : {
1659 0 : tree res_op0;
1660 0 : {
1661 0 : tree _o1[2], _r1;
1662 0 : _o1[0] = captures[1];
1663 0 : _o1[1] = wide_int_to_tree (type0,
1664 0 : wi::mask (tree_to_uhwi (captures[3]) + 1,
1665 : false, prec));
1666 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1667 0 : res_op0 = _r1;
1668 : }
1669 0 : tree res_op1;
1670 0 : res_op1 = wide_int_to_tree (type0,
1671 0 : wi::shifted_mask (tree_to_uhwi (captures[3]), 1,
1672 : false, prec));
1673 0 : tree _r;
1674 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1675 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 452, __FILE__, __LINE__, true);
1676 0 : return _r;
1677 : }
1678 0 : next_after_fail559:;
1679 : }
1680 : }
1681 : }
1682 : }
1683 0 : return NULL_TREE;
1684 : }
1685 :
1686 : tree
1687 2362 : generic_simplify_311 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1688 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1689 : const enum tree_code ARG_UNUSED (div))
1690 : {
1691 2362 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1692 2362 : if (!integer_zerop (captures[1])
1693 : )
1694 : {
1695 1737 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail579;
1696 1737 : {
1697 1737 : tree _r;
1698 1737 : _r = captures[0];
1699 1737 : if (TREE_SIDE_EFFECTS (captures[1]))
1700 59 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1701 1737 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 470, __FILE__, __LINE__, true);
1702 1737 : return _r;
1703 : }
1704 0 : next_after_fail579:;
1705 : }
1706 : return NULL_TREE;
1707 : }
1708 :
1709 : tree
1710 9113 : generic_simplify_317 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1711 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1712 : const enum tree_code ARG_UNUSED (div))
1713 : {
1714 9113 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1715 9113 : {
1716 9113 : wi::overflow_type overflow;
1717 9113 : wide_int mul = wi::mul (wi::to_wide (captures[2]), wi::to_wide (captures[3]),
1718 18226 : TYPE_SIGN (type), &overflow);
1719 9113 : if (div == EXACT_DIV_EXPR
1720 9113 : || optimize_successive_divisions_p (captures[3], captures[0])
1721 : )
1722 : {
1723 0 : if (!overflow
1724 : )
1725 : {
1726 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail585;
1727 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail585;
1728 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail585;
1729 0 : {
1730 0 : tree res_op0;
1731 0 : res_op0 = captures[1];
1732 0 : tree res_op1;
1733 0 : res_op1 = wide_int_to_tree (type, mul);
1734 0 : tree _r;
1735 0 : _r = fold_build2_loc (loc, div, type, res_op0, res_op1);
1736 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 476, __FILE__, __LINE__, true);
1737 0 : return _r;
1738 : }
1739 9113 : next_after_fail585:;
1740 : }
1741 : else
1742 : {
1743 0 : if (TYPE_UNSIGNED (type)
1744 0 : || mul != wi::min_value (TYPE_PRECISION (type), SIGNED)
1745 : )
1746 : {
1747 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail586;
1748 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail586;
1749 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail586;
1750 0 : {
1751 0 : tree _r;
1752 0 : _r = build_zero_cst (type);
1753 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1754 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1755 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 477, __FILE__, __LINE__, true);
1756 0 : return _r;
1757 : }
1758 9113 : next_after_fail586:;
1759 : }
1760 : }
1761 : }
1762 0 : }
1763 9113 : return NULL_TREE;
1764 : }
1765 :
1766 : tree
1767 1575935 : generic_simplify_329 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1768 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1769 : const enum tree_code ARG_UNUSED (mod))
1770 : {
1771 1575935 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1772 1856787 : if ((TYPE_UNSIGNED (type) || tree_expr_nonnegative_p (captures[0]))
1773 1297547 : && INTEGRAL_TYPE_P (type)
1774 1297547 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1775 1297547 : && (TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (captures[1]))
1776 3 : || TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1777 1 : || !TYPE_UNSIGNED (type))
1778 2873482 : && integer_pow2p (captures[2]) && tree_int_cst_sgn (captures[2]) > 0
1779 : )
1780 : {
1781 953481 : {
1782 953481 : tree utype = TREE_TYPE (captures[1]);
1783 953481 : if (!TYPE_OVERFLOW_WRAPS (utype))
1784 303 : utype = unsigned_type_for (utype);
1785 953481 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail598;
1786 953481 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail598;
1787 953481 : {
1788 953481 : tree res_op0;
1789 953481 : res_op0 = captures[0];
1790 953481 : tree res_op1;
1791 953481 : {
1792 953481 : tree _o1[1], _r1;
1793 953481 : {
1794 953481 : tree _o2[2], _r2;
1795 953481 : {
1796 953481 : tree _o3[1], _r3;
1797 953481 : _o3[0] = captures[1];
1798 953481 : if (TREE_TYPE (_o3[0]) != utype)
1799 : {
1800 303 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
1801 : }
1802 : else
1803 : _r3 = _o3[0];
1804 953481 : _o2[0] = _r3;
1805 : }
1806 953481 : _o2[1] = build_one_cst (utype);
1807 953481 : _r2 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
1808 953481 : _o1[0] = _r2;
1809 : }
1810 953481 : if (TREE_TYPE (_o1[0]) != type)
1811 : {
1812 19333 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
1813 : }
1814 : else
1815 : _r1 = _o1[0];
1816 953481 : res_op1 = _r1;
1817 : }
1818 953481 : tree _r;
1819 953481 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
1820 953481 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 489, __FILE__, __LINE__, true);
1821 953481 : return _r;
1822 : }
1823 : next_after_fail598:;
1824 : }
1825 : }
1826 : return NULL_TREE;
1827 : }
1828 :
1829 : tree
1830 39 : generic_simplify_346 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1831 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1832 : const enum tree_code ARG_UNUSED (cmp),
1833 : const enum tree_code ARG_UNUSED (minmax))
1834 : {
1835 39 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1836 39 : {
1837 39 : tree_code code = minmax_from_comparison (cmp, captures[0], captures[1], captures[0], captures[4]);
1838 39 : if ((cmp == LT_EXPR || cmp == LE_EXPR)
1839 15 : && code == MIN_EXPR
1840 43 : && integer_nonzerop (fold_build2 (LE_EXPR, boolean_type_node, captures[3], captures[4]))
1841 : )
1842 : {
1843 4 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail621;
1844 4 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail621;
1845 4 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail621;
1846 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail621;
1847 4 : {
1848 4 : tree res_op0;
1849 4 : res_op0 = captures[2];
1850 4 : tree res_op1;
1851 4 : res_op1 = captures[4];
1852 4 : tree _r;
1853 4 : _r = fold_build2_loc (loc, MIN_EXPR, type, res_op0, res_op1);
1854 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 512, __FILE__, __LINE__, true);
1855 4 : return _r;
1856 : }
1857 : next_after_fail621:;
1858 : }
1859 : else
1860 : {
1861 35 : if ((cmp == GT_EXPR || cmp == GE_EXPR)
1862 24 : && code == MAX_EXPR
1863 59 : && integer_nonzerop (fold_build2 (GE_EXPR, boolean_type_node, captures[3], captures[4]))
1864 : )
1865 : {
1866 10 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail622;
1867 10 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail622;
1868 10 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail622;
1869 10 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail622;
1870 10 : {
1871 10 : tree res_op0;
1872 10 : res_op0 = captures[2];
1873 10 : tree res_op1;
1874 10 : res_op1 = captures[4];
1875 10 : tree _r;
1876 10 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
1877 10 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 513, __FILE__, __LINE__, true);
1878 10 : return _r;
1879 : }
1880 : next_after_fail622:;
1881 : }
1882 : }
1883 : }
1884 : return NULL_TREE;
1885 : }
1886 :
1887 : tree
1888 51 : generic_simplify_359 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1889 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1890 : const enum tree_code ARG_UNUSED (op))
1891 : {
1892 51 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1893 51 : if (bitwise_equal_p (captures[0], captures[2])
1894 1 : && tree_expr_nonzero_p (captures[3])
1895 52 : && expr_no_side_effects_p (captures[2])
1896 : )
1897 : {
1898 1 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail636;
1899 1 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail636;
1900 1 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail636;
1901 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail636;
1902 1 : {
1903 1 : tree _r;
1904 1 : _r = captures[1];
1905 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 527, __FILE__, __LINE__, true);
1906 1 : return _r;
1907 : }
1908 : next_after_fail636:;
1909 : }
1910 : return NULL_TREE;
1911 : }
1912 :
1913 : tree
1914 9 : generic_simplify_368 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1915 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1916 : const combined_fn ARG_UNUSED (func))
1917 : {
1918 9 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1919 9 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail646;
1920 9 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail646;
1921 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail646;
1922 9 : {
1923 9 : tree _r;
1924 9 : _r = captures[2];
1925 9 : if (TREE_SIDE_EFFECTS (captures[1]))
1926 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1927 9 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 537, __FILE__, __LINE__, true);
1928 : return _r;
1929 : }
1930 : next_after_fail646:;
1931 : return NULL_TREE;
1932 : }
1933 :
1934 : tree
1935 100 : generic_simplify_376 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1936 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1937 : const enum tree_code ARG_UNUSED (cmp))
1938 : {
1939 100 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1940 100 : if (TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1941 : )
1942 : {
1943 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail657;
1944 0 : {
1945 0 : tree _r;
1946 0 : _r = constant_boolean_node (cmp == LT_EXPR, type);
1947 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1948 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1949 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1950 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1951 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 546, __FILE__, __LINE__, true);
1952 0 : return _r;
1953 : }
1954 0 : next_after_fail657:;
1955 : }
1956 : return NULL_TREE;
1957 : }
1958 :
1959 : tree
1960 433 : generic_simplify_382 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1961 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1962 : const enum tree_code ARG_UNUSED (op))
1963 : {
1964 433 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1965 866 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1966 866 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
1967 : )
1968 : {
1969 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail664;
1970 0 : {
1971 0 : tree res_op0;
1972 0 : res_op0 = captures[2];
1973 0 : tree res_op1;
1974 0 : res_op1 = captures[1];
1975 0 : tree _r;
1976 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1977 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1978 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1979 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 553, __FILE__, __LINE__, true);
1980 0 : return _r;
1981 : }
1982 0 : next_after_fail664:;
1983 : }
1984 : return NULL_TREE;
1985 : }
1986 :
1987 : tree
1988 6 : generic_simplify_388 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1989 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1990 : const enum tree_code ARG_UNUSED (cmp))
1991 : {
1992 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1993 12 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1994 12 : && TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1995 : )
1996 : {
1997 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail671;
1998 6 : {
1999 6 : tree res_op0;
2000 6 : res_op0 = captures[0];
2001 6 : tree res_op1;
2002 6 : res_op1 = captures[1];
2003 6 : tree _r;
2004 6 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2005 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 560, __FILE__, __LINE__, true);
2006 6 : return _r;
2007 : }
2008 0 : next_after_fail671:;
2009 : }
2010 : return NULL_TREE;
2011 : }
2012 :
2013 : tree
2014 165 : generic_simplify_395 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2015 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2016 : const enum tree_code ARG_UNUSED (cmp),
2017 : const enum tree_code ARG_UNUSED (out))
2018 : {
2019 165 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2020 165 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))
2021 165 : && types_match (TREE_TYPE (captures[3]), TREE_TYPE (captures[0]))
2022 93 : && tree_nop_conversion_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[3]))
2023 165 : && wi::to_wide (captures[4]) != 0
2024 0 : && single_use (captures[1])
2025 : )
2026 : {
2027 93 : {
2028 93 : unsigned int prec = TYPE_PRECISION (TREE_TYPE (captures[3]));
2029 93 : signop sign = TYPE_SIGN (TREE_TYPE (captures[3]));
2030 93 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail710;
2031 93 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail710;
2032 93 : {
2033 93 : tree res_op0;
2034 93 : res_op0 = captures[3];
2035 93 : tree res_op1;
2036 93 : res_op1 = wide_int_to_tree (TREE_TYPE (captures[3]),
2037 93 : wi::max_value (prec, sign)
2038 279 : - wi::to_wide (captures[4]));
2039 93 : tree _r;
2040 93 : _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
2041 93 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 562, __FILE__, __LINE__, true);
2042 93 : return _r;
2043 : }
2044 : next_after_fail710:;
2045 : }
2046 : }
2047 : return NULL_TREE;
2048 : }
2049 :
2050 : tree
2051 50 : generic_simplify_403 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2052 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2053 : const enum tree_code ARG_UNUSED (op),
2054 : const enum tree_code ARG_UNUSED (cmp),
2055 : const combined_fn ARG_UNUSED (ctz))
2056 : {
2057 50 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2058 50 : {
2059 50 : bool ok = true;
2060 50 : HOST_WIDE_INT val = 0;
2061 50 : if (sanitize_flags_p (SANITIZE_BUILTIN)
2062 50 : && (!cfun
2063 32 : || (cfun->curr_properties & PROP_ssa) == 0))
2064 : ok = false;
2065 18 : else if (!tree_fits_shwi_p (captures[2]))
2066 : ok = false;
2067 : else
2068 : {
2069 18 : val = tree_to_shwi (captures[2]);
2070 18 : if (op == GT_EXPR || op == LE_EXPR)
2071 : {
2072 10 : if (val == HOST_WIDE_INT_MAX)
2073 : ok = false;
2074 : else
2075 10 : val++;
2076 : }
2077 : }
2078 50 : tree type0 = TREE_TYPE (captures[1]);
2079 50 : int prec = TYPE_PRECISION (type0);
2080 68 : if (ok && prec <= MAX_FIXED_MODE_SIZE
2081 : )
2082 : {
2083 18 : if (val <= 0
2084 : )
2085 : {
2086 8 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail721;
2087 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail721;
2088 8 : {
2089 8 : tree _r;
2090 8 : _r = constant_boolean_node (cmp == EQ_EXPR ? true : false, type);
2091 8 : if (TREE_SIDE_EFFECTS (captures[1]))
2092 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2093 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 593, __FILE__, __LINE__, true);
2094 8 : return _r;
2095 : }
2096 : next_after_fail721:;
2097 : }
2098 : else
2099 : {
2100 10 : if (val >= prec
2101 : )
2102 : {
2103 5 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail722;
2104 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail722;
2105 5 : {
2106 5 : tree _r;
2107 5 : _r = constant_boolean_node (cmp == EQ_EXPR ? false : true, type);
2108 5 : if (TREE_SIDE_EFFECTS (captures[1]))
2109 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2110 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 594, __FILE__, __LINE__, true);
2111 5 : return _r;
2112 : }
2113 : next_after_fail722:;
2114 : }
2115 : else
2116 : {
2117 5 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail723;
2118 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail723;
2119 5 : {
2120 5 : tree res_op0;
2121 5 : {
2122 5 : tree _o1[2], _r1;
2123 5 : _o1[0] = captures[1];
2124 5 : _o1[1] = wide_int_to_tree (type0,
2125 5 : wi::mask (val, false, prec));
2126 5 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2127 5 : res_op0 = _r1;
2128 : }
2129 5 : tree res_op1;
2130 5 : res_op1 = build_zero_cst (type0);
2131 5 : tree _r;
2132 5 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2133 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 595, __FILE__, __LINE__, true);
2134 5 : return _r;
2135 : }
2136 : next_after_fail723:;
2137 : }
2138 : }
2139 : }
2140 : }
2141 : return NULL_TREE;
2142 : }
2143 :
2144 : tree
2145 355 : generic_simplify_416 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2146 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2147 : const enum tree_code ARG_UNUSED (shift),
2148 : const enum tree_code ARG_UNUSED (mod))
2149 : {
2150 355 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2151 355 : if (integer_pow2p (captures[3]) && tree_int_cst_sgn (captures[3]) > 0
2152 : )
2153 : {
2154 280 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail742;
2155 280 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail742;
2156 280 : {
2157 280 : tree res_op0;
2158 280 : res_op0 = captures[0];
2159 280 : tree res_op1;
2160 280 : {
2161 280 : tree _o1[2], _r1;
2162 280 : _o1[0] = captures[1];
2163 280 : {
2164 280 : tree _o2[2], _r2;
2165 280 : _o2[0] = captures[2];
2166 280 : _o2[1] = build_int_cst (TREE_TYPE (captures[2]),
2167 : 1);
2168 280 : _r2 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
2169 280 : _o1[1] = _r2;
2170 : }
2171 280 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2172 280 : res_op1 = _r1;
2173 : }
2174 280 : tree _r;
2175 280 : _r = fold_build2_loc (loc, shift, type, res_op0, res_op1);
2176 280 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 610, __FILE__, __LINE__, true);
2177 280 : return _r;
2178 : }
2179 : next_after_fail742:;
2180 : }
2181 : return NULL_TREE;
2182 : }
2183 :
2184 : tree
2185 27461 : generic_simplify_425 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2186 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2187 : const enum tree_code ARG_UNUSED (bit_op),
2188 : const enum tree_code ARG_UNUSED (shift))
2189 : {
2190 27461 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2191 27461 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[2]))
2192 : )
2193 : {
2194 27461 : {
2195 27461 : tree mask = int_const_binop (shift, fold_convert (type, captures[3]), captures[4]);
2196 27461 : if (mask
2197 : )
2198 : {
2199 27454 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail754;
2200 27454 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail754;
2201 27454 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail754;
2202 27454 : {
2203 27454 : tree res_op0;
2204 27454 : {
2205 27454 : tree _o1[2], _r1;
2206 27454 : {
2207 27454 : tree _o2[1], _r2;
2208 27454 : _o2[0] = captures[2];
2209 27454 : if (TREE_TYPE (_o2[0]) != type)
2210 : {
2211 70 : _r2 = fold_build1_loc (loc, NOP_EXPR, type, _o2[0]);
2212 : }
2213 : else
2214 : _r2 = _o2[0];
2215 27454 : _o1[0] = _r2;
2216 : }
2217 27454 : _o1[1] = captures[4];
2218 27454 : _r1 = fold_build2_loc (loc, shift, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2219 27454 : res_op0 = _r1;
2220 : }
2221 27454 : tree res_op1;
2222 27454 : res_op1 = mask;
2223 27454 : tree _r;
2224 27454 : _r = fold_build2_loc (loc, bit_op, type, res_op0, res_op1);
2225 27454 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 620, __FILE__, __LINE__, true);
2226 27454 : return _r;
2227 : }
2228 : next_after_fail754:;
2229 : }
2230 : }
2231 : }
2232 : return NULL_TREE;
2233 : }
2234 :
2235 : tree
2236 7275 : generic_simplify_431 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2237 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2238 : const enum tree_code ARG_UNUSED (minmax))
2239 : {
2240 7275 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2241 7275 : if (INTEGRAL_TYPE_P (type)
2242 7275 : && types_match (captures[1], type) && int_fits_type_p (captures[2], type)
2243 633 : && TYPE_SIGN (TREE_TYPE (captures[0])) == TYPE_SIGN (type)
2244 7275 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (type)
2245 : )
2246 : {
2247 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail766;
2248 0 : {
2249 0 : tree res_op0;
2250 0 : res_op0 = captures[1];
2251 0 : tree res_op1;
2252 0 : {
2253 0 : tree _o1[1], _r1;
2254 0 : _o1[0] = captures[2];
2255 0 : if (TREE_TYPE (_o1[0]) != type)
2256 : {
2257 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2258 : }
2259 : else
2260 : _r1 = _o1[0];
2261 0 : res_op1 = _r1;
2262 : }
2263 0 : tree _r;
2264 0 : _r = fold_build2_loc (loc, minmax, type, res_op0, res_op1);
2265 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 632, __FILE__, __LINE__, true);
2266 0 : return _r;
2267 : }
2268 0 : next_after_fail766:;
2269 : }
2270 : return NULL_TREE;
2271 : }
2272 :
2273 : tree
2274 2439866 : generic_simplify_434 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2275 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2276 : const enum tree_code ARG_UNUSED (op))
2277 : {
2278 2439866 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2279 2439866 : if (INTEGRAL_TYPE_P (type)
2280 1989156 : && op != MULT_EXPR
2281 1989156 : && op != RDIV_EXPR
2282 1309090 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2283 1309090 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2284 1309090 : && type_has_mode_precision_p (TREE_TYPE (captures[2]))
2285 1308711 : && type_has_mode_precision_p (TREE_TYPE (captures[4]))
2286 1307941 : && type_has_mode_precision_p (type)
2287 1304088 : && TYPE_PRECISION (TREE_TYPE (captures[1])) > TYPE_PRECISION (TREE_TYPE (captures[2]))
2288 0 : && types_match (captures[2], type)
2289 2439866 : && (types_match (captures[2], captures[4])
2290 0 : || poly_int_tree_p (captures[3]))
2291 : )
2292 : {
2293 0 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))
2294 : )
2295 : {
2296 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail775;
2297 0 : {
2298 0 : tree res_op0;
2299 0 : res_op0 = captures[2];
2300 0 : tree res_op1;
2301 0 : {
2302 0 : tree _o1[1], _r1;
2303 0 : _o1[0] = captures[4];
2304 0 : if (TREE_TYPE (_o1[0]) != type)
2305 : {
2306 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2307 : }
2308 : else
2309 : _r1 = _o1[0];
2310 0 : res_op1 = _r1;
2311 : }
2312 0 : tree _r;
2313 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2314 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 633, __FILE__, __LINE__, true);
2315 0 : return _r;
2316 : }
2317 0 : next_after_fail775:;
2318 : }
2319 : else
2320 : {
2321 0 : {
2322 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
2323 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail776;
2324 0 : {
2325 0 : tree res_op0;
2326 0 : {
2327 0 : tree _o1[2], _r1;
2328 0 : {
2329 0 : tree _o2[1], _r2;
2330 0 : _o2[0] = captures[2];
2331 0 : if (TREE_TYPE (_o2[0]) != utype)
2332 : {
2333 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2334 : }
2335 : else
2336 : _r2 = _o2[0];
2337 0 : _o1[0] = _r2;
2338 : }
2339 0 : {
2340 0 : tree _o2[1], _r2;
2341 0 : _o2[0] = captures[4];
2342 0 : if (TREE_TYPE (_o2[0]) != utype)
2343 : {
2344 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2345 : }
2346 : else
2347 : _r2 = _o2[0];
2348 0 : _o1[1] = _r2;
2349 : }
2350 0 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2351 0 : res_op0 = _r1;
2352 : }
2353 0 : tree _r;
2354 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2355 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 634, __FILE__, __LINE__, true);
2356 0 : return _r;
2357 : }
2358 0 : next_after_fail776:;
2359 : }
2360 : }
2361 : }
2362 : else
2363 : {
2364 2427420 : if (FLOAT_TYPE_P (type)
2365 2452312 : && DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
2366 12446 : == DECIMAL_FLOAT_TYPE_P (type)
2367 : )
2368 : {
2369 12423 : {
2370 12423 : tree arg0 = strip_float_extensions (captures[2]);
2371 12423 : tree arg1 = strip_float_extensions (captures[4]);
2372 12423 : tree itype = TREE_TYPE (captures[0]);
2373 12423 : tree ty1 = TREE_TYPE (arg0);
2374 12423 : tree ty2 = TREE_TYPE (arg1);
2375 12423 : enum tree_code code = TREE_CODE (itype);
2376 0 : if (FLOAT_TYPE_P (ty1)
2377 12423 : && FLOAT_TYPE_P (ty2)
2378 : )
2379 : {
2380 12423 : {
2381 12423 : tree newtype = type;
2382 12423 : if (TYPE_MODE (ty1) == SDmode
2383 12414 : || TYPE_MODE (ty2) == SDmode
2384 24837 : || TYPE_MODE (type) == SDmode)
2385 9 : newtype = dfloat32_type_node;
2386 12423 : if (TYPE_MODE (ty1) == DDmode
2387 12417 : || TYPE_MODE (ty2) == DDmode
2388 24840 : || TYPE_MODE (type) == DDmode)
2389 6 : newtype = dfloat64_type_node;
2390 12423 : if (TYPE_MODE (ty1) == TDmode
2391 12423 : || TYPE_MODE (ty2) == TDmode
2392 24846 : || TYPE_MODE (type) == TDmode)
2393 15 : newtype = dfloat128_type_node;
2394 12423 : if ((newtype == dfloat32_type_node
2395 12423 : || newtype == dfloat64_type_node
2396 12423 : || newtype == dfloat128_type_node)
2397 15 : && newtype == type
2398 12429 : && types_match (newtype, type)
2399 : )
2400 : {
2401 6 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail777;
2402 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail777;
2403 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail777;
2404 0 : {
2405 0 : tree res_op0;
2406 0 : {
2407 0 : tree _o1[1], _r1;
2408 0 : _o1[0] = captures[2];
2409 0 : if (TREE_TYPE (_o1[0]) != newtype)
2410 : {
2411 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
2412 : }
2413 : else
2414 : _r1 = _o1[0];
2415 0 : res_op0 = _r1;
2416 : }
2417 0 : tree res_op1;
2418 0 : {
2419 0 : tree _o1[1], _r1;
2420 0 : _o1[0] = captures[4];
2421 0 : if (TREE_TYPE (_o1[0]) != newtype)
2422 : {
2423 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
2424 : }
2425 : else
2426 : _r1 = _o1[0];
2427 0 : res_op1 = _r1;
2428 : }
2429 0 : tree _r;
2430 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2431 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 635, __FILE__, __LINE__, true);
2432 0 : return _r;
2433 : }
2434 : next_after_fail777:;
2435 : }
2436 : else
2437 : {
2438 12417 : {
2439 12417 : if (element_precision (ty1) > element_precision (newtype))
2440 751 : newtype = ty1;
2441 12417 : if (element_precision (ty2) > element_precision (newtype))
2442 2 : newtype = ty2;
2443 12417 : if (element_precision (newtype) < element_precision (itype)
2444 11112 : && (!VECTOR_MODE_P (TYPE_MODE (newtype))
2445 0 : || target_supports_op_p (newtype, op, optab_default))
2446 11112 : && (flag_unsafe_math_optimizations
2447 11100 : || (element_precision (newtype) == element_precision (type)
2448 11096 : && real_can_shorten_arithmetic (element_mode (itype),
2449 : element_mode (type))
2450 4066 : && !excess_precision_type (newtype)))
2451 13090 : && !types_match (itype, newtype)
2452 : )
2453 : {
2454 673 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail778;
2455 673 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail778;
2456 655 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail778;
2457 655 : {
2458 655 : tree res_op0;
2459 655 : {
2460 655 : tree _o1[2], _r1;
2461 655 : {
2462 655 : tree _o2[1], _r2;
2463 655 : _o2[0] = captures[2];
2464 655 : if (TREE_TYPE (_o2[0]) != newtype)
2465 : {
2466 655 : _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
2467 : }
2468 : else
2469 : _r2 = _o2[0];
2470 655 : _o1[0] = _r2;
2471 : }
2472 655 : {
2473 655 : tree _o2[1], _r2;
2474 655 : _o2[0] = captures[4];
2475 655 : if (TREE_TYPE (_o2[0]) != newtype)
2476 : {
2477 604 : _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
2478 : }
2479 : else
2480 : _r2 = _o2[0];
2481 655 : _o1[1] = _r2;
2482 : }
2483 655 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2484 655 : res_op0 = _r1;
2485 : }
2486 655 : tree _r;
2487 655 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2488 655 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 636, __FILE__, __LINE__, true);
2489 655 : return _r;
2490 : }
2491 : next_after_fail778:;
2492 : }
2493 : }
2494 : }
2495 : }
2496 : }
2497 : }
2498 : }
2499 : }
2500 : return NULL_TREE;
2501 : }
2502 :
2503 : tree
2504 1667 : generic_simplify_465 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2505 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2506 : {
2507 1667 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2508 1667 : {
2509 1667 : bool wascmp;
2510 1667 : if (bitwise_inverted_equal_p (captures[0], captures[2], wascmp)
2511 1667 : || bitwise_inverted_equal_p (captures[1], captures[2], wascmp)
2512 : )
2513 : {
2514 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail812;
2515 8 : {
2516 8 : tree _r;
2517 8 : _r = wascmp ? constant_boolean_node (false, type) : build_zero_cst (type);
2518 8 : if (TREE_SIDE_EFFECTS (captures[0]))
2519 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2520 8 : if (TREE_SIDE_EFFECTS (captures[1]))
2521 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2522 8 : if (TREE_SIDE_EFFECTS (captures[2]))
2523 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2524 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 665, __FILE__, __LINE__, true);
2525 8 : return _r;
2526 : }
2527 0 : next_after_fail812:;
2528 : }
2529 : }
2530 1659 : return NULL_TREE;
2531 : }
2532 :
2533 : tree
2534 0 : generic_simplify_476 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2535 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2536 : {
2537 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2538 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail844;
2539 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail844;
2540 0 : {
2541 0 : tree _r;
2542 0 : _r = captures[2];
2543 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2544 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2545 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 687, __FILE__, __LINE__, true);
2546 : return _r;
2547 : }
2548 : next_after_fail844:;
2549 : return NULL_TREE;
2550 : }
2551 :
2552 : tree
2553 3 : generic_simplify_481 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2554 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2555 : {
2556 3 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2557 6 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2558 6 : && TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))
2559 : )
2560 : {
2561 3 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail862;
2562 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail862;
2563 3 : {
2564 3 : tree res_op0;
2565 3 : res_op0 = captures[3];
2566 3 : tree res_op1;
2567 3 : {
2568 3 : tree _o1[2], _r1;
2569 3 : _o1[0] = captures[1];
2570 3 : _o1[1] = build_int_cst (TREE_TYPE (captures[1]), 1);
2571 3 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2572 3 : res_op1 = _r1;
2573 : }
2574 3 : tree _r;
2575 3 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
2576 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 689, __FILE__, __LINE__, true);
2577 3 : return _r;
2578 : }
2579 : next_after_fail862:;
2580 : }
2581 : return NULL_TREE;
2582 : }
2583 :
2584 : tree
2585 32530 : generic_simplify_488 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2586 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2587 : const enum tree_code ARG_UNUSED (shift))
2588 : {
2589 32530 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2590 32530 : if (tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
2591 22380 : && TYPE_PRECISION (type) <= HOST_BITS_PER_WIDE_INT
2592 22380 : && tree_fits_uhwi_p (captures[4])
2593 22380 : && tree_to_uhwi (captures[4]) > 0
2594 54910 : && tree_to_uhwi (captures[4]) < TYPE_PRECISION (type)
2595 : )
2596 : {
2597 22380 : {
2598 22380 : unsigned int shiftc = tree_to_uhwi (captures[4]);
2599 22380 : unsigned HOST_WIDE_INT mask = TREE_INT_CST_LOW (captures[5]);
2600 22380 : unsigned HOST_WIDE_INT newmask, zerobits = 0;
2601 22380 : tree shift_type = TREE_TYPE (captures[2]);
2602 22380 : unsigned int prec;
2603 22380 : if (shift == LSHIFT_EXPR)
2604 0 : zerobits = ((HOST_WIDE_INT_1U << shiftc) - 1);
2605 22380 : else if (shift == RSHIFT_EXPR
2606 22380 : && type_has_mode_precision_p (shift_type))
2607 : {
2608 22380 : prec = TYPE_PRECISION (TREE_TYPE (captures[2]));
2609 22380 : tree arg00 = captures[3];
2610 22380 : if (captures[2] != captures[3]
2611 22380 : && TYPE_UNSIGNED (TREE_TYPE (captures[3])))
2612 : {
2613 21973 : tree inner_type = TREE_TYPE (captures[3]);
2614 21973 : if (type_has_mode_precision_p (inner_type)
2615 21973 : && TYPE_PRECISION (inner_type) < prec)
2616 : {
2617 34 : prec = TYPE_PRECISION (inner_type);
2618 34 : if (shiftc < prec)
2619 34 : shift_type = inner_type;
2620 : }
2621 : }
2622 22380 : zerobits = HOST_WIDE_INT_M1U;
2623 22380 : if (shiftc < prec)
2624 : {
2625 22380 : zerobits >>= HOST_BITS_PER_WIDE_INT - shiftc;
2626 22380 : zerobits <<= prec - shiftc;
2627 : }
2628 22380 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[2]))
2629 22380 : && prec == TYPE_PRECISION (TREE_TYPE (captures[2])))
2630 : {
2631 73 : if ((mask & zerobits) == 0)
2632 59 : shift_type = unsigned_type_for (TREE_TYPE (captures[2]));
2633 : else
2634 : zerobits = 0;
2635 : }
2636 : }
2637 22366 : if ((mask & zerobits) == mask
2638 : )
2639 : {
2640 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail873;
2641 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail873;
2642 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail873;
2643 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail873;
2644 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail873;
2645 0 : {
2646 0 : tree _r;
2647 0 : _r = build_int_cst (type, 0);
2648 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 691, __FILE__, __LINE__, true);
2649 0 : return _r;
2650 : }
2651 : next_after_fail873:;
2652 : }
2653 : else
2654 : {
2655 22380 : {
2656 22380 : newmask = mask | zerobits;
2657 22380 : if (newmask != mask && (newmask & (newmask + 1)) == 0
2658 : )
2659 : {
2660 : {
2661 65 : for (prec = BITS_PER_UNIT;
2662 122 : prec < HOST_BITS_PER_WIDE_INT; prec <<= 1)
2663 118 : if (newmask == (HOST_WIDE_INT_1U << prec) - 1)
2664 : break;
2665 57 : if (prec < HOST_BITS_PER_WIDE_INT
2666 4 : || newmask == HOST_WIDE_INT_M1U
2667 : )
2668 : {
2669 57 : {
2670 57 : tree newmaskt = build_int_cst_type (TREE_TYPE (captures[5]), newmask);
2671 57 : if (!tree_int_cst_equal (newmaskt, captures[5])
2672 : )
2673 : {
2674 57 : if (shift_type != TREE_TYPE (captures[2])
2675 : )
2676 : {
2677 47 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail874;
2678 47 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail874;
2679 47 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail874;
2680 47 : {
2681 47 : tree res_op0;
2682 47 : {
2683 47 : tree _o1[1], _r1;
2684 47 : {
2685 47 : tree _o2[2], _r2;
2686 47 : {
2687 47 : tree _o3[1], _r3;
2688 47 : _o3[0] = captures[2];
2689 47 : if (TREE_TYPE (_o3[0]) != shift_type)
2690 : {
2691 47 : _r3 = fold_build1_loc (loc, NOP_EXPR, shift_type, _o3[0]);
2692 : }
2693 : else
2694 : _r3 = _o3[0];
2695 47 : _o2[0] = _r3;
2696 : }
2697 47 : _o2[1] = captures[4];
2698 47 : _r2 = fold_build2_loc (loc, shift, shift_type, _o2[0], _o2[1]);
2699 47 : _o1[0] = _r2;
2700 : }
2701 47 : if (TREE_TYPE (_o1[0]) != type)
2702 : {
2703 47 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2704 : }
2705 : else
2706 : _r1 = _o1[0];
2707 47 : res_op0 = _r1;
2708 : }
2709 47 : tree res_op1;
2710 47 : res_op1 = newmaskt;
2711 47 : tree _r;
2712 47 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2713 47 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 692, __FILE__, __LINE__, true);
2714 47 : return _r;
2715 : }
2716 : next_after_fail874:;
2717 : }
2718 : else
2719 : {
2720 10 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail875;
2721 10 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail875;
2722 10 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail875;
2723 10 : {
2724 10 : tree res_op0;
2725 10 : res_op0 = captures[0];
2726 10 : tree res_op1;
2727 10 : res_op1 = newmaskt;
2728 10 : tree _r;
2729 10 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2730 10 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 693, __FILE__, __LINE__, true);
2731 10 : return _r;
2732 : }
2733 : next_after_fail875:;
2734 : }
2735 : }
2736 : }
2737 : }
2738 : }
2739 : }
2740 : }
2741 : }
2742 : }
2743 : }
2744 : return NULL_TREE;
2745 : }
2746 :
2747 : tree
2748 108 : generic_simplify_498 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2749 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2750 : {
2751 108 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2752 108 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail889;
2753 108 : {
2754 108 : tree res_op0;
2755 108 : res_op0 = captures[1];
2756 108 : tree res_op1;
2757 108 : {
2758 108 : tree _o1[1], _r1;
2759 108 : _o1[0] = captures[2];
2760 108 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2761 108 : res_op1 = _r1;
2762 : }
2763 108 : tree _r;
2764 108 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2765 108 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 703, __FILE__, __LINE__, true);
2766 : return _r;
2767 : }
2768 0 : next_after_fail889:;
2769 0 : return NULL_TREE;
2770 : }
2771 :
2772 : tree
2773 29 : generic_simplify_504 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2774 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2775 : {
2776 29 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2777 29 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
2778 : )
2779 : {
2780 29 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail895;
2781 29 : {
2782 29 : tree res_op0;
2783 29 : {
2784 29 : tree _o1[2], _r1;
2785 29 : _o1[0] = captures[0];
2786 29 : {
2787 29 : tree _o2[1], _r2;
2788 29 : _o2[0] = captures[1];
2789 29 : _r2 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
2790 29 : _o1[1] = _r2;
2791 : }
2792 29 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2793 29 : res_op0 = _r1;
2794 : }
2795 29 : tree _r;
2796 29 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2797 29 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 709, __FILE__, __LINE__, true);
2798 29 : return _r;
2799 : }
2800 0 : next_after_fail895:;
2801 : }
2802 : return NULL_TREE;
2803 : }
2804 :
2805 : tree
2806 16 : generic_simplify_512 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2807 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2808 : {
2809 16 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2810 16 : if (ANY_INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_SANITIZED (type)
2811 : )
2812 : {
2813 16 : {
2814 16 : tree ptrdifftype = TREE_TYPE (captures[0]);
2815 16 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail904;
2816 16 : {
2817 16 : tree res_op0;
2818 16 : {
2819 16 : tree _o1[2], _r1;
2820 16 : _o1[0] = captures[2];
2821 16 : _o1[1] = captures[1];
2822 16 : _r1 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ptrdifftype, _o1[0], _o1[1]);
2823 16 : res_op0 = _r1;
2824 : }
2825 16 : tree _r;
2826 16 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2827 16 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 716, __FILE__, __LINE__, true);
2828 16 : return _r;
2829 : }
2830 0 : next_after_fail904:;
2831 : }
2832 : }
2833 : return NULL_TREE;
2834 : }
2835 :
2836 : tree
2837 0 : generic_simplify_519 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2838 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2839 : const enum tree_code ARG_UNUSED (minmax))
2840 : {
2841 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2842 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail912;
2843 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail912;
2844 0 : {
2845 0 : tree _r;
2846 0 : _r = captures[0];
2847 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 724, __FILE__, __LINE__, true);
2848 : return _r;
2849 : }
2850 : next_after_fail912:;
2851 : return NULL_TREE;
2852 : }
2853 :
2854 : tree
2855 47 : generic_simplify_527 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2856 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2857 : const enum tree_code ARG_UNUSED (minmax),
2858 : const enum tree_code ARG_UNUSED (cmp))
2859 : {
2860 47 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2861 47 : {
2862 47 : poly_int64 off0, off1;
2863 47 : tree base0, base1;
2864 47 : int equal = address_compare (cmp, TREE_TYPE (captures[0]), captures[1], captures[3], base0, base1,
2865 : off0, off1,
2866 : 1
2867 : );
2868 47 : if (equal == 1
2869 : )
2870 : {
2871 0 : if (minmax == MIN_EXPR
2872 : )
2873 : {
2874 0 : if (known_le (off0, off1)
2875 : )
2876 : {
2877 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail922;
2878 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail922;
2879 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail922;
2880 0 : {
2881 0 : tree _r;
2882 0 : _r = captures[0];
2883 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 733, __FILE__, __LINE__, true);
2884 0 : return _r;
2885 : }
2886 47 : next_after_fail922:;
2887 : }
2888 : else
2889 : {
2890 0 : if (known_gt (off0, off1)
2891 : )
2892 : {
2893 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail923;
2894 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail923;
2895 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail923;
2896 0 : {
2897 0 : tree _r;
2898 0 : _r = captures[2];
2899 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 734, __FILE__, __LINE__, true);
2900 0 : return _r;
2901 : }
2902 47 : next_after_fail923:;
2903 : }
2904 : }
2905 : }
2906 : else
2907 : {
2908 0 : if (known_ge (off0, off1)
2909 : )
2910 : {
2911 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail924;
2912 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail924;
2913 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail924;
2914 0 : {
2915 0 : tree _r;
2916 0 : _r = captures[0];
2917 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 735, __FILE__, __LINE__, true);
2918 0 : return _r;
2919 : }
2920 47 : next_after_fail924:;
2921 : }
2922 : else
2923 : {
2924 0 : if (known_lt (off0, off1)
2925 : )
2926 : {
2927 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail925;
2928 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail925;
2929 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail925;
2930 0 : {
2931 0 : tree _r;
2932 0 : _r = captures[2];
2933 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 736, __FILE__, __LINE__, true);
2934 0 : return _r;
2935 : }
2936 47 : next_after_fail925:;
2937 : }
2938 : }
2939 : }
2940 : }
2941 : }
2942 47 : return NULL_TREE;
2943 : }
2944 :
2945 : tree
2946 0 : generic_simplify_548 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2947 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
2948 : const combined_fn ARG_UNUSED (cond_len_op))
2949 : {
2950 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2951 0 : {
2952 0 : tree op_type = TREE_TYPE (captures[3]);
2953 0 : if (element_precision (type) == element_precision (op_type)
2954 : )
2955 : {
2956 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail955;
2957 0 : {
2958 0 : tree res_op0;
2959 0 : {
2960 0 : tree _o1[6], _r1;
2961 0 : _o1[0] = captures[0];
2962 0 : _o1[1] = captures[1];
2963 0 : _o1[2] = captures[2];
2964 0 : {
2965 0 : tree _o2[1], _r2;
2966 0 : _o2[0] = captures[6];
2967 0 : if (TREE_TYPE (_o2[0]) != op_type)
2968 : {
2969 0 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
2970 : }
2971 : else
2972 : _r2 = _o2[0];
2973 0 : _o1[3] = _r2;
2974 : }
2975 0 : _o1[4] = captures[4];
2976 0 : _o1[5] = captures[5];
2977 0 : _r1 = maybe_build_call_expr_loc (loc, cond_len_op, TREE_TYPE (_o1[1]), 6, _o1[0], _o1[1], _o1[2], _o1[3], _o1[4], _o1[5]);
2978 0 : if (!_r1)
2979 0 : goto next_after_fail955;
2980 0 : res_op0 = _r1;
2981 : }
2982 0 : tree _r;
2983 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
2984 0 : if (TREE_SIDE_EFFECTS (captures[3]))
2985 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
2986 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 749, __FILE__, __LINE__, true);
2987 0 : return _r;
2988 : }
2989 : next_after_fail955:;
2990 : }
2991 : }
2992 : return NULL_TREE;
2993 : }
2994 :
2995 : tree
2996 0 : generic_simplify_558 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2997 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2998 : const combined_fn ARG_UNUSED (bswap))
2999 : {
3000 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3001 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail968;
3002 0 : {
3003 0 : tree _r;
3004 0 : _r = captures[0];
3005 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 762, __FILE__, __LINE__, true);
3006 : return _r;
3007 : }
3008 0 : next_after_fail968:;
3009 0 : return NULL_TREE;
3010 : }
3011 :
3012 : tree
3013 0 : generic_simplify_565 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3014 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
3015 : const combined_fn ARG_UNUSED (ovf))
3016 : {
3017 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3018 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
3019 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
3020 0 : && TYPE_PRECISION (TREE_TYPE (captures[1])) > TYPE_PRECISION (TREE_TYPE (captures[2]))
3021 0 : && (!TYPE_UNSIGNED (TREE_TYPE (captures[1])) || TYPE_UNSIGNED (TREE_TYPE (captures[2])))
3022 : )
3023 : {
3024 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail975;
3025 0 : {
3026 0 : tree res_op0;
3027 0 : res_op0 = captures[0];
3028 0 : tree res_op1;
3029 0 : res_op1 = captures[2];
3030 0 : tree _r;
3031 0 : _r = maybe_build_call_expr_loc (loc, ovf, type, 2, res_op0, res_op1);
3032 0 : if (!_r)
3033 0 : goto next_after_fail975;
3034 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 769, __FILE__, __LINE__, true);
3035 0 : return _r;
3036 : }
3037 : next_after_fail975:;
3038 : }
3039 : return NULL_TREE;
3040 : }
3041 :
3042 : tree
3043 0 : generic_simplify_573 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3044 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3045 : const combined_fn ARG_UNUSED (fns))
3046 : {
3047 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3048 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail983;
3049 0 : {
3050 0 : tree _r;
3051 0 : _r = captures[0];
3052 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 777, __FILE__, __LINE__, true);
3053 : return _r;
3054 : }
3055 0 : next_after_fail983:;
3056 0 : return NULL_TREE;
3057 : }
3058 :
3059 : tree
3060 0 : generic_simplify_578 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3061 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
3062 : {
3063 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3064 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail988;
3065 0 : {
3066 0 : tree _r;
3067 0 : _r = captures[0];
3068 0 : if (TREE_SIDE_EFFECTS (captures[1]))
3069 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3070 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 782, __FILE__, __LINE__, true);
3071 : return _r;
3072 : }
3073 0 : next_after_fail988:;
3074 0 : return NULL_TREE;
3075 : }
3076 :
3077 : tree
3078 0 : generic_simplify_585 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3079 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3080 : const combined_fn ARG_UNUSED (rints))
3081 : {
3082 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3083 0 : if (canonicalize_math_p ()
3084 : )
3085 : {
3086 0 : if (!flag_errno_math
3087 : )
3088 : {
3089 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail995;
3090 0 : {
3091 0 : tree res_op0;
3092 0 : res_op0 = captures[0];
3093 0 : tree _r;
3094 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3095 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 789, __FILE__, __LINE__, true);
3096 0 : return _r;
3097 : }
3098 0 : next_after_fail995:;
3099 : }
3100 : }
3101 : return NULL_TREE;
3102 : }
3103 :
3104 : tree
3105 0 : generic_simplify_591 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3106 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
3107 : const combined_fn ARG_UNUSED (fmas))
3108 : {
3109 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3110 0 : if (canonicalize_math_after_vectorization_p ()
3111 : )
3112 : {
3113 : {
3114 : tree t = TREE_TYPE (captures[0]);
3115 : if ((!ANY_INTEGRAL_TYPE_P (type)
3116 : || TYPE_UNSIGNED (type)
3117 : || !TYPE_OVERFLOW_SANITIZED (type))
3118 : && (!ANY_INTEGRAL_TYPE_P (t)
3119 : || TYPE_UNSIGNED (t)
3120 : || !TYPE_OVERFLOW_SANITIZED (type))
3121 : )
3122 : {
3123 : {
3124 : tree utype = unsigned_type_for (type);
3125 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1001;
3126 : {
3127 : tree res_op0;
3128 : {
3129 : tree _o1[3], _r1;
3130 : {
3131 : tree _o2[1], _r2;
3132 : _o2[0] = captures[0];
3133 : if (TREE_TYPE (_o2[0]) != utype)
3134 : {
3135 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
3136 : }
3137 : else
3138 : _r2 = _o2[0];
3139 : _o1[0] = _r2;
3140 : }
3141 : {
3142 : tree _o2[1], _r2;
3143 : _o2[0] = captures[1];
3144 : if (TREE_TYPE (_o2[0]) != utype)
3145 : {
3146 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
3147 : }
3148 : else
3149 : _r2 = _o2[0];
3150 : _o1[1] = _r2;
3151 : }
3152 : {
3153 : tree _o2[1], _r2;
3154 : _o2[0] = captures[2];
3155 : if (TREE_TYPE (_o2[0]) != utype)
3156 : {
3157 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
3158 : }
3159 : else
3160 : _r2 = _o2[0];
3161 : _o1[2] = _r2;
3162 : }
3163 : _r1 = maybe_build_call_expr_loc (loc, CFN_FNMA, TREE_TYPE (_o1[0]), 3, _o1[0], _o1[1], _o1[2]);
3164 : if (!_r1)
3165 : goto next_after_fail1001;
3166 : res_op0 = _r1;
3167 : }
3168 : tree _r;
3169 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3170 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 795, __FILE__, __LINE__, true);
3171 : return _r;
3172 : }
3173 0 : next_after_fail1001:;
3174 : }
3175 : }
3176 : }
3177 : }
3178 0 : return NULL_TREE;
3179 : }
3180 :
3181 : tree
3182 0 : generic_simplify_613 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3183 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3184 : const combined_fn ARG_UNUSED (bswap),
3185 : const combined_fn ARG_UNUSED (popcount))
3186 : {
3187 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3188 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3189 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
3190 : )
3191 : {
3192 0 : {
3193 0 : tree type0 = TREE_TYPE (captures[0]);
3194 0 : tree type1 = TREE_TYPE (captures[1]);
3195 0 : unsigned int prec0 = TYPE_PRECISION (type0);
3196 0 : unsigned int prec1 = TYPE_PRECISION (type1);
3197 0 : if (prec0 == prec1 || (prec0 > prec1 && TYPE_UNSIGNED (type1))
3198 : )
3199 : {
3200 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1023;
3201 0 : {
3202 0 : tree res_op0;
3203 0 : {
3204 0 : tree _o1[1], _r1;
3205 0 : {
3206 0 : tree _o2[1], _r2;
3207 0 : _o2[0] = captures[2];
3208 0 : if (TREE_TYPE (_o2[0]) != type1)
3209 : {
3210 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, type1, _o2[0]);
3211 : }
3212 : else
3213 : _r2 = _o2[0];
3214 0 : _o1[0] = _r2;
3215 : }
3216 0 : if (TREE_TYPE (_o1[0]) != type0)
3217 : {
3218 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type0, _o1[0]);
3219 : }
3220 : else
3221 : _r1 = _o1[0];
3222 0 : res_op0 = _r1;
3223 : }
3224 0 : tree _r;
3225 0 : _r = maybe_build_call_expr_loc (loc, popcount, type, 1, res_op0);
3226 0 : if (!_r)
3227 0 : goto next_after_fail1023;
3228 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 811, __FILE__, __LINE__, true);
3229 0 : return _r;
3230 : }
3231 : next_after_fail1023:;
3232 : }
3233 : }
3234 : }
3235 : return NULL_TREE;
3236 : }
3237 :
3238 : tree
3239 2141781 : generic_simplify_ABS_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0)
3240 : {
3241 2141781 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3242 2141781 : switch (TREE_CODE (_p0))
3243 : {
3244 185482 : CASE_CONVERT:
3245 185482 : {
3246 185482 : tree _q20 = TREE_OPERAND (_p0, 0);
3247 185482 : {
3248 185482 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3249 370962 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3250 914 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
3251 840 : && element_precision (type) > element_precision (TREE_TYPE (captures[0]))
3252 185707 : && (!VECTOR_TYPE_P (type)
3253 0 : || target_supports_op_p (TREE_TYPE (captures[0]), ABSU_EXPR, optab_vector))
3254 : )
3255 : {
3256 225 : {
3257 225 : tree utype = unsigned_type_for (TREE_TYPE (captures[0]));
3258 225 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1037;
3259 225 : {
3260 225 : tree res_op0;
3261 225 : {
3262 225 : tree _o1[1], _r1;
3263 225 : _o1[0] = captures[0];
3264 225 : _r1 = fold_build1_loc (loc, ABSU_EXPR, utype, _o1[0]);
3265 225 : res_op0 = _r1;
3266 : }
3267 225 : tree _r;
3268 225 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3269 225 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 824, __FILE__, __LINE__, true);
3270 225 : return _r;
3271 : }
3272 0 : next_after_fail1037:;
3273 : }
3274 : }
3275 : }
3276 : break;
3277 : }
3278 12 : case ABS_EXPR:
3279 12 : {
3280 12 : tree _q20 = TREE_OPERAND (_p0, 0);
3281 12 : {
3282 12 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3283 12 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1038;
3284 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1038;
3285 12 : {
3286 12 : tree _r;
3287 12 : _r = captures[0];
3288 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 825, __FILE__, __LINE__, true);
3289 12 : return _r;
3290 : }
3291 0 : next_after_fail1038:;
3292 : }
3293 0 : break;
3294 : }
3295 57 : case NEGATE_EXPR:
3296 57 : {
3297 57 : tree _q20 = TREE_OPERAND (_p0, 0);
3298 57 : {
3299 57 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3300 57 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1039;
3301 57 : {
3302 57 : tree res_op0;
3303 57 : res_op0 = captures[0];
3304 57 : tree _r;
3305 57 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
3306 57 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 826, __FILE__, __LINE__, true);
3307 2141781 : return _r;
3308 : }
3309 0 : next_after_fail1039:;
3310 : }
3311 0 : break;
3312 : }
3313 317 : case PLUS_EXPR:
3314 317 : {
3315 317 : tree _q20 = TREE_OPERAND (_p0, 0);
3316 317 : tree _q21 = TREE_OPERAND (_p0, 1);
3317 317 : if (real_zerop (_q21))
3318 : {
3319 3 : {
3320 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3321 3 : tree res = generic_simplify_1 (loc, type, _p0, captures, PLUS_EXPR);
3322 3 : if (res) return res;
3323 : }
3324 : }
3325 : break;
3326 : }
3327 7793 : case MINUS_EXPR:
3328 7793 : {
3329 7793 : tree _q20 = TREE_OPERAND (_p0, 0);
3330 7793 : tree _q21 = TREE_OPERAND (_p0, 1);
3331 7793 : if (real_zerop (_q21))
3332 : {
3333 0 : {
3334 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3335 0 : tree res = generic_simplify_1 (loc, type, _p0, captures, MINUS_EXPR);
3336 0 : if (res) return res;
3337 : }
3338 : }
3339 : break;
3340 : }
3341 0 : case VEC_COND_EXPR:
3342 0 : {
3343 0 : tree _q20 = TREE_OPERAND (_p0, 0);
3344 0 : tree _q21 = TREE_OPERAND (_p0, 1);
3345 0 : tree _q22 = TREE_OPERAND (_p0, 2);
3346 0 : {
3347 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
3348 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1040;
3349 0 : {
3350 0 : tree res_op0;
3351 0 : res_op0 = captures[1];
3352 0 : tree res_op1;
3353 0 : {
3354 0 : tree _o1[1], _r1;
3355 0 : _o1[0] = captures[2];
3356 0 : _r1 = fold_build1_loc (loc, ABS_EXPR, type, _o1[0]);
3357 0 : if (EXPR_P (_r1))
3358 0 : goto next_after_fail1040;
3359 0 : res_op1 = _r1;
3360 : }
3361 0 : tree res_op2;
3362 0 : {
3363 0 : tree _o1[1], _r1;
3364 0 : _o1[0] = captures[3];
3365 0 : _r1 = fold_build1_loc (loc, ABS_EXPR, type, _o1[0]);
3366 0 : if (EXPR_P (_r1))
3367 0 : goto next_after_fail1040;
3368 0 : res_op2 = _r1;
3369 : }
3370 0 : tree _r;
3371 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
3372 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 827, __FILE__, __LINE__, true);
3373 0 : return _r;
3374 : }
3375 0 : next_after_fail1040:;
3376 : }
3377 0 : break;
3378 : }
3379 702 : case CALL_EXPR:
3380 702 : switch (get_call_combined_fn (_p0))
3381 : {
3382 0 : case CFN_BUILT_IN_COPYSIGNF16:
3383 0 : if (call_expr_nargs (_p0) == 2)
3384 : {
3385 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3386 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3387 0 : {
3388 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3389 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF16);
3390 0 : if (res) return res;
3391 : }
3392 : }
3393 : break;
3394 0 : case CFN_BUILT_IN_COPYSIGNF32:
3395 0 : if (call_expr_nargs (_p0) == 2)
3396 : {
3397 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3398 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3399 0 : {
3400 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3401 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF32);
3402 0 : if (res) return res;
3403 : }
3404 : }
3405 : break;
3406 0 : case CFN_BUILT_IN_COPYSIGNF64:
3407 0 : if (call_expr_nargs (_p0) == 2)
3408 : {
3409 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3410 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3411 0 : {
3412 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3413 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF64);
3414 0 : if (res) return res;
3415 : }
3416 : }
3417 : break;
3418 0 : case CFN_BUILT_IN_COPYSIGNF128X:
3419 0 : if (call_expr_nargs (_p0) == 2)
3420 : {
3421 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3422 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3423 0 : {
3424 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3425 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF128X);
3426 0 : if (res) return res;
3427 : }
3428 : }
3429 : break;
3430 0 : case CFN_BUILT_IN_COPYSIGNF128:
3431 0 : if (call_expr_nargs (_p0) == 2)
3432 : {
3433 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3434 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3435 0 : {
3436 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3437 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF128);
3438 0 : if (res) return res;
3439 : }
3440 : }
3441 : break;
3442 0 : case CFN_BUILT_IN_COPYSIGNF32X:
3443 0 : if (call_expr_nargs (_p0) == 2)
3444 : {
3445 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3446 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3447 0 : {
3448 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3449 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF32X);
3450 0 : if (res) return res;
3451 : }
3452 : }
3453 : break;
3454 0 : case CFN_BUILT_IN_COPYSIGNF64X:
3455 0 : if (call_expr_nargs (_p0) == 2)
3456 : {
3457 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3458 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3459 0 : {
3460 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3461 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF64X);
3462 0 : if (res) return res;
3463 : }
3464 : }
3465 : break;
3466 0 : case CFN_BUILT_IN_COPYSIGN:
3467 0 : if (call_expr_nargs (_p0) == 2)
3468 : {
3469 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3470 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3471 0 : {
3472 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3473 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGN);
3474 0 : if (res) return res;
3475 : }
3476 : }
3477 : break;
3478 1 : case CFN_BUILT_IN_COPYSIGNF:
3479 1 : if (call_expr_nargs (_p0) == 2)
3480 : {
3481 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3482 1 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3483 1 : {
3484 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3485 1 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF);
3486 1 : if (res) return res;
3487 : }
3488 : }
3489 : break;
3490 0 : case CFN_BUILT_IN_COPYSIGNL:
3491 0 : if (call_expr_nargs (_p0) == 2)
3492 : {
3493 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3494 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3495 0 : {
3496 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3497 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNL);
3498 0 : if (res) return res;
3499 : }
3500 : }
3501 : break;
3502 0 : case CFN_COPYSIGN:
3503 0 : if (call_expr_nargs (_p0) == 2)
3504 : {
3505 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3506 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3507 0 : {
3508 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3509 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_COPYSIGN);
3510 0 : if (res) return res;
3511 : }
3512 : }
3513 : break;
3514 : default:;
3515 : }
3516 : break;
3517 2141484 : default:;
3518 : }
3519 2141484 : if (tree_expr_nonnegative_p (_p0))
3520 : {
3521 548 : {
3522 548 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3523 548 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1041;
3524 548 : {
3525 548 : tree _r;
3526 548 : _r = captures[0];
3527 548 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 828, __FILE__, __LINE__, true);
3528 548 : return _r;
3529 : }
3530 0 : next_after_fail1041:;
3531 : }
3532 : }
3533 : return NULL_TREE;
3534 : }
3535 :
3536 : tree
3537 998490 : generic_simplify_BIT_XOR_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
3538 : {
3539 998490 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3540 998490 : switch (TREE_CODE (_p0))
3541 : {
3542 102 : case MINUS_EXPR:
3543 102 : {
3544 102 : tree _q20 = TREE_OPERAND (_p0, 0);
3545 102 : tree _q21 = TREE_OPERAND (_p0, 1);
3546 102 : switch (TREE_CODE (_q21))
3547 : {
3548 22 : CASE_CONVERT:
3549 22 : {
3550 22 : tree _q40 = TREE_OPERAND (_q21, 0);
3551 22 : switch (TREE_CODE (_q40))
3552 : {
3553 0 : case LT_EXPR:
3554 0 : {
3555 0 : tree _q50 = TREE_OPERAND (_q40, 0);
3556 0 : tree _q51 = TREE_OPERAND (_q40, 1);
3557 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
3558 : {
3559 0 : if (integer_zerop (_q51))
3560 : {
3561 0 : switch (TREE_CODE (_p1))
3562 : {
3563 0 : case NEGATE_EXPR:
3564 0 : {
3565 0 : tree _q80 = TREE_OPERAND (_p1, 0);
3566 0 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
3567 : {
3568 0 : {
3569 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3570 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3571 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
3572 : )
3573 : {
3574 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1160;
3575 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1160;
3576 0 : {
3577 0 : tree res_op0;
3578 0 : res_op0 = captures[0];
3579 0 : tree _r;
3580 0 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
3581 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 885, __FILE__, __LINE__, true);
3582 0 : return _r;
3583 : }
3584 0 : next_after_fail1160:;
3585 : }
3586 : }
3587 : }
3588 : break;
3589 : }
3590 : default:;
3591 : }
3592 : }
3593 : }
3594 : break;
3595 : }
3596 : default:;
3597 : }
3598 : break;
3599 : }
3600 : default:;
3601 : }
3602 : break;
3603 : }
3604 142 : case NEGATE_EXPR:
3605 142 : {
3606 142 : tree _q20 = TREE_OPERAND (_p0, 0);
3607 142 : switch (TREE_CODE (_p1))
3608 : {
3609 0 : case MINUS_EXPR:
3610 0 : {
3611 0 : tree _q40 = TREE_OPERAND (_p1, 0);
3612 0 : tree _q41 = TREE_OPERAND (_p1, 1);
3613 0 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
3614 : {
3615 0 : switch (TREE_CODE (_q41))
3616 : {
3617 0 : CASE_CONVERT:
3618 0 : {
3619 0 : tree _q70 = TREE_OPERAND (_q41, 0);
3620 0 : switch (TREE_CODE (_q70))
3621 : {
3622 0 : case LT_EXPR:
3623 0 : {
3624 0 : tree _q80 = TREE_OPERAND (_q70, 0);
3625 0 : tree _q81 = TREE_OPERAND (_q70, 1);
3626 0 : if ((_q80 == _q40 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q40, 0) && types_match (_q80, _q40)))
3627 : {
3628 0 : if (integer_zerop (_q81))
3629 : {
3630 0 : {
3631 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
3632 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3633 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
3634 : )
3635 : {
3636 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1161;
3637 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1161;
3638 0 : {
3639 0 : tree res_op0;
3640 0 : res_op0 = captures[0];
3641 0 : tree _r;
3642 0 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
3643 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 885, __FILE__, __LINE__, true);
3644 0 : return _r;
3645 : }
3646 0 : next_after_fail1161:;
3647 : }
3648 : }
3649 : }
3650 : }
3651 : break;
3652 : }
3653 : default:;
3654 : }
3655 : break;
3656 : }
3657 : default:;
3658 : }
3659 : }
3660 : break;
3661 : }
3662 : default:;
3663 : }
3664 : break;
3665 : }
3666 998490 : default:;
3667 : }
3668 998490 : if (integer_zerop (_p1))
3669 : {
3670 543 : {
3671 543 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3672 543 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1162;
3673 543 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1162;
3674 543 : {
3675 543 : tree res_op0;
3676 543 : res_op0 = captures[0];
3677 543 : tree _r;
3678 543 : _r = non_lvalue_loc (loc, res_op0);
3679 543 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 886, __FILE__, __LINE__, true);
3680 543 : return _r;
3681 : }
3682 : next_after_fail1162:;
3683 : }
3684 : }
3685 997947 : switch (TREE_CODE (_p0))
3686 : {
3687 2970 : case LSHIFT_EXPR:
3688 2970 : {
3689 2970 : tree _q20 = TREE_OPERAND (_p0, 0);
3690 2970 : tree _q21 = TREE_OPERAND (_p0, 1);
3691 2970 : switch (TREE_CODE (_p1))
3692 : {
3693 10 : case LSHIFT_EXPR:
3694 10 : {
3695 10 : tree _q50 = TREE_OPERAND (_p1, 0);
3696 10 : tree _q51 = TREE_OPERAND (_p1, 1);
3697 10 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
3698 : {
3699 1 : {
3700 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
3701 1 : tree res = generic_simplify_3 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3702 1 : if (res) return res;
3703 : }
3704 : }
3705 : break;
3706 : }
3707 : default:;
3708 : }
3709 : break;
3710 : }
3711 22430 : case RSHIFT_EXPR:
3712 22430 : {
3713 22430 : tree _q20 = TREE_OPERAND (_p0, 0);
3714 22430 : tree _q21 = TREE_OPERAND (_p0, 1);
3715 22430 : switch (TREE_CODE (_p1))
3716 : {
3717 20 : case RSHIFT_EXPR:
3718 20 : {
3719 20 : tree _q50 = TREE_OPERAND (_p1, 0);
3720 20 : tree _q51 = TREE_OPERAND (_p1, 1);
3721 20 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
3722 : {
3723 10 : {
3724 10 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
3725 10 : tree res = generic_simplify_4 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3726 10 : if (res) return res;
3727 : }
3728 : }
3729 : break;
3730 : }
3731 : default:;
3732 : }
3733 : break;
3734 : }
3735 3380 : case BIT_AND_EXPR:
3736 3380 : {
3737 3380 : tree _q20 = TREE_OPERAND (_p0, 0);
3738 3380 : tree _q21 = TREE_OPERAND (_p0, 1);
3739 3380 : switch (TREE_CODE (_p1))
3740 : {
3741 354 : case BIT_AND_EXPR:
3742 354 : {
3743 354 : tree _q50 = TREE_OPERAND (_p1, 0);
3744 354 : tree _q51 = TREE_OPERAND (_p1, 1);
3745 354 : {
3746 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51 };
3747 354 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3748 354 : if (res) return res;
3749 : }
3750 354 : {
3751 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q51, _q50 };
3752 354 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3753 354 : if (res) return res;
3754 : }
3755 354 : {
3756 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q50, _q51 };
3757 354 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3758 354 : if (res) return res;
3759 : }
3760 354 : {
3761 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q51, _q50 };
3762 354 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3763 354 : if (res) return res;
3764 : }
3765 354 : break;
3766 : }
3767 3380 : default:;
3768 : }
3769 3380 : switch (TREE_CODE (_q21))
3770 : {
3771 41 : case BIT_NOT_EXPR:
3772 41 : {
3773 41 : tree _q40 = TREE_OPERAND (_q21, 0);
3774 41 : switch (TREE_CODE (_p1))
3775 : {
3776 0 : case BIT_NOT_EXPR:
3777 0 : {
3778 0 : tree _q60 = TREE_OPERAND (_p1, 0);
3779 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
3780 : {
3781 0 : {
3782 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
3783 0 : tree res = generic_simplify_6 (loc, type, _p0, _p1, captures);
3784 0 : if (res) return res;
3785 : }
3786 : }
3787 : break;
3788 : }
3789 : default:;
3790 : }
3791 : break;
3792 : }
3793 3380 : default:;
3794 : }
3795 3380 : switch (TREE_CODE (_q20))
3796 : {
3797 90 : case BIT_NOT_EXPR:
3798 90 : {
3799 90 : tree _q30 = TREE_OPERAND (_q20, 0);
3800 90 : switch (TREE_CODE (_p1))
3801 : {
3802 0 : case BIT_NOT_EXPR:
3803 0 : {
3804 0 : tree _q60 = TREE_OPERAND (_p1, 0);
3805 0 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
3806 : {
3807 0 : {
3808 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q30 };
3809 0 : tree res = generic_simplify_6 (loc, type, _p0, _p1, captures);
3810 0 : if (res) return res;
3811 : }
3812 : }
3813 : break;
3814 : }
3815 90 : default:;
3816 : }
3817 90 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
3818 : {
3819 0 : {
3820 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q21 };
3821 0 : tree res = generic_simplify_7 (loc, type, _p0, _p1, captures);
3822 0 : if (res) return res;
3823 : }
3824 : }
3825 : break;
3826 : }
3827 3380 : default:;
3828 : }
3829 3380 : switch (TREE_CODE (_q21))
3830 : {
3831 41 : case BIT_NOT_EXPR:
3832 41 : {
3833 41 : tree _q40 = TREE_OPERAND (_q21, 0);
3834 41 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
3835 : {
3836 0 : {
3837 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q20 };
3838 0 : tree res = generic_simplify_7 (loc, type, _p0, _p1, captures);
3839 0 : if (res) return res;
3840 : }
3841 : }
3842 : break;
3843 : }
3844 : default:;
3845 : }
3846 : break;
3847 : }
3848 505 : case BIT_NOT_EXPR:
3849 505 : {
3850 505 : tree _q20 = TREE_OPERAND (_p0, 0);
3851 505 : switch (TREE_CODE (_p1))
3852 : {
3853 51 : case BIT_AND_EXPR:
3854 51 : {
3855 51 : tree _q40 = TREE_OPERAND (_p1, 0);
3856 51 : tree _q41 = TREE_OPERAND (_p1, 1);
3857 51 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
3858 : {
3859 0 : switch (TREE_CODE (_q41))
3860 : {
3861 0 : case BIT_NOT_EXPR:
3862 0 : {
3863 0 : tree _q60 = TREE_OPERAND (_q41, 0);
3864 0 : {
3865 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q20, _q60 };
3866 0 : tree res = generic_simplify_6 (loc, type, _p0, _p1, captures);
3867 0 : if (res) return res;
3868 : }
3869 0 : break;
3870 : }
3871 : default:;
3872 : }
3873 : }
3874 51 : switch (TREE_CODE (_q40))
3875 : {
3876 7 : case BIT_NOT_EXPR:
3877 7 : {
3878 7 : tree _q50 = TREE_OPERAND (_q40, 0);
3879 7 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
3880 : {
3881 0 : {
3882 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q20, _q50 };
3883 0 : tree res = generic_simplify_6 (loc, type, _p0, _p1, captures);
3884 0 : if (res) return res;
3885 : }
3886 : }
3887 : break;
3888 : }
3889 : default:;
3890 : }
3891 : break;
3892 : }
3893 : default:;
3894 : }
3895 : break;
3896 : }
3897 997936 : default:;
3898 : }
3899 997936 : switch (TREE_CODE (_p1))
3900 : {
3901 789 : case BIT_AND_EXPR:
3902 789 : {
3903 789 : tree _q30 = TREE_OPERAND (_p1, 0);
3904 789 : tree _q31 = TREE_OPERAND (_p1, 1);
3905 789 : switch (TREE_CODE (_q30))
3906 : {
3907 57 : case BIT_NOT_EXPR:
3908 57 : {
3909 57 : tree _q40 = TREE_OPERAND (_q30, 0);
3910 57 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
3911 : {
3912 0 : {
3913 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q31 };
3914 0 : tree res = generic_simplify_7 (loc, type, _p0, _p1, captures);
3915 0 : if (res) return res;
3916 : }
3917 : }
3918 : break;
3919 : }
3920 789 : default:;
3921 : }
3922 789 : switch (TREE_CODE (_q31))
3923 : {
3924 8 : case BIT_NOT_EXPR:
3925 8 : {
3926 8 : tree _q50 = TREE_OPERAND (_q31, 0);
3927 8 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
3928 : {
3929 0 : {
3930 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q30 };
3931 0 : tree res = generic_simplify_7 (loc, type, _p0, _p1, captures);
3932 0 : if (res) return res;
3933 : }
3934 : }
3935 : break;
3936 : }
3937 : default:;
3938 : }
3939 : break;
3940 : }
3941 997936 : default:;
3942 : }
3943 997936 : switch (TREE_CODE (_p0))
3944 : {
3945 21587 : case PLUS_EXPR:
3946 21587 : {
3947 21587 : tree _q20 = TREE_OPERAND (_p0, 0);
3948 21587 : tree _q21 = TREE_OPERAND (_p0, 1);
3949 21587 : if (integer_minus_onep (_q21))
3950 : {
3951 10450 : switch (TREE_CODE (_p1))
3952 : {
3953 11 : case NEGATE_EXPR:
3954 11 : {
3955 11 : tree _q50 = TREE_OPERAND (_p1, 0);
3956 11 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
3957 : {
3958 11 : {
3959 11 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3960 11 : tree res = generic_simplify_8 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3961 11 : if (res) return res;
3962 : }
3963 : }
3964 : break;
3965 : }
3966 : default:;
3967 : }
3968 : }
3969 : break;
3970 : }
3971 142 : case NEGATE_EXPR:
3972 142 : {
3973 142 : tree _q20 = TREE_OPERAND (_p0, 0);
3974 142 : switch (TREE_CODE (_p1))
3975 : {
3976 0 : case PLUS_EXPR:
3977 0 : {
3978 0 : tree _q40 = TREE_OPERAND (_p1, 0);
3979 0 : tree _q41 = TREE_OPERAND (_p1, 1);
3980 0 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
3981 : {
3982 0 : if (integer_minus_onep (_q41))
3983 : {
3984 0 : {
3985 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3986 0 : tree res = generic_simplify_9 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3987 0 : if (res) return res;
3988 : }
3989 : }
3990 : }
3991 : break;
3992 : }
3993 0 : case MINUS_EXPR:
3994 0 : {
3995 0 : tree _q40 = TREE_OPERAND (_p1, 0);
3996 0 : tree _q41 = TREE_OPERAND (_p1, 1);
3997 0 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
3998 : {
3999 0 : if (integer_onep (_q41))
4000 : {
4001 0 : {
4002 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4003 0 : tree res = generic_simplify_10 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4004 0 : if (res) return res;
4005 : }
4006 : }
4007 : }
4008 : break;
4009 : }
4010 : default:;
4011 : }
4012 : break;
4013 : }
4014 102 : case MINUS_EXPR:
4015 102 : {
4016 102 : tree _q20 = TREE_OPERAND (_p0, 0);
4017 102 : tree _q21 = TREE_OPERAND (_p0, 1);
4018 102 : if (integer_onep (_q21))
4019 : {
4020 0 : switch (TREE_CODE (_p1))
4021 : {
4022 0 : case NEGATE_EXPR:
4023 0 : {
4024 0 : tree _q50 = TREE_OPERAND (_p1, 0);
4025 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4026 : {
4027 0 : {
4028 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4029 0 : tree res = generic_simplify_11 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4030 0 : if (res) return res;
4031 : }
4032 : }
4033 : break;
4034 : }
4035 : default:;
4036 : }
4037 : }
4038 : break;
4039 : }
4040 1310 : case BIT_IOR_EXPR:
4041 1310 : {
4042 1310 : tree _q20 = TREE_OPERAND (_p0, 0);
4043 1310 : tree _q21 = TREE_OPERAND (_p0, 1);
4044 1310 : switch (TREE_CODE (_p1))
4045 : {
4046 65 : case BIT_AND_EXPR:
4047 65 : {
4048 65 : tree _q50 = TREE_OPERAND (_p1, 0);
4049 65 : tree _q51 = TREE_OPERAND (_p1, 1);
4050 65 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4051 : {
4052 15 : {
4053 15 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4054 15 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4055 15 : if (res) return res;
4056 : }
4057 : }
4058 65 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4059 : {
4060 12 : {
4061 12 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
4062 12 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4063 12 : if (res) return res;
4064 : }
4065 : }
4066 65 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4067 : {
4068 3 : {
4069 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
4070 3 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4071 3 : if (res) return res;
4072 : }
4073 : }
4074 65 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4075 : {
4076 6 : {
4077 6 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
4078 6 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4079 6 : if (res) return res;
4080 : }
4081 : }
4082 : break;
4083 : }
4084 1310 : default:;
4085 : }
4086 1310 : switch (TREE_CODE (_q20))
4087 : {
4088 481 : case BIT_NOT_EXPR:
4089 481 : {
4090 481 : tree _q30 = TREE_OPERAND (_q20, 0);
4091 481 : {
4092 481 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _p1 };
4093 481 : tree res = generic_simplify_13 (loc, type, _p0, _p1, captures);
4094 481 : if (res) return res;
4095 : }
4096 480 : break;
4097 : }
4098 1309 : default:;
4099 : }
4100 1309 : switch (TREE_CODE (_q21))
4101 : {
4102 62 : case BIT_NOT_EXPR:
4103 62 : {
4104 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4105 62 : {
4106 62 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20, _p1 };
4107 62 : tree res = generic_simplify_13 (loc, type, _p0, _p1, captures);
4108 62 : if (res) return res;
4109 : }
4110 62 : break;
4111 : }
4112 : default:;
4113 : }
4114 : break;
4115 : }
4116 3380 : case BIT_AND_EXPR:
4117 3380 : {
4118 3380 : tree _q20 = TREE_OPERAND (_p0, 0);
4119 3380 : tree _q21 = TREE_OPERAND (_p0, 1);
4120 3380 : switch (TREE_CODE (_p1))
4121 : {
4122 74 : case BIT_IOR_EXPR:
4123 74 : {
4124 74 : tree _q50 = TREE_OPERAND (_p1, 0);
4125 74 : tree _q51 = TREE_OPERAND (_p1, 1);
4126 74 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4127 : {
4128 18 : {
4129 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q21, _q20 };
4130 18 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4131 18 : if (res) return res;
4132 : }
4133 : }
4134 74 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4135 : {
4136 9 : {
4137 9 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q20, _q21 };
4138 9 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4139 9 : if (res) return res;
4140 : }
4141 : }
4142 74 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4143 : {
4144 9 : {
4145 9 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q21, _q20 };
4146 9 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4147 9 : if (res) return res;
4148 : }
4149 : }
4150 74 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4151 : {
4152 18 : {
4153 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q20, _q21 };
4154 18 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4155 18 : if (res) return res;
4156 : }
4157 : }
4158 : break;
4159 : }
4160 : default:;
4161 : }
4162 : break;
4163 : }
4164 997924 : default:;
4165 : }
4166 997924 : switch (TREE_CODE (_p1))
4167 : {
4168 521 : case BIT_IOR_EXPR:
4169 521 : {
4170 521 : tree _q30 = TREE_OPERAND (_p1, 0);
4171 521 : tree _q31 = TREE_OPERAND (_p1, 1);
4172 521 : switch (TREE_CODE (_q30))
4173 : {
4174 21 : case BIT_NOT_EXPR:
4175 21 : {
4176 21 : tree _q40 = TREE_OPERAND (_q30, 0);
4177 21 : {
4178 21 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _q31, _p0 };
4179 21 : tree res = generic_simplify_13 (loc, type, _p0, _p1, captures);
4180 21 : if (res) return res;
4181 : }
4182 21 : break;
4183 : }
4184 521 : default:;
4185 : }
4186 521 : switch (TREE_CODE (_q31))
4187 : {
4188 25 : case BIT_NOT_EXPR:
4189 25 : {
4190 25 : tree _q50 = TREE_OPERAND (_q31, 0);
4191 25 : {
4192 25 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q31, _q50, _q30, _p0 };
4193 25 : tree res = generic_simplify_13 (loc, type, _p0, _p1, captures);
4194 25 : if (res) return res;
4195 : }
4196 25 : break;
4197 : }
4198 : default:;
4199 : }
4200 : break;
4201 : }
4202 997924 : default:;
4203 : }
4204 997924 : switch (TREE_CODE (_p0))
4205 : {
4206 3380 : case BIT_AND_EXPR:
4207 3380 : {
4208 3380 : tree _q20 = TREE_OPERAND (_p0, 0);
4209 3380 : tree _q21 = TREE_OPERAND (_p0, 1);
4210 3380 : switch (TREE_CODE (_q20))
4211 : {
4212 90 : case BIT_NOT_EXPR:
4213 90 : {
4214 90 : tree _q30 = TREE_OPERAND (_q20, 0);
4215 90 : {
4216 90 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _p1 };
4217 90 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures);
4218 90 : if (res) return res;
4219 : }
4220 89 : break;
4221 : }
4222 3379 : default:;
4223 : }
4224 3379 : switch (TREE_CODE (_q21))
4225 : {
4226 41 : case BIT_NOT_EXPR:
4227 41 : {
4228 41 : tree _q40 = TREE_OPERAND (_q21, 0);
4229 41 : {
4230 41 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20, _p1 };
4231 41 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures);
4232 41 : if (res) return res;
4233 : }
4234 41 : break;
4235 : }
4236 : default:;
4237 : }
4238 : break;
4239 : }
4240 997923 : default:;
4241 : }
4242 997923 : switch (TREE_CODE (_p1))
4243 : {
4244 789 : case BIT_AND_EXPR:
4245 789 : {
4246 789 : tree _q30 = TREE_OPERAND (_p1, 0);
4247 789 : tree _q31 = TREE_OPERAND (_p1, 1);
4248 789 : switch (TREE_CODE (_q30))
4249 : {
4250 57 : case BIT_NOT_EXPR:
4251 57 : {
4252 57 : tree _q40 = TREE_OPERAND (_q30, 0);
4253 57 : {
4254 57 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _q31, _p0 };
4255 57 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures);
4256 57 : if (res) return res;
4257 : }
4258 57 : break;
4259 : }
4260 789 : default:;
4261 : }
4262 789 : switch (TREE_CODE (_q31))
4263 : {
4264 8 : case BIT_NOT_EXPR:
4265 8 : {
4266 8 : tree _q50 = TREE_OPERAND (_q31, 0);
4267 8 : {
4268 8 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q31, _q50, _q30, _p0 };
4269 8 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures);
4270 8 : if (res) return res;
4271 : }
4272 8 : break;
4273 : }
4274 : default:;
4275 : }
4276 : break;
4277 : }
4278 997923 : default:;
4279 : }
4280 997923 : switch (TREE_CODE (_p0))
4281 : {
4282 635772 : CASE_CONVERT:
4283 635772 : {
4284 635772 : tree _q20 = TREE_OPERAND (_p0, 0);
4285 635772 : switch (TREE_CODE (_p1))
4286 : {
4287 631555 : CASE_CONVERT:
4288 631555 : {
4289 631555 : tree _q40 = TREE_OPERAND (_p1, 0);
4290 631555 : {
4291 631555 : tree _q40_pops[1];
4292 631555 : if (tree_maybe_bit_not (_q40, _q40_pops))
4293 : {
4294 0 : tree _q50 = _q40_pops[0];
4295 0 : {
4296 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
4297 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4298 0 : if (res) return res;
4299 : }
4300 : }
4301 : }
4302 631555 : break;
4303 : }
4304 635772 : default:;
4305 : }
4306 635772 : {
4307 635772 : tree _q20_pops[1];
4308 635772 : if (tree_maybe_bit_not (_q20, _q20_pops))
4309 : {
4310 60485 : tree _q30 = _q20_pops[0];
4311 60485 : switch (TREE_CODE (_p1))
4312 : {
4313 60435 : CASE_CONVERT:
4314 60435 : {
4315 60435 : tree _q50 = TREE_OPERAND (_p1, 0);
4316 60435 : {
4317 60435 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
4318 60435 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4319 60435 : if (res) return res;
4320 : }
4321 60435 : break;
4322 : }
4323 : default:;
4324 : }
4325 : }
4326 : }
4327 635772 : break;
4328 : }
4329 997923 : default:;
4330 : }
4331 997923 : {
4332 997923 : tree _p1_pops[1];
4333 997923 : if (tree_maybe_bit_not (_p1, _p1_pops))
4334 : {
4335 9341 : tree _q30 = _p1_pops[0];
4336 9341 : {
4337 9341 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
4338 9341 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4339 9341 : if (res) return res;
4340 : }
4341 : }
4342 : }
4343 997923 : {
4344 997923 : tree _p0_pops[1];
4345 997923 : if (tree_maybe_bit_not (_p0, _p0_pops))
4346 : {
4347 1052 : tree _q20 = _p0_pops[0];
4348 1052 : {
4349 1052 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _q20 };
4350 1052 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4351 1052 : if (res) return res;
4352 : }
4353 : }
4354 : }
4355 997902 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
4356 : {
4357 149 : {
4358 149 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4359 149 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1163;
4360 149 : {
4361 149 : tree _r;
4362 149 : _r = build_zero_cst (type);
4363 149 : if (TREE_SIDE_EFFECTS (captures[0]))
4364 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4365 149 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 887, __FILE__, __LINE__, true);
4366 149 : return _r;
4367 : }
4368 0 : next_after_fail1163:;
4369 : }
4370 : }
4371 997753 : if (integer_all_onesp (_p1))
4372 : {
4373 1080 : {
4374 1080 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4375 1080 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1164;
4376 1080 : {
4377 1080 : tree res_op0;
4378 1080 : res_op0 = captures[0];
4379 1080 : tree _r;
4380 1080 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
4381 1080 : if (TREE_SIDE_EFFECTS (captures[1]))
4382 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4383 1080 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 888, __FILE__, __LINE__, true);
4384 1080 : return _r;
4385 : }
4386 0 : next_after_fail1164:;
4387 : }
4388 : }
4389 996673 : switch (TREE_CODE (_p0))
4390 : {
4391 1302 : case BIT_IOR_EXPR:
4392 1302 : {
4393 1302 : tree _q20 = TREE_OPERAND (_p0, 0);
4394 1302 : tree _q21 = TREE_OPERAND (_p0, 1);
4395 1302 : switch (TREE_CODE (_p1))
4396 : {
4397 179 : case BIT_IOR_EXPR:
4398 179 : {
4399 179 : tree _q50 = TREE_OPERAND (_p1, 0);
4400 179 : tree _q51 = TREE_OPERAND (_p1, 1);
4401 179 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4402 : {
4403 0 : switch (TREE_CODE (_q51))
4404 : {
4405 0 : case BIT_NOT_EXPR:
4406 0 : {
4407 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4408 0 : if ((_q70 == _q21 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q21, 0) && types_match (_q70, _q21)))
4409 : {
4410 0 : {
4411 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4412 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4413 0 : if (res) return res;
4414 : }
4415 : }
4416 : break;
4417 : }
4418 : default:;
4419 : }
4420 : }
4421 179 : switch (TREE_CODE (_q50))
4422 : {
4423 20 : case BIT_NOT_EXPR:
4424 20 : {
4425 20 : tree _q60 = TREE_OPERAND (_q50, 0);
4426 20 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
4427 : {
4428 2 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4429 : {
4430 1 : {
4431 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4432 1 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4433 1 : if (res) return res;
4434 : }
4435 : }
4436 : }
4437 19 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4438 : {
4439 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4440 : {
4441 0 : {
4442 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
4443 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4444 0 : if (res) return res;
4445 : }
4446 : }
4447 : }
4448 : break;
4449 : }
4450 178 : default:;
4451 : }
4452 178 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4453 : {
4454 0 : switch (TREE_CODE (_q51))
4455 : {
4456 0 : case BIT_NOT_EXPR:
4457 0 : {
4458 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4459 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4460 : {
4461 0 : {
4462 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
4463 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4464 0 : if (res) return res;
4465 : }
4466 : }
4467 : break;
4468 : }
4469 : default:;
4470 : }
4471 : }
4472 : break;
4473 : }
4474 1301 : default:;
4475 : }
4476 1301 : switch (TREE_CODE (_q21))
4477 : {
4478 62 : case BIT_NOT_EXPR:
4479 62 : {
4480 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4481 62 : switch (TREE_CODE (_p1))
4482 : {
4483 9 : case BIT_IOR_EXPR:
4484 9 : {
4485 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4486 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4487 9 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4488 : {
4489 0 : if ((_q61 == _q40 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q40, 0) && types_match (_q61, _q40)))
4490 : {
4491 0 : {
4492 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
4493 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4494 0 : if (res) return res;
4495 : }
4496 : }
4497 : }
4498 : break;
4499 : }
4500 : default:;
4501 : }
4502 : break;
4503 : }
4504 1301 : default:;
4505 : }
4506 1301 : switch (TREE_CODE (_q20))
4507 : {
4508 480 : case BIT_NOT_EXPR:
4509 480 : {
4510 480 : tree _q30 = TREE_OPERAND (_q20, 0);
4511 480 : switch (TREE_CODE (_p1))
4512 : {
4513 28 : case BIT_IOR_EXPR:
4514 28 : {
4515 28 : tree _q60 = TREE_OPERAND (_p1, 0);
4516 28 : tree _q61 = TREE_OPERAND (_p1, 1);
4517 28 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
4518 : {
4519 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
4520 : {
4521 0 : {
4522 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q30 };
4523 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4524 0 : if (res) return res;
4525 : }
4526 : }
4527 : }
4528 28 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
4529 : {
4530 9 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
4531 : {
4532 0 : {
4533 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q30 };
4534 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4535 0 : if (res) return res;
4536 : }
4537 : }
4538 9 : switch (TREE_CODE (_q61))
4539 : {
4540 0 : case BIT_NOT_EXPR:
4541 0 : {
4542 0 : tree _q80 = TREE_OPERAND (_q61, 0);
4543 0 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
4544 : {
4545 0 : {
4546 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q21 };
4547 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
4548 0 : if (res) return res;
4549 : }
4550 : }
4551 : break;
4552 : }
4553 : default:;
4554 : }
4555 : }
4556 28 : switch (TREE_CODE (_q60))
4557 : {
4558 1 : case BIT_NOT_EXPR:
4559 1 : {
4560 1 : tree _q70 = TREE_OPERAND (_q60, 0);
4561 1 : if ((_q70 == _q21 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q21, 0) && types_match (_q70, _q21)))
4562 : {
4563 1 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
4564 : {
4565 1 : {
4566 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q21 };
4567 1 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
4568 1 : if (res) return res;
4569 : }
4570 : }
4571 : }
4572 : break;
4573 : }
4574 : default:;
4575 : }
4576 : break;
4577 : }
4578 9 : case BIT_XOR_EXPR:
4579 9 : {
4580 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4581 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4582 9 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
4583 : {
4584 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
4585 : {
4586 0 : {
4587 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q21, _p1 };
4588 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
4589 0 : if (res) return res;
4590 : }
4591 : }
4592 : }
4593 : break;
4594 : }
4595 479 : default:;
4596 : }
4597 479 : {
4598 479 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q21, _p1 };
4599 479 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
4600 479 : if (res) return res;
4601 : }
4602 431 : break;
4603 : }
4604 1252 : default:;
4605 : }
4606 1252 : switch (TREE_CODE (_q21))
4607 : {
4608 62 : case BIT_NOT_EXPR:
4609 62 : {
4610 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4611 62 : switch (TREE_CODE (_p1))
4612 : {
4613 9 : case BIT_IOR_EXPR:
4614 9 : {
4615 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4616 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4617 9 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
4618 : {
4619 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
4620 : {
4621 0 : {
4622 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
4623 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4624 0 : if (res) return res;
4625 : }
4626 : }
4627 : }
4628 : break;
4629 : }
4630 9 : case BIT_XOR_EXPR:
4631 9 : {
4632 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4633 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4634 9 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
4635 : {
4636 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
4637 : {
4638 0 : {
4639 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q40, _q20, _p1 };
4640 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
4641 0 : if (res) return res;
4642 : }
4643 : }
4644 : }
4645 : break;
4646 : }
4647 : default:;
4648 : }
4649 : break;
4650 : }
4651 1252 : default:;
4652 : }
4653 1252 : switch (TREE_CODE (_p1))
4654 : {
4655 65 : case BIT_AND_EXPR:
4656 65 : {
4657 65 : tree _q50 = TREE_OPERAND (_p1, 0);
4658 65 : tree _q51 = TREE_OPERAND (_p1, 1);
4659 65 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4660 : {
4661 6 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4662 : {
4663 0 : {
4664 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4665 0 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
4666 0 : if (res) return res;
4667 : }
4668 : }
4669 : }
4670 : break;
4671 : }
4672 36 : case BIT_XOR_EXPR:
4673 36 : {
4674 36 : tree _q50 = TREE_OPERAND (_p1, 0);
4675 36 : tree _q51 = TREE_OPERAND (_p1, 1);
4676 36 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4677 : {
4678 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4679 : {
4680 0 : {
4681 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4682 0 : tree res = generic_simplify_21 (loc, type, _p0, _p1, captures);
4683 0 : if (res) return res;
4684 : }
4685 : }
4686 : }
4687 : break;
4688 : }
4689 1252 : default:;
4690 : }
4691 1252 : switch (TREE_CODE (_q21))
4692 : {
4693 62 : case BIT_NOT_EXPR:
4694 62 : {
4695 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4696 62 : switch (TREE_CODE (_p1))
4697 : {
4698 9 : case BIT_IOR_EXPR:
4699 9 : {
4700 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4701 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4702 9 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
4703 : {
4704 0 : switch (TREE_CODE (_q61))
4705 : {
4706 0 : case BIT_NOT_EXPR:
4707 0 : {
4708 0 : tree _q80 = TREE_OPERAND (_q61, 0);
4709 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
4710 : {
4711 0 : {
4712 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
4713 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
4714 0 : if (res) return res;
4715 : }
4716 : }
4717 : break;
4718 : }
4719 : default:;
4720 : }
4721 : }
4722 9 : switch (TREE_CODE (_q60))
4723 : {
4724 0 : case BIT_NOT_EXPR:
4725 0 : {
4726 0 : tree _q70 = TREE_OPERAND (_q60, 0);
4727 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4728 : {
4729 0 : if ((_q61 == _q40 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q40, 0) && types_match (_q61, _q40)))
4730 : {
4731 0 : {
4732 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
4733 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
4734 0 : if (res) return res;
4735 : }
4736 : }
4737 : }
4738 : break;
4739 : }
4740 : default:;
4741 : }
4742 : break;
4743 : }
4744 : default:;
4745 : }
4746 : break;
4747 : }
4748 1252 : default:;
4749 : }
4750 1252 : switch (TREE_CODE (_p1))
4751 : {
4752 24 : CASE_CONVERT:
4753 24 : {
4754 24 : tree _q50 = TREE_OPERAND (_p1, 0);
4755 24 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
4756 : {
4757 0 : {
4758 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q20 };
4759 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
4760 0 : if (res) return res;
4761 : }
4762 : }
4763 24 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q21, 0))
4764 : {
4765 0 : {
4766 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q21 };
4767 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
4768 0 : if (res) return res;
4769 : }
4770 : }
4771 : break;
4772 : }
4773 1252 : default:;
4774 : }
4775 1252 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q20, 0))
4776 : {
4777 3 : {
4778 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q20 };
4779 3 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
4780 3 : if (res) return res;
4781 : }
4782 : }
4783 1249 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q21, 0))
4784 : {
4785 3 : {
4786 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q21 };
4787 3 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
4788 3 : if (res) return res;
4789 : }
4790 : }
4791 1246 : {
4792 1246 : tree _q20_pops[1];
4793 1246 : if (tree_nop_convert (_q20, _q20_pops))
4794 : {
4795 8 : tree _q30 = _q20_pops[0];
4796 8 : switch (TREE_CODE (_q30))
4797 : {
4798 8 : case BIT_NOT_EXPR:
4799 8 : {
4800 8 : tree _q40 = TREE_OPERAND (_q30, 0);
4801 8 : {
4802 8 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q21, _p1 };
4803 8 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
4804 8 : if (res) return res;
4805 : }
4806 0 : break;
4807 : }
4808 : default:;
4809 : }
4810 : }
4811 : }
4812 1238 : switch (TREE_CODE (_q21))
4813 : {
4814 62 : case BIT_NOT_EXPR:
4815 62 : {
4816 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4817 62 : {
4818 62 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q20, _p1 };
4819 62 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
4820 62 : if (res) return res;
4821 : }
4822 54 : break;
4823 : }
4824 1230 : default:;
4825 : }
4826 1230 : {
4827 1230 : tree _q21_pops[1];
4828 1230 : if (tree_nop_convert (_q21, _q21_pops))
4829 : {
4830 0 : tree _q40 = _q21_pops[0];
4831 0 : switch (TREE_CODE (_q40))
4832 : {
4833 0 : case BIT_NOT_EXPR:
4834 0 : {
4835 0 : tree _q50 = TREE_OPERAND (_q40, 0);
4836 0 : {
4837 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q20, _p1 };
4838 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
4839 0 : if (res) return res;
4840 : }
4841 0 : break;
4842 : }
4843 : default:;
4844 : }
4845 : }
4846 : }
4847 1230 : break;
4848 : }
4849 3935 : case BIT_XOR_EXPR:
4850 3935 : {
4851 3935 : tree _q20 = TREE_OPERAND (_p0, 0);
4852 3935 : tree _q21 = TREE_OPERAND (_p0, 1);
4853 3935 : switch (TREE_CODE (_p1))
4854 : {
4855 203 : case BIT_IOR_EXPR:
4856 203 : {
4857 203 : tree _q50 = TREE_OPERAND (_p1, 0);
4858 203 : tree _q51 = TREE_OPERAND (_p1, 1);
4859 203 : switch (TREE_CODE (_q50))
4860 : {
4861 1 : case BIT_NOT_EXPR:
4862 1 : {
4863 1 : tree _q60 = TREE_OPERAND (_q50, 0);
4864 1 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4865 : {
4866 1 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4867 : {
4868 1 : {
4869 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q20, _q21, _p0 };
4870 1 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
4871 1 : if (res) return res;
4872 : }
4873 : }
4874 : }
4875 : break;
4876 : }
4877 202 : default:;
4878 : }
4879 202 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4880 : {
4881 0 : switch (TREE_CODE (_q51))
4882 : {
4883 0 : case BIT_NOT_EXPR:
4884 0 : {
4885 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4886 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4887 : {
4888 0 : {
4889 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q20, _q21, _p0 };
4890 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
4891 0 : if (res) return res;
4892 : }
4893 : }
4894 : break;
4895 : }
4896 : default:;
4897 : }
4898 : }
4899 202 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4900 : {
4901 1 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4902 : {
4903 0 : {
4904 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4905 0 : tree res = generic_simplify_21 (loc, type, _p0, _p1, captures);
4906 0 : if (res) return res;
4907 : }
4908 : }
4909 : }
4910 : break;
4911 : }
4912 41 : case BIT_AND_EXPR:
4913 41 : {
4914 41 : tree _q50 = TREE_OPERAND (_p1, 0);
4915 41 : tree _q51 = TREE_OPERAND (_p1, 1);
4916 41 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4917 : {
4918 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4919 : {
4920 0 : {
4921 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4922 0 : tree res = generic_simplify_23 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4923 0 : if (res) return res;
4924 : }
4925 : }
4926 : }
4927 : break;
4928 : }
4929 198 : CASE_CONVERT:
4930 198 : {
4931 198 : tree _q50 = TREE_OPERAND (_p1, 0);
4932 198 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q21, 0))
4933 : {
4934 0 : {
4935 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q21 };
4936 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
4937 0 : if (res) return res;
4938 : }
4939 : }
4940 198 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
4941 : {
4942 0 : {
4943 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q20 };
4944 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
4945 0 : if (res) return res;
4946 : }
4947 : }
4948 : break;
4949 : }
4950 3934 : default:;
4951 : }
4952 3934 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q21, 0))
4953 : {
4954 0 : {
4955 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q21 };
4956 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
4957 0 : if (res) return res;
4958 : }
4959 : }
4960 3934 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q20, 0))
4961 : {
4962 11 : {
4963 11 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q20 };
4964 11 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
4965 11 : if (res) return res;
4966 : }
4967 : }
4968 : break;
4969 : }
4970 3379 : case BIT_AND_EXPR:
4971 3379 : {
4972 3379 : tree _q20 = TREE_OPERAND (_p0, 0);
4973 3379 : tree _q21 = TREE_OPERAND (_p0, 1);
4974 3379 : switch (TREE_CODE (_p1))
4975 : {
4976 74 : case BIT_IOR_EXPR:
4977 74 : {
4978 74 : tree _q50 = TREE_OPERAND (_p1, 0);
4979 74 : tree _q51 = TREE_OPERAND (_p1, 1);
4980 74 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4981 : {
4982 18 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4983 : {
4984 0 : {
4985 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4986 0 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
4987 0 : if (res) return res;
4988 : }
4989 : }
4990 : }
4991 : break;
4992 : }
4993 30 : case BIT_XOR_EXPR:
4994 30 : {
4995 30 : tree _q50 = TREE_OPERAND (_p1, 0);
4996 30 : tree _q51 = TREE_OPERAND (_p1, 1);
4997 30 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4998 : {
4999 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5000 : {
5001 0 : {
5002 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5003 0 : tree res = generic_simplify_23 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5004 0 : if (res) return res;
5005 : }
5006 : }
5007 : }
5008 : break;
5009 : }
5010 3379 : default:;
5011 : }
5012 3379 : switch (TREE_CODE (_q21))
5013 : {
5014 1554 : case INTEGER_CST:
5015 1554 : {
5016 1554 : switch (TREE_CODE (_p1))
5017 : {
5018 15 : CASE_CONVERT:
5019 15 : {
5020 15 : tree _q50 = TREE_OPERAND (_p1, 0);
5021 15 : switch (TREE_CODE (_q50))
5022 : {
5023 0 : case BIT_AND_EXPR:
5024 0 : {
5025 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5026 0 : tree _q61 = TREE_OPERAND (_q50, 1);
5027 0 : switch (TREE_CODE (_q61))
5028 : {
5029 0 : case INTEGER_CST:
5030 0 : {
5031 0 : {
5032 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50, _q60, _q61 };
5033 0 : tree res = generic_simplify_25 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5034 0 : if (res) return res;
5035 : }
5036 0 : break;
5037 : }
5038 : default:;
5039 : }
5040 : break;
5041 : }
5042 : default:;
5043 : }
5044 : break;
5045 : }
5046 210 : case BIT_AND_EXPR:
5047 210 : {
5048 210 : tree _q50 = TREE_OPERAND (_p1, 0);
5049 210 : tree _q51 = TREE_OPERAND (_p1, 1);
5050 210 : switch (TREE_CODE (_q51))
5051 : {
5052 210 : case INTEGER_CST:
5053 210 : {
5054 210 : {
5055 210 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50, _q51 };
5056 210 : tree res = generic_simplify_25 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5057 210 : if (res) return res;
5058 : }
5059 209 : break;
5060 : }
5061 : default:;
5062 : }
5063 : break;
5064 : }
5065 : default:;
5066 : }
5067 : break;
5068 : }
5069 : default:;
5070 : }
5071 : break;
5072 : }
5073 635615 : CASE_CONVERT:
5074 635615 : {
5075 635615 : tree _q20 = TREE_OPERAND (_p0, 0);
5076 635615 : switch (TREE_CODE (_q20))
5077 : {
5078 24 : case BIT_AND_EXPR:
5079 24 : {
5080 24 : tree _q30 = TREE_OPERAND (_q20, 0);
5081 24 : tree _q31 = TREE_OPERAND (_q20, 1);
5082 24 : switch (TREE_CODE (_q31))
5083 : {
5084 0 : case INTEGER_CST:
5085 0 : {
5086 0 : switch (TREE_CODE (_p1))
5087 : {
5088 0 : CASE_CONVERT:
5089 0 : {
5090 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5091 0 : switch (TREE_CODE (_q60))
5092 : {
5093 0 : case BIT_AND_EXPR:
5094 0 : {
5095 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5096 0 : tree _q71 = TREE_OPERAND (_q60, 1);
5097 0 : switch (TREE_CODE (_q71))
5098 : {
5099 0 : case INTEGER_CST:
5100 0 : {
5101 0 : {
5102 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q60, _q70, _q71 };
5103 0 : tree res = generic_simplify_25 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5104 0 : if (res) return res;
5105 : }
5106 0 : break;
5107 : }
5108 : default:;
5109 : }
5110 : break;
5111 : }
5112 : default:;
5113 : }
5114 : break;
5115 : }
5116 0 : case BIT_AND_EXPR:
5117 0 : {
5118 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5119 0 : tree _q61 = TREE_OPERAND (_p1, 1);
5120 0 : switch (TREE_CODE (_q61))
5121 : {
5122 0 : case INTEGER_CST:
5123 0 : {
5124 0 : {
5125 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _p1, _q60, _q61 };
5126 0 : tree res = generic_simplify_25 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5127 0 : if (res) return res;
5128 : }
5129 0 : break;
5130 : }
5131 : default:;
5132 : }
5133 : break;
5134 : }
5135 : default:;
5136 : }
5137 : break;
5138 : }
5139 : default:;
5140 : }
5141 : break;
5142 : }
5143 24 : case BIT_IOR_EXPR:
5144 24 : {
5145 24 : tree _q30 = TREE_OPERAND (_q20, 0);
5146 24 : tree _q31 = TREE_OPERAND (_q20, 1);
5147 24 : switch (TREE_CODE (_p1))
5148 : {
5149 16 : CASE_CONVERT:
5150 16 : {
5151 16 : tree _q60 = TREE_OPERAND (_p1, 0);
5152 16 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q30, 0))
5153 : {
5154 0 : {
5155 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q30 };
5156 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5157 0 : if (res) return res;
5158 : }
5159 : }
5160 16 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q31, 0))
5161 : {
5162 0 : {
5163 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q31 };
5164 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5165 0 : if (res) return res;
5166 : }
5167 : }
5168 : break;
5169 : }
5170 24 : default:;
5171 : }
5172 24 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q30, 0))
5173 : {
5174 0 : {
5175 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q30 };
5176 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5177 0 : if (res) return res;
5178 : }
5179 : }
5180 24 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q31, 0))
5181 : {
5182 0 : {
5183 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q31 };
5184 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5185 0 : if (res) return res;
5186 : }
5187 : }
5188 : break;
5189 : }
5190 635615 : default:;
5191 : }
5192 635615 : switch (TREE_CODE (_p1))
5193 : {
5194 631548 : CASE_CONVERT:
5195 631548 : {
5196 631548 : tree _q40 = TREE_OPERAND (_p1, 0);
5197 631548 : switch (TREE_CODE (_q40))
5198 : {
5199 0 : case BIT_IOR_EXPR:
5200 0 : {
5201 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5202 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5203 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
5204 : {
5205 0 : {
5206 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
5207 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5208 0 : if (res) return res;
5209 : }
5210 : }
5211 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
5212 : {
5213 0 : {
5214 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q50, _q20 };
5215 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5216 0 : if (res) return res;
5217 : }
5218 : }
5219 : break;
5220 : }
5221 : default:;
5222 : }
5223 : break;
5224 : }
5225 26 : case BIT_IOR_EXPR:
5226 26 : {
5227 26 : tree _q40 = TREE_OPERAND (_p1, 0);
5228 26 : tree _q41 = TREE_OPERAND (_p1, 1);
5229 26 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _q20, 0))
5230 : {
5231 0 : {
5232 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q20 };
5233 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5234 0 : if (res) return res;
5235 : }
5236 : }
5237 26 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _q20, 0))
5238 : {
5239 0 : {
5240 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q20 };
5241 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5242 0 : if (res) return res;
5243 : }
5244 : }
5245 : break;
5246 : }
5247 : default:;
5248 : }
5249 : break;
5250 : }
5251 996588 : default:;
5252 : }
5253 996588 : switch (TREE_CODE (_p1))
5254 : {
5255 760758 : CASE_CONVERT:
5256 760758 : {
5257 760758 : tree _q30 = TREE_OPERAND (_p1, 0);
5258 760758 : switch (TREE_CODE (_q30))
5259 : {
5260 6 : case BIT_IOR_EXPR:
5261 6 : {
5262 6 : tree _q40 = TREE_OPERAND (_q30, 0);
5263 6 : tree _q41 = TREE_OPERAND (_q30, 1);
5264 6 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _p0, 0))
5265 : {
5266 0 : {
5267 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _p0 };
5268 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5269 0 : if (res) return res;
5270 : }
5271 : }
5272 6 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _p0, 0))
5273 : {
5274 0 : {
5275 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _p0 };
5276 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5277 0 : if (res) return res;
5278 : }
5279 : }
5280 : break;
5281 : }
5282 : default:;
5283 : }
5284 : break;
5285 : }
5286 518 : case BIT_IOR_EXPR:
5287 518 : {
5288 518 : tree _q30 = TREE_OPERAND (_p1, 0);
5289 518 : tree _q31 = TREE_OPERAND (_p1, 1);
5290 518 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || operand_equal_p (_q30, _p0, 0))
5291 : {
5292 1 : {
5293 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
5294 1 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5295 1 : if (res) return res;
5296 : }
5297 : }
5298 517 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || operand_equal_p (_q31, _p0, 0))
5299 : {
5300 1 : {
5301 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _p0 };
5302 1 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5303 1 : if (res) return res;
5304 : }
5305 : }
5306 : break;
5307 : }
5308 996586 : default:;
5309 : }
5310 996586 : {
5311 996586 : tree _p0_pops[1];
5312 996586 : if (tree_nop_convert (_p0, _p0_pops))
5313 : {
5314 508139 : tree _q20 = _p0_pops[0];
5315 508139 : switch (TREE_CODE (_q20))
5316 : {
5317 16 : case BIT_IOR_EXPR:
5318 16 : {
5319 16 : tree _q30 = TREE_OPERAND (_q20, 0);
5320 16 : tree _q31 = TREE_OPERAND (_q20, 1);
5321 16 : {
5322 16 : tree _q30_pops[1];
5323 16 : if (tree_nop_convert (_q30, _q30_pops))
5324 : {
5325 0 : tree _q40 = _q30_pops[0];
5326 0 : switch (TREE_CODE (_q40))
5327 : {
5328 0 : case BIT_NOT_EXPR:
5329 0 : {
5330 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5331 0 : {
5332 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q31, _p1 };
5333 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5334 0 : if (res) return res;
5335 : }
5336 0 : break;
5337 : }
5338 : default:;
5339 : }
5340 : }
5341 : }
5342 16 : {
5343 16 : tree _q31_pops[1];
5344 16 : if (tree_nop_convert (_q31, _q31_pops))
5345 : {
5346 0 : tree _q50 = _q31_pops[0];
5347 0 : switch (TREE_CODE (_q50))
5348 : {
5349 0 : case BIT_NOT_EXPR:
5350 0 : {
5351 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5352 0 : {
5353 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q30, _p1 };
5354 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5355 0 : if (res) return res;
5356 : }
5357 0 : break;
5358 : }
5359 : default:;
5360 : }
5361 : }
5362 : }
5363 16 : switch (TREE_CODE (_q30))
5364 : {
5365 16 : case BIT_NOT_EXPR:
5366 16 : {
5367 16 : tree _q40 = TREE_OPERAND (_q30, 0);
5368 16 : {
5369 16 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q31, _p1 };
5370 16 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5371 16 : if (res) return res;
5372 : }
5373 0 : break;
5374 : }
5375 0 : default:;
5376 : }
5377 0 : switch (TREE_CODE (_q31))
5378 : {
5379 0 : case BIT_NOT_EXPR:
5380 0 : {
5381 0 : tree _q50 = TREE_OPERAND (_q31, 0);
5382 0 : {
5383 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q30, _p1 };
5384 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5385 0 : if (res) return res;
5386 : }
5387 0 : break;
5388 : }
5389 : default:;
5390 : }
5391 : break;
5392 : }
5393 : default:;
5394 : }
5395 : }
5396 : }
5397 996570 : switch (TREE_CODE (_p1))
5398 : {
5399 516 : case BIT_IOR_EXPR:
5400 516 : {
5401 516 : tree _q30 = TREE_OPERAND (_p1, 0);
5402 516 : tree _q31 = TREE_OPERAND (_p1, 1);
5403 516 : {
5404 516 : tree _q30_pops[1];
5405 516 : if (tree_nop_convert (_q30, _q30_pops))
5406 : {
5407 2 : tree _q40 = _q30_pops[0];
5408 2 : switch (TREE_CODE (_q40))
5409 : {
5410 0 : case BIT_NOT_EXPR:
5411 0 : {
5412 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5413 0 : {
5414 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q31, _p0 };
5415 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5416 0 : if (res) return res;
5417 : }
5418 0 : break;
5419 : }
5420 : default:;
5421 : }
5422 : }
5423 : }
5424 516 : {
5425 516 : tree _q31_pops[1];
5426 516 : if (tree_nop_convert (_q31, _q31_pops))
5427 : {
5428 2 : tree _q50 = _q31_pops[0];
5429 2 : switch (TREE_CODE (_q50))
5430 : {
5431 0 : case BIT_NOT_EXPR:
5432 0 : {
5433 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5434 0 : {
5435 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q30, _p0 };
5436 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5437 0 : if (res) return res;
5438 : }
5439 0 : break;
5440 : }
5441 : default:;
5442 : }
5443 : }
5444 : }
5445 516 : switch (TREE_CODE (_q30))
5446 : {
5447 18 : case BIT_NOT_EXPR:
5448 18 : {
5449 18 : tree _q40 = TREE_OPERAND (_q30, 0);
5450 18 : {
5451 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q31, _p0 };
5452 18 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5453 18 : if (res) return res;
5454 : }
5455 18 : break;
5456 : }
5457 516 : default:;
5458 : }
5459 516 : switch (TREE_CODE (_q31))
5460 : {
5461 25 : case BIT_NOT_EXPR:
5462 25 : {
5463 25 : tree _q50 = TREE_OPERAND (_q31, 0);
5464 25 : {
5465 25 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q30, _p0 };
5466 25 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5467 25 : if (res) return res;
5468 : }
5469 17 : break;
5470 : }
5471 : default:;
5472 : }
5473 : break;
5474 : }
5475 996562 : default:;
5476 : }
5477 996562 : {
5478 996562 : tree _p1_pops[1];
5479 996562 : if (tree_nop_convert (_p1, _p1_pops))
5480 : {
5481 635875 : tree _q30 = _p1_pops[0];
5482 635875 : switch (TREE_CODE (_q30))
5483 : {
5484 0 : case BIT_IOR_EXPR:
5485 0 : {
5486 0 : tree _q40 = TREE_OPERAND (_q30, 0);
5487 0 : tree _q41 = TREE_OPERAND (_q30, 1);
5488 0 : {
5489 0 : tree _q40_pops[1];
5490 0 : if (tree_nop_convert (_q40, _q40_pops))
5491 : {
5492 0 : tree _q50 = _q40_pops[0];
5493 0 : switch (TREE_CODE (_q50))
5494 : {
5495 0 : case BIT_NOT_EXPR:
5496 0 : {
5497 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5498 0 : {
5499 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q41, _p0 };
5500 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5501 0 : if (res) return res;
5502 : }
5503 0 : break;
5504 : }
5505 : default:;
5506 : }
5507 : }
5508 : }
5509 0 : {
5510 0 : tree _q41_pops[1];
5511 0 : if (tree_nop_convert (_q41, _q41_pops))
5512 : {
5513 0 : tree _q60 = _q41_pops[0];
5514 0 : switch (TREE_CODE (_q60))
5515 : {
5516 0 : case BIT_NOT_EXPR:
5517 0 : {
5518 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5519 0 : {
5520 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q70, _q40, _p0 };
5521 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5522 0 : if (res) return res;
5523 : }
5524 0 : break;
5525 : }
5526 : default:;
5527 : }
5528 : }
5529 : }
5530 0 : switch (TREE_CODE (_q40))
5531 : {
5532 0 : case BIT_NOT_EXPR:
5533 0 : {
5534 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5535 0 : {
5536 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q41, _p0 };
5537 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5538 0 : if (res) return res;
5539 : }
5540 0 : break;
5541 : }
5542 0 : default:;
5543 : }
5544 0 : switch (TREE_CODE (_q41))
5545 : {
5546 0 : case BIT_NOT_EXPR:
5547 0 : {
5548 0 : tree _q60 = TREE_OPERAND (_q41, 0);
5549 0 : {
5550 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q40, _p0 };
5551 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5552 0 : if (res) return res;
5553 : }
5554 0 : break;
5555 : }
5556 : default:;
5557 : }
5558 : break;
5559 : }
5560 : default:;
5561 : }
5562 : }
5563 : }
5564 996562 : switch (TREE_CODE (_p0))
5565 : {
5566 635591 : CASE_CONVERT:
5567 635591 : {
5568 635591 : tree _q20 = TREE_OPERAND (_p0, 0);
5569 635591 : switch (TREE_CODE (_q20))
5570 : {
5571 50 : case BIT_NOT_EXPR:
5572 50 : {
5573 50 : tree _q30 = TREE_OPERAND (_q20, 0);
5574 50 : switch (TREE_CODE (_p1))
5575 : {
5576 0 : CASE_CONVERT:
5577 0 : {
5578 0 : tree _q50 = TREE_OPERAND (_p1, 0);
5579 0 : switch (TREE_CODE (_q50))
5580 : {
5581 0 : case BIT_NOT_EXPR:
5582 0 : {
5583 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5584 0 : {
5585 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q60 };
5586 0 : tree res = generic_simplify_26 (loc, type, _p0, _p1, captures);
5587 0 : if (res) return res;
5588 : }
5589 0 : break;
5590 : }
5591 : default:;
5592 : }
5593 : break;
5594 : }
5595 0 : case BIT_NOT_EXPR:
5596 0 : {
5597 0 : tree _q50 = TREE_OPERAND (_p1, 0);
5598 0 : {
5599 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q50 };
5600 0 : tree res = generic_simplify_26 (loc, type, _p0, _p1, captures);
5601 0 : if (res) return res;
5602 : }
5603 0 : break;
5604 : }
5605 26 : case INTEGER_CST:
5606 26 : {
5607 26 : {
5608 26 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p1 };
5609 26 : tree res = generic_simplify_27 (loc, type, _p0, _p1, captures);
5610 26 : if (res) return res;
5611 : }
5612 24 : break;
5613 : }
5614 : default:;
5615 : }
5616 : break;
5617 : }
5618 : default:;
5619 : }
5620 : break;
5621 : }
5622 484 : case BIT_NOT_EXPR:
5623 484 : {
5624 484 : tree _q20 = TREE_OPERAND (_p0, 0);
5625 484 : switch (TREE_CODE (_p1))
5626 : {
5627 18 : CASE_CONVERT:
5628 18 : {
5629 18 : tree _q40 = TREE_OPERAND (_p1, 0);
5630 18 : switch (TREE_CODE (_q40))
5631 : {
5632 0 : case BIT_NOT_EXPR:
5633 0 : {
5634 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5635 0 : {
5636 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
5637 0 : tree res = generic_simplify_26 (loc, type, _p0, _p1, captures);
5638 0 : if (res) return res;
5639 : }
5640 0 : break;
5641 : }
5642 : default:;
5643 : }
5644 : break;
5645 : }
5646 10 : case BIT_NOT_EXPR:
5647 10 : {
5648 10 : tree _q40 = TREE_OPERAND (_p1, 0);
5649 10 : {
5650 10 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
5651 10 : tree res = generic_simplify_26 (loc, type, _p0, _p1, captures);
5652 10 : if (res) return res;
5653 : }
5654 0 : break;
5655 : }
5656 31 : case INTEGER_CST:
5657 31 : {
5658 31 : {
5659 31 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
5660 31 : tree res = generic_simplify_27 (loc, type, _p0, _p1, captures);
5661 31 : if (res) return res;
5662 : }
5663 0 : break;
5664 : }
5665 443 : default:;
5666 : }
5667 443 : {
5668 443 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _p1 };
5669 443 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
5670 443 : if (res) return res;
5671 : }
5672 0 : break;
5673 : }
5674 3376 : case BIT_AND_EXPR:
5675 3376 : {
5676 3376 : tree _q20 = TREE_OPERAND (_p0, 0);
5677 3376 : tree _q21 = TREE_OPERAND (_p0, 1);
5678 3376 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5679 : {
5680 75 : {
5681 75 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
5682 75 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5683 75 : if (res) return res;
5684 : }
5685 : }
5686 3301 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5687 : {
5688 3 : {
5689 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
5690 3 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5691 3 : if (res) return res;
5692 : }
5693 : }
5694 3298 : switch (TREE_CODE (_p1))
5695 : {
5696 353 : case BIT_AND_EXPR:
5697 353 : {
5698 353 : tree _q50 = TREE_OPERAND (_p1, 0);
5699 353 : tree _q51 = TREE_OPERAND (_p1, 1);
5700 353 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
5701 : {
5702 21 : {
5703 21 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q51, _q20 };
5704 21 : tree res = generic_simplify_30 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5705 21 : if (res) return res;
5706 : }
5707 : }
5708 332 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
5709 : {
5710 0 : {
5711 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q20 };
5712 0 : tree res = generic_simplify_30 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5713 0 : if (res) return res;
5714 : }
5715 : }
5716 332 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q21, 0))
5717 : {
5718 0 : {
5719 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q51, _q21 };
5720 0 : tree res = generic_simplify_30 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5721 0 : if (res) return res;
5722 : }
5723 : }
5724 332 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q21, 0))
5725 : {
5726 201 : {
5727 201 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q50, _q21 };
5728 201 : tree res = generic_simplify_30 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5729 201 : if (res) return res;
5730 : }
5731 : }
5732 : break;
5733 : }
5734 : default:;
5735 : }
5736 : break;
5737 : }
5738 995776 : default:;
5739 : }
5740 995776 : switch (TREE_CODE (_p1))
5741 : {
5742 513 : case BIT_AND_EXPR:
5743 513 : {
5744 513 : tree _q30 = TREE_OPERAND (_p1, 0);
5745 513 : tree _q31 = TREE_OPERAND (_p1, 1);
5746 513 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5747 : {
5748 0 : {
5749 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
5750 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5751 0 : if (res) return res;
5752 : }
5753 : }
5754 513 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5755 : {
5756 0 : {
5757 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q31, _p0 };
5758 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5759 0 : if (res) return res;
5760 : }
5761 : }
5762 : break;
5763 : }
5764 995776 : default:;
5765 : }
5766 995776 : switch (TREE_CODE (_p0))
5767 : {
5768 635589 : CASE_CONVERT:
5769 635589 : {
5770 635589 : tree _q20 = TREE_OPERAND (_p0, 0);
5771 635589 : switch (TREE_CODE (_q20))
5772 : {
5773 24 : case BIT_AND_EXPR:
5774 24 : {
5775 24 : tree _q30 = TREE_OPERAND (_q20, 0);
5776 24 : tree _q31 = TREE_OPERAND (_q20, 1);
5777 24 : switch (TREE_CODE (_p1))
5778 : {
5779 8 : CASE_CONVERT:
5780 8 : {
5781 8 : tree _q60 = TREE_OPERAND (_p1, 0);
5782 8 : switch (TREE_CODE (_q60))
5783 : {
5784 0 : case BIT_AND_EXPR:
5785 0 : {
5786 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5787 0 : tree _q71 = TREE_OPERAND (_q60, 1);
5788 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || operand_equal_p (_q70, _q30, 0))
5789 : {
5790 0 : {
5791 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q71, _q30 };
5792 0 : tree res = generic_simplify_30 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5793 0 : if (res) return res;
5794 : }
5795 : }
5796 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || operand_equal_p (_q71, _q30, 0))
5797 : {
5798 0 : {
5799 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q70, _q30 };
5800 0 : tree res = generic_simplify_30 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5801 0 : if (res) return res;
5802 : }
5803 : }
5804 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || operand_equal_p (_q70, _q31, 0))
5805 : {
5806 0 : {
5807 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q31, _q30, _q71, _q31 };
5808 0 : tree res = generic_simplify_30 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5809 0 : if (res) return res;
5810 : }
5811 : }
5812 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || operand_equal_p (_q71, _q31, 0))
5813 : {
5814 0 : {
5815 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q31, _q30, _q70, _q31 };
5816 0 : tree res = generic_simplify_30 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5817 0 : if (res) return res;
5818 : }
5819 : }
5820 : break;
5821 : }
5822 : default:;
5823 : }
5824 : break;
5825 : }
5826 : default:;
5827 : }
5828 : break;
5829 : }
5830 60549 : case BIT_XOR_EXPR:
5831 60549 : {
5832 60549 : tree _q30 = TREE_OPERAND (_q20, 0);
5833 60549 : tree _q31 = TREE_OPERAND (_q20, 1);
5834 60549 : switch (TREE_CODE (_p1))
5835 : {
5836 60483 : CASE_CONVERT:
5837 60483 : {
5838 60483 : tree _q60 = TREE_OPERAND (_p1, 0);
5839 60483 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q31, 0))
5840 : {
5841 0 : {
5842 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q31 };
5843 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5844 0 : if (res) return res;
5845 : }
5846 : }
5847 60483 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q30, 0))
5848 : {
5849 0 : {
5850 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q30 };
5851 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5852 0 : if (res) return res;
5853 : }
5854 : }
5855 : break;
5856 : }
5857 60549 : default:;
5858 : }
5859 60549 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q31, 0))
5860 : {
5861 0 : {
5862 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q31 };
5863 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5864 0 : if (res) return res;
5865 : }
5866 : }
5867 60549 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q30, 0))
5868 : {
5869 0 : {
5870 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q30 };
5871 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5872 0 : if (res) return res;
5873 : }
5874 : }
5875 : break;
5876 : }
5877 635589 : default:;
5878 : }
5879 635589 : switch (TREE_CODE (_p1))
5880 : {
5881 631532 : CASE_CONVERT:
5882 631532 : {
5883 631532 : tree _q40 = TREE_OPERAND (_p1, 0);
5884 631532 : switch (TREE_CODE (_q40))
5885 : {
5886 0 : case BIT_XOR_EXPR:
5887 0 : {
5888 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5889 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5890 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
5891 : {
5892 0 : {
5893 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
5894 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5895 0 : if (res) return res;
5896 : }
5897 : }
5898 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
5899 : {
5900 0 : {
5901 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q50, _q20 };
5902 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5903 0 : if (res) return res;
5904 : }
5905 : }
5906 : break;
5907 : }
5908 : default:;
5909 : }
5910 : break;
5911 : }
5912 2 : case BIT_XOR_EXPR:
5913 2 : {
5914 2 : tree _q40 = TREE_OPERAND (_p1, 0);
5915 2 : tree _q41 = TREE_OPERAND (_p1, 1);
5916 2 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _q20, 0))
5917 : {
5918 0 : {
5919 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q20 };
5920 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5921 0 : if (res) return res;
5922 : }
5923 : }
5924 2 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _q20, 0))
5925 : {
5926 0 : {
5927 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q20 };
5928 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5929 0 : if (res) return res;
5930 : }
5931 : }
5932 : break;
5933 : }
5934 : default:;
5935 : }
5936 : break;
5937 : }
5938 995776 : default:;
5939 : }
5940 995776 : switch (TREE_CODE (_p1))
5941 : {
5942 760724 : CASE_CONVERT:
5943 760724 : {
5944 760724 : tree _q30 = TREE_OPERAND (_p1, 0);
5945 760724 : switch (TREE_CODE (_q30))
5946 : {
5947 8 : case BIT_XOR_EXPR:
5948 8 : {
5949 8 : tree _q40 = TREE_OPERAND (_q30, 0);
5950 8 : tree _q41 = TREE_OPERAND (_q30, 1);
5951 8 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _p0, 0))
5952 : {
5953 0 : {
5954 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _p0 };
5955 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5956 0 : if (res) return res;
5957 : }
5958 : }
5959 8 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _p0, 0))
5960 : {
5961 0 : {
5962 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _p0 };
5963 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5964 0 : if (res) return res;
5965 : }
5966 : }
5967 : break;
5968 : }
5969 : default:;
5970 : }
5971 : break;
5972 : }
5973 78 : case BIT_XOR_EXPR:
5974 78 : {
5975 78 : tree _q30 = TREE_OPERAND (_p1, 0);
5976 78 : tree _q31 = TREE_OPERAND (_p1, 1);
5977 78 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || operand_equal_p (_q31, _p0, 0))
5978 : {
5979 0 : {
5980 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
5981 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5982 0 : if (res) return res;
5983 : }
5984 : }
5985 78 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || operand_equal_p (_q30, _p0, 0))
5986 : {
5987 0 : {
5988 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _p0 };
5989 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5990 0 : if (res) return res;
5991 : }
5992 : }
5993 : break;
5994 : }
5995 995776 : default:;
5996 : }
5997 995776 : switch (TREE_CODE (_p0))
5998 : {
5999 635589 : CASE_CONVERT:
6000 635589 : {
6001 635589 : tree _q20 = TREE_OPERAND (_p0, 0);
6002 635589 : switch (TREE_CODE (_q20))
6003 : {
6004 60549 : case BIT_XOR_EXPR:
6005 60549 : {
6006 60549 : tree _q30 = TREE_OPERAND (_q20, 0);
6007 60549 : tree _q31 = TREE_OPERAND (_q20, 1);
6008 60549 : switch (TREE_CODE (_p1))
6009 : {
6010 60483 : CASE_CONVERT:
6011 60483 : {
6012 60483 : tree _q60 = TREE_OPERAND (_p1, 0);
6013 60483 : switch (TREE_CODE (_q60))
6014 : {
6015 0 : case BIT_XOR_EXPR:
6016 0 : {
6017 0 : tree _q70 = TREE_OPERAND (_q60, 0);
6018 0 : tree _q71 = TREE_OPERAND (_q60, 1);
6019 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
6020 : {
6021 0 : {
6022 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q71 };
6023 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6024 0 : if (res) return res;
6025 : }
6026 : }
6027 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
6028 : {
6029 0 : {
6030 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q70 };
6031 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6032 0 : if (res) return res;
6033 : }
6034 : }
6035 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
6036 : {
6037 0 : {
6038 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q71 };
6039 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6040 0 : if (res) return res;
6041 : }
6042 : }
6043 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
6044 : {
6045 0 : {
6046 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q70 };
6047 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6048 0 : if (res) return res;
6049 : }
6050 : }
6051 : break;
6052 : }
6053 : default:;
6054 : }
6055 : break;
6056 : }
6057 0 : case BIT_XOR_EXPR:
6058 0 : {
6059 0 : tree _q60 = TREE_OPERAND (_p1, 0);
6060 0 : tree _q61 = TREE_OPERAND (_p1, 1);
6061 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
6062 : {
6063 0 : {
6064 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q61 };
6065 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6066 0 : if (res) return res;
6067 : }
6068 : }
6069 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
6070 : {
6071 0 : {
6072 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q60 };
6073 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6074 0 : if (res) return res;
6075 : }
6076 : }
6077 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
6078 : {
6079 0 : {
6080 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q61 };
6081 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6082 0 : if (res) return res;
6083 : }
6084 : }
6085 0 : if ((_q61 == _q31 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q31, 0) && types_match (_q61, _q31)))
6086 : {
6087 0 : {
6088 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q60 };
6089 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6090 0 : if (res) return res;
6091 : }
6092 : }
6093 : break;
6094 : }
6095 : default:;
6096 : }
6097 : break;
6098 : }
6099 635589 : default:;
6100 : }
6101 635589 : switch (TREE_CODE (_p1))
6102 : {
6103 631532 : CASE_CONVERT:
6104 631532 : {
6105 631532 : tree _q40 = TREE_OPERAND (_p1, 0);
6106 631532 : {
6107 631532 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
6108 631532 : tree res = generic_simplify_32 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
6109 631532 : if (res) return res;
6110 : }
6111 544021 : break;
6112 : }
6113 548078 : default:;
6114 : }
6115 548078 : {
6116 548078 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
6117 548078 : tree res = generic_simplify_33 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
6118 548078 : if (res) return res;
6119 : }
6120 547970 : break;
6121 : }
6122 3923 : case BIT_XOR_EXPR:
6123 3923 : {
6124 3923 : tree _q20 = TREE_OPERAND (_p0, 0);
6125 3923 : tree _q21 = TREE_OPERAND (_p0, 1);
6126 3923 : switch (TREE_CODE (_p1))
6127 : {
6128 198 : CASE_CONVERT:
6129 198 : {
6130 198 : tree _q50 = TREE_OPERAND (_p1, 0);
6131 198 : switch (TREE_CODE (_q50))
6132 : {
6133 0 : case BIT_XOR_EXPR:
6134 0 : {
6135 0 : tree _q60 = TREE_OPERAND (_q50, 0);
6136 0 : tree _q61 = TREE_OPERAND (_q50, 1);
6137 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6138 : {
6139 0 : {
6140 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q61 };
6141 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6142 0 : if (res) return res;
6143 : }
6144 : }
6145 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
6146 : {
6147 0 : {
6148 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q60 };
6149 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6150 0 : if (res) return res;
6151 : }
6152 : }
6153 0 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
6154 : {
6155 0 : {
6156 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q61 };
6157 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6158 0 : if (res) return res;
6159 : }
6160 : }
6161 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
6162 : {
6163 0 : {
6164 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q60 };
6165 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6166 0 : if (res) return res;
6167 : }
6168 : }
6169 : break;
6170 : }
6171 : default:;
6172 : }
6173 : break;
6174 : }
6175 10 : case BIT_XOR_EXPR:
6176 10 : {
6177 10 : tree _q50 = TREE_OPERAND (_p1, 0);
6178 10 : tree _q51 = TREE_OPERAND (_p1, 1);
6179 10 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6180 : {
6181 0 : {
6182 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
6183 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6184 0 : if (res) return res;
6185 : }
6186 : }
6187 10 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6188 : {
6189 0 : {
6190 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
6191 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6192 0 : if (res) return res;
6193 : }
6194 : }
6195 10 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6196 : {
6197 0 : {
6198 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
6199 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6200 0 : if (res) return res;
6201 : }
6202 : }
6203 10 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6204 : {
6205 0 : {
6206 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
6207 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6208 0 : if (res) return res;
6209 : }
6210 : }
6211 : break;
6212 : }
6213 : default:;
6214 : }
6215 : break;
6216 : }
6217 3076 : case BIT_AND_EXPR:
6218 3076 : {
6219 3076 : tree _q20 = TREE_OPERAND (_p0, 0);
6220 3076 : tree _q21 = TREE_OPERAND (_p0, 1);
6221 3076 : {
6222 3076 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6223 3076 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR, BIT_IOR_EXPR);
6224 3076 : if (res) return res;
6225 : }
6226 3076 : {
6227 3076 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _p1 };
6228 3076 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR, BIT_IOR_EXPR);
6229 3076 : if (res) return res;
6230 : }
6231 3076 : if (tree_truth_valued_p (_q20))
6232 : {
6233 0 : if (tree_truth_valued_p (_q21))
6234 : {
6235 0 : switch (TREE_CODE (_p1))
6236 : {
6237 0 : case EQ_EXPR:
6238 0 : {
6239 0 : tree _q50 = TREE_OPERAND (_p1, 0);
6240 0 : tree _q51 = TREE_OPERAND (_p1, 1);
6241 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6242 : {
6243 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6244 : {
6245 0 : {
6246 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6247 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1165;
6248 0 : {
6249 0 : tree res_op0;
6250 0 : {
6251 0 : tree _o1[2], _r1;
6252 0 : _o1[0] = captures[0];
6253 0 : _o1[1] = captures[1];
6254 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
6255 0 : res_op0 = _r1;
6256 : }
6257 0 : tree _r;
6258 0 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
6259 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 889, __FILE__, __LINE__, true);
6260 0 : return _r;
6261 : }
6262 0 : next_after_fail1165:;
6263 : }
6264 : }
6265 : }
6266 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6267 : {
6268 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6269 : {
6270 0 : {
6271 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6272 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1166;
6273 0 : {
6274 0 : tree res_op0;
6275 0 : {
6276 0 : tree _o1[2], _r1;
6277 0 : _o1[0] = captures[0];
6278 0 : _o1[1] = captures[1];
6279 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
6280 0 : res_op0 = _r1;
6281 : }
6282 0 : tree _r;
6283 0 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
6284 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 889, __FILE__, __LINE__, true);
6285 0 : return _r;
6286 : }
6287 0 : next_after_fail1166:;
6288 : }
6289 : }
6290 : }
6291 : break;
6292 : }
6293 : default:;
6294 : }
6295 : }
6296 : }
6297 : break;
6298 : }
6299 908157 : default:;
6300 : }
6301 908157 : switch (TREE_CODE (_p1))
6302 : {
6303 513 : case BIT_AND_EXPR:
6304 513 : {
6305 513 : tree _q30 = TREE_OPERAND (_p1, 0);
6306 513 : tree _q31 = TREE_OPERAND (_p1, 1);
6307 513 : {
6308 513 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
6309 513 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR, BIT_IOR_EXPR);
6310 513 : if (res) return res;
6311 : }
6312 513 : {
6313 513 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _p0 };
6314 513 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR, BIT_IOR_EXPR);
6315 513 : if (res) return res;
6316 : }
6317 513 : break;
6318 : }
6319 908157 : default:;
6320 : }
6321 908157 : switch (TREE_CODE (_p0))
6322 : {
6323 3923 : case BIT_XOR_EXPR:
6324 3923 : {
6325 3923 : tree _q20 = TREE_OPERAND (_p0, 0);
6326 3923 : tree _q21 = TREE_OPERAND (_p0, 1);
6327 3923 : if (CONSTANT_CLASS_P (_q21))
6328 : {
6329 49 : if (CONSTANT_CLASS_P (_p1))
6330 : {
6331 30 : {
6332 30 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6333 30 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
6334 30 : if (res) return res;
6335 : }
6336 : }
6337 : }
6338 : break;
6339 : }
6340 70 : case COND_EXPR:
6341 70 : {
6342 70 : tree _q20 = TREE_OPERAND (_p0, 0);
6343 70 : tree _q21 = TREE_OPERAND (_p0, 1);
6344 70 : tree _q22 = TREE_OPERAND (_p0, 2);
6345 70 : if (integer_zerop (_q22))
6346 : {
6347 70 : switch (TREE_CODE (_p1))
6348 : {
6349 4 : case COND_EXPR:
6350 4 : {
6351 4 : tree _q60 = TREE_OPERAND (_p1, 0);
6352 4 : tree _q61 = TREE_OPERAND (_p1, 1);
6353 4 : tree _q62 = TREE_OPERAND (_p1, 2);
6354 4 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6355 : {
6356 0 : if (integer_zerop (_q61))
6357 : {
6358 0 : {
6359 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q62 };
6360 0 : const enum tree_code op = BIT_XOR_EXPR;
6361 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1167;
6362 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1167;
6363 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1167;
6364 0 : {
6365 0 : tree res_op0;
6366 0 : res_op0 = captures[1];
6367 0 : tree res_op1;
6368 0 : res_op1 = captures[2];
6369 0 : tree res_op2;
6370 0 : res_op2 = captures[4];
6371 0 : tree _r;
6372 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
6373 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 890, __FILE__, __LINE__, true);
6374 0 : return _r;
6375 : }
6376 0 : next_after_fail1167:;
6377 : }
6378 : }
6379 : }
6380 : break;
6381 : }
6382 : default:;
6383 : }
6384 : }
6385 70 : if (integer_zerop (_q21))
6386 : {
6387 0 : switch (TREE_CODE (_p1))
6388 : {
6389 0 : case COND_EXPR:
6390 0 : {
6391 0 : tree _q60 = TREE_OPERAND (_p1, 0);
6392 0 : tree _q61 = TREE_OPERAND (_p1, 1);
6393 0 : tree _q62 = TREE_OPERAND (_p1, 2);
6394 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6395 : {
6396 0 : if (integer_zerop (_q62))
6397 : {
6398 0 : {
6399 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q20, _q61, _p0, _q22 };
6400 0 : const enum tree_code op = BIT_XOR_EXPR;
6401 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1168;
6402 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1168;
6403 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1168;
6404 0 : {
6405 0 : tree res_op0;
6406 0 : res_op0 = captures[1];
6407 0 : tree res_op1;
6408 0 : res_op1 = captures[2];
6409 0 : tree res_op2;
6410 0 : res_op2 = captures[4];
6411 0 : tree _r;
6412 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
6413 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 890, __FILE__, __LINE__, true);
6414 0 : return _r;
6415 : }
6416 0 : next_after_fail1168:;
6417 : }
6418 : }
6419 : }
6420 : break;
6421 : }
6422 : default:;
6423 : }
6424 : }
6425 70 : switch (TREE_CODE (_q20))
6426 : {
6427 0 : case LT_EXPR:
6428 0 : {
6429 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6430 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6431 0 : if (zerop (_q22))
6432 : {
6433 0 : switch (TREE_CODE (_p1))
6434 : {
6435 0 : case COND_EXPR:
6436 0 : {
6437 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6438 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6439 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6440 0 : switch (TREE_CODE (_q80))
6441 : {
6442 0 : case GE_EXPR:
6443 0 : {
6444 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6445 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6446 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6447 : {
6448 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6449 : {
6450 0 : if (zerop (_q82))
6451 : {
6452 0 : {
6453 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6454 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LT_EXPR, GE_EXPR);
6455 0 : if (res) return res;
6456 : }
6457 : }
6458 : }
6459 : }
6460 : break;
6461 : }
6462 : default:;
6463 : }
6464 : break;
6465 : }
6466 : default:;
6467 : }
6468 : }
6469 : break;
6470 : }
6471 38 : case LE_EXPR:
6472 38 : {
6473 38 : tree _q30 = TREE_OPERAND (_q20, 0);
6474 38 : tree _q31 = TREE_OPERAND (_q20, 1);
6475 38 : if (zerop (_q22))
6476 : {
6477 38 : switch (TREE_CODE (_p1))
6478 : {
6479 0 : case COND_EXPR:
6480 0 : {
6481 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6482 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6483 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6484 0 : switch (TREE_CODE (_q80))
6485 : {
6486 0 : case GT_EXPR:
6487 0 : {
6488 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6489 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6490 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6491 : {
6492 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6493 : {
6494 0 : if (zerop (_q82))
6495 : {
6496 0 : {
6497 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6498 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LE_EXPR, GT_EXPR);
6499 0 : if (res) return res;
6500 : }
6501 : }
6502 : }
6503 : }
6504 : break;
6505 : }
6506 : default:;
6507 : }
6508 : break;
6509 : }
6510 : default:;
6511 : }
6512 : }
6513 : break;
6514 : }
6515 0 : case EQ_EXPR:
6516 0 : {
6517 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6518 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6519 0 : if (zerop (_q22))
6520 : {
6521 0 : switch (TREE_CODE (_p1))
6522 : {
6523 0 : case COND_EXPR:
6524 0 : {
6525 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6526 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6527 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6528 0 : switch (TREE_CODE (_q80))
6529 : {
6530 0 : case NE_EXPR:
6531 0 : {
6532 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6533 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6534 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6535 : {
6536 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6537 : {
6538 0 : if (zerop (_q82))
6539 : {
6540 0 : {
6541 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6542 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, EQ_EXPR, NE_EXPR);
6543 0 : if (res) return res;
6544 : }
6545 : }
6546 : }
6547 : }
6548 : break;
6549 : }
6550 : default:;
6551 : }
6552 : break;
6553 : }
6554 : default:;
6555 : }
6556 : }
6557 : break;
6558 : }
6559 32 : case NE_EXPR:
6560 32 : {
6561 32 : tree _q30 = TREE_OPERAND (_q20, 0);
6562 32 : tree _q31 = TREE_OPERAND (_q20, 1);
6563 32 : if (zerop (_q22))
6564 : {
6565 32 : switch (TREE_CODE (_p1))
6566 : {
6567 4 : case COND_EXPR:
6568 4 : {
6569 4 : tree _q80 = TREE_OPERAND (_p1, 0);
6570 4 : tree _q81 = TREE_OPERAND (_p1, 1);
6571 4 : tree _q82 = TREE_OPERAND (_p1, 2);
6572 4 : switch (TREE_CODE (_q80))
6573 : {
6574 0 : case EQ_EXPR:
6575 0 : {
6576 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6577 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6578 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6579 : {
6580 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6581 : {
6582 0 : if (zerop (_q82))
6583 : {
6584 0 : {
6585 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6586 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, NE_EXPR, EQ_EXPR);
6587 0 : if (res) return res;
6588 : }
6589 : }
6590 : }
6591 : }
6592 : break;
6593 : }
6594 : default:;
6595 : }
6596 : break;
6597 : }
6598 : default:;
6599 : }
6600 : }
6601 : break;
6602 : }
6603 0 : case GE_EXPR:
6604 0 : {
6605 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6606 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6607 0 : if (zerop (_q22))
6608 : {
6609 0 : switch (TREE_CODE (_p1))
6610 : {
6611 0 : case COND_EXPR:
6612 0 : {
6613 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6614 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6615 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6616 0 : switch (TREE_CODE (_q80))
6617 : {
6618 0 : case LT_EXPR:
6619 0 : {
6620 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6621 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6622 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6623 : {
6624 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6625 : {
6626 0 : if (zerop (_q82))
6627 : {
6628 0 : {
6629 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6630 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GE_EXPR, LT_EXPR);
6631 0 : if (res) return res;
6632 : }
6633 : }
6634 : }
6635 : }
6636 : break;
6637 : }
6638 : default:;
6639 : }
6640 : break;
6641 : }
6642 : default:;
6643 : }
6644 : }
6645 : break;
6646 : }
6647 0 : case GT_EXPR:
6648 0 : {
6649 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6650 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6651 0 : if (zerop (_q22))
6652 : {
6653 0 : switch (TREE_CODE (_p1))
6654 : {
6655 0 : case COND_EXPR:
6656 0 : {
6657 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6658 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6659 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6660 0 : switch (TREE_CODE (_q80))
6661 : {
6662 0 : case LE_EXPR:
6663 0 : {
6664 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6665 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6666 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6667 : {
6668 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6669 : {
6670 0 : if (zerop (_q82))
6671 : {
6672 0 : {
6673 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6674 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GT_EXPR, LE_EXPR);
6675 0 : if (res) return res;
6676 : }
6677 : }
6678 : }
6679 : }
6680 : break;
6681 : }
6682 : default:;
6683 : }
6684 : break;
6685 : }
6686 : default:;
6687 : }
6688 : }
6689 : break;
6690 : }
6691 0 : case UNORDERED_EXPR:
6692 0 : {
6693 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6694 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6695 0 : if (zerop (_q22))
6696 : {
6697 0 : switch (TREE_CODE (_p1))
6698 : {
6699 0 : case COND_EXPR:
6700 0 : {
6701 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6702 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6703 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6704 0 : switch (TREE_CODE (_q80))
6705 : {
6706 0 : case ORDERED_EXPR:
6707 0 : {
6708 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6709 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6710 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6711 : {
6712 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6713 : {
6714 0 : if (zerop (_q82))
6715 : {
6716 0 : {
6717 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6718 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNORDERED_EXPR, ORDERED_EXPR);
6719 0 : if (res) return res;
6720 : }
6721 : }
6722 : }
6723 : }
6724 : break;
6725 : }
6726 : default:;
6727 : }
6728 : break;
6729 : }
6730 : default:;
6731 : }
6732 : }
6733 : break;
6734 : }
6735 0 : case ORDERED_EXPR:
6736 0 : {
6737 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6738 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6739 0 : if (zerop (_q22))
6740 : {
6741 0 : switch (TREE_CODE (_p1))
6742 : {
6743 0 : case COND_EXPR:
6744 0 : {
6745 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6746 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6747 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6748 0 : switch (TREE_CODE (_q80))
6749 : {
6750 0 : case UNORDERED_EXPR:
6751 0 : {
6752 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6753 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6754 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6755 : {
6756 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6757 : {
6758 0 : if (zerop (_q82))
6759 : {
6760 0 : {
6761 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6762 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, ORDERED_EXPR, UNORDERED_EXPR);
6763 0 : if (res) return res;
6764 : }
6765 : }
6766 : }
6767 : }
6768 : break;
6769 : }
6770 : default:;
6771 : }
6772 : break;
6773 : }
6774 : default:;
6775 : }
6776 : }
6777 : break;
6778 : }
6779 0 : case UNLT_EXPR:
6780 0 : {
6781 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6782 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6783 0 : if (zerop (_q22))
6784 : {
6785 0 : switch (TREE_CODE (_p1))
6786 : {
6787 0 : case COND_EXPR:
6788 0 : {
6789 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6790 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6791 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6792 0 : switch (TREE_CODE (_q80))
6793 : {
6794 0 : case GE_EXPR:
6795 0 : {
6796 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6797 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6798 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6799 : {
6800 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6801 : {
6802 0 : if (zerop (_q82))
6803 : {
6804 0 : {
6805 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6806 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLT_EXPR, GE_EXPR);
6807 0 : if (res) return res;
6808 : }
6809 : }
6810 : }
6811 : }
6812 : break;
6813 : }
6814 : default:;
6815 : }
6816 : break;
6817 : }
6818 : default:;
6819 : }
6820 : }
6821 : break;
6822 : }
6823 0 : case UNLE_EXPR:
6824 0 : {
6825 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6826 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6827 0 : if (zerop (_q22))
6828 : {
6829 0 : switch (TREE_CODE (_p1))
6830 : {
6831 0 : case COND_EXPR:
6832 0 : {
6833 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6834 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6835 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6836 0 : switch (TREE_CODE (_q80))
6837 : {
6838 0 : case GT_EXPR:
6839 0 : {
6840 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6841 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6842 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6843 : {
6844 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6845 : {
6846 0 : if (zerop (_q82))
6847 : {
6848 0 : {
6849 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6850 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLE_EXPR, GT_EXPR);
6851 0 : if (res) return res;
6852 : }
6853 : }
6854 : }
6855 : }
6856 : break;
6857 : }
6858 : default:;
6859 : }
6860 : break;
6861 : }
6862 : default:;
6863 : }
6864 : }
6865 : break;
6866 : }
6867 0 : case UNGT_EXPR:
6868 0 : {
6869 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6870 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6871 0 : if (zerop (_q22))
6872 : {
6873 0 : switch (TREE_CODE (_p1))
6874 : {
6875 0 : case COND_EXPR:
6876 0 : {
6877 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6878 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6879 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6880 0 : switch (TREE_CODE (_q80))
6881 : {
6882 0 : case LE_EXPR:
6883 0 : {
6884 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6885 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6886 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6887 : {
6888 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6889 : {
6890 0 : if (zerop (_q82))
6891 : {
6892 0 : {
6893 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6894 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGT_EXPR, LE_EXPR);
6895 0 : if (res) return res;
6896 : }
6897 : }
6898 : }
6899 : }
6900 : break;
6901 : }
6902 : default:;
6903 : }
6904 : break;
6905 : }
6906 : default:;
6907 : }
6908 : }
6909 : break;
6910 : }
6911 0 : case UNGE_EXPR:
6912 0 : {
6913 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6914 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6915 0 : if (zerop (_q22))
6916 : {
6917 0 : switch (TREE_CODE (_p1))
6918 : {
6919 0 : case COND_EXPR:
6920 0 : {
6921 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6922 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6923 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6924 0 : switch (TREE_CODE (_q80))
6925 : {
6926 0 : case LT_EXPR:
6927 0 : {
6928 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6929 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6930 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6931 : {
6932 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6933 : {
6934 0 : if (zerop (_q82))
6935 : {
6936 0 : {
6937 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6938 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGE_EXPR, LT_EXPR);
6939 0 : if (res) return res;
6940 : }
6941 : }
6942 : }
6943 : }
6944 : break;
6945 : }
6946 : default:;
6947 : }
6948 : break;
6949 : }
6950 : default:;
6951 : }
6952 : }
6953 : break;
6954 : }
6955 0 : case UNEQ_EXPR:
6956 0 : {
6957 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6958 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6959 0 : if (zerop (_q22))
6960 : {
6961 0 : switch (TREE_CODE (_p1))
6962 : {
6963 0 : case COND_EXPR:
6964 0 : {
6965 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6966 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6967 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6968 0 : switch (TREE_CODE (_q80))
6969 : {
6970 0 : case LTGT_EXPR:
6971 0 : {
6972 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6973 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6974 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6975 : {
6976 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6977 : {
6978 0 : if (zerop (_q82))
6979 : {
6980 0 : {
6981 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6982 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNEQ_EXPR, LTGT_EXPR);
6983 0 : if (res) return res;
6984 : }
6985 : }
6986 : }
6987 : }
6988 : break;
6989 : }
6990 : default:;
6991 : }
6992 : break;
6993 : }
6994 : default:;
6995 : }
6996 : }
6997 : break;
6998 : }
6999 0 : case LTGT_EXPR:
7000 0 : {
7001 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7002 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7003 0 : if (zerop (_q22))
7004 : {
7005 0 : switch (TREE_CODE (_p1))
7006 : {
7007 0 : case COND_EXPR:
7008 0 : {
7009 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7010 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7011 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7012 0 : switch (TREE_CODE (_q80))
7013 : {
7014 0 : case UNEQ_EXPR:
7015 0 : {
7016 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7017 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7018 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7019 : {
7020 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7021 : {
7022 0 : if (zerop (_q82))
7023 : {
7024 0 : {
7025 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7026 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LTGT_EXPR, UNEQ_EXPR);
7027 0 : if (res) return res;
7028 : }
7029 : }
7030 : }
7031 : }
7032 : break;
7033 : }
7034 : default:;
7035 : }
7036 : break;
7037 : }
7038 : default:;
7039 : }
7040 : }
7041 : break;
7042 : }
7043 : default:;
7044 : }
7045 : break;
7046 : }
7047 1 : case VEC_COND_EXPR:
7048 1 : {
7049 1 : tree _q20 = TREE_OPERAND (_p0, 0);
7050 1 : tree _q21 = TREE_OPERAND (_p0, 1);
7051 1 : tree _q22 = TREE_OPERAND (_p0, 2);
7052 1 : if (integer_zerop (_q22))
7053 : {
7054 1 : switch (TREE_CODE (_p1))
7055 : {
7056 0 : case VEC_COND_EXPR:
7057 0 : {
7058 0 : tree _q60 = TREE_OPERAND (_p1, 0);
7059 0 : tree _q61 = TREE_OPERAND (_p1, 1);
7060 0 : tree _q62 = TREE_OPERAND (_p1, 2);
7061 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7062 : {
7063 0 : if (integer_zerop (_q61))
7064 : {
7065 0 : {
7066 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q62 };
7067 0 : const enum tree_code op = BIT_XOR_EXPR;
7068 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1169;
7069 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1169;
7070 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1169;
7071 0 : {
7072 0 : tree res_op0;
7073 0 : res_op0 = captures[1];
7074 0 : tree res_op1;
7075 0 : res_op1 = captures[2];
7076 0 : tree res_op2;
7077 0 : res_op2 = captures[4];
7078 0 : tree _r;
7079 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7080 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 890, __FILE__, __LINE__, true);
7081 0 : return _r;
7082 : }
7083 0 : next_after_fail1169:;
7084 : }
7085 : }
7086 : }
7087 : break;
7088 : }
7089 : default:;
7090 : }
7091 : }
7092 1 : if (integer_zerop (_q21))
7093 : {
7094 0 : switch (TREE_CODE (_p1))
7095 : {
7096 0 : case VEC_COND_EXPR:
7097 0 : {
7098 0 : tree _q60 = TREE_OPERAND (_p1, 0);
7099 0 : tree _q61 = TREE_OPERAND (_p1, 1);
7100 0 : tree _q62 = TREE_OPERAND (_p1, 2);
7101 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7102 : {
7103 0 : if (integer_zerop (_q62))
7104 : {
7105 0 : {
7106 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q20, _q61, _p0, _q22 };
7107 0 : const enum tree_code op = BIT_XOR_EXPR;
7108 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1170;
7109 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1170;
7110 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1170;
7111 0 : {
7112 0 : tree res_op0;
7113 0 : res_op0 = captures[1];
7114 0 : tree res_op1;
7115 0 : res_op1 = captures[2];
7116 0 : tree res_op2;
7117 0 : res_op2 = captures[4];
7118 0 : tree _r;
7119 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7120 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 890, __FILE__, __LINE__, true);
7121 0 : return _r;
7122 : }
7123 0 : next_after_fail1170:;
7124 : }
7125 : }
7126 : }
7127 : break;
7128 : }
7129 : default:;
7130 : }
7131 : }
7132 1 : switch (TREE_CODE (_q20))
7133 : {
7134 0 : case LT_EXPR:
7135 0 : {
7136 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7137 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7138 0 : if (integer_zerop (_q22))
7139 : {
7140 0 : switch (TREE_CODE (_p1))
7141 : {
7142 0 : case VEC_COND_EXPR:
7143 0 : {
7144 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7145 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7146 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7147 0 : switch (TREE_CODE (_q80))
7148 : {
7149 0 : case GE_EXPR:
7150 0 : {
7151 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7152 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7153 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7154 : {
7155 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7156 : {
7157 0 : if (integer_zerop (_q82))
7158 : {
7159 0 : {
7160 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7161 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LT_EXPR, GE_EXPR);
7162 0 : if (res) return res;
7163 : }
7164 : }
7165 : }
7166 : }
7167 : break;
7168 : }
7169 : default:;
7170 : }
7171 : break;
7172 : }
7173 : default:;
7174 : }
7175 : }
7176 : break;
7177 : }
7178 0 : case LE_EXPR:
7179 0 : {
7180 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7181 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7182 0 : if (integer_zerop (_q22))
7183 : {
7184 0 : switch (TREE_CODE (_p1))
7185 : {
7186 0 : case VEC_COND_EXPR:
7187 0 : {
7188 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7189 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7190 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7191 0 : switch (TREE_CODE (_q80))
7192 : {
7193 0 : case GT_EXPR:
7194 0 : {
7195 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7196 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7197 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7198 : {
7199 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7200 : {
7201 0 : if (integer_zerop (_q82))
7202 : {
7203 0 : {
7204 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7205 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LE_EXPR, GT_EXPR);
7206 0 : if (res) return res;
7207 : }
7208 : }
7209 : }
7210 : }
7211 : break;
7212 : }
7213 : default:;
7214 : }
7215 : break;
7216 : }
7217 : default:;
7218 : }
7219 : }
7220 : break;
7221 : }
7222 0 : case EQ_EXPR:
7223 0 : {
7224 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7225 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7226 0 : if (integer_zerop (_q22))
7227 : {
7228 0 : switch (TREE_CODE (_p1))
7229 : {
7230 0 : case VEC_COND_EXPR:
7231 0 : {
7232 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7233 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7234 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7235 0 : switch (TREE_CODE (_q80))
7236 : {
7237 0 : case NE_EXPR:
7238 0 : {
7239 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7240 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7241 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7242 : {
7243 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7244 : {
7245 0 : if (integer_zerop (_q82))
7246 : {
7247 0 : {
7248 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7249 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, EQ_EXPR, NE_EXPR);
7250 0 : if (res) return res;
7251 : }
7252 : }
7253 : }
7254 : }
7255 : break;
7256 : }
7257 : default:;
7258 : }
7259 : break;
7260 : }
7261 : default:;
7262 : }
7263 : }
7264 : break;
7265 : }
7266 1 : case NE_EXPR:
7267 1 : {
7268 1 : tree _q30 = TREE_OPERAND (_q20, 0);
7269 1 : tree _q31 = TREE_OPERAND (_q20, 1);
7270 1 : if (integer_zerop (_q22))
7271 : {
7272 1 : switch (TREE_CODE (_p1))
7273 : {
7274 0 : case VEC_COND_EXPR:
7275 0 : {
7276 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7277 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7278 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7279 0 : switch (TREE_CODE (_q80))
7280 : {
7281 0 : case EQ_EXPR:
7282 0 : {
7283 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7284 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7285 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7286 : {
7287 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7288 : {
7289 0 : if (integer_zerop (_q82))
7290 : {
7291 0 : {
7292 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7293 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, NE_EXPR, EQ_EXPR);
7294 0 : if (res) return res;
7295 : }
7296 : }
7297 : }
7298 : }
7299 : break;
7300 : }
7301 : default:;
7302 : }
7303 : break;
7304 : }
7305 : default:;
7306 : }
7307 : }
7308 : break;
7309 : }
7310 0 : case GE_EXPR:
7311 0 : {
7312 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7313 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7314 0 : if (integer_zerop (_q22))
7315 : {
7316 0 : switch (TREE_CODE (_p1))
7317 : {
7318 0 : case VEC_COND_EXPR:
7319 0 : {
7320 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7321 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7322 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7323 0 : switch (TREE_CODE (_q80))
7324 : {
7325 0 : case LT_EXPR:
7326 0 : {
7327 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7328 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7329 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7330 : {
7331 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7332 : {
7333 0 : if (integer_zerop (_q82))
7334 : {
7335 0 : {
7336 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7337 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GE_EXPR, LT_EXPR);
7338 0 : if (res) return res;
7339 : }
7340 : }
7341 : }
7342 : }
7343 : break;
7344 : }
7345 : default:;
7346 : }
7347 : break;
7348 : }
7349 : default:;
7350 : }
7351 : }
7352 : break;
7353 : }
7354 0 : case GT_EXPR:
7355 0 : {
7356 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7357 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7358 0 : if (integer_zerop (_q22))
7359 : {
7360 0 : switch (TREE_CODE (_p1))
7361 : {
7362 0 : case VEC_COND_EXPR:
7363 0 : {
7364 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7365 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7366 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7367 0 : switch (TREE_CODE (_q80))
7368 : {
7369 0 : case LE_EXPR:
7370 0 : {
7371 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7372 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7373 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7374 : {
7375 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7376 : {
7377 0 : if (integer_zerop (_q82))
7378 : {
7379 0 : {
7380 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7381 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GT_EXPR, LE_EXPR);
7382 0 : if (res) return res;
7383 : }
7384 : }
7385 : }
7386 : }
7387 : break;
7388 : }
7389 : default:;
7390 : }
7391 : break;
7392 : }
7393 : default:;
7394 : }
7395 : }
7396 : break;
7397 : }
7398 0 : case UNORDERED_EXPR:
7399 0 : {
7400 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7401 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7402 0 : if (integer_zerop (_q22))
7403 : {
7404 0 : switch (TREE_CODE (_p1))
7405 : {
7406 0 : case VEC_COND_EXPR:
7407 0 : {
7408 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7409 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7410 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7411 0 : switch (TREE_CODE (_q80))
7412 : {
7413 0 : case ORDERED_EXPR:
7414 0 : {
7415 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7416 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7417 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7418 : {
7419 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7420 : {
7421 0 : if (integer_zerop (_q82))
7422 : {
7423 0 : {
7424 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7425 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNORDERED_EXPR, ORDERED_EXPR);
7426 0 : if (res) return res;
7427 : }
7428 : }
7429 : }
7430 : }
7431 : break;
7432 : }
7433 : default:;
7434 : }
7435 : break;
7436 : }
7437 : default:;
7438 : }
7439 : }
7440 : break;
7441 : }
7442 0 : case ORDERED_EXPR:
7443 0 : {
7444 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7445 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7446 0 : if (integer_zerop (_q22))
7447 : {
7448 0 : switch (TREE_CODE (_p1))
7449 : {
7450 0 : case VEC_COND_EXPR:
7451 0 : {
7452 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7453 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7454 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7455 0 : switch (TREE_CODE (_q80))
7456 : {
7457 0 : case UNORDERED_EXPR:
7458 0 : {
7459 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7460 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7461 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7462 : {
7463 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7464 : {
7465 0 : if (integer_zerop (_q82))
7466 : {
7467 0 : {
7468 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7469 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, ORDERED_EXPR, UNORDERED_EXPR);
7470 0 : if (res) return res;
7471 : }
7472 : }
7473 : }
7474 : }
7475 : break;
7476 : }
7477 : default:;
7478 : }
7479 : break;
7480 : }
7481 : default:;
7482 : }
7483 : }
7484 : break;
7485 : }
7486 0 : case UNLT_EXPR:
7487 0 : {
7488 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7489 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7490 0 : if (integer_zerop (_q22))
7491 : {
7492 0 : switch (TREE_CODE (_p1))
7493 : {
7494 0 : case VEC_COND_EXPR:
7495 0 : {
7496 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7497 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7498 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7499 0 : switch (TREE_CODE (_q80))
7500 : {
7501 0 : case GE_EXPR:
7502 0 : {
7503 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7504 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7505 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7506 : {
7507 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7508 : {
7509 0 : if (integer_zerop (_q82))
7510 : {
7511 0 : {
7512 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7513 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLT_EXPR, GE_EXPR);
7514 0 : if (res) return res;
7515 : }
7516 : }
7517 : }
7518 : }
7519 : break;
7520 : }
7521 : default:;
7522 : }
7523 : break;
7524 : }
7525 : default:;
7526 : }
7527 : }
7528 : break;
7529 : }
7530 0 : case UNLE_EXPR:
7531 0 : {
7532 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7533 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7534 0 : if (integer_zerop (_q22))
7535 : {
7536 0 : switch (TREE_CODE (_p1))
7537 : {
7538 0 : case VEC_COND_EXPR:
7539 0 : {
7540 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7541 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7542 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7543 0 : switch (TREE_CODE (_q80))
7544 : {
7545 0 : case GT_EXPR:
7546 0 : {
7547 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7548 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7549 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7550 : {
7551 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7552 : {
7553 0 : if (integer_zerop (_q82))
7554 : {
7555 0 : {
7556 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7557 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLE_EXPR, GT_EXPR);
7558 0 : if (res) return res;
7559 : }
7560 : }
7561 : }
7562 : }
7563 : break;
7564 : }
7565 : default:;
7566 : }
7567 : break;
7568 : }
7569 : default:;
7570 : }
7571 : }
7572 : break;
7573 : }
7574 0 : case UNGT_EXPR:
7575 0 : {
7576 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7577 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7578 0 : if (integer_zerop (_q22))
7579 : {
7580 0 : switch (TREE_CODE (_p1))
7581 : {
7582 0 : case VEC_COND_EXPR:
7583 0 : {
7584 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7585 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7586 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7587 0 : switch (TREE_CODE (_q80))
7588 : {
7589 0 : case LE_EXPR:
7590 0 : {
7591 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7592 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7593 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7594 : {
7595 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7596 : {
7597 0 : if (integer_zerop (_q82))
7598 : {
7599 0 : {
7600 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7601 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGT_EXPR, LE_EXPR);
7602 0 : if (res) return res;
7603 : }
7604 : }
7605 : }
7606 : }
7607 : break;
7608 : }
7609 : default:;
7610 : }
7611 : break;
7612 : }
7613 : default:;
7614 : }
7615 : }
7616 : break;
7617 : }
7618 0 : case UNGE_EXPR:
7619 0 : {
7620 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7621 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7622 0 : if (integer_zerop (_q22))
7623 : {
7624 0 : switch (TREE_CODE (_p1))
7625 : {
7626 0 : case VEC_COND_EXPR:
7627 0 : {
7628 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7629 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7630 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7631 0 : switch (TREE_CODE (_q80))
7632 : {
7633 0 : case LT_EXPR:
7634 0 : {
7635 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7636 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7637 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7638 : {
7639 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7640 : {
7641 0 : if (integer_zerop (_q82))
7642 : {
7643 0 : {
7644 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7645 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGE_EXPR, LT_EXPR);
7646 0 : if (res) return res;
7647 : }
7648 : }
7649 : }
7650 : }
7651 : break;
7652 : }
7653 : default:;
7654 : }
7655 : break;
7656 : }
7657 : default:;
7658 : }
7659 : }
7660 : break;
7661 : }
7662 0 : case UNEQ_EXPR:
7663 0 : {
7664 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7665 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7666 0 : if (integer_zerop (_q22))
7667 : {
7668 0 : switch (TREE_CODE (_p1))
7669 : {
7670 0 : case VEC_COND_EXPR:
7671 0 : {
7672 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7673 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7674 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7675 0 : switch (TREE_CODE (_q80))
7676 : {
7677 0 : case LTGT_EXPR:
7678 0 : {
7679 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7680 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7681 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7682 : {
7683 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7684 : {
7685 0 : if (integer_zerop (_q82))
7686 : {
7687 0 : {
7688 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7689 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNEQ_EXPR, LTGT_EXPR);
7690 0 : if (res) return res;
7691 : }
7692 : }
7693 : }
7694 : }
7695 : break;
7696 : }
7697 : default:;
7698 : }
7699 : break;
7700 : }
7701 : default:;
7702 : }
7703 : }
7704 : break;
7705 : }
7706 0 : case LTGT_EXPR:
7707 0 : {
7708 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7709 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7710 0 : if (integer_zerop (_q22))
7711 : {
7712 0 : switch (TREE_CODE (_p1))
7713 : {
7714 0 : case VEC_COND_EXPR:
7715 0 : {
7716 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7717 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7718 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7719 0 : switch (TREE_CODE (_q80))
7720 : {
7721 0 : case UNEQ_EXPR:
7722 0 : {
7723 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7724 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7725 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7726 : {
7727 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7728 : {
7729 0 : if (integer_zerop (_q82))
7730 : {
7731 0 : {
7732 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7733 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LTGT_EXPR, UNEQ_EXPR);
7734 0 : if (res) return res;
7735 : }
7736 : }
7737 : }
7738 : }
7739 : break;
7740 : }
7741 : default:;
7742 : }
7743 : break;
7744 : }
7745 : default:;
7746 : }
7747 : }
7748 : break;
7749 : }
7750 : default:;
7751 : }
7752 : break;
7753 : }
7754 119 : case EQ_EXPR:
7755 119 : {
7756 119 : tree _q20 = TREE_OPERAND (_p0, 0);
7757 119 : tree _q21 = TREE_OPERAND (_p0, 1);
7758 119 : switch (TREE_CODE (_p1))
7759 : {
7760 0 : case BIT_AND_EXPR:
7761 0 : {
7762 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7763 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7764 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7765 : {
7766 0 : if (tree_truth_valued_p (_q50))
7767 : {
7768 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7769 : {
7770 0 : if (tree_truth_valued_p (_q51))
7771 : {
7772 0 : {
7773 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7774 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1171;
7775 0 : {
7776 0 : tree res_op0;
7777 0 : {
7778 0 : tree _o1[2], _r1;
7779 0 : _o1[0] = captures[0];
7780 0 : _o1[1] = captures[1];
7781 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
7782 0 : res_op0 = _r1;
7783 : }
7784 0 : tree _r;
7785 0 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
7786 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 889, __FILE__, __LINE__, true);
7787 0 : return _r;
7788 : }
7789 0 : next_after_fail1171:;
7790 : }
7791 : }
7792 : }
7793 : }
7794 : }
7795 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7796 : {
7797 0 : if (tree_truth_valued_p (_q50))
7798 : {
7799 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7800 : {
7801 0 : if (tree_truth_valued_p (_q51))
7802 : {
7803 0 : {
7804 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7805 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1172;
7806 0 : {
7807 0 : tree res_op0;
7808 0 : {
7809 0 : tree _o1[2], _r1;
7810 0 : _o1[0] = captures[0];
7811 0 : _o1[1] = captures[1];
7812 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
7813 0 : res_op0 = _r1;
7814 : }
7815 0 : tree _r;
7816 0 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
7817 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 889, __FILE__, __LINE__, true);
7818 0 : return _r;
7819 : }
7820 0 : next_after_fail1172:;
7821 : }
7822 : }
7823 : }
7824 : }
7825 : }
7826 : break;
7827 : }
7828 : default:;
7829 : }
7830 : break;
7831 : }
7832 908127 : default:;
7833 : }
7834 908127 : {
7835 908127 : tree _p0_pops[1];
7836 908127 : if (tree_logical_inverted_value (_p0, _p0_pops))
7837 : {
7838 52 : tree _q20 = _p0_pops[0];
7839 52 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
7840 : {
7841 4 : if (tree_truth_valued_p (_p1))
7842 : {
7843 4 : {
7844 4 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
7845 4 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
7846 4 : if (res) return res;
7847 : }
7848 : }
7849 : }
7850 : }
7851 : }
7852 908123 : {
7853 908123 : tree _p0_pops[1];
7854 908123 : if (tree_nop_convert (_p0, _p0_pops))
7855 : {
7856 508121 : tree _q20 = _p0_pops[0];
7857 508121 : switch (TREE_CODE (_q20))
7858 : {
7859 24 : case BIT_NOT_EXPR:
7860 24 : {
7861 24 : tree _q30 = TREE_OPERAND (_q20, 0);
7862 24 : {
7863 24 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _p1 };
7864 24 : tree res = generic_simplify_39 (loc, type, _p0, _p1, captures);
7865 24 : if (res) return res;
7866 : }
7867 0 : break;
7868 : }
7869 20 : case MULT_EXPR:
7870 20 : {
7871 20 : tree _q30 = TREE_OPERAND (_q20, 0);
7872 20 : tree _q31 = TREE_OPERAND (_q20, 1);
7873 20 : {
7874 20 : tree _q30_pops[1];
7875 20 : if (tree_nop_convert (_q30, _q30_pops))
7876 : {
7877 0 : tree _q40 = _q30_pops[0];
7878 0 : switch (TREE_CODE (_q31))
7879 : {
7880 0 : case INTEGER_CST:
7881 0 : {
7882 0 : switch (TREE_CODE (_p1))
7883 : {
7884 0 : case LSHIFT_EXPR:
7885 0 : {
7886 0 : tree _q70 = TREE_OPERAND (_p1, 0);
7887 0 : tree _q71 = TREE_OPERAND (_p1, 1);
7888 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
7889 : {
7890 0 : switch (TREE_CODE (_q71))
7891 : {
7892 0 : case INTEGER_CST:
7893 0 : {
7894 0 : {
7895 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31, _p1, _q71 };
7896 0 : tree res = generic_simplify_41 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
7897 0 : if (res) return res;
7898 : }
7899 0 : break;
7900 : }
7901 : default:;
7902 : }
7903 : }
7904 : break;
7905 : }
7906 0 : default:;
7907 : }
7908 0 : {
7909 0 : tree _p1_pops[1];
7910 0 : if (tree_nop_convert (_p1, _p1_pops))
7911 : {
7912 0 : tree _q70 = _p1_pops[0];
7913 0 : switch (TREE_CODE (_q70))
7914 : {
7915 0 : case MULT_EXPR:
7916 0 : {
7917 0 : tree _q80 = TREE_OPERAND (_q70, 0);
7918 0 : tree _q81 = TREE_OPERAND (_q70, 1);
7919 0 : {
7920 0 : tree _q80_pops[1];
7921 0 : if (tree_nop_convert (_q80, _q80_pops))
7922 : {
7923 0 : tree _q90 = _q80_pops[0];
7924 0 : switch (TREE_CODE (_q81))
7925 : {
7926 0 : case INTEGER_CST:
7927 0 : {
7928 0 : {
7929 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31, _p1, _q70, _q90, _q81 };
7930 0 : tree res = generic_simplify_40 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
7931 0 : if (res) return res;
7932 : }
7933 0 : break;
7934 : }
7935 : default:;
7936 : }
7937 : }
7938 : }
7939 0 : break;
7940 : }
7941 : default:;
7942 : }
7943 : }
7944 : }
7945 0 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
7946 : {
7947 0 : {
7948 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31 };
7949 0 : tree res = generic_simplify_42 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
7950 0 : if (res) return res;
7951 : }
7952 : }
7953 : break;
7954 : }
7955 : default:;
7956 : }
7957 : }
7958 : }
7959 20 : break;
7960 : }
7961 : default:;
7962 : }
7963 : }
7964 : }
7965 908099 : if (tree_truth_valued_p (_p0))
7966 : {
7967 135539 : {
7968 135539 : tree _p1_pops[1];
7969 135539 : if (tree_logical_inverted_value (_p1, _p1_pops))
7970 : {
7971 13 : tree _q30 = _p1_pops[0];
7972 13 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
7973 : {
7974 0 : {
7975 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
7976 0 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
7977 0 : if (res) return res;
7978 : }
7979 : }
7980 : }
7981 : }
7982 : }
7983 908099 : switch (TREE_CODE (_p1))
7984 : {
7985 288 : case BIT_NOT_EXPR:
7986 288 : {
7987 288 : tree _q30 = TREE_OPERAND (_p1, 0);
7988 288 : {
7989 288 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0 };
7990 288 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
7991 288 : if (res) return res;
7992 : }
7993 0 : break;
7994 : }
7995 907811 : default:;
7996 : }
7997 907811 : {
7998 907811 : tree _p1_pops[1];
7999 907811 : if (tree_nop_convert (_p1, _p1_pops))
8000 : {
8001 635866 : tree _q30 = _p1_pops[0];
8002 635866 : switch (TREE_CODE (_q30))
8003 : {
8004 0 : case BIT_NOT_EXPR:
8005 0 : {
8006 0 : tree _q40 = TREE_OPERAND (_q30, 0);
8007 0 : {
8008 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0 };
8009 0 : tree res = generic_simplify_39 (loc, type, _p0, _p1, captures);
8010 0 : if (res) return res;
8011 : }
8012 0 : break;
8013 : }
8014 : default:;
8015 : }
8016 : }
8017 : }
8018 907811 : switch (TREE_CODE (_p0))
8019 : {
8020 1131 : case BIT_IOR_EXPR:
8021 1131 : {
8022 1131 : tree _q20 = TREE_OPERAND (_p0, 0);
8023 1131 : tree _q21 = TREE_OPERAND (_p0, 1);
8024 1131 : switch (TREE_CODE (_q21))
8025 : {
8026 23 : case INTEGER_CST:
8027 23 : {
8028 23 : switch (TREE_CODE (_p1))
8029 : {
8030 23 : case INTEGER_CST:
8031 23 : {
8032 23 : {
8033 23 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
8034 23 : tree res = generic_simplify_43 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_XOR_EXPR);
8035 23 : if (res) return res;
8036 : }
8037 23 : break;
8038 : }
8039 : default:;
8040 : }
8041 : break;
8042 : }
8043 : default:;
8044 : }
8045 : break;
8046 : }
8047 90 : case LT_EXPR:
8048 90 : {
8049 90 : tree _q20 = TREE_OPERAND (_p0, 0);
8050 90 : tree _q21 = TREE_OPERAND (_p0, 1);
8051 90 : switch (TREE_CODE (_p1))
8052 : {
8053 0 : case GT_EXPR:
8054 0 : {
8055 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8056 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8057 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8058 : {
8059 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8060 : {
8061 0 : {
8062 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8063 0 : const enum tree_code cmp1 = LT_EXPR;
8064 0 : const enum tree_code cmp2 = GT_EXPR;
8065 0 : const enum tree_code rcmp = NE_EXPR;
8066 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8067 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8068 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8069 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8070 : )
8071 : {
8072 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1173;
8073 0 : {
8074 0 : tree res_op0;
8075 0 : res_op0 = captures[0];
8076 0 : tree res_op1;
8077 0 : res_op1 = captures[1];
8078 0 : tree _r;
8079 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8080 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8081 0 : return _r;
8082 : }
8083 0 : next_after_fail1173:;
8084 : }
8085 : }
8086 : }
8087 : }
8088 : break;
8089 : }
8090 0 : case EQ_EXPR:
8091 0 : {
8092 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8093 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8094 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8095 : {
8096 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8097 : {
8098 0 : {
8099 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8100 0 : const enum tree_code cmp1 = LT_EXPR;
8101 0 : const enum tree_code cmp2 = EQ_EXPR;
8102 0 : const enum tree_code rcmp = LE_EXPR;
8103 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8104 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8105 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8106 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8107 : )
8108 : {
8109 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1174;
8110 0 : {
8111 0 : tree res_op0;
8112 0 : res_op0 = captures[0];
8113 0 : tree res_op1;
8114 0 : res_op1 = captures[1];
8115 0 : tree _r;
8116 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8117 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8118 0 : return _r;
8119 : }
8120 0 : next_after_fail1174:;
8121 : }
8122 : }
8123 : }
8124 : }
8125 : break;
8126 : }
8127 0 : case NE_EXPR:
8128 0 : {
8129 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8130 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8131 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8132 : {
8133 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8134 : {
8135 0 : {
8136 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8137 0 : const enum tree_code cmp1 = LT_EXPR;
8138 0 : const enum tree_code cmp2 = NE_EXPR;
8139 0 : const enum tree_code rcmp = GT_EXPR;
8140 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8141 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8142 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8143 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8144 : )
8145 : {
8146 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1175;
8147 0 : {
8148 0 : tree res_op0;
8149 0 : res_op0 = captures[0];
8150 0 : tree res_op1;
8151 0 : res_op1 = captures[1];
8152 0 : tree _r;
8153 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8154 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8155 0 : return _r;
8156 : }
8157 0 : next_after_fail1175:;
8158 : }
8159 : }
8160 : }
8161 : }
8162 : break;
8163 : }
8164 : default:;
8165 : }
8166 : break;
8167 : }
8168 85 : case LE_EXPR:
8169 85 : {
8170 85 : tree _q20 = TREE_OPERAND (_p0, 0);
8171 85 : tree _q21 = TREE_OPERAND (_p0, 1);
8172 85 : switch (TREE_CODE (_p1))
8173 : {
8174 0 : case GE_EXPR:
8175 0 : {
8176 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8177 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8178 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8179 : {
8180 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8181 : {
8182 0 : {
8183 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8184 0 : const enum tree_code cmp1 = LE_EXPR;
8185 0 : const enum tree_code cmp2 = GE_EXPR;
8186 0 : const enum tree_code rcmp = NE_EXPR;
8187 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8188 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8189 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8190 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8191 : )
8192 : {
8193 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1176;
8194 0 : {
8195 0 : tree res_op0;
8196 0 : res_op0 = captures[0];
8197 0 : tree res_op1;
8198 0 : res_op1 = captures[1];
8199 0 : tree _r;
8200 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8201 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8202 0 : return _r;
8203 : }
8204 0 : next_after_fail1176:;
8205 : }
8206 : }
8207 : }
8208 : }
8209 : break;
8210 : }
8211 0 : case EQ_EXPR:
8212 0 : {
8213 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8214 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8215 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8216 : {
8217 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8218 : {
8219 0 : {
8220 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8221 0 : const enum tree_code cmp1 = LE_EXPR;
8222 0 : const enum tree_code cmp2 = EQ_EXPR;
8223 0 : const enum tree_code rcmp = LT_EXPR;
8224 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8225 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8226 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8227 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8228 : )
8229 : {
8230 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1177;
8231 0 : {
8232 0 : tree res_op0;
8233 0 : res_op0 = captures[0];
8234 0 : tree res_op1;
8235 0 : res_op1 = captures[1];
8236 0 : tree _r;
8237 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8238 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8239 0 : return _r;
8240 : }
8241 0 : next_after_fail1177:;
8242 : }
8243 : }
8244 : }
8245 : }
8246 : break;
8247 : }
8248 0 : case NE_EXPR:
8249 0 : {
8250 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8251 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8252 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8253 : {
8254 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8255 : {
8256 0 : {
8257 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8258 0 : const enum tree_code cmp1 = LE_EXPR;
8259 0 : const enum tree_code cmp2 = NE_EXPR;
8260 0 : const enum tree_code rcmp = GE_EXPR;
8261 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8262 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8263 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8264 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8265 : )
8266 : {
8267 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1178;
8268 0 : {
8269 0 : tree res_op0;
8270 0 : res_op0 = captures[0];
8271 0 : tree res_op1;
8272 0 : res_op1 = captures[1];
8273 0 : tree _r;
8274 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8275 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8276 0 : return _r;
8277 : }
8278 0 : next_after_fail1178:;
8279 : }
8280 : }
8281 : }
8282 : }
8283 : break;
8284 : }
8285 : default:;
8286 : }
8287 : break;
8288 : }
8289 100 : case GT_EXPR:
8290 100 : {
8291 100 : tree _q20 = TREE_OPERAND (_p0, 0);
8292 100 : tree _q21 = TREE_OPERAND (_p0, 1);
8293 100 : switch (TREE_CODE (_p1))
8294 : {
8295 0 : case GT_EXPR:
8296 0 : {
8297 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8298 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8299 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8300 : {
8301 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8302 : {
8303 0 : {
8304 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8305 0 : const enum tree_code cmp1 = LT_EXPR;
8306 0 : const enum tree_code cmp2 = GT_EXPR;
8307 0 : const enum tree_code rcmp = NE_EXPR;
8308 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8309 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8310 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8311 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8312 : )
8313 : {
8314 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1179;
8315 0 : {
8316 0 : tree res_op0;
8317 0 : res_op0 = captures[0];
8318 0 : tree res_op1;
8319 0 : res_op1 = captures[1];
8320 0 : tree _r;
8321 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8322 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8323 0 : return _r;
8324 : }
8325 0 : next_after_fail1179:;
8326 : }
8327 : }
8328 0 : {
8329 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8330 0 : const enum tree_code cmp1 = LT_EXPR;
8331 0 : const enum tree_code cmp2 = GT_EXPR;
8332 0 : const enum tree_code rcmp = NE_EXPR;
8333 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8334 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8335 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8336 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8337 : )
8338 : {
8339 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1180;
8340 0 : {
8341 0 : tree res_op0;
8342 0 : res_op0 = captures[0];
8343 0 : tree res_op1;
8344 0 : res_op1 = captures[1];
8345 0 : tree _r;
8346 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8347 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8348 0 : return _r;
8349 : }
8350 0 : next_after_fail1180:;
8351 : }
8352 : }
8353 : }
8354 : }
8355 : break;
8356 : }
8357 0 : case EQ_EXPR:
8358 0 : {
8359 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8360 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8361 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8362 : {
8363 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8364 : {
8365 0 : {
8366 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8367 0 : const enum tree_code cmp1 = LT_EXPR;
8368 0 : const enum tree_code cmp2 = EQ_EXPR;
8369 0 : const enum tree_code rcmp = LE_EXPR;
8370 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8371 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8372 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8373 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8374 : )
8375 : {
8376 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1181;
8377 0 : {
8378 0 : tree res_op0;
8379 0 : res_op0 = captures[0];
8380 0 : tree res_op1;
8381 0 : res_op1 = captures[1];
8382 0 : tree _r;
8383 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8384 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8385 0 : return _r;
8386 : }
8387 0 : next_after_fail1181:;
8388 : }
8389 : }
8390 : }
8391 : }
8392 : break;
8393 : }
8394 12 : case NE_EXPR:
8395 12 : {
8396 12 : tree _q50 = TREE_OPERAND (_p1, 0);
8397 12 : tree _q51 = TREE_OPERAND (_p1, 1);
8398 12 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8399 : {
8400 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8401 : {
8402 0 : {
8403 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8404 0 : const enum tree_code cmp1 = LT_EXPR;
8405 0 : const enum tree_code cmp2 = NE_EXPR;
8406 0 : const enum tree_code rcmp = GT_EXPR;
8407 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8408 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8409 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8410 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8411 : )
8412 : {
8413 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1182;
8414 0 : {
8415 0 : tree res_op0;
8416 0 : res_op0 = captures[0];
8417 0 : tree res_op1;
8418 0 : res_op1 = captures[1];
8419 0 : tree _r;
8420 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8421 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8422 0 : return _r;
8423 : }
8424 0 : next_after_fail1182:;
8425 : }
8426 : }
8427 : }
8428 : }
8429 : break;
8430 : }
8431 0 : case LT_EXPR:
8432 0 : {
8433 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8434 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8435 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8436 : {
8437 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8438 : {
8439 0 : {
8440 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8441 0 : const enum tree_code cmp1 = LT_EXPR;
8442 0 : const enum tree_code cmp2 = GT_EXPR;
8443 0 : const enum tree_code rcmp = NE_EXPR;
8444 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8445 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8446 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8447 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8448 : )
8449 : {
8450 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1183;
8451 0 : {
8452 0 : tree res_op0;
8453 0 : res_op0 = captures[0];
8454 0 : tree res_op1;
8455 0 : res_op1 = captures[1];
8456 0 : tree _r;
8457 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8458 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8459 0 : return _r;
8460 : }
8461 0 : next_after_fail1183:;
8462 : }
8463 : }
8464 : }
8465 : }
8466 : break;
8467 : }
8468 : default:;
8469 : }
8470 : break;
8471 : }
8472 62 : case GE_EXPR:
8473 62 : {
8474 62 : tree _q20 = TREE_OPERAND (_p0, 0);
8475 62 : tree _q21 = TREE_OPERAND (_p0, 1);
8476 62 : switch (TREE_CODE (_p1))
8477 : {
8478 1 : case GE_EXPR:
8479 1 : {
8480 1 : tree _q50 = TREE_OPERAND (_p1, 0);
8481 1 : tree _q51 = TREE_OPERAND (_p1, 1);
8482 1 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8483 : {
8484 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8485 : {
8486 0 : {
8487 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8488 0 : const enum tree_code cmp1 = LE_EXPR;
8489 0 : const enum tree_code cmp2 = GE_EXPR;
8490 0 : const enum tree_code rcmp = NE_EXPR;
8491 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8492 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8493 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8494 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8495 : )
8496 : {
8497 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1184;
8498 0 : {
8499 0 : tree res_op0;
8500 0 : res_op0 = captures[0];
8501 0 : tree res_op1;
8502 0 : res_op1 = captures[1];
8503 0 : tree _r;
8504 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8505 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8506 0 : return _r;
8507 : }
8508 0 : next_after_fail1184:;
8509 : }
8510 : }
8511 0 : {
8512 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8513 0 : const enum tree_code cmp1 = LE_EXPR;
8514 0 : const enum tree_code cmp2 = GE_EXPR;
8515 0 : const enum tree_code rcmp = NE_EXPR;
8516 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8517 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8518 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8519 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8520 : )
8521 : {
8522 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1185;
8523 0 : {
8524 0 : tree res_op0;
8525 0 : res_op0 = captures[0];
8526 0 : tree res_op1;
8527 0 : res_op1 = captures[1];
8528 0 : tree _r;
8529 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8530 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8531 0 : return _r;
8532 : }
8533 0 : next_after_fail1185:;
8534 : }
8535 : }
8536 : }
8537 : }
8538 : break;
8539 : }
8540 0 : case EQ_EXPR:
8541 0 : {
8542 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8543 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8544 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8545 : {
8546 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8547 : {
8548 0 : {
8549 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8550 0 : const enum tree_code cmp1 = LE_EXPR;
8551 0 : const enum tree_code cmp2 = EQ_EXPR;
8552 0 : const enum tree_code rcmp = LT_EXPR;
8553 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8554 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8555 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8556 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8557 : )
8558 : {
8559 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1186;
8560 0 : {
8561 0 : tree res_op0;
8562 0 : res_op0 = captures[0];
8563 0 : tree res_op1;
8564 0 : res_op1 = captures[1];
8565 0 : tree _r;
8566 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8567 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8568 0 : return _r;
8569 : }
8570 0 : next_after_fail1186:;
8571 : }
8572 : }
8573 : }
8574 : }
8575 : break;
8576 : }
8577 8 : case NE_EXPR:
8578 8 : {
8579 8 : tree _q50 = TREE_OPERAND (_p1, 0);
8580 8 : tree _q51 = TREE_OPERAND (_p1, 1);
8581 8 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8582 : {
8583 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8584 : {
8585 0 : {
8586 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8587 0 : const enum tree_code cmp1 = LE_EXPR;
8588 0 : const enum tree_code cmp2 = NE_EXPR;
8589 0 : const enum tree_code rcmp = GE_EXPR;
8590 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8591 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8592 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8593 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8594 : )
8595 : {
8596 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1187;
8597 0 : {
8598 0 : tree res_op0;
8599 0 : res_op0 = captures[0];
8600 0 : tree res_op1;
8601 0 : res_op1 = captures[1];
8602 0 : tree _r;
8603 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8604 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8605 0 : return _r;
8606 : }
8607 0 : next_after_fail1187:;
8608 : }
8609 : }
8610 : }
8611 : }
8612 : break;
8613 : }
8614 0 : case LE_EXPR:
8615 0 : {
8616 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8617 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8618 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8619 : {
8620 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8621 : {
8622 0 : {
8623 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8624 0 : const enum tree_code cmp1 = LE_EXPR;
8625 0 : const enum tree_code cmp2 = GE_EXPR;
8626 0 : const enum tree_code rcmp = NE_EXPR;
8627 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8628 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8629 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8630 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8631 : )
8632 : {
8633 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1188;
8634 0 : {
8635 0 : tree res_op0;
8636 0 : res_op0 = captures[0];
8637 0 : tree res_op1;
8638 0 : res_op1 = captures[1];
8639 0 : tree _r;
8640 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8641 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8642 0 : return _r;
8643 : }
8644 0 : next_after_fail1188:;
8645 : }
8646 : }
8647 : }
8648 : }
8649 : break;
8650 : }
8651 : default:;
8652 : }
8653 : break;
8654 : }
8655 119 : case EQ_EXPR:
8656 119 : {
8657 119 : tree _q20 = TREE_OPERAND (_p0, 0);
8658 119 : tree _q21 = TREE_OPERAND (_p0, 1);
8659 119 : switch (TREE_CODE (_p1))
8660 : {
8661 0 : case LT_EXPR:
8662 0 : {
8663 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8664 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8665 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8666 : {
8667 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8668 : {
8669 0 : {
8670 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8671 0 : const enum tree_code cmp1 = LT_EXPR;
8672 0 : const enum tree_code cmp2 = EQ_EXPR;
8673 0 : const enum tree_code rcmp = LE_EXPR;
8674 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8675 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8676 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8677 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8678 : )
8679 : {
8680 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1189;
8681 0 : {
8682 0 : tree res_op0;
8683 0 : res_op0 = captures[0];
8684 0 : tree res_op1;
8685 0 : res_op1 = captures[1];
8686 0 : tree _r;
8687 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8688 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8689 0 : return _r;
8690 : }
8691 0 : next_after_fail1189:;
8692 : }
8693 : }
8694 : }
8695 : }
8696 : break;
8697 : }
8698 0 : case LE_EXPR:
8699 0 : {
8700 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8701 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8702 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8703 : {
8704 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8705 : {
8706 0 : {
8707 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8708 0 : const enum tree_code cmp1 = LE_EXPR;
8709 0 : const enum tree_code cmp2 = EQ_EXPR;
8710 0 : const enum tree_code rcmp = LT_EXPR;
8711 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8712 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8713 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8714 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8715 : )
8716 : {
8717 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1190;
8718 0 : {
8719 0 : tree res_op0;
8720 0 : res_op0 = captures[0];
8721 0 : tree res_op1;
8722 0 : res_op1 = captures[1];
8723 0 : tree _r;
8724 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8725 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8726 0 : return _r;
8727 : }
8728 0 : next_after_fail1190:;
8729 : }
8730 : }
8731 : }
8732 : }
8733 : break;
8734 : }
8735 0 : case GT_EXPR:
8736 0 : {
8737 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8738 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8739 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8740 : {
8741 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8742 : {
8743 0 : {
8744 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8745 0 : const enum tree_code cmp1 = LT_EXPR;
8746 0 : const enum tree_code cmp2 = EQ_EXPR;
8747 0 : const enum tree_code rcmp = LE_EXPR;
8748 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8749 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8750 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8751 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8752 : )
8753 : {
8754 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1191;
8755 0 : {
8756 0 : tree res_op0;
8757 0 : res_op0 = captures[0];
8758 0 : tree res_op1;
8759 0 : res_op1 = captures[1];
8760 0 : tree _r;
8761 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8762 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8763 0 : return _r;
8764 : }
8765 0 : next_after_fail1191:;
8766 : }
8767 : }
8768 : }
8769 : }
8770 : break;
8771 : }
8772 8 : case GE_EXPR:
8773 8 : {
8774 8 : tree _q50 = TREE_OPERAND (_p1, 0);
8775 8 : tree _q51 = TREE_OPERAND (_p1, 1);
8776 8 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8777 : {
8778 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8779 : {
8780 0 : {
8781 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8782 0 : const enum tree_code cmp1 = LE_EXPR;
8783 0 : const enum tree_code cmp2 = EQ_EXPR;
8784 0 : const enum tree_code rcmp = LT_EXPR;
8785 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8786 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8787 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8788 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8789 : )
8790 : {
8791 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1192;
8792 0 : {
8793 0 : tree res_op0;
8794 0 : res_op0 = captures[0];
8795 0 : tree res_op1;
8796 0 : res_op1 = captures[1];
8797 0 : tree _r;
8798 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8799 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8800 0 : return _r;
8801 : }
8802 0 : next_after_fail1192:;
8803 : }
8804 : }
8805 : }
8806 : }
8807 : break;
8808 : }
8809 : default:;
8810 : }
8811 : break;
8812 : }
8813 113 : case NE_EXPR:
8814 113 : {
8815 113 : tree _q20 = TREE_OPERAND (_p0, 0);
8816 113 : tree _q21 = TREE_OPERAND (_p0, 1);
8817 113 : switch (TREE_CODE (_p1))
8818 : {
8819 0 : case LT_EXPR:
8820 0 : {
8821 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8822 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8823 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8824 : {
8825 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8826 : {
8827 0 : {
8828 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8829 0 : const enum tree_code cmp1 = LT_EXPR;
8830 0 : const enum tree_code cmp2 = NE_EXPR;
8831 0 : const enum tree_code rcmp = GT_EXPR;
8832 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8833 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8834 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8835 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8836 : )
8837 : {
8838 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1193;
8839 0 : {
8840 0 : tree res_op0;
8841 0 : res_op0 = captures[0];
8842 0 : tree res_op1;
8843 0 : res_op1 = captures[1];
8844 0 : tree _r;
8845 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8846 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8847 0 : return _r;
8848 : }
8849 0 : next_after_fail1193:;
8850 : }
8851 : }
8852 : }
8853 : }
8854 : break;
8855 : }
8856 0 : case LE_EXPR:
8857 0 : {
8858 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8859 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8860 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8861 : {
8862 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8863 : {
8864 0 : {
8865 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8866 0 : const enum tree_code cmp1 = LE_EXPR;
8867 0 : const enum tree_code cmp2 = NE_EXPR;
8868 0 : const enum tree_code rcmp = GE_EXPR;
8869 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8870 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8871 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8872 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8873 : )
8874 : {
8875 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1194;
8876 0 : {
8877 0 : tree res_op0;
8878 0 : res_op0 = captures[0];
8879 0 : tree res_op1;
8880 0 : res_op1 = captures[1];
8881 0 : tree _r;
8882 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8883 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8884 0 : return _r;
8885 : }
8886 0 : next_after_fail1194:;
8887 : }
8888 : }
8889 : }
8890 : }
8891 : break;
8892 : }
8893 0 : case GT_EXPR:
8894 0 : {
8895 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8896 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8897 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8898 : {
8899 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8900 : {
8901 0 : {
8902 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8903 0 : const enum tree_code cmp1 = LT_EXPR;
8904 0 : const enum tree_code cmp2 = NE_EXPR;
8905 0 : const enum tree_code rcmp = GT_EXPR;
8906 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8907 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8908 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8909 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8910 : )
8911 : {
8912 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1195;
8913 0 : {
8914 0 : tree res_op0;
8915 0 : res_op0 = captures[0];
8916 0 : tree res_op1;
8917 0 : res_op1 = captures[1];
8918 0 : tree _r;
8919 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8920 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8921 0 : return _r;
8922 : }
8923 0 : next_after_fail1195:;
8924 : }
8925 : }
8926 : }
8927 : }
8928 : break;
8929 : }
8930 6 : case GE_EXPR:
8931 6 : {
8932 6 : tree _q50 = TREE_OPERAND (_p1, 0);
8933 6 : tree _q51 = TREE_OPERAND (_p1, 1);
8934 6 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8935 : {
8936 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8937 : {
8938 0 : {
8939 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8940 0 : const enum tree_code cmp1 = LE_EXPR;
8941 0 : const enum tree_code cmp2 = NE_EXPR;
8942 0 : const enum tree_code rcmp = GE_EXPR;
8943 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8944 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8945 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8946 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8947 : )
8948 : {
8949 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1196;
8950 0 : {
8951 0 : tree res_op0;
8952 0 : res_op0 = captures[0];
8953 0 : tree res_op1;
8954 0 : res_op1 = captures[1];
8955 0 : tree _r;
8956 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8957 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
8958 0 : return _r;
8959 : }
8960 0 : next_after_fail1196:;
8961 : }
8962 : }
8963 : }
8964 : }
8965 : break;
8966 : }
8967 : default:;
8968 : }
8969 : break;
8970 : }
8971 524 : case MULT_EXPR:
8972 524 : {
8973 524 : tree _q20 = TREE_OPERAND (_p0, 0);
8974 524 : tree _q21 = TREE_OPERAND (_p0, 1);
8975 524 : switch (TREE_CODE (_q21))
8976 : {
8977 498 : case INTEGER_CST:
8978 498 : {
8979 498 : switch (TREE_CODE (_p1))
8980 : {
8981 12 : case MULT_EXPR:
8982 12 : {
8983 12 : tree _q50 = TREE_OPERAND (_p1, 0);
8984 12 : tree _q51 = TREE_OPERAND (_p1, 1);
8985 12 : switch (TREE_CODE (_q51))
8986 : {
8987 12 : case INTEGER_CST:
8988 12 : {
8989 12 : {
8990 12 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1, _p1, _q50, _q51 };
8991 12 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
8992 12 : if (res) return res;
8993 : }
8994 12 : break;
8995 : }
8996 : default:;
8997 : }
8998 : break;
8999 : }
9000 0 : case LSHIFT_EXPR:
9001 0 : {
9002 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9003 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9004 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9005 : {
9006 0 : switch (TREE_CODE (_q51))
9007 : {
9008 0 : case INTEGER_CST:
9009 0 : {
9010 0 : {
9011 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1, _q51 };
9012 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9013 0 : if (res) return res;
9014 : }
9015 0 : break;
9016 : }
9017 : default:;
9018 : }
9019 : }
9020 : break;
9021 : }
9022 498 : default:;
9023 : }
9024 498 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9025 : {
9026 18 : {
9027 18 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
9028 18 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9029 18 : if (res) return res;
9030 : }
9031 : }
9032 : break;
9033 : }
9034 524 : default:;
9035 : }
9036 524 : switch (TREE_CODE (_q20))
9037 : {
9038 0 : case BIT_XOR_EXPR:
9039 0 : {
9040 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9041 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9042 0 : if (tree_zero_one_valued_p (_q21))
9043 : {
9044 0 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
9045 : {
9046 0 : {
9047 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q21 };
9048 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
9049 0 : if (res) return res;
9050 : }
9051 : }
9052 0 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
9053 : {
9054 0 : {
9055 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q21 };
9056 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
9057 0 : if (res) return res;
9058 : }
9059 : }
9060 : }
9061 : break;
9062 : }
9063 524 : default:;
9064 : }
9065 524 : if (tree_zero_one_valued_p (_q20))
9066 : {
9067 8 : switch (TREE_CODE (_q21))
9068 : {
9069 2 : case BIT_XOR_EXPR:
9070 2 : {
9071 2 : tree _q40 = TREE_OPERAND (_q21, 0);
9072 2 : tree _q41 = TREE_OPERAND (_q21, 1);
9073 2 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
9074 : {
9075 2 : {
9076 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q20 };
9077 2 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
9078 2 : if (res) return res;
9079 : }
9080 : }
9081 0 : if ((_p1 == _q41 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q41, 0) && types_match (_p1, _q41)))
9082 : {
9083 0 : {
9084 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q20 };
9085 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
9086 0 : if (res) return res;
9087 : }
9088 : }
9089 : break;
9090 : }
9091 : default:;
9092 : }
9093 : }
9094 : break;
9095 : }
9096 2503 : case LSHIFT_EXPR:
9097 2503 : {
9098 2503 : tree _q20 = TREE_OPERAND (_p0, 0);
9099 2503 : tree _q21 = TREE_OPERAND (_p0, 1);
9100 2503 : switch (TREE_CODE (_q21))
9101 : {
9102 1122 : case INTEGER_CST:
9103 1122 : {
9104 1122 : switch (TREE_CODE (_p1))
9105 : {
9106 0 : case MULT_EXPR:
9107 0 : {
9108 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9109 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9110 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9111 : {
9112 0 : switch (TREE_CODE (_q51))
9113 : {
9114 0 : case INTEGER_CST:
9115 0 : {
9116 0 : {
9117 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _p1, _q20, _q51, _p0, _q21 };
9118 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9119 0 : if (res) return res;
9120 : }
9121 0 : break;
9122 : }
9123 : default:;
9124 : }
9125 : }
9126 : break;
9127 : }
9128 1122 : default:;
9129 : }
9130 1122 : {
9131 1122 : tree _p1_pops[1];
9132 1122 : if (tree_nop_convert (_p1, _p1_pops))
9133 : {
9134 23 : tree _q50 = _p1_pops[0];
9135 23 : switch (TREE_CODE (_q50))
9136 : {
9137 0 : case MULT_EXPR:
9138 0 : {
9139 0 : tree _q60 = TREE_OPERAND (_q50, 0);
9140 0 : tree _q61 = TREE_OPERAND (_q50, 1);
9141 0 : {
9142 0 : tree _q60_pops[1];
9143 0 : if (tree_nop_convert (_q60, _q60_pops))
9144 : {
9145 0 : tree _q70 = _q60_pops[0];
9146 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
9147 : {
9148 0 : switch (TREE_CODE (_q61))
9149 : {
9150 0 : case INTEGER_CST:
9151 0 : {
9152 0 : {
9153 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _q50, _q20, _q61, _p0, _q21 };
9154 0 : tree res = generic_simplify_41 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9155 0 : if (res) return res;
9156 : }
9157 0 : break;
9158 : }
9159 : default:;
9160 : }
9161 : }
9162 : }
9163 : }
9164 0 : break;
9165 : }
9166 : default:;
9167 : }
9168 : }
9169 : }
9170 1122 : break;
9171 : }
9172 : default:;
9173 : }
9174 : break;
9175 : }
9176 907809 : default:;
9177 : }
9178 907809 : switch (TREE_CODE (_p1))
9179 : {
9180 244 : case MULT_EXPR:
9181 244 : {
9182 244 : tree _q30 = TREE_OPERAND (_p1, 0);
9183 244 : tree _q31 = TREE_OPERAND (_p1, 1);
9184 244 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9185 : {
9186 0 : switch (TREE_CODE (_q31))
9187 : {
9188 0 : case INTEGER_CST:
9189 0 : {
9190 0 : {
9191 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _p0, _q31 };
9192 0 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9193 0 : if (res) return res;
9194 : }
9195 0 : break;
9196 : }
9197 : default:;
9198 : }
9199 : }
9200 : break;
9201 : }
9202 907809 : default:;
9203 : }
9204 907809 : {
9205 907809 : tree _p1_pops[1];
9206 907809 : if (tree_nop_convert (_p1, _p1_pops))
9207 : {
9208 635866 : tree _q30 = _p1_pops[0];
9209 635866 : switch (TREE_CODE (_q30))
9210 : {
9211 17 : case MULT_EXPR:
9212 17 : {
9213 17 : tree _q40 = TREE_OPERAND (_q30, 0);
9214 17 : tree _q41 = TREE_OPERAND (_q30, 1);
9215 17 : {
9216 17 : tree _q40_pops[1];
9217 17 : if (tree_nop_convert (_q40, _q40_pops))
9218 : {
9219 0 : tree _q50 = _q40_pops[0];
9220 0 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
9221 : {
9222 0 : switch (TREE_CODE (_q41))
9223 : {
9224 0 : case INTEGER_CST:
9225 0 : {
9226 0 : {
9227 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _p0, _q41 };
9228 0 : tree res = generic_simplify_42 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9229 0 : if (res) return res;
9230 : }
9231 0 : break;
9232 : }
9233 : default:;
9234 : }
9235 : }
9236 : }
9237 : }
9238 17 : break;
9239 : }
9240 : default:;
9241 : }
9242 : }
9243 : }
9244 907809 : switch (TREE_CODE (_p0))
9245 : {
9246 2503 : case LSHIFT_EXPR:
9247 2503 : {
9248 2503 : tree _q20 = TREE_OPERAND (_p0, 0);
9249 2503 : tree _q21 = TREE_OPERAND (_p0, 1);
9250 2503 : switch (TREE_CODE (_q21))
9251 : {
9252 1122 : case INTEGER_CST:
9253 1122 : {
9254 1122 : switch (TREE_CODE (_p1))
9255 : {
9256 9 : case LSHIFT_EXPR:
9257 9 : {
9258 9 : tree _q50 = TREE_OPERAND (_p1, 0);
9259 9 : tree _q51 = TREE_OPERAND (_p1, 1);
9260 9 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9261 : {
9262 3 : switch (TREE_CODE (_q51))
9263 : {
9264 3 : case INTEGER_CST:
9265 3 : {
9266 3 : {
9267 3 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
9268 3 : tree res = generic_simplify_48 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9269 3 : if (res) return res;
9270 : }
9271 1 : break;
9272 : }
9273 : default:;
9274 : }
9275 : }
9276 : break;
9277 : }
9278 1120 : default:;
9279 : }
9280 1120 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9281 : {
9282 57 : {
9283 57 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
9284 57 : tree res = generic_simplify_49 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9285 57 : if (res) return res;
9286 : }
9287 : }
9288 : break;
9289 : }
9290 : default:;
9291 : }
9292 : break;
9293 : }
9294 907807 : default:;
9295 : }
9296 907807 : switch (TREE_CODE (_p1))
9297 : {
9298 1982 : case LSHIFT_EXPR:
9299 1982 : {
9300 1982 : tree _q30 = TREE_OPERAND (_p1, 0);
9301 1982 : tree _q31 = TREE_OPERAND (_p1, 1);
9302 1982 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9303 : {
9304 3 : switch (TREE_CODE (_q31))
9305 : {
9306 3 : case INTEGER_CST:
9307 3 : {
9308 3 : {
9309 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q31 };
9310 3 : tree res = generic_simplify_49 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9311 3 : if (res) return res;
9312 : }
9313 0 : break;
9314 : }
9315 : default:;
9316 : }
9317 : }
9318 : break;
9319 : }
9320 907804 : default:;
9321 : }
9322 907804 : switch (TREE_CODE (_p0))
9323 : {
9324 0 : case MIN_EXPR:
9325 0 : {
9326 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9327 0 : tree _q21 = TREE_OPERAND (_p0, 1);
9328 0 : switch (TREE_CODE (_p1))
9329 : {
9330 0 : case MAX_EXPR:
9331 0 : {
9332 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9333 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9334 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9335 : {
9336 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9337 : {
9338 0 : {
9339 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9340 0 : if (!HONOR_NANS (captures[0])
9341 : )
9342 : {
9343 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1197;
9344 0 : {
9345 0 : tree res_op0;
9346 0 : res_op0 = captures[0];
9347 0 : tree res_op1;
9348 0 : res_op1 = captures[1];
9349 0 : tree _r;
9350 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
9351 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
9352 0 : return _r;
9353 : }
9354 0 : next_after_fail1197:;
9355 : }
9356 : }
9357 : }
9358 : }
9359 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9360 : {
9361 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9362 : {
9363 0 : {
9364 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9365 0 : if (!HONOR_NANS (captures[0])
9366 : )
9367 : {
9368 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1198;
9369 0 : {
9370 0 : tree res_op0;
9371 0 : res_op0 = captures[0];
9372 0 : tree res_op1;
9373 0 : res_op1 = captures[1];
9374 0 : tree _r;
9375 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
9376 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
9377 0 : return _r;
9378 : }
9379 0 : next_after_fail1198:;
9380 : }
9381 : }
9382 : }
9383 : }
9384 : break;
9385 : }
9386 : default:;
9387 : }
9388 : break;
9389 : }
9390 126 : case MAX_EXPR:
9391 126 : {
9392 126 : tree _q20 = TREE_OPERAND (_p0, 0);
9393 126 : tree _q21 = TREE_OPERAND (_p0, 1);
9394 126 : switch (TREE_CODE (_p1))
9395 : {
9396 0 : case MIN_EXPR:
9397 0 : {
9398 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9399 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9400 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9401 : {
9402 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9403 : {
9404 0 : {
9405 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9406 0 : if (!HONOR_NANS (captures[0])
9407 : )
9408 : {
9409 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1199;
9410 0 : {
9411 0 : tree res_op0;
9412 0 : res_op0 = captures[0];
9413 0 : tree res_op1;
9414 0 : res_op1 = captures[1];
9415 0 : tree _r;
9416 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
9417 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
9418 0 : return _r;
9419 : }
9420 0 : next_after_fail1199:;
9421 : }
9422 : }
9423 : }
9424 : }
9425 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9426 : {
9427 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9428 : {
9429 0 : {
9430 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9431 0 : if (!HONOR_NANS (captures[0])
9432 : )
9433 : {
9434 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1200;
9435 0 : {
9436 0 : tree res_op0;
9437 0 : res_op0 = captures[0];
9438 0 : tree res_op1;
9439 0 : res_op1 = captures[1];
9440 0 : tree _r;
9441 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
9442 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
9443 0 : return _r;
9444 : }
9445 0 : next_after_fail1200:;
9446 : }
9447 : }
9448 : }
9449 : }
9450 : break;
9451 : }
9452 : default:;
9453 : }
9454 : break;
9455 : }
9456 907804 : default:;
9457 : }
9458 907804 : switch (TREE_CODE (_p1))
9459 : {
9460 244 : case MULT_EXPR:
9461 244 : {
9462 244 : tree _q30 = TREE_OPERAND (_p1, 0);
9463 244 : tree _q31 = TREE_OPERAND (_p1, 1);
9464 244 : switch (TREE_CODE (_q30))
9465 : {
9466 0 : case BIT_XOR_EXPR:
9467 0 : {
9468 0 : tree _q40 = TREE_OPERAND (_q30, 0);
9469 0 : tree _q41 = TREE_OPERAND (_q30, 1);
9470 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
9471 : {
9472 0 : if (tree_zero_one_valued_p (_q31))
9473 : {
9474 0 : {
9475 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q31 };
9476 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
9477 0 : if (res) return res;
9478 : }
9479 : }
9480 : }
9481 0 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
9482 : {
9483 0 : if (tree_zero_one_valued_p (_q31))
9484 : {
9485 0 : {
9486 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q31 };
9487 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
9488 0 : if (res) return res;
9489 : }
9490 : }
9491 : }
9492 : break;
9493 : }
9494 244 : default:;
9495 : }
9496 244 : if (tree_zero_one_valued_p (_q30))
9497 : {
9498 17 : switch (TREE_CODE (_q31))
9499 : {
9500 0 : case BIT_XOR_EXPR:
9501 0 : {
9502 0 : tree _q50 = TREE_OPERAND (_q31, 0);
9503 0 : tree _q51 = TREE_OPERAND (_q31, 1);
9504 0 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
9505 : {
9506 0 : {
9507 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q51, _q30 };
9508 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
9509 0 : if (res) return res;
9510 : }
9511 : }
9512 0 : if ((_q51 == _p0 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _p0, 0) && types_match (_q51, _p0)))
9513 : {
9514 0 : {
9515 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q50, _q30 };
9516 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
9517 0 : if (res) return res;
9518 : }
9519 : }
9520 : break;
9521 : }
9522 : default:;
9523 : }
9524 : }
9525 : break;
9526 : }
9527 907804 : default:;
9528 : }
9529 907804 : switch (TREE_CODE (_p0))
9530 : {
9531 1 : case VEC_COND_EXPR:
9532 1 : {
9533 1 : tree _q20 = TREE_OPERAND (_p0, 0);
9534 1 : tree _q21 = TREE_OPERAND (_p0, 1);
9535 1 : tree _q22 = TREE_OPERAND (_p0, 2);
9536 1 : switch (TREE_CODE (_p1))
9537 : {
9538 0 : case VEC_COND_EXPR:
9539 0 : {
9540 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9541 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9542 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9543 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9544 : {
9545 0 : {
9546 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
9547 0 : if (VECTOR_TYPE_P (type)
9548 0 : && (TREE_CODE_CLASS (BIT_XOR_EXPR) != tcc_comparison
9549 : || types_match (type, TREE_TYPE (captures[2]))
9550 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9551 : || (optimize_vectors_before_lowering_p ()
9552 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9553 : )
9554 : {
9555 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1201;
9556 0 : {
9557 0 : tree res_op0;
9558 0 : res_op0 = captures[1];
9559 0 : tree res_op1;
9560 0 : {
9561 0 : tree _o1[2], _r1;
9562 0 : _o1[0] = captures[2];
9563 0 : _o1[1] = captures[5];
9564 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
9565 0 : if (EXPR_P (_r1))
9566 0 : goto next_after_fail1201;
9567 0 : res_op1 = _r1;
9568 : }
9569 0 : tree res_op2;
9570 0 : {
9571 0 : tree _o1[2], _r1;
9572 0 : _o1[0] = captures[3];
9573 0 : _o1[1] = captures[6];
9574 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
9575 0 : if (EXPR_P (_r1))
9576 0 : goto next_after_fail1201;
9577 0 : res_op2 = _r1;
9578 : }
9579 0 : tree _r;
9580 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9581 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
9582 0 : return _r;
9583 : }
9584 0 : next_after_fail1201:;
9585 : }
9586 : }
9587 : }
9588 : break;
9589 : }
9590 1 : default:;
9591 : }
9592 1 : if (integer_minus_onep (_q21))
9593 : {
9594 1 : if (integer_zerop (_q22))
9595 : {
9596 1 : switch (TREE_CODE (_p1))
9597 : {
9598 0 : case VEC_COND_EXPR:
9599 0 : {
9600 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9601 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9602 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9603 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
9604 : {
9605 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
9606 : {
9607 0 : {
9608 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9609 0 : const enum tree_code lop = BIT_XOR_EXPR;
9610 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9611 : )
9612 : {
9613 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1202;
9614 0 : {
9615 0 : tree res_op0;
9616 0 : {
9617 0 : tree _o1[2], _r1;
9618 0 : _o1[0] = captures[0];
9619 0 : _o1[1] = captures[3];
9620 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9621 0 : res_op0 = _r1;
9622 : }
9623 0 : tree res_op1;
9624 0 : res_op1 = captures[1];
9625 0 : tree res_op2;
9626 0 : res_op2 = captures[2];
9627 0 : tree _r;
9628 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9629 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
9630 0 : return _r;
9631 : }
9632 0 : next_after_fail1202:;
9633 : }
9634 : }
9635 0 : {
9636 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9637 0 : const enum tree_code lop = BIT_XOR_EXPR;
9638 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9639 : )
9640 : {
9641 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1203;
9642 0 : {
9643 0 : tree res_op0;
9644 0 : {
9645 0 : tree _o1[2], _r1;
9646 0 : _o1[0] = captures[0];
9647 0 : _o1[1] = captures[3];
9648 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9649 0 : res_op0 = _r1;
9650 : }
9651 0 : tree res_op1;
9652 0 : res_op1 = captures[1];
9653 0 : tree res_op2;
9654 0 : res_op2 = captures[2];
9655 0 : tree _r;
9656 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9657 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
9658 0 : return _r;
9659 : }
9660 0 : next_after_fail1203:;
9661 : }
9662 : }
9663 0 : {
9664 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9665 0 : const enum tree_code lop = BIT_XOR_EXPR;
9666 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9667 : )
9668 : {
9669 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1204;
9670 0 : {
9671 0 : tree res_op0;
9672 0 : {
9673 0 : tree _o1[2], _r1;
9674 0 : _o1[0] = captures[0];
9675 0 : _o1[1] = captures[3];
9676 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9677 0 : res_op0 = _r1;
9678 : }
9679 0 : tree res_op1;
9680 0 : res_op1 = captures[1];
9681 0 : tree res_op2;
9682 0 : res_op2 = captures[2];
9683 0 : tree _r;
9684 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9685 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
9686 0 : return _r;
9687 : }
9688 0 : next_after_fail1204:;
9689 : }
9690 : }
9691 0 : {
9692 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9693 0 : const enum tree_code lop = BIT_XOR_EXPR;
9694 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9695 : )
9696 : {
9697 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1205;
9698 0 : {
9699 0 : tree res_op0;
9700 0 : {
9701 0 : tree _o1[2], _r1;
9702 0 : _o1[0] = captures[0];
9703 0 : _o1[1] = captures[3];
9704 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9705 0 : res_op0 = _r1;
9706 : }
9707 0 : tree res_op1;
9708 0 : res_op1 = captures[1];
9709 0 : tree res_op2;
9710 0 : res_op2 = captures[2];
9711 0 : tree _r;
9712 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9713 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
9714 0 : return _r;
9715 : }
9716 0 : next_after_fail1205:;
9717 : }
9718 : }
9719 0 : {
9720 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9721 0 : const enum tree_code lop = BIT_XOR_EXPR;
9722 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9723 : )
9724 : {
9725 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1206;
9726 0 : {
9727 0 : tree res_op0;
9728 0 : {
9729 0 : tree _o1[2], _r1;
9730 0 : _o1[0] = captures[0];
9731 0 : _o1[1] = captures[3];
9732 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9733 0 : res_op0 = _r1;
9734 : }
9735 0 : tree res_op1;
9736 0 : res_op1 = captures[1];
9737 0 : tree res_op2;
9738 0 : res_op2 = captures[2];
9739 0 : tree _r;
9740 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9741 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
9742 0 : return _r;
9743 : }
9744 0 : next_after_fail1206:;
9745 : }
9746 : }
9747 0 : {
9748 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9749 0 : const enum tree_code lop = BIT_XOR_EXPR;
9750 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9751 : )
9752 : {
9753 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1207;
9754 0 : {
9755 0 : tree res_op0;
9756 0 : {
9757 0 : tree _o1[2], _r1;
9758 0 : _o1[0] = captures[0];
9759 0 : _o1[1] = captures[3];
9760 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9761 0 : res_op0 = _r1;
9762 : }
9763 0 : tree res_op1;
9764 0 : res_op1 = captures[1];
9765 0 : tree res_op2;
9766 0 : res_op2 = captures[2];
9767 0 : tree _r;
9768 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9769 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
9770 0 : return _r;
9771 : }
9772 0 : next_after_fail1207:;
9773 : }
9774 : }
9775 0 : {
9776 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9777 0 : const enum tree_code lop = BIT_XOR_EXPR;
9778 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9779 : )
9780 : {
9781 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1208;
9782 0 : {
9783 0 : tree res_op0;
9784 0 : {
9785 0 : tree _o1[2], _r1;
9786 0 : _o1[0] = captures[0];
9787 0 : _o1[1] = captures[3];
9788 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9789 0 : res_op0 = _r1;
9790 : }
9791 0 : tree res_op1;
9792 0 : res_op1 = captures[1];
9793 0 : tree res_op2;
9794 0 : res_op2 = captures[2];
9795 0 : tree _r;
9796 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9797 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
9798 0 : return _r;
9799 : }
9800 0 : next_after_fail1208:;
9801 : }
9802 : }
9803 0 : {
9804 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9805 0 : const enum tree_code lop = BIT_XOR_EXPR;
9806 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9807 : )
9808 : {
9809 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1209;
9810 0 : {
9811 0 : tree res_op0;
9812 0 : {
9813 0 : tree _o1[2], _r1;
9814 0 : _o1[0] = captures[0];
9815 0 : _o1[1] = captures[3];
9816 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9817 0 : res_op0 = _r1;
9818 : }
9819 0 : tree res_op1;
9820 0 : res_op1 = captures[1];
9821 0 : tree res_op2;
9822 0 : res_op2 = captures[2];
9823 0 : tree _r;
9824 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9825 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
9826 0 : return _r;
9827 : }
9828 0 : next_after_fail1209:;
9829 : }
9830 : }
9831 0 : {
9832 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9833 0 : const enum tree_code lop = BIT_XOR_EXPR;
9834 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9835 : )
9836 : {
9837 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1210;
9838 0 : {
9839 0 : tree res_op0;
9840 0 : {
9841 0 : tree _o1[2], _r1;
9842 0 : _o1[0] = captures[0];
9843 0 : _o1[1] = captures[3];
9844 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9845 0 : res_op0 = _r1;
9846 : }
9847 0 : tree res_op1;
9848 0 : res_op1 = captures[1];
9849 0 : tree res_op2;
9850 0 : res_op2 = captures[2];
9851 0 : tree _r;
9852 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9853 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
9854 0 : return _r;
9855 : }
9856 0 : next_after_fail1210:;
9857 : }
9858 : }
9859 0 : {
9860 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9861 0 : const enum tree_code lop = BIT_XOR_EXPR;
9862 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9863 : )
9864 : {
9865 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1211;
9866 0 : {
9867 0 : tree res_op0;
9868 0 : {
9869 0 : tree _o1[2], _r1;
9870 0 : _o1[0] = captures[0];
9871 0 : _o1[1] = captures[3];
9872 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9873 0 : res_op0 = _r1;
9874 : }
9875 0 : tree res_op1;
9876 0 : res_op1 = captures[1];
9877 0 : tree res_op2;
9878 0 : res_op2 = captures[2];
9879 0 : tree _r;
9880 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9881 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
9882 0 : return _r;
9883 : }
9884 0 : next_after_fail1211:;
9885 : }
9886 : }
9887 0 : {
9888 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9889 0 : const enum tree_code lop = BIT_XOR_EXPR;
9890 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9891 : )
9892 : {
9893 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1212;
9894 0 : {
9895 0 : tree res_op0;
9896 0 : {
9897 0 : tree _o1[2], _r1;
9898 0 : _o1[0] = captures[0];
9899 0 : _o1[1] = captures[3];
9900 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9901 0 : res_op0 = _r1;
9902 : }
9903 0 : tree res_op1;
9904 0 : res_op1 = captures[1];
9905 0 : tree res_op2;
9906 0 : res_op2 = captures[2];
9907 0 : tree _r;
9908 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9909 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
9910 0 : return _r;
9911 : }
9912 0 : next_after_fail1212:;
9913 : }
9914 : }
9915 0 : {
9916 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9917 0 : const enum tree_code lop = BIT_XOR_EXPR;
9918 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9919 : )
9920 : {
9921 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1213;
9922 0 : {
9923 0 : tree res_op0;
9924 0 : {
9925 0 : tree _o1[2], _r1;
9926 0 : _o1[0] = captures[0];
9927 0 : _o1[1] = captures[3];
9928 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9929 0 : res_op0 = _r1;
9930 : }
9931 0 : tree res_op1;
9932 0 : res_op1 = captures[1];
9933 0 : tree res_op2;
9934 0 : res_op2 = captures[2];
9935 0 : tree _r;
9936 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9937 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
9938 0 : return _r;
9939 : }
9940 0 : next_after_fail1213:;
9941 : }
9942 : }
9943 0 : {
9944 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9945 0 : const enum tree_code lop = BIT_XOR_EXPR;
9946 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9947 : )
9948 : {
9949 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1214;
9950 0 : {
9951 0 : tree res_op0;
9952 0 : {
9953 0 : tree _o1[2], _r1;
9954 0 : _o1[0] = captures[0];
9955 0 : _o1[1] = captures[3];
9956 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9957 0 : res_op0 = _r1;
9958 : }
9959 0 : tree res_op1;
9960 0 : res_op1 = captures[1];
9961 0 : tree res_op2;
9962 0 : res_op2 = captures[2];
9963 0 : tree _r;
9964 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9965 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
9966 0 : return _r;
9967 : }
9968 0 : next_after_fail1214:;
9969 : }
9970 : }
9971 0 : {
9972 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9973 0 : const enum tree_code lop = BIT_XOR_EXPR;
9974 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9975 : )
9976 : {
9977 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1215;
9978 0 : {
9979 0 : tree res_op0;
9980 0 : {
9981 0 : tree _o1[2], _r1;
9982 0 : _o1[0] = captures[0];
9983 0 : _o1[1] = captures[3];
9984 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9985 0 : res_op0 = _r1;
9986 : }
9987 0 : tree res_op1;
9988 0 : res_op1 = captures[1];
9989 0 : tree res_op2;
9990 0 : res_op2 = captures[2];
9991 0 : tree _r;
9992 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9993 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
9994 0 : return _r;
9995 : }
9996 0 : next_after_fail1215:;
9997 : }
9998 : }
9999 0 : {
10000 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10001 0 : const enum tree_code lop = BIT_XOR_EXPR;
10002 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10003 : )
10004 : {
10005 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1216;
10006 0 : {
10007 0 : tree res_op0;
10008 0 : {
10009 0 : tree _o1[2], _r1;
10010 0 : _o1[0] = captures[0];
10011 0 : _o1[1] = captures[3];
10012 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10013 0 : res_op0 = _r1;
10014 : }
10015 0 : tree res_op1;
10016 0 : res_op1 = captures[1];
10017 0 : tree res_op2;
10018 0 : res_op2 = captures[2];
10019 0 : tree _r;
10020 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10021 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10022 0 : return _r;
10023 : }
10024 0 : next_after_fail1216:;
10025 : }
10026 : }
10027 0 : {
10028 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10029 0 : const enum tree_code lop = BIT_XOR_EXPR;
10030 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10031 : )
10032 : {
10033 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1217;
10034 0 : {
10035 0 : tree res_op0;
10036 0 : {
10037 0 : tree _o1[2], _r1;
10038 0 : _o1[0] = captures[0];
10039 0 : _o1[1] = captures[3];
10040 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10041 0 : res_op0 = _r1;
10042 : }
10043 0 : tree res_op1;
10044 0 : res_op1 = captures[1];
10045 0 : tree res_op2;
10046 0 : res_op2 = captures[2];
10047 0 : tree _r;
10048 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10049 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10050 0 : return _r;
10051 : }
10052 0 : next_after_fail1217:;
10053 : }
10054 : }
10055 0 : {
10056 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10057 0 : const enum tree_code lop = BIT_XOR_EXPR;
10058 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10059 : )
10060 : {
10061 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1218;
10062 0 : {
10063 0 : tree res_op0;
10064 0 : {
10065 0 : tree _o1[2], _r1;
10066 0 : _o1[0] = captures[0];
10067 0 : _o1[1] = captures[3];
10068 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10069 0 : res_op0 = _r1;
10070 : }
10071 0 : tree res_op1;
10072 0 : res_op1 = captures[1];
10073 0 : tree res_op2;
10074 0 : res_op2 = captures[2];
10075 0 : tree _r;
10076 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10077 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10078 0 : return _r;
10079 : }
10080 0 : next_after_fail1218:;
10081 : }
10082 : }
10083 0 : {
10084 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10085 0 : const enum tree_code lop = BIT_XOR_EXPR;
10086 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10087 : )
10088 : {
10089 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1219;
10090 0 : {
10091 0 : tree res_op0;
10092 0 : {
10093 0 : tree _o1[2], _r1;
10094 0 : _o1[0] = captures[0];
10095 0 : _o1[1] = captures[3];
10096 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10097 0 : res_op0 = _r1;
10098 : }
10099 0 : tree res_op1;
10100 0 : res_op1 = captures[1];
10101 0 : tree res_op2;
10102 0 : res_op2 = captures[2];
10103 0 : tree _r;
10104 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10105 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10106 0 : return _r;
10107 : }
10108 0 : next_after_fail1219:;
10109 : }
10110 : }
10111 0 : {
10112 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10113 0 : const enum tree_code lop = BIT_XOR_EXPR;
10114 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10115 : )
10116 : {
10117 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1220;
10118 0 : {
10119 0 : tree res_op0;
10120 0 : {
10121 0 : tree _o1[2], _r1;
10122 0 : _o1[0] = captures[0];
10123 0 : _o1[1] = captures[3];
10124 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10125 0 : res_op0 = _r1;
10126 : }
10127 0 : tree res_op1;
10128 0 : res_op1 = captures[1];
10129 0 : tree res_op2;
10130 0 : res_op2 = captures[2];
10131 0 : tree _r;
10132 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10133 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10134 0 : return _r;
10135 : }
10136 0 : next_after_fail1220:;
10137 : }
10138 : }
10139 0 : {
10140 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10141 0 : const enum tree_code lop = BIT_XOR_EXPR;
10142 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10143 : )
10144 : {
10145 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1221;
10146 0 : {
10147 0 : tree res_op0;
10148 0 : {
10149 0 : tree _o1[2], _r1;
10150 0 : _o1[0] = captures[0];
10151 0 : _o1[1] = captures[3];
10152 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10153 0 : res_op0 = _r1;
10154 : }
10155 0 : tree res_op1;
10156 0 : res_op1 = captures[1];
10157 0 : tree res_op2;
10158 0 : res_op2 = captures[2];
10159 0 : tree _r;
10160 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10161 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10162 0 : return _r;
10163 : }
10164 0 : next_after_fail1221:;
10165 : }
10166 : }
10167 0 : {
10168 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10169 0 : const enum tree_code lop = BIT_XOR_EXPR;
10170 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10171 : )
10172 : {
10173 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1222;
10174 0 : {
10175 0 : tree res_op0;
10176 0 : {
10177 0 : tree _o1[2], _r1;
10178 0 : _o1[0] = captures[0];
10179 0 : _o1[1] = captures[3];
10180 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10181 0 : res_op0 = _r1;
10182 : }
10183 0 : tree res_op1;
10184 0 : res_op1 = captures[1];
10185 0 : tree res_op2;
10186 0 : res_op2 = captures[2];
10187 0 : tree _r;
10188 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10189 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10190 0 : return _r;
10191 : }
10192 0 : next_after_fail1222:;
10193 : }
10194 : }
10195 0 : {
10196 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10197 0 : const enum tree_code lop = BIT_XOR_EXPR;
10198 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10199 : )
10200 : {
10201 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1223;
10202 0 : {
10203 0 : tree res_op0;
10204 0 : {
10205 0 : tree _o1[2], _r1;
10206 0 : _o1[0] = captures[0];
10207 0 : _o1[1] = captures[3];
10208 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10209 0 : res_op0 = _r1;
10210 : }
10211 0 : tree res_op1;
10212 0 : res_op1 = captures[1];
10213 0 : tree res_op2;
10214 0 : res_op2 = captures[2];
10215 0 : tree _r;
10216 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10217 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10218 0 : return _r;
10219 : }
10220 0 : next_after_fail1223:;
10221 : }
10222 : }
10223 0 : {
10224 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10225 0 : const enum tree_code lop = BIT_XOR_EXPR;
10226 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10227 : )
10228 : {
10229 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1224;
10230 0 : {
10231 0 : tree res_op0;
10232 0 : {
10233 0 : tree _o1[2], _r1;
10234 0 : _o1[0] = captures[0];
10235 0 : _o1[1] = captures[3];
10236 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10237 0 : res_op0 = _r1;
10238 : }
10239 0 : tree res_op1;
10240 0 : res_op1 = captures[1];
10241 0 : tree res_op2;
10242 0 : res_op2 = captures[2];
10243 0 : tree _r;
10244 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10245 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10246 0 : return _r;
10247 : }
10248 0 : next_after_fail1224:;
10249 : }
10250 : }
10251 0 : {
10252 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10253 0 : const enum tree_code lop = BIT_XOR_EXPR;
10254 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10255 : )
10256 : {
10257 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1225;
10258 0 : {
10259 0 : tree res_op0;
10260 0 : {
10261 0 : tree _o1[2], _r1;
10262 0 : _o1[0] = captures[0];
10263 0 : _o1[1] = captures[3];
10264 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10265 0 : res_op0 = _r1;
10266 : }
10267 0 : tree res_op1;
10268 0 : res_op1 = captures[1];
10269 0 : tree res_op2;
10270 0 : res_op2 = captures[2];
10271 0 : tree _r;
10272 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10273 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10274 0 : return _r;
10275 : }
10276 0 : next_after_fail1225:;
10277 : }
10278 : }
10279 0 : {
10280 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10281 0 : const enum tree_code lop = BIT_XOR_EXPR;
10282 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10283 : )
10284 : {
10285 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1226;
10286 0 : {
10287 0 : tree res_op0;
10288 0 : {
10289 0 : tree _o1[2], _r1;
10290 0 : _o1[0] = captures[0];
10291 0 : _o1[1] = captures[3];
10292 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10293 0 : res_op0 = _r1;
10294 : }
10295 0 : tree res_op1;
10296 0 : res_op1 = captures[1];
10297 0 : tree res_op2;
10298 0 : res_op2 = captures[2];
10299 0 : tree _r;
10300 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10301 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10302 0 : return _r;
10303 : }
10304 0 : next_after_fail1226:;
10305 : }
10306 : }
10307 0 : {
10308 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10309 0 : const enum tree_code lop = BIT_XOR_EXPR;
10310 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10311 : )
10312 : {
10313 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1227;
10314 0 : {
10315 0 : tree res_op0;
10316 0 : {
10317 0 : tree _o1[2], _r1;
10318 0 : _o1[0] = captures[0];
10319 0 : _o1[1] = captures[3];
10320 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10321 0 : res_op0 = _r1;
10322 : }
10323 0 : tree res_op1;
10324 0 : res_op1 = captures[1];
10325 0 : tree res_op2;
10326 0 : res_op2 = captures[2];
10327 0 : tree _r;
10328 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10329 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10330 0 : return _r;
10331 : }
10332 0 : next_after_fail1227:;
10333 : }
10334 : }
10335 0 : {
10336 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10337 0 : const enum tree_code lop = BIT_XOR_EXPR;
10338 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10339 : )
10340 : {
10341 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1228;
10342 0 : {
10343 0 : tree res_op0;
10344 0 : {
10345 0 : tree _o1[2], _r1;
10346 0 : _o1[0] = captures[0];
10347 0 : _o1[1] = captures[3];
10348 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10349 0 : res_op0 = _r1;
10350 : }
10351 0 : tree res_op1;
10352 0 : res_op1 = captures[1];
10353 0 : tree res_op2;
10354 0 : res_op2 = captures[2];
10355 0 : tree _r;
10356 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10357 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10358 0 : return _r;
10359 : }
10360 0 : next_after_fail1228:;
10361 : }
10362 : }
10363 0 : {
10364 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10365 0 : const enum tree_code lop = BIT_XOR_EXPR;
10366 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10367 : )
10368 : {
10369 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1229;
10370 0 : {
10371 0 : tree res_op0;
10372 0 : {
10373 0 : tree _o1[2], _r1;
10374 0 : _o1[0] = captures[0];
10375 0 : _o1[1] = captures[3];
10376 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10377 0 : res_op0 = _r1;
10378 : }
10379 0 : tree res_op1;
10380 0 : res_op1 = captures[1];
10381 0 : tree res_op2;
10382 0 : res_op2 = captures[2];
10383 0 : tree _r;
10384 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10385 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10386 0 : return _r;
10387 : }
10388 0 : next_after_fail1229:;
10389 : }
10390 : }
10391 0 : {
10392 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10393 0 : const enum tree_code lop = BIT_XOR_EXPR;
10394 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10395 : )
10396 : {
10397 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1230;
10398 0 : {
10399 0 : tree res_op0;
10400 0 : {
10401 0 : tree _o1[2], _r1;
10402 0 : _o1[0] = captures[0];
10403 0 : _o1[1] = captures[3];
10404 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10405 0 : res_op0 = _r1;
10406 : }
10407 0 : tree res_op1;
10408 0 : res_op1 = captures[1];
10409 0 : tree res_op2;
10410 0 : res_op2 = captures[2];
10411 0 : tree _r;
10412 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10413 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10414 0 : return _r;
10415 : }
10416 0 : next_after_fail1230:;
10417 : }
10418 : }
10419 0 : {
10420 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10421 0 : const enum tree_code lop = BIT_XOR_EXPR;
10422 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10423 : )
10424 : {
10425 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1231;
10426 0 : {
10427 0 : tree res_op0;
10428 0 : {
10429 0 : tree _o1[2], _r1;
10430 0 : _o1[0] = captures[0];
10431 0 : _o1[1] = captures[3];
10432 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10433 0 : res_op0 = _r1;
10434 : }
10435 0 : tree res_op1;
10436 0 : res_op1 = captures[1];
10437 0 : tree res_op2;
10438 0 : res_op2 = captures[2];
10439 0 : tree _r;
10440 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10441 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10442 0 : return _r;
10443 : }
10444 0 : next_after_fail1231:;
10445 : }
10446 : }
10447 0 : {
10448 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10449 0 : const enum tree_code lop = BIT_XOR_EXPR;
10450 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10451 : )
10452 : {
10453 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1232;
10454 0 : {
10455 0 : tree res_op0;
10456 0 : {
10457 0 : tree _o1[2], _r1;
10458 0 : _o1[0] = captures[0];
10459 0 : _o1[1] = captures[3];
10460 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10461 0 : res_op0 = _r1;
10462 : }
10463 0 : tree res_op1;
10464 0 : res_op1 = captures[1];
10465 0 : tree res_op2;
10466 0 : res_op2 = captures[2];
10467 0 : tree _r;
10468 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10469 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10470 0 : return _r;
10471 : }
10472 0 : next_after_fail1232:;
10473 : }
10474 : }
10475 0 : {
10476 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10477 0 : const enum tree_code lop = BIT_XOR_EXPR;
10478 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10479 : )
10480 : {
10481 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1233;
10482 0 : {
10483 0 : tree res_op0;
10484 0 : {
10485 0 : tree _o1[2], _r1;
10486 0 : _o1[0] = captures[0];
10487 0 : _o1[1] = captures[3];
10488 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10489 0 : res_op0 = _r1;
10490 : }
10491 0 : tree res_op1;
10492 0 : res_op1 = captures[1];
10493 0 : tree res_op2;
10494 0 : res_op2 = captures[2];
10495 0 : tree _r;
10496 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10497 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10498 0 : return _r;
10499 : }
10500 0 : next_after_fail1233:;
10501 : }
10502 : }
10503 0 : {
10504 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10505 0 : const enum tree_code lop = BIT_XOR_EXPR;
10506 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10507 : )
10508 : {
10509 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1234;
10510 0 : {
10511 0 : tree res_op0;
10512 0 : {
10513 0 : tree _o1[2], _r1;
10514 0 : _o1[0] = captures[0];
10515 0 : _o1[1] = captures[3];
10516 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10517 0 : res_op0 = _r1;
10518 : }
10519 0 : tree res_op1;
10520 0 : res_op1 = captures[1];
10521 0 : tree res_op2;
10522 0 : res_op2 = captures[2];
10523 0 : tree _r;
10524 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10525 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10526 0 : return _r;
10527 : }
10528 0 : next_after_fail1234:;
10529 : }
10530 : }
10531 0 : {
10532 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10533 0 : const enum tree_code lop = BIT_XOR_EXPR;
10534 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10535 : )
10536 : {
10537 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1235;
10538 0 : {
10539 0 : tree res_op0;
10540 0 : {
10541 0 : tree _o1[2], _r1;
10542 0 : _o1[0] = captures[0];
10543 0 : _o1[1] = captures[3];
10544 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10545 0 : res_op0 = _r1;
10546 : }
10547 0 : tree res_op1;
10548 0 : res_op1 = captures[1];
10549 0 : tree res_op2;
10550 0 : res_op2 = captures[2];
10551 0 : tree _r;
10552 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10553 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10554 0 : return _r;
10555 : }
10556 0 : next_after_fail1235:;
10557 : }
10558 : }
10559 : }
10560 : }
10561 : break;
10562 : }
10563 : default:;
10564 : }
10565 : }
10566 : }
10567 1 : {
10568 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
10569 1 : if (VECTOR_TYPE_P (type)
10570 1 : && (TREE_CODE_CLASS (BIT_XOR_EXPR) != tcc_comparison
10571 : || types_match (type, TREE_TYPE (captures[2]))
10572 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10573 : || (optimize_vectors_before_lowering_p ()
10574 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10575 : )
10576 : {
10577 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1236;
10578 1 : {
10579 1 : if (! tree_invariant_p (captures[4])) goto next_after_fail1236;
10580 0 : tree res_op0;
10581 0 : res_op0 = captures[1];
10582 0 : tree res_op1;
10583 0 : {
10584 0 : tree _o1[2], _r1;
10585 0 : _o1[0] = captures[2];
10586 0 : _o1[1] = unshare_expr (captures[4]);
10587 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
10588 0 : if (EXPR_P (_r1))
10589 0 : goto next_after_fail1236;
10590 0 : res_op1 = _r1;
10591 : }
10592 0 : tree res_op2;
10593 0 : {
10594 0 : tree _o1[2], _r1;
10595 0 : _o1[0] = captures[3];
10596 0 : _o1[1] = captures[4];
10597 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
10598 0 : if (EXPR_P (_r1))
10599 0 : goto next_after_fail1236;
10600 0 : res_op2 = _r1;
10601 : }
10602 0 : tree _r;
10603 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10604 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 895, __FILE__, __LINE__, true);
10605 0 : return _r;
10606 : }
10607 1 : next_after_fail1236:;
10608 : }
10609 : }
10610 1 : break;
10611 : }
10612 907804 : default:;
10613 : }
10614 907804 : switch (TREE_CODE (_p1))
10615 : {
10616 0 : case VEC_COND_EXPR:
10617 0 : {
10618 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10619 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10620 0 : tree _q32 = TREE_OPERAND (_p1, 2);
10621 0 : {
10622 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
10623 0 : if (VECTOR_TYPE_P (type)
10624 0 : && (TREE_CODE_CLASS (BIT_XOR_EXPR) != tcc_comparison
10625 : || types_match (type, TREE_TYPE (captures[3]))
10626 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
10627 : || (optimize_vectors_before_lowering_p ()
10628 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
10629 : )
10630 : {
10631 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1237;
10632 0 : {
10633 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1237;
10634 0 : tree res_op0;
10635 0 : res_op0 = captures[2];
10636 0 : tree res_op1;
10637 0 : {
10638 0 : tree _o1[2], _r1;
10639 0 : _o1[0] = unshare_expr (captures[0]);
10640 0 : _o1[1] = captures[3];
10641 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
10642 0 : if (EXPR_P (_r1))
10643 0 : goto next_after_fail1237;
10644 0 : res_op1 = _r1;
10645 : }
10646 0 : tree res_op2;
10647 0 : {
10648 0 : tree _o1[2], _r1;
10649 0 : _o1[0] = captures[0];
10650 0 : _o1[1] = captures[4];
10651 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
10652 0 : if (EXPR_P (_r1))
10653 0 : goto next_after_fail1237;
10654 0 : res_op2 = _r1;
10655 : }
10656 0 : tree _r;
10657 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10658 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
10659 0 : return _r;
10660 : }
10661 0 : next_after_fail1237:;
10662 : }
10663 : }
10664 0 : break;
10665 : }
10666 907804 : default:;
10667 : }
10668 907804 : switch (TREE_CODE (_p0))
10669 : {
10670 90 : case LT_EXPR:
10671 90 : {
10672 90 : tree _q20 = TREE_OPERAND (_p0, 0);
10673 90 : tree _q21 = TREE_OPERAND (_p0, 1);
10674 90 : if (integer_truep (_p1))
10675 : {
10676 14 : {
10677 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10678 14 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, LT_EXPR, GE_EXPR, UNGE_EXPR);
10679 14 : if (res) return res;
10680 : }
10681 : }
10682 76 : if (integer_zerop (_q21))
10683 : {
10684 24 : switch (TREE_CODE (_p1))
10685 : {
10686 17 : case LT_EXPR:
10687 17 : {
10688 17 : tree _q50 = TREE_OPERAND (_p1, 0);
10689 17 : tree _q51 = TREE_OPERAND (_p1, 1);
10690 17 : if (integer_zerop (_q51))
10691 : {
10692 17 : {
10693 17 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q50 };
10694 17 : tree res = generic_simplify_51 (loc, type, _p0, _p1, captures, LT_EXPR);
10695 17 : if (res) return res;
10696 : }
10697 : }
10698 : break;
10699 : }
10700 0 : case GE_EXPR:
10701 0 : {
10702 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10703 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10704 0 : if (integer_zerop (_q51))
10705 : {
10706 0 : {
10707 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q50 };
10708 0 : tree res = generic_simplify_52 (loc, type, _p0, _p1, captures);
10709 0 : if (res) return res;
10710 : }
10711 : }
10712 : break;
10713 : }
10714 : default:;
10715 : }
10716 : }
10717 : break;
10718 : }
10719 85 : case LE_EXPR:
10720 85 : {
10721 85 : tree _q20 = TREE_OPERAND (_p0, 0);
10722 85 : tree _q21 = TREE_OPERAND (_p0, 1);
10723 85 : if (integer_truep (_p1))
10724 : {
10725 15 : {
10726 15 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10727 15 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR, UNGT_EXPR);
10728 15 : if (res) return res;
10729 : }
10730 : }
10731 : break;
10732 : }
10733 119 : case EQ_EXPR:
10734 119 : {
10735 119 : tree _q20 = TREE_OPERAND (_p0, 0);
10736 119 : tree _q21 = TREE_OPERAND (_p0, 1);
10737 119 : if (integer_truep (_p1))
10738 : {
10739 14 : {
10740 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10741 14 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR, NE_EXPR);
10742 14 : if (res) return res;
10743 : }
10744 : }
10745 : break;
10746 : }
10747 113 : case NE_EXPR:
10748 113 : {
10749 113 : tree _q20 = TREE_OPERAND (_p0, 0);
10750 113 : tree _q21 = TREE_OPERAND (_p0, 1);
10751 113 : if (integer_truep (_p1))
10752 : {
10753 7 : {
10754 7 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10755 7 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR, EQ_EXPR);
10756 7 : if (res) return res;
10757 : }
10758 : }
10759 : break;
10760 : }
10761 62 : case GE_EXPR:
10762 62 : {
10763 62 : tree _q20 = TREE_OPERAND (_p0, 0);
10764 62 : tree _q21 = TREE_OPERAND (_p0, 1);
10765 62 : if (integer_truep (_p1))
10766 : {
10767 0 : {
10768 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10769 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, GE_EXPR, LT_EXPR, UNLT_EXPR);
10770 0 : if (res) return res;
10771 : }
10772 : }
10773 62 : if (integer_zerop (_q21))
10774 : {
10775 26 : switch (TREE_CODE (_p1))
10776 : {
10777 1 : case GE_EXPR:
10778 1 : {
10779 1 : tree _q50 = TREE_OPERAND (_p1, 0);
10780 1 : tree _q51 = TREE_OPERAND (_p1, 1);
10781 1 : if (integer_zerop (_q51))
10782 : {
10783 1 : {
10784 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q50 };
10785 1 : tree res = generic_simplify_51 (loc, type, _p0, _p1, captures, GE_EXPR);
10786 1 : if (res) return res;
10787 : }
10788 : }
10789 : break;
10790 : }
10791 5 : case LT_EXPR:
10792 5 : {
10793 5 : tree _q50 = TREE_OPERAND (_p1, 0);
10794 5 : tree _q51 = TREE_OPERAND (_p1, 1);
10795 5 : if (integer_zerop (_q51))
10796 : {
10797 5 : {
10798 5 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q50, _p0, _q20 };
10799 5 : tree res = generic_simplify_52 (loc, type, _p0, _p1, captures);
10800 5 : if (res) return res;
10801 : }
10802 : }
10803 : break;
10804 : }
10805 : default:;
10806 : }
10807 : }
10808 : break;
10809 : }
10810 100 : case GT_EXPR:
10811 100 : {
10812 100 : tree _q20 = TREE_OPERAND (_p0, 0);
10813 100 : tree _q21 = TREE_OPERAND (_p0, 1);
10814 100 : if (integer_truep (_p1))
10815 : {
10816 14 : {
10817 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10818 14 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, GT_EXPR, LE_EXPR, UNLE_EXPR);
10819 14 : if (res) return res;
10820 : }
10821 : }
10822 : break;
10823 : }
10824 0 : case UNORDERED_EXPR:
10825 0 : {
10826 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10827 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10828 0 : if (integer_truep (_p1))
10829 : {
10830 0 : {
10831 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10832 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR);
10833 0 : if (res) return res;
10834 : }
10835 : }
10836 : break;
10837 : }
10838 0 : case ORDERED_EXPR:
10839 0 : {
10840 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10841 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10842 0 : if (integer_truep (_p1))
10843 : {
10844 0 : {
10845 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10846 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR);
10847 0 : if (res) return res;
10848 : }
10849 : }
10850 : break;
10851 : }
10852 0 : case UNLT_EXPR:
10853 0 : {
10854 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10855 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10856 0 : if (integer_truep (_p1))
10857 : {
10858 0 : {
10859 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10860 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, UNLT_EXPR, GE_EXPR, GE_EXPR);
10861 0 : if (res) return res;
10862 : }
10863 : }
10864 : break;
10865 : }
10866 0 : case UNLE_EXPR:
10867 0 : {
10868 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10869 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10870 0 : if (integer_truep (_p1))
10871 : {
10872 0 : {
10873 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10874 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, UNLE_EXPR, GT_EXPR, GT_EXPR);
10875 0 : if (res) return res;
10876 : }
10877 : }
10878 : break;
10879 : }
10880 0 : case UNGT_EXPR:
10881 0 : {
10882 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10883 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10884 0 : if (integer_truep (_p1))
10885 : {
10886 0 : {
10887 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10888 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, UNGT_EXPR, LE_EXPR, LE_EXPR);
10889 0 : if (res) return res;
10890 : }
10891 : }
10892 : break;
10893 : }
10894 0 : case UNGE_EXPR:
10895 0 : {
10896 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10897 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10898 0 : if (integer_truep (_p1))
10899 : {
10900 0 : {
10901 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10902 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, UNGE_EXPR, LT_EXPR, LT_EXPR);
10903 0 : if (res) return res;
10904 : }
10905 : }
10906 : break;
10907 : }
10908 0 : case UNEQ_EXPR:
10909 0 : {
10910 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10911 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10912 0 : if (integer_truep (_p1))
10913 : {
10914 0 : {
10915 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10916 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR);
10917 0 : if (res) return res;
10918 : }
10919 : }
10920 : break;
10921 : }
10922 0 : case LTGT_EXPR:
10923 0 : {
10924 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10925 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10926 0 : if (integer_truep (_p1))
10927 : {
10928 0 : {
10929 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10930 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR);
10931 0 : if (res) return res;
10932 : }
10933 : }
10934 : break;
10935 : }
10936 7 : case VEC_PERM_EXPR:
10937 7 : {
10938 7 : tree _q20 = TREE_OPERAND (_p0, 0);
10939 7 : tree _q21 = TREE_OPERAND (_p0, 1);
10940 7 : tree _q22 = TREE_OPERAND (_p0, 2);
10941 7 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
10942 : {
10943 0 : switch (TREE_CODE (_p1))
10944 : {
10945 0 : case VEC_PERM_EXPR:
10946 0 : {
10947 0 : tree _q60 = TREE_OPERAND (_p1, 0);
10948 0 : tree _q61 = TREE_OPERAND (_p1, 1);
10949 0 : tree _q62 = TREE_OPERAND (_p1, 2);
10950 0 : if ((_q61 == _q60 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q60, 0) && types_match (_q61, _q60)))
10951 : {
10952 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
10953 : {
10954 0 : {
10955 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q22, _q60 };
10956 0 : if (VECTOR_INTEGER_TYPE_P (type)
10957 : )
10958 : {
10959 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1238;
10960 0 : {
10961 0 : tree res_op0;
10962 0 : {
10963 0 : tree _o1[2], _r1;
10964 0 : _o1[0] = captures[0];
10965 0 : _o1[1] = captures[2];
10966 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10967 0 : captures[3] = _r1;
10968 : }
10969 0 : res_op0 = unshare_expr (captures[3]);
10970 0 : tree res_op1;
10971 0 : res_op1 = captures[3];
10972 0 : tree res_op2;
10973 0 : res_op2 = captures[1];
10974 0 : tree _r;
10975 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
10976 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10977 0 : return _r;
10978 : }
10979 0 : next_after_fail1238:;
10980 : }
10981 : }
10982 : }
10983 : }
10984 : break;
10985 : }
10986 : default:;
10987 : }
10988 : }
10989 : break;
10990 : }
10991 3247 : case CALL_EXPR:
10992 3247 : switch (get_call_combined_fn (_p0))
10993 : {
10994 1 : case CFN_PARITY:
10995 1 : if (call_expr_nargs (_p0) == 1)
10996 : {
10997 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10998 1 : switch (TREE_CODE (_p1))
10999 : {
11000 1 : case CALL_EXPR:
11001 1 : switch (get_call_combined_fn (_p1))
11002 : {
11003 1 : case CFN_PARITY:
11004 1 : if (call_expr_nargs (_p1) == 1)
11005 : {
11006 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11007 1 : {
11008 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11009 1 : tree res = generic_simplify_53 (loc, type, _p0, _p1, captures, CFN_PARITY);
11010 1 : if (res) return res;
11011 : }
11012 : }
11013 : break;
11014 : default:;
11015 : }
11016 : break;
11017 : default:;
11018 : }
11019 : }
11020 : break;
11021 1 : case CFN_BUILT_IN_PARITYL:
11022 1 : if (call_expr_nargs (_p0) == 1)
11023 : {
11024 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11025 1 : switch (TREE_CODE (_p1))
11026 : {
11027 1 : case CALL_EXPR:
11028 1 : switch (get_call_combined_fn (_p1))
11029 : {
11030 1 : case CFN_BUILT_IN_PARITYL:
11031 1 : if (call_expr_nargs (_p1) == 1)
11032 : {
11033 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11034 1 : {
11035 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11036 1 : tree res = generic_simplify_53 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITYL);
11037 1 : if (res) return res;
11038 : }
11039 : }
11040 : break;
11041 : default:;
11042 : }
11043 : break;
11044 : default:;
11045 : }
11046 : }
11047 : break;
11048 0 : case CFN_BUILT_IN_PARITYIMAX:
11049 0 : if (call_expr_nargs (_p0) == 1)
11050 : {
11051 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11052 0 : switch (TREE_CODE (_p1))
11053 : {
11054 0 : case CALL_EXPR:
11055 0 : switch (get_call_combined_fn (_p1))
11056 : {
11057 0 : case CFN_BUILT_IN_PARITYIMAX:
11058 0 : if (call_expr_nargs (_p1) == 1)
11059 : {
11060 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11061 0 : {
11062 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11063 0 : tree res = generic_simplify_53 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITYIMAX);
11064 0 : if (res) return res;
11065 : }
11066 : }
11067 : break;
11068 : default:;
11069 : }
11070 : break;
11071 : default:;
11072 : }
11073 : }
11074 : break;
11075 1 : case CFN_BUILT_IN_PARITY:
11076 1 : if (call_expr_nargs (_p0) == 1)
11077 : {
11078 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11079 1 : switch (TREE_CODE (_p1))
11080 : {
11081 1 : case CALL_EXPR:
11082 1 : switch (get_call_combined_fn (_p1))
11083 : {
11084 1 : case CFN_BUILT_IN_PARITY:
11085 1 : if (call_expr_nargs (_p1) == 1)
11086 : {
11087 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11088 1 : {
11089 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11090 1 : tree res = generic_simplify_53 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITY);
11091 1 : if (res) return res;
11092 : }
11093 : }
11094 : break;
11095 : default:;
11096 : }
11097 : break;
11098 : default:;
11099 : }
11100 : }
11101 : break;
11102 8 : case CFN_BUILT_IN_PARITYLL:
11103 8 : if (call_expr_nargs (_p0) == 1)
11104 : {
11105 8 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11106 8 : switch (TREE_CODE (_p1))
11107 : {
11108 8 : case CALL_EXPR:
11109 8 : switch (get_call_combined_fn (_p1))
11110 : {
11111 8 : case CFN_BUILT_IN_PARITYLL:
11112 8 : if (call_expr_nargs (_p1) == 1)
11113 : {
11114 8 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11115 8 : {
11116 8 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11117 8 : tree res = generic_simplify_53 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITYLL);
11118 8 : if (res) return res;
11119 : }
11120 : }
11121 : break;
11122 : default:;
11123 : }
11124 : break;
11125 : default:;
11126 : }
11127 : }
11128 : break;
11129 : default:;
11130 : }
11131 : break;
11132 : default:;
11133 : }
11134 : return NULL_TREE;
11135 : }
11136 :
11137 : tree
11138 34934345 : generic_simplify (location_t loc, enum tree_code code, const tree type ATTRIBUTE_UNUSED, tree _p0, tree _p1, tree _p2)
11139 : {
11140 34934345 : switch (code)
11141 : {
11142 12470522 : case COND_EXPR:
11143 12470522 : return generic_simplify_COND_EXPR (loc, code, type, _p0, _p1, _p2);
11144 391960 : case VEC_COND_EXPR:
11145 391960 : return generic_simplify_VEC_COND_EXPR (loc, code, type, _p0, _p1, _p2);
11146 766220 : case BIT_FIELD_REF:
11147 766220 : return generic_simplify_BIT_FIELD_REF (loc, code, type, _p0, _p1, _p2);
11148 14844 : case BIT_INSERT_EXPR:
11149 14844 : return generic_simplify_BIT_INSERT_EXPR (loc, code, type, _p0, _p1, _p2);
11150 773506 : case VEC_PERM_EXPR:
11151 773506 : return generic_simplify_VEC_PERM_EXPR (loc, code, type, _p0, _p1, _p2);
11152 : default:;
11153 : }
11154 : return NULL_TREE;
11155 : }
11156 :
11157 : tree
11158 0 : generic_simplify (location_t, enum tree_code,
11159 : const tree, tree, tree, tree, tree)
11160 : {
11161 0 : return NULL_TREE;
11162 : }
11163 :
11164 : tree
11165 0 : generic_simplify (location_t, enum tree_code,
11166 : const tree, tree, tree, tree, tree, tree)
11167 : {
11168 0 : return NULL_TREE;
11169 : }
11170 :
11171 : tree
11172 0 : generic_simplify (location_t, enum tree_code,
11173 : const tree, tree, tree, tree, tree, tree, tree)
11174 : {
11175 0 : return NULL_TREE;
11176 : }
11177 :
11178 : tree
11179 0 : generic_simplify (location_t, enum tree_code,
11180 : const tree, tree, tree, tree, tree, tree, tree, tree)
11181 : {
11182 0 : return NULL_TREE;
11183 : }
11184 : void
11185 18347 : generic_dump_logs (const char *file1, int line1_id, const char *file2, int line2, bool simplify)
11186 : {
11187 18347 : static int dbg_line_numbers[1112] = {
11188 : /* 0 */ 163, 166, 175, 177, 180, 183, 185, 191, 199, 197,
11189 : /* 10 */ 201, 203, 972, 974, 2165, 2171, 2173, 2176, 2181, 2184,
11190 : /* 20 */ 2432, 2436, 2438, 2440, 2442, 2444, 2446, 2448, 2475, 2491,
11191 : /* 30 */ 2499, 2481, 3094, 3096, 3098, 3105, 3102, 3112, 3114, 3121,
11192 : /* 40 */ 3118, 3329, 3339, 5684, 9119, 9140, 11566, 11569, 11574, 2132,
11193 : /* 50 */ 8939, 1347, 1351, 1511, 1526, 1531, 1578, 1579, 1583, 1584,
11194 : /* 60 */ 1626, 1651, 1656, 1749, 1873, 1963, 1883, 2027, 1893, 1898,
11195 : /* 70 */ 2021, 1906, 2073, 2015, 2034, 2040, 2707, 2047, 2061, 2107,
11196 : /* 80 */ 2324, 2390, 2413, 2424, 2427, 2459, 2565, 2597, 4366, 4379,
11197 : /* 90 */ 4389, 3171, 3173, 4729, 4403, 4415, 7081, 7083, 7148, 7156,
11198 : /* 100 */ 10477, 10483, 266, 293, 294, 505, 1341, 1856, 1911, 1974,
11199 : /* 110 */ 3861, 3799, 3904, 3905, 3909, 3910, 3920, 3924, 3928, 3943,
11200 : /* 120 */ 3946, 3950, 3876, 3879, 3884, 4030, 4036, 4042, 4222, 4223,
11201 : /* 130 */ 4252, 4273, 4292, 4717, 5583, 7012, 7097, 7099, 8567, 8642,
11202 : /* 140 */ 10308, 10356, 10370, 11593, 12018, 956, 962, 1491, 1500, 1992,
11203 : /* 150 */ 1983, 1930, 2733, 3812, 3852, 3857, 3858, 3866, 3867, 3870,
11204 : /* 160 */ 3887, 3962, 3965, 3969, 4050, 4072, 4110, 4121, 4160, 4175,
11205 : /* 170 */ 4723, 7022, 8647, 10366, 11597, 1477, 1486, 1516, 1521, 1563,
11206 : /* 180 */ 1548, 1555, 1605, 2069, 1610, 1617, 1646, 1773, 1863, 1868,
11207 : /* 190 */ 1878, 1888, 2002, 2089, 2099, 2101, 2360, 2365, 2370, 2376,
11208 : /* 200 */ 2377, 2399, 2548, 2577, 2579, 2584, 2586, 2726, 3385, 3400,
11209 : /* 210 */ 3418, 3618, 3619, 3620, 3628, 3636, 3645, 3654, 3686, 3687,
11210 : /* 220 */ 3692, 3693, 3698, 3703, 3707, 3762, 3776, 3390, 3409, 3411,
11211 : /* 230 */ 3395, 7685, 9517, 12116, 12131, 473, 479, 511, 1286, 1306,
11212 : /* 240 */ 1311, 2157, 2158, 2195, 2742, 5268, 5569, 5576, 5626, 5629,
11213 : /* 250 */ 5679, 8560, 8974, 8804, 8811, 8968, 9013, 9018, 341, 918,
11214 : /* 260 */ 1359, 3013, 2809, 2815, 2818, 2823, 2464, 2721, 2517, 2659,
11215 : /* 270 */ 2897, 2760, 2770, 2839, 2841, 2842, 2845, 2847, 2848, 2850,
11216 : /* 280 */ 2852, 2854, 2856, 2858, 2860, 2874, 2875, 2931, 3019, 3044,
11217 : /* 290 */ 2960, 2987, 3027, 3032, 3057, 3064, 3130, 3734, 4659, 4667,
11218 : /* 300 */ 4670, 4676, 4679, 4706, 5060, 5061, 5095, 5099, 5228, 5068,
11219 : /* 310 */ 5069, 5113, 5116, 5117, 5122, 5125, 5128, 5129, 5081, 5084,
11220 : /* 320 */ 5301, 5305, 5310, 5594, 5746, 5750, 7108, 7124, 7126, 7138,
11221 : /* 330 */ 7168, 7174, 7175, 7190, 7191, 7195, 7213, 7218, 7250, 7258,
11222 : /* 340 */ 7268, 7277, 7281, 7287, 7294, 7310, 7314, 7318, 7325, 7326,
11223 : /* 350 */ 7331, 7332, 7339, 7340, 7342, 7343, 7359, 7370, 7382, 7386,
11224 : /* 360 */ 7388, 7393, 7396, 7399, 7407, 7469, 7470, 7474, 7475, 7482,
11225 : /* 370 */ 7486, 7490, 7493, 7499, 7500, 7504, 7507, 7514, 7534, 7537,
11226 : /* 380 */ 7540, 7543, 7592, 7595, 7599, 7606, 7612, 7620, 7629, 7630,
11227 : /* 390 */ 7728, 7738, 7777, 7783, 7799, 7812, 7814, 7816, 7827, 7855,
11228 : /* 400 */ 7897, 7876, 7877, 7884, 7886, 7902, 7908, 7913, 7922, 7928,
11229 : /* 410 */ 7934, 7939, 7944, 7976, 8039, 7958, 7968, 8068, 8087, 8089,
11230 : /* 420 */ 8091, 8093, 8095, 8097, 8101, 8103, 8126, 8149, 8261, 8268,
11231 : /* 430 */ 8269, 8277, 8278, 8480, 9561, 9563, 9641, 9643, 9644, 9650,
11232 : /* 440 */ 9666, 9668, 9670, 9688, 9689, 10093, 10096, 10110, 10119, 10183,
11233 : /* 450 */ 10184, 10238, 10240, 10316, 10908, 10910, 10912, 11346, 7104, 7115,
11234 : /* 460 */ 7117, 7225, 485, 1259, 1280, 8924, 8929, 8934, 545, 546,
11235 : /* 470 */ 557, 562, 569, 578, 586, 595, 641, 644, 853, 1007,
11236 : /* 480 */ 1035, 1066, 606, 883, 887, 892, 898, 902, 910, 999,
11237 : /* 490 */ 757, 767, 769, 771, 8554, 8979, 9001, 8984, 8989, 8994,
11238 : /* 500 */ 9008, 9042, 9047, 828, 6328, 6396, 6398, 6400, 6500, 6503,
11239 : /* 510 */ 6677, 6679, 6693, 6697, 6720, 6726, 6737, 6799, 6814, 4753,
11240 : /* 520 */ 4773, 4780, 4786, 4792, 4798, 6805, 4766, 4809, 4822, 6309,
11241 : /* 530 */ 6610, 6614, 6622, 6951, 9534, 9535, 6961, 10537, 10545, 12159,
11242 : /* 540 */ 7992, 7993, 8007, 8008, 840, 843, 1724, 2783, 2786, 2905,
11243 : /* 550 */ 2917, 3002, 2946, 2973, 3085, 3088, 4529, 4540, 4689, 4697,
11244 : /* 560 */ 4976, 7046, 8405, 7642, 7645, 7671, 7672, 8174, 8176, 8178,
11245 : /* 570 */ 8180, 8184, 8186, 8188, 8190, 8194, 8199, 8206, 8211, 8231,
11246 : /* 580 */ 8233, 8235, 8237, 8418, 8431, 8441, 8449, 8459, 8581, 8583,
11247 : /* 590 */ 9575, 9584, 9624, 10161, 10163, 10164, 10219, 10222, 10224, 2799,
11248 : /* 600 */ 7036, 7715, 8655, 8660, 10929, 10931, 10933, 10935, 10939, 945,
11249 : /* 610 */ 981, 1331, 4857, 4927, 4930, 4938, 5029, 5031, 5032, 5033,
11250 : /* 620 */ 5240, 4908, 4917, 5801, 5804, 5805, 5813, 2335, 2345, 2352,
11251 : /* 630 */ 3745, 3750, 4601, 9400, 9402, 9433, 9468, 11962, 1223, 8872,
11252 : /* 640 */ 8893, 1232, 8616, 8622, 8919, 9347, 1246, 1250, 8914, 9097,
11253 : /* 650 */ 1459, 1543, 1591, 1536, 1568, 1599, 1641, 1682, 1693, 1704,
11254 : /* 660 */ 1716, 2609, 1945, 1953, 1958, 2081, 2454, 2748, 3325, 3355,
11255 : /* 670 */ 3357, 3367, 3369, 3476, 3477, 3478, 3486, 3494, 3503, 3512,
11256 : /* 680 */ 3546, 3547, 3552, 3553, 3558, 3563, 3567, 3375, 3380, 3425,
11257 : /* 690 */ 4734, 5199, 5217, 5218, 5772, 5778, 5826, 7240, 7688, 9503,
11258 : /* 700 */ 9505, 10351, 1631, 1636, 2686, 1804, 2691, 5279, 2666, 2697,
11259 : /* 710 */ 2701, 5293, 4644, 7073, 7075, 2202, 2216, 2671, 3837, 2241,
11260 : /* 720 */ 2264, 2265, 9964, 4422, 4426, 4436, 4454, 4485, 4494, 4553,
11261 : /* 730 */ 4556, 4565, 4566, 4584, 4586, 4588, 4590, 4639, 9525, 4440,
11262 : /* 740 */ 4447, 4432, 4611, 4620, 4623, 11138, 11144, 11152, 11158, 11167,
11263 : /* 750 */ 11173, 11181, 11187, 11233, 11241, 4844, 5001, 5011, 8509, 8512,
11264 : /* 760 */ 8531, 5722, 5734, 5737, 5741, 8293, 7233, 7229, 8490, 8497,
11265 : /* 770 */ 8632, 8637, 8738, 8835, 8852, 8884, 8904, 8909, 9160, 9137,
11266 : /* 780 */ 9116, 8945, 8949, 9240, 9250, 9257, 9266, 9284, 9291, 9272,
11267 : /* 790 */ 9540, 9546, 9954, 9960, 9957, 9977, 9982, 9988, 9996, 10002,
11268 : /* 800 */ 10010, 10016, 10026, 10032, 10040, 10046, 10054, 10060, 10068, 10074,
11269 : /* 810 */ 10128, 10331, 10346, 10382, 10636, 10639, 10444, 10458, 10471, 11315,
11270 : /* 820 */ 11330, 11421, 11422, 12071, 223, 2113, 2123, 5858, 2141, 1173,
11271 : /* 830 */ 2620, 3306, 5321, 5323, 5333, 5450, 5461, 5474, 5497, 5507,
11272 : /* 840 */ 5516, 5528, 5554, 5868, 6315, 1801, 1815, 1822, 1844, 1851,
11273 : /* 850 */ 2469, 2714, 2118, 2136, 2145, 2211, 2247, 2253, 3824, 6999,
11274 : /* 860 */ 3832, 10036, 9992, 10050, 10064, 10078, 10006, 10020, 5338, 5348,
11275 : /* 870 */ 5357, 5384, 5394, 5400, 5879, 5409, 5406, 5692, 5700, 5708,
11276 : /* 880 */ 5712, 5695, 5703, 5716, 5728, 241, 249, 1757, 1762, 2679,
11277 : /* 890 */ 2533, 3722, 4519, 5897, 5906, 5917, 5926, 11977, 739, 5641,
11278 : /* 900 */ 5647, 5649, 3178, 3182, 254, 3199, 3203, 3234, 3242, 3215,
11279 : /* 910 */ 3229, 272, 309, 1495, 1810, 1918, 1925, 1935, 1940, 2222,
11280 : /* 920 */ 3250, 3262, 3256, 3268, 2233, 2926, 2954, 2981, 2965, 2992,
11281 : /* 930 */ 4084, 4056, 4131, 4140, 4183, 4194, 5654, 5665, 11943, 11944,
11282 : /* 940 */ 1729, 1734, 7678, 11292, 11296, 259, 312, 2935, 2938, 3275,
11283 : /* 950 */ 3282, 3289, 3295, 4093, 3300, 4149, 4203, 5657, 385, 316,
11284 : /* 960 */ 353, 362, 370, 444, 459, 467, 658, 698, 1016, 1211,
11285 : /* 970 */ 1216, 1314, 1317, 1451, 2523, 5670, 8589, 8595, 8786, 9036,
11286 : /* 980 */ 2640, 6105, 6115, 7745, 8325, 8385, 8386, 2630, 8319, 621,
11287 : /* 990 */ 624, 748, 777, 783, 789, 797, 802, 807, 871, 875,
11288 : /* 1000 */ 8601, 8607, 8243, 929, 1406, 4873, 1395, 1398, 1430, 1441,
11289 : /* 1010 */ 4850, 4922, 5039, 1465, 1663, 1739, 1767, 2404, 5045, 5046,
11290 : /* 1020 */ 7682, 11950, 4461, 4465, 4511, 4512, 4632, 4472, 4476, 4502,
11291 : /* 1030 */ 4503, 4982, 5689, 8301, 8303, 8310, 8312, 7237, 6821, 4740,
11292 : /* 1040 */ 5937, 4837, 5946, 6629, 6634, 6772, 6774, 6780, 6789, 6790,
11293 : /* 1050 */ 5844, 5846, 6827, 6830, 6839, 6843, 6848, 6877, 6882, 6948,
11294 : /* 1060 */ 6890, 6895, 6958, 8022, 8024, 6914, 6915, 6916, 6971, 6938,
11295 : /* 1070 */ 6939, 6940, 6986, 6987, 8053, 8058, 6856, 5850, 5852, 6126,
11296 : /* 1080 */ 6128, 9696, 9702, 9707, 9716, 9718, 9738, 9783, 9786, 9787,
11297 : /* 1090 */ 9819, 9825, 9827, 9828, 9884, 9885, 9906, 9911, 9916, 9946,
11298 : /* 1100 */ 11446, 11448, 11483, 11558, 11561, 11646, 11581, 11587, 11715, 11717,
11299 : /* 1110 */ 11779, 11781
11300 : };
11301 :
11302 27401 : fprintf (dump_file, "%s %s:%d, %s:%d\n",
11303 : simplify ? "Applying pattern" : "Matching expression", file1, dbg_line_numbers[line1_id], file2, line2);
11304 18347 : }
11305 :
11306 : #pragma GCC diagnostic pop
|
