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 166886013 : tree_truth_valued_p (tree t)
11 : {
12 166886013 : const tree type = TREE_TYPE (t);
13 166886013 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 166886013 : if (TREE_SIDE_EFFECTS (t)) return false;
15 161634393 : {
16 161634393 : tree captures[1] ATTRIBUTE_UNUSED = { t };
17 161634393 : if (INTEGRAL_TYPE_P (type) && TYPE_PRECISION (type) == 1
18 : )
19 : {
20 5868713 : {
21 5868713 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 20, __FILE__, __LINE__, false);
22 5868713 : return true;
23 : }
24 : }
25 : }
26 155765680 : switch (TREE_CODE (t))
27 : {
28 817 : case LT_EXPR:
29 817 : {
30 817 : tree _p0 = TREE_OPERAND (t, 0);
31 817 : tree _p1 = TREE_OPERAND (t, 1);
32 817 : {
33 817 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
34 817 : {
35 817 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
36 817 : return true;
37 : }
38 : }
39 721 : break;
40 : }
41 721 : case LE_EXPR:
42 721 : {
43 721 : tree _p0 = TREE_OPERAND (t, 0);
44 721 : tree _p1 = TREE_OPERAND (t, 1);
45 721 : {
46 721 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
47 721 : {
48 721 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
49 721 : return true;
50 : }
51 : }
52 11899 : break;
53 : }
54 11899 : case EQ_EXPR:
55 11899 : {
56 11899 : tree _p0 = TREE_OPERAND (t, 0);
57 11899 : tree _p1 = TREE_OPERAND (t, 1);
58 11899 : {
59 11899 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
60 11899 : {
61 11899 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
62 11899 : return true;
63 : }
64 : }
65 4440 : break;
66 : }
67 4440 : case NE_EXPR:
68 4440 : {
69 4440 : tree _p0 = TREE_OPERAND (t, 0);
70 4440 : tree _p1 = TREE_OPERAND (t, 1);
71 4440 : {
72 4440 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
73 4440 : {
74 4440 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
75 4440 : return true;
76 : }
77 : }
78 392 : break;
79 : }
80 392 : case GE_EXPR:
81 392 : {
82 392 : tree _p0 = TREE_OPERAND (t, 0);
83 392 : tree _p1 = TREE_OPERAND (t, 1);
84 392 : {
85 392 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
86 392 : {
87 392 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
88 392 : return true;
89 : }
90 : }
91 236462 : break;
92 : }
93 236462 : case GT_EXPR:
94 236462 : {
95 236462 : tree _p0 = TREE_OPERAND (t, 0);
96 236462 : tree _p1 = TREE_OPERAND (t, 1);
97 236462 : {
98 236462 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
99 236462 : {
100 236462 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
101 236462 : return true;
102 : }
103 : }
104 135735 : break;
105 : }
106 135735 : case UNORDERED_EXPR:
107 135735 : {
108 135735 : tree _p0 = TREE_OPERAND (t, 0);
109 135735 : tree _p1 = TREE_OPERAND (t, 1);
110 135735 : {
111 135735 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
112 135735 : {
113 135735 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
114 135735 : return true;
115 : }
116 : }
117 16 : break;
118 : }
119 16 : case ORDERED_EXPR:
120 16 : {
121 16 : tree _p0 = TREE_OPERAND (t, 0);
122 16 : tree _p1 = TREE_OPERAND (t, 1);
123 16 : {
124 16 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
125 16 : {
126 16 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
127 16 : return true;
128 : }
129 : }
130 70 : break;
131 : }
132 70 : case UNLT_EXPR:
133 70 : {
134 70 : tree _p0 = TREE_OPERAND (t, 0);
135 70 : tree _p1 = TREE_OPERAND (t, 1);
136 70 : {
137 70 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
138 70 : {
139 70 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
140 70 : return true;
141 : }
142 : }
143 1157 : break;
144 : }
145 1157 : case UNLE_EXPR:
146 1157 : {
147 1157 : tree _p0 = TREE_OPERAND (t, 0);
148 1157 : tree _p1 = TREE_OPERAND (t, 1);
149 1157 : {
150 1157 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
151 1157 : {
152 1157 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
153 1157 : return true;
154 : }
155 : }
156 70 : break;
157 : }
158 70 : case UNGT_EXPR:
159 70 : {
160 70 : tree _p0 = TREE_OPERAND (t, 0);
161 70 : tree _p1 = TREE_OPERAND (t, 1);
162 70 : {
163 70 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
164 70 : {
165 70 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
166 70 : return true;
167 : }
168 : }
169 70 : break;
170 : }
171 70 : case UNGE_EXPR:
172 70 : {
173 70 : tree _p0 = TREE_OPERAND (t, 0);
174 70 : tree _p1 = TREE_OPERAND (t, 1);
175 70 : {
176 70 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
177 70 : {
178 70 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
179 70 : return true;
180 : }
181 : }
182 84 : break;
183 : }
184 84 : case UNEQ_EXPR:
185 84 : {
186 84 : tree _p0 = TREE_OPERAND (t, 0);
187 84 : tree _p1 = TREE_OPERAND (t, 1);
188 84 : {
189 84 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
190 84 : {
191 84 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
192 84 : return true;
193 : }
194 : }
195 24 : break;
196 : }
197 24 : case LTGT_EXPR:
198 24 : {
199 24 : tree _p0 = TREE_OPERAND (t, 0);
200 24 : tree _p1 = TREE_OPERAND (t, 1);
201 24 : {
202 24 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
203 24 : {
204 24 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
205 24 : return true;
206 : }
207 : }
208 106 : break;
209 : }
210 106 : case TRUTH_AND_EXPR:
211 106 : {
212 106 : tree _p0 = TREE_OPERAND (t, 0);
213 106 : tree _p1 = TREE_OPERAND (t, 1);
214 106 : {
215 106 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
216 106 : {
217 106 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
218 106 : return true;
219 : }
220 : }
221 488 : break;
222 : }
223 488 : case TRUTH_ANDIF_EXPR:
224 488 : {
225 488 : tree _p0 = TREE_OPERAND (t, 0);
226 488 : tree _p1 = TREE_OPERAND (t, 1);
227 488 : {
228 488 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
229 488 : {
230 488 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
231 488 : return true;
232 : }
233 : }
234 53 : break;
235 : }
236 53 : case TRUTH_OR_EXPR:
237 53 : {
238 53 : tree _p0 = TREE_OPERAND (t, 0);
239 53 : tree _p1 = TREE_OPERAND (t, 1);
240 53 : {
241 53 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
242 53 : {
243 53 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
244 53 : return true;
245 : }
246 : }
247 1385 : break;
248 : }
249 1385 : case TRUTH_ORIF_EXPR:
250 1385 : {
251 1385 : tree _p0 = TREE_OPERAND (t, 0);
252 1385 : tree _p1 = TREE_OPERAND (t, 1);
253 1385 : {
254 1385 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
255 1385 : {
256 1385 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
257 1385 : return true;
258 : }
259 : }
260 0 : break;
261 : }
262 0 : case TRUTH_XOR_EXPR:
263 0 : {
264 0 : tree _p0 = TREE_OPERAND (t, 0);
265 0 : tree _p1 = TREE_OPERAND (t, 1);
266 0 : {
267 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
268 0 : {
269 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
270 0 : return true;
271 : }
272 : }
273 585504 : break;
274 : }
275 585504 : case TRUTH_NOT_EXPR:
276 585504 : {
277 585504 : tree _p0 = TREE_OPERAND (t, 0);
278 585504 : {
279 585504 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
280 585504 : {
281 585504 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
282 585504 : return true;
283 : }
284 : }
285 : break;
286 : }
287 : default:;
288 : }
289 : return false;
290 : }
291 :
292 : tree
293 56 : generic_simplify_40 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
294 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
295 : const enum tree_code ARG_UNUSED (inner_op),
296 : const enum tree_code ARG_UNUSED (outer_op))
297 : {
298 56 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
299 56 : {
300 56 : bool fail = false;
301 56 : wide_int zero_mask_not;
302 56 : wide_int C0;
303 56 : wide_int cst_emit;
304 56 : if (TREE_CODE (captures[1]) == SSA_NAME)
305 0 : zero_mask_not = get_nonzero_bits (captures[1]);
306 : else
307 : fail = true;
308 56 : if (inner_op == BIT_XOR_EXPR)
309 : {
310 33 : C0 = wi::bit_and_not (wi::to_wide (captures[2]), wi::to_wide (captures[3]));
311 33 : cst_emit = C0 | wi::to_wide (captures[3]);
312 : }
313 : else
314 : {
315 23 : C0 = wi::to_wide (captures[2]);
316 23 : cst_emit = C0 ^ wi::to_wide (captures[3]);
317 : }
318 56 : if (!fail && (C0 & zero_mask_not) == 0
319 : )
320 : {
321 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail116;
322 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail116;
323 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail116;
324 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail116;
325 0 : {
326 0 : tree res_op0;
327 0 : res_op0 = captures[1];
328 0 : tree res_op1;
329 0 : res_op1 = wide_int_to_tree (type, cst_emit);
330 0 : tree _r;
331 0 : _r = fold_build2_loc (loc, outer_op, type, res_op0, res_op1);
332 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 89, __FILE__, __LINE__, true);
333 0 : return _r;
334 : }
335 56 : next_after_fail116:;
336 : }
337 : else
338 : {
339 56 : if (!fail && (wi::to_wide (captures[3]) & zero_mask_not) == 0
340 : )
341 : {
342 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail117;
343 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail117;
344 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail117;
345 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail117;
346 0 : {
347 0 : tree res_op0;
348 0 : res_op0 = captures[1];
349 0 : tree res_op1;
350 0 : res_op1 = wide_int_to_tree (type, cst_emit);
351 0 : tree _r;
352 0 : _r = fold_build2_loc (loc, inner_op, type, res_op0, res_op1);
353 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 90, __FILE__, __LINE__, true);
354 0 : return _r;
355 : }
356 56 : next_after_fail117:;
357 : }
358 : }
359 56 : }
360 56 : return NULL_TREE;
361 : }
362 :
363 : tree
364 66 : generic_simplify_55 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
365 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
366 : {
367 66 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
368 66 : if (ANY_INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_UNDEFINED (type)
369 : )
370 : {
371 66 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail135;
372 66 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail135;
373 66 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail135;
374 66 : {
375 66 : tree res_op0;
376 66 : res_op0 = captures[0];
377 66 : tree _r;
378 66 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
379 66 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 104, __FILE__, __LINE__, true);
380 66 : return _r;
381 : }
382 : next_after_fail135:;
383 : }
384 : return NULL_TREE;
385 : }
386 :
387 : tree
388 241323 : generic_simplify_63 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
389 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
390 : const enum tree_code ARG_UNUSED (outer_op))
391 : {
392 241323 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
393 241323 : if (!TYPE_SATURATING (type)
394 : )
395 : {
396 241323 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
397 482639 : && !FIXED_POINT_TYPE_P (type)
398 : )
399 : {
400 241316 : if (!ANY_INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_WRAPS (type)
401 : )
402 : {
403 227782 : if (!CONSTANT_CLASS_P (captures[1])
404 : )
405 : {
406 227782 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail149;
407 227782 : {
408 227782 : tree res_op0;
409 227782 : {
410 227782 : tree _o1[2], _r1;
411 227782 : {
412 227782 : tree _o2[1], _r2;
413 227782 : _o2[0] = captures[0];
414 227782 : if (TREE_TYPE (_o2[0]) != type)
415 : {
416 3297 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o2[0]);
417 : }
418 : else
419 : _r2 = _o2[0];
420 227782 : _o1[0] = _r2;
421 : }
422 227782 : _o1[1] = captures[2];
423 227782 : _r1 = fold_build2_loc (loc, outer_op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
424 227782 : if (EXPR_P (_r1))
425 0 : goto next_after_fail149;
426 227782 : res_op0 = _r1;
427 : }
428 227782 : tree res_op1;
429 227782 : {
430 227782 : tree _o1[1], _r1;
431 227782 : _o1[0] = captures[1];
432 227782 : if (TREE_TYPE (_o1[0]) != type)
433 : {
434 3329 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
435 : }
436 : else
437 : _r1 = _o1[0];
438 227782 : res_op1 = _r1;
439 : }
440 227782 : tree _r;
441 227782 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
442 227782 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 118, __FILE__, __LINE__, true);
443 227782 : return _r;
444 : }
445 : next_after_fail149:;
446 : }
447 : }
448 : else
449 : {
450 27068 : if (!ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
451 27068 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))
452 : )
453 : {
454 2317 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail150;
455 2317 : {
456 2317 : tree res_op0;
457 2317 : {
458 2317 : tree _o1[2], _r1;
459 2317 : {
460 2317 : tree _o2[2], _r2;
461 2317 : _o2[0] = captures[0];
462 2317 : {
463 2317 : tree _o3[1], _r3;
464 2317 : _o3[0] = captures[2];
465 2317 : if (TREE_TYPE (_o3[0]) != TREE_TYPE (_o2[0]))
466 : {
467 2317 : _r3 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (_o2[0]), _o3[0]);
468 : }
469 : else
470 : _r3 = _o3[0];
471 2317 : _o2[1] = _r3;
472 : }
473 2317 : _r2 = fold_build2_loc (loc, outer_op, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
474 2317 : if (EXPR_P (_r2))
475 0 : goto next_after_fail150;
476 2317 : _o1[0] = _r2;
477 : }
478 2317 : _o1[1] = captures[1];
479 2317 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
480 2317 : res_op0 = _r1;
481 : }
482 2317 : tree _r;
483 2317 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
484 2317 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 119, __FILE__, __LINE__, true);
485 2317 : return _r;
486 : }
487 : next_after_fail150:;
488 : }
489 : else
490 : {
491 11217 : if (types_match (type, captures[1]) && !TYPE_OVERFLOW_SANITIZED (type)
492 : )
493 : {
494 11189 : {
495 11189 : tree cst = const_binop (outer_op, type, captures[0], captures[2]);
496 11189 : if (cst && !TREE_OVERFLOW (cst)
497 : )
498 : {
499 11182 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail151;
500 11182 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail151;
501 11182 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail151;
502 11182 : {
503 11182 : tree res_op0;
504 11182 : res_op0 = cst;
505 11182 : tree res_op1;
506 11182 : res_op1 = captures[1];
507 11182 : tree _r;
508 11182 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
509 11182 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 120, __FILE__, __LINE__, true);
510 11182 : return _r;
511 : }
512 : next_after_fail151:;
513 : }
514 : }
515 : }
516 : }
517 : }
518 : }
519 : }
520 : return NULL_TREE;
521 : }
522 :
523 : tree
524 1 : generic_simplify_87 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
525 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
526 : {
527 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
528 1 : if (INTEGRAL_TYPE_P (type)
529 : )
530 : {
531 1 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail177;
532 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail177;
533 1 : {
534 1 : tree res_op0;
535 1 : res_op0 = unshare_expr (captures[1]);
536 1 : tree res_op1;
537 1 : {
538 1 : tree _o1[2], _r1;
539 1 : _o1[0] = captures[4];
540 1 : _o1[1] = captures[1];
541 1 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
542 1 : res_op1 = _r1;
543 : }
544 1 : tree _r;
545 1 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
546 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 146, __FILE__, __LINE__, true);
547 1 : return _r;
548 : }
549 : next_after_fail177:;
550 : }
551 : return NULL_TREE;
552 : }
553 :
554 : tree
555 1 : generic_simplify_95 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
556 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
557 : {
558 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
559 1 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
560 1 : && tree_nop_conversion_p (type, TREE_TYPE (captures[3]))
561 : )
562 : {
563 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail185;
564 1 : {
565 1 : tree res_op0;
566 1 : {
567 1 : tree _o1[2], _r1;
568 1 : {
569 1 : tree _o2[1], _r2;
570 1 : _o2[0] = captures[3];
571 1 : _r2 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
572 1 : _o1[0] = _r2;
573 : }
574 1 : _o1[1] = captures[0];
575 1 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
576 1 : res_op0 = _r1;
577 : }
578 1 : tree _r;
579 1 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
580 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 154, __FILE__, __LINE__, true);
581 1 : return _r;
582 : }
583 0 : next_after_fail185:;
584 : }
585 : return NULL_TREE;
586 : }
587 :
588 : tree
589 664 : generic_simplify_103 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
590 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
591 : {
592 664 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
593 664 : if (!TYPE_SATURATING (type)
594 : )
595 : {
596 664 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
597 1328 : && !FIXED_POINT_TYPE_P (type)
598 : )
599 : {
600 664 : if (!ANY_INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_WRAPS (type)
601 : )
602 : {
603 24 : if (!CONSTANT_CLASS_P (captures[2])
604 : )
605 : {
606 24 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail195;
607 24 : {
608 24 : tree res_op0;
609 24 : {
610 24 : tree _o1[1], _r1;
611 24 : _o1[0] = captures[2];
612 24 : if (TREE_TYPE (_o1[0]) != type)
613 : {
614 24 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
615 : }
616 : else
617 : _r1 = _o1[0];
618 24 : res_op0 = _r1;
619 : }
620 24 : tree res_op1;
621 24 : {
622 24 : tree _o1[2], _r1;
623 24 : _o1[0] = captures[0];
624 24 : {
625 24 : tree _o2[1], _r2;
626 24 : _o2[0] = captures[1];
627 24 : if (TREE_TYPE (_o2[0]) != type)
628 : {
629 24 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o2[0]);
630 : }
631 : else
632 : _r2 = _o2[0];
633 24 : _o1[1] = _r2;
634 : }
635 24 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
636 24 : if (EXPR_P (_r1))
637 0 : goto next_after_fail195;
638 24 : res_op1 = _r1;
639 : }
640 24 : tree _r;
641 24 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
642 24 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 163, __FILE__, __LINE__, true);
643 24 : return _r;
644 : }
645 : next_after_fail195:;
646 : }
647 : }
648 : else
649 : {
650 1280 : if (!ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
651 1280 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))
652 : )
653 : {
654 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail196;
655 1 : {
656 1 : tree res_op0;
657 1 : {
658 1 : tree _o1[2], _r1;
659 1 : _o1[0] = captures[2];
660 1 : {
661 1 : tree _o2[2], _r2;
662 1 : {
663 1 : tree _o3[1], _r3;
664 1 : _o3[0] = captures[0];
665 1 : if (TREE_TYPE (_o3[0]) != TREE_TYPE (_o1[0]))
666 : {
667 1 : _r3 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (_o1[0]), _o3[0]);
668 : }
669 : else
670 : _r3 = _o3[0];
671 1 : _o2[0] = _r3;
672 : }
673 1 : _o2[1] = captures[1];
674 1 : _r2 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
675 1 : if (EXPR_P (_r2))
676 0 : goto next_after_fail196;
677 1 : _o1[1] = _r2;
678 : }
679 1 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
680 1 : res_op0 = _r1;
681 : }
682 1 : tree _r;
683 1 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
684 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 164, __FILE__, __LINE__, true);
685 1 : return _r;
686 : }
687 : next_after_fail196:;
688 : }
689 : else
690 : {
691 639 : if (types_match (type, captures[2]) && !TYPE_OVERFLOW_SANITIZED (type)
692 : )
693 : {
694 630 : {
695 630 : tree cst = const_binop (MINUS_EXPR, type, captures[0], captures[1]);
696 630 : if (cst && !TREE_OVERFLOW (cst)
697 : )
698 : {
699 630 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail197;
700 630 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail197;
701 630 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail197;
702 630 : {
703 630 : tree res_op0;
704 630 : res_op0 = cst;
705 630 : tree res_op1;
706 630 : res_op1 = captures[2];
707 630 : tree _r;
708 630 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
709 630 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 165, __FILE__, __LINE__, true);
710 630 : return _r;
711 : }
712 : next_after_fail197:;
713 : }
714 : }
715 : }
716 : }
717 : }
718 : }
719 : }
720 : return NULL_TREE;
721 : }
722 :
723 : tree
724 0 : generic_simplify_131 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
725 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
726 : {
727 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
728 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
729 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
730 : )
731 : {
732 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail229;
733 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail229;
734 0 : {
735 0 : tree _r;
736 0 : _r = captures[2];
737 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 189, __FILE__, __LINE__, true);
738 0 : return _r;
739 : }
740 : next_after_fail229:;
741 : }
742 : return NULL_TREE;
743 : }
744 :
745 : tree
746 0 : generic_simplify_141 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
747 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
748 : const enum tree_code ARG_UNUSED (op))
749 : {
750 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
751 0 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[3]))
752 0 : && tree_nop_conversion_p (type, TREE_TYPE (captures[6]))
753 : )
754 : {
755 0 : if (single_use (captures[4]) && single_use (captures[5])
756 : )
757 : {
758 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail240;
759 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail240;
760 0 : {
761 0 : tree res_op0;
762 0 : res_op0 = captures[0];
763 0 : tree res_op1;
764 0 : {
765 0 : tree _o1[1], _r1;
766 0 : _o1[0] = captures[6];
767 0 : if (TREE_TYPE (_o1[0]) != type)
768 : {
769 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
770 : }
771 : else
772 : _r1 = _o1[0];
773 0 : res_op1 = _r1;
774 : }
775 0 : tree _r;
776 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
777 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 197, __FILE__, __LINE__, true);
778 0 : return _r;
779 : }
780 : next_after_fail240:;
781 : }
782 : else
783 : {
784 : if (single_use (captures[0]) && single_use (captures[1])
785 : )
786 : {
787 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail241;
788 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail241;
789 : {
790 : tree res_op0;
791 : {
792 : tree _o1[1], _r1;
793 : _o1[0] = captures[3];
794 : if (TREE_TYPE (_o1[0]) != type)
795 : {
796 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
797 : }
798 : else
799 : _r1 = _o1[0];
800 : res_op0 = _r1;
801 : }
802 : tree res_op1;
803 : res_op1 = captures[4];
804 : tree _r;
805 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
806 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 198, __FILE__, __LINE__, true);
807 : return _r;
808 : }
809 : next_after_fail241:;
810 : }
811 : }
812 : }
813 : return NULL_TREE;
814 : }
815 :
816 : tree
817 300 : generic_simplify_156 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
818 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
819 : {
820 300 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
821 300 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail262;
822 300 : {
823 300 : if (! tree_invariant_p (captures[1])) goto next_after_fail262;
824 0 : tree res_op0;
825 0 : {
826 0 : tree _o1[2], _r1;
827 0 : {
828 0 : tree _o2[2], _r2;
829 0 : _o2[0] = unshare_expr (captures[1]);
830 0 : _o2[1] = captures[4];
831 0 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
832 0 : _o1[0] = _r2;
833 : }
834 0 : _o1[1] = captures[2];
835 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
836 0 : res_op0 = _r1;
837 : }
838 0 : tree res_op1;
839 0 : res_op1 = captures[1];
840 0 : tree _r;
841 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
842 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 210, __FILE__, __LINE__, true);
843 : return _r;
844 : }
845 : next_after_fail262:;
846 : return NULL_TREE;
847 : }
848 :
849 : tree
850 0 : generic_simplify_167 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
851 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
852 : {
853 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
854 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail292;
855 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail292;
856 0 : {
857 0 : tree _r;
858 0 : _r = constant_boolean_node (true, type);
859 0 : if (TREE_SIDE_EFFECTS (captures[1]))
860 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
861 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 232, __FILE__, __LINE__, true);
862 : return _r;
863 : }
864 : next_after_fail292:;
865 : return NULL_TREE;
866 : }
867 :
868 : tree
869 0 : generic_simplify_170 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
870 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
871 : const enum tree_code ARG_UNUSED (code2),
872 : const enum tree_code ARG_UNUSED (code1))
873 : {
874 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
875 0 : if ((TREE_CODE (captures[2]) == INTEGER_CST
876 0 : && TREE_CODE (captures[5]) == INTEGER_CST)
877 0 : || ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
878 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[2])))
879 0 : || POINTER_TYPE_P (TREE_TYPE (captures[2])))
880 0 : && bitwise_equal_p (captures[2], captures[5]))
881 : )
882 : {
883 0 : {
884 0 : bool one_before = false;
885 0 : bool one_after = false;
886 0 : int cmp = 0;
887 0 : bool allbits = true;
888 0 : if (TREE_CODE (captures[2]) == INTEGER_CST
889 0 : && TREE_CODE (captures[5]) == INTEGER_CST)
890 : {
891 0 : allbits = TYPE_PRECISION (TREE_TYPE (captures[2])) <= TYPE_PRECISION (TREE_TYPE (captures[5]));
892 0 : auto t1 = wi::to_wide (fold_convert (TREE_TYPE (captures[5]), captures[2]));
893 0 : auto t2 = wi::to_wide (captures[5]);
894 0 : cmp = wi::cmp (t1, t2, TYPE_SIGN (TREE_TYPE (captures[5])));
895 0 : if (cmp < 0
896 0 : && t1 == t2 - 1)
897 : one_before = true;
898 0 : if (cmp > 0
899 0 : && t1 == t2 + 1)
900 : one_after = true;
901 : }
902 0 : bool val;
903 0 : switch (code2)
904 : {
905 0 : case EQ_EXPR: val = (cmp == 0); break;
906 0 : case NE_EXPR: val = (cmp != 0); break;
907 0 : case LT_EXPR: val = (cmp < 0); break;
908 0 : case GT_EXPR: val = (cmp > 0); break;
909 0 : case LE_EXPR: val = (cmp <= 0); break;
910 0 : case GE_EXPR: val = (cmp >= 0); break;
911 0 : default: gcc_unreachable ();
912 : }
913 0 : if (code1 == EQ_EXPR && val
914 : )
915 : {
916 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail296;
917 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail296;
918 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail296;
919 0 : {
920 0 : tree _r;
921 0 : _r = captures[3];
922 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 214, __FILE__, __LINE__, true);
923 0 : return _r;
924 : }
925 : next_after_fail296:;
926 : }
927 : else
928 : {
929 0 : if (code1 == NE_EXPR && val && allbits
930 : )
931 : {
932 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail297;
933 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail297;
934 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail297;
935 0 : {
936 0 : tree _r;
937 0 : _r = constant_boolean_node (true, type);
938 0 : if (TREE_SIDE_EFFECTS (captures[1]))
939 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
940 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 215, __FILE__, __LINE__, true);
941 0 : return _r;
942 : }
943 : next_after_fail297:;
944 : }
945 : else
946 : {
947 0 : if (code1 == NE_EXPR && !val && allbits
948 : )
949 : {
950 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail298;
951 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail298;
952 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail298;
953 0 : {
954 0 : tree _r;
955 0 : _r = captures[0];
956 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 216, __FILE__, __LINE__, true);
957 0 : return _r;
958 : }
959 : next_after_fail298:;
960 : }
961 : else
962 : {
963 0 : if (code1 == EQ_EXPR
964 0 : && code2 == GT_EXPR
965 0 : && cmp == 0
966 0 : && allbits
967 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
968 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GE_EXPR))
969 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
970 : )
971 : {
972 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail299;
973 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail299;
974 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail299;
975 0 : {
976 0 : tree res_op0;
977 0 : res_op0 = captures[4];
978 0 : tree res_op1;
979 0 : res_op1 = captures[5];
980 0 : tree _r;
981 0 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
982 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 217, __FILE__, __LINE__, true);
983 0 : return _r;
984 : }
985 : next_after_fail299:;
986 : }
987 : else
988 : {
989 0 : if (code1 == EQ_EXPR
990 0 : && code2 == LT_EXPR
991 0 : && cmp == 0
992 0 : && allbits
993 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
994 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LE_EXPR))
995 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
996 : )
997 : {
998 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail300;
999 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail300;
1000 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail300;
1001 0 : {
1002 0 : tree res_op0;
1003 0 : res_op0 = captures[4];
1004 0 : tree res_op1;
1005 0 : res_op1 = captures[5];
1006 0 : tree _r;
1007 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1008 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 218, __FILE__, __LINE__, true);
1009 0 : return _r;
1010 : }
1011 : next_after_fail300:;
1012 : }
1013 : else
1014 : {
1015 0 : if (code1 == EQ_EXPR
1016 0 : && code2 == GE_EXPR
1017 : && one_before
1018 0 : && allbits
1019 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
1020 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GE_EXPR))
1021 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
1022 : )
1023 : {
1024 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail301;
1025 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail301;
1026 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail301;
1027 0 : {
1028 0 : tree res_op0;
1029 0 : res_op0 = captures[4];
1030 0 : tree res_op1;
1031 0 : {
1032 0 : tree _o1[1], _r1;
1033 0 : _o1[0] = captures[2];
1034 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
1035 : {
1036 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
1037 : }
1038 : else
1039 : _r1 = _o1[0];
1040 0 : res_op1 = _r1;
1041 : }
1042 0 : tree _r;
1043 0 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
1044 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 219, __FILE__, __LINE__, true);
1045 0 : return _r;
1046 : }
1047 : next_after_fail301:;
1048 : }
1049 : else
1050 : {
1051 0 : if (code1 == EQ_EXPR
1052 0 : && code2 == LE_EXPR
1053 : && one_after
1054 0 : && allbits
1055 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
1056 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LE_EXPR))
1057 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
1058 : )
1059 : {
1060 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail302;
1061 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail302;
1062 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail302;
1063 0 : {
1064 0 : tree res_op0;
1065 0 : res_op0 = captures[4];
1066 0 : tree res_op1;
1067 0 : {
1068 0 : tree _o1[1], _r1;
1069 0 : _o1[0] = captures[2];
1070 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
1071 : {
1072 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
1073 : }
1074 : else
1075 : _r1 = _o1[0];
1076 0 : res_op1 = _r1;
1077 : }
1078 0 : tree _r;
1079 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1080 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 220, __FILE__, __LINE__, true);
1081 0 : return _r;
1082 : }
1083 : next_after_fail302:;
1084 : }
1085 : }
1086 : }
1087 : }
1088 : }
1089 : }
1090 : }
1091 : }
1092 : }
1093 : return NULL_TREE;
1094 : }
1095 :
1096 : tree
1097 64 : generic_simplify_211 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1098 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1099 : const enum tree_code ARG_UNUSED (cmp))
1100 : {
1101 64 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1102 120 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1103 120 : && tree_expr_nonzero_p (captures[0])
1104 : )
1105 : {
1106 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail353;
1107 12 : {
1108 12 : tree _r;
1109 12 : _r = constant_boolean_node (cmp != EQ_EXPR, type);
1110 12 : if (TREE_SIDE_EFFECTS (captures[0]))
1111 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1112 12 : if (TREE_SIDE_EFFECTS (captures[1]))
1113 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1114 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 266, __FILE__, __LINE__, true);
1115 12 : return _r;
1116 : }
1117 0 : next_after_fail353:;
1118 : }
1119 : return NULL_TREE;
1120 : }
1121 :
1122 : tree
1123 9574 : generic_simplify_219 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1124 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1125 : const enum tree_code ARG_UNUSED (neeq),
1126 : const enum tree_code ARG_UNUSED (ltge))
1127 : {
1128 9574 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1129 9574 : {
1130 9574 : tree itype = signed_type_for (TREE_TYPE (captures[1]));
1131 18935 : if (wi::to_wide (captures[2]) == element_precision (itype) - 1
1132 9574 : && (!VECTOR_TYPE_P (itype)
1133 15 : || (cfun
1134 15 : && cfun->after_inlining
1135 7 : && VECTOR_BOOLEAN_TYPE_P (type)
1136 4 : && (expand_vec_cmp_expr_p (itype, type, ltge)
1137 4 : || !expand_vec_cmp_expr_p (TREE_TYPE (captures[0]),
1138 : type, neeq))))
1139 : )
1140 : {
1141 213 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail365;
1142 213 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail365;
1143 213 : {
1144 213 : tree res_op0;
1145 213 : {
1146 213 : tree _o1[1], _r1;
1147 213 : _o1[0] = captures[1];
1148 213 : if (TREE_TYPE (_o1[0]) != itype)
1149 : {
1150 161 : _r1 = fold_build1_loc (loc, NOP_EXPR, itype, _o1[0]);
1151 : }
1152 : else
1153 : _r1 = _o1[0];
1154 213 : res_op0 = _r1;
1155 : }
1156 213 : tree res_op1;
1157 213 : res_op1 = build_zero_cst (itype);
1158 213 : tree _r;
1159 213 : _r = fold_build2_loc (loc, ltge, type, res_op0, res_op1);
1160 213 : if (TREE_SIDE_EFFECTS (captures[2]))
1161 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1162 213 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 277, __FILE__, __LINE__, true);
1163 213 : return _r;
1164 : }
1165 : next_after_fail365:;
1166 : }
1167 : }
1168 : return NULL_TREE;
1169 : }
1170 :
1171 : tree
1172 438 : generic_simplify_231 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1173 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1174 : const enum tree_code ARG_UNUSED (cmp),
1175 : const enum tree_code ARG_UNUSED (ocmp))
1176 : {
1177 438 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1178 438 : if (TREE_CODE (TREE_TYPE (captures[0])) != COMPLEX_TYPE
1179 438 : && (VECTOR_TYPE_P (type) || !VECTOR_TYPE_P (TREE_TYPE (captures[0])))
1180 : )
1181 : {
1182 416 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail390;
1183 416 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail390;
1184 416 : {
1185 416 : tree res_op0;
1186 416 : res_op0 = captures[0];
1187 416 : tree res_op1;
1188 416 : res_op1 = captures[1];
1189 416 : tree _r;
1190 416 : _r = fold_build2_loc (loc, ocmp, type, res_op0, res_op1);
1191 416 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 301, __FILE__, __LINE__, true);
1192 416 : return _r;
1193 : }
1194 : next_after_fail390:;
1195 : }
1196 : return NULL_TREE;
1197 : }
1198 :
1199 : tree
1200 732 : generic_simplify_237 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1201 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1202 : const enum tree_code ARG_UNUSED (cmp))
1203 : {
1204 732 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1205 732 : if (wi::gt_p (wi::to_wide (captures[1]), wi::to_wide (captures[2]),
1206 732 : TYPE_SIGN (TREE_TYPE (captures[0])))
1207 : )
1208 : {
1209 42 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail397;
1210 42 : {
1211 42 : tree _r;
1212 42 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1213 42 : if (TREE_SIDE_EFFECTS (captures[0]))
1214 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1215 42 : if (TREE_SIDE_EFFECTS (captures[1]))
1216 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1217 42 : if (TREE_SIDE_EFFECTS (captures[2]))
1218 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1219 42 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 308, __FILE__, __LINE__, true);
1220 42 : return _r;
1221 : }
1222 0 : next_after_fail397:;
1223 : }
1224 : else
1225 : {
1226 690 : if (wi::lt_p (wi::to_wide (captures[1]), wi::to_wide (captures[2]),
1227 690 : TYPE_SIGN (TREE_TYPE (captures[0])))
1228 : )
1229 : {
1230 690 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail398;
1231 690 : {
1232 690 : tree res_op0;
1233 690 : res_op0 = captures[0];
1234 690 : tree res_op1;
1235 690 : res_op1 = captures[2];
1236 690 : tree _r;
1237 690 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1238 690 : if (TREE_SIDE_EFFECTS (captures[1]))
1239 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1240 690 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 309, __FILE__, __LINE__, true);
1241 690 : return _r;
1242 : }
1243 0 : next_after_fail398:;
1244 : }
1245 : }
1246 : return NULL_TREE;
1247 : }
1248 :
1249 : tree
1250 47 : generic_simplify_248 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1251 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
1252 : {
1253 47 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1254 47 : if (TREE_CODE (TREE_TYPE (captures[1])) != COMPLEX_TYPE
1255 47 : && (!VECTOR_MODE_P (TYPE_MODE (TREE_TYPE (captures[1])))
1256 7 : || !target_supports_op_p (TREE_TYPE (captures[1]), TRUNC_DIV_EXPR,
1257 : optab_vector)
1258 0 : || target_supports_op_p (TREE_TYPE (captures[1]), TRUNC_MOD_EXPR,
1259 : optab_vector))
1260 : )
1261 : {
1262 47 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail419;
1263 47 : {
1264 47 : tree res_op0;
1265 47 : {
1266 47 : tree _o1[2], _r1;
1267 47 : _o1[0] = captures[1];
1268 47 : _o1[1] = captures[2];
1269 47 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1270 47 : res_op0 = _r1;
1271 : }
1272 47 : tree res_op1;
1273 47 : res_op1 = build_zero_cst (TREE_TYPE (captures[1]));
1274 47 : tree _r;
1275 47 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
1276 47 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 330, __FILE__, __LINE__, true);
1277 47 : return _r;
1278 : }
1279 0 : next_after_fail419:;
1280 : }
1281 : return NULL_TREE;
1282 : }
1283 :
1284 : tree
1285 61285 : generic_simplify_256 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1286 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1287 : const enum tree_code ARG_UNUSED (cmp))
1288 : {
1289 61285 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1290 122570 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1291 122570 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
1292 139332 : && wi::to_wide (captures[1]) != 0
1293 : )
1294 : {
1295 16762 : {
1296 16762 : widest_int quot;
1297 16762 : if (wi::multiple_of_p (wi::to_widest (captures[2]), wi::to_widest (captures[1]),
1298 16762 : TYPE_SIGN (TREE_TYPE (captures[0])), ")
1299 : )
1300 : {
1301 12541 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail430;
1302 12541 : {
1303 12541 : tree res_op0;
1304 12541 : res_op0 = captures[0];
1305 12541 : tree res_op1;
1306 12541 : res_op1 = wide_int_to_tree (TREE_TYPE (captures[0]), quot);
1307 12541 : tree _r;
1308 12541 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1309 12541 : if (TREE_SIDE_EFFECTS (captures[1]))
1310 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1311 12541 : if (TREE_SIDE_EFFECTS (captures[2]))
1312 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1313 12541 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 340, __FILE__, __LINE__, true);
1314 12541 : return _r;
1315 : }
1316 0 : next_after_fail430:;
1317 : }
1318 : else
1319 : {
1320 4221 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail431;
1321 4221 : {
1322 4221 : tree _r;
1323 4221 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1324 4221 : if (TREE_SIDE_EFFECTS (captures[0]))
1325 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1326 4221 : if (TREE_SIDE_EFFECTS (captures[1]))
1327 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1328 4221 : if (TREE_SIDE_EFFECTS (captures[2]))
1329 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1330 4221 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 341, __FILE__, __LINE__, true);
1331 4221 : return _r;
1332 : }
1333 0 : next_after_fail431:;
1334 : }
1335 16762 : }
1336 : }
1337 : else
1338 : {
1339 89046 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1340 44523 : && TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0]))
1341 89046 : && (wi::bit_and (wi::to_wide (captures[1]), 1) == 1)
1342 : )
1343 : {
1344 1144 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail432;
1345 1144 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail432;
1346 1144 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail432;
1347 1144 : {
1348 1144 : tree res_op0;
1349 1144 : res_op0 = captures[0];
1350 1144 : tree res_op1;
1351 1144 : tree itype = TREE_TYPE (captures[0]);
1352 1144 : int p = TYPE_PRECISION (itype);
1353 1144 : wide_int m = wi::one (p + 1) << p;
1354 1144 : wide_int a = wide_int::from (wi::to_wide (captures[1]), p + 1, UNSIGNED);
1355 1144 : wide_int i = wide_int::from (wi::mod_inv (a, m),
1356 2288 : p, TYPE_SIGN (itype)); res_op1 =
1357 1144 : wide_int_to_tree (itype, wi::mul (i, wi::to_wide (captures[2])));
1358 1144 : tree _r;
1359 1144 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1360 1144 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 342, __FILE__, __LINE__, true);
1361 1144 : return _r;
1362 1144 : }
1363 : next_after_fail432:;
1364 : }
1365 : }
1366 : return NULL_TREE;
1367 : }
1368 :
1369 : tree
1370 8019391 : generic_simplify_272 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1371 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1372 : const enum tree_code ARG_UNUSED (cmp))
1373 : {
1374 8019391 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1375 16038758 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1376 2610335 : && !(targetm.have_canonicalize_funcptr_for_compare ()
1377 0 : && ((POINTER_TYPE_P (TREE_TYPE (captures[1]))
1378 0 : && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (captures[1]))))
1379 0 : || (POINTER_TYPE_P (TREE_TYPE (captures[3]))
1380 0 : && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (captures[3]))))))
1381 8019391 : && single_use (captures[0])
1382 : )
1383 : {
1384 2610335 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (TREE_TYPE (captures[0]))
1385 1842352 : && (TREE_CODE (captures[3]) == INTEGER_CST
1386 1842352 : || captures[2] != captures[3])
1387 1842352 : && (TYPE_UNSIGNED (TREE_TYPE (captures[1])) == TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1388 : || cmp == NE_EXPR
1389 1049596 : || cmp == EQ_EXPR)
1390 830100 : && !POINTER_TYPE_P (TREE_TYPE (captures[1]))
1391 3327005 : && (TREE_CODE (TREE_TYPE (captures[1])) != BOOLEAN_TYPE
1392 390 : || TREE_CODE (TREE_TYPE (captures[3])) == BOOLEAN_TYPE)
1393 : )
1394 : {
1395 716670 : if (TREE_CODE (captures[2]) == INTEGER_CST
1396 : )
1397 : {
1398 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail490;
1399 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail490;
1400 0 : {
1401 0 : tree res_op0;
1402 0 : res_op0 = captures[1];
1403 0 : tree res_op1;
1404 0 : res_op1 = force_fit_type (TREE_TYPE (captures[1]),
1405 0 : wide_int::from (wi::to_wide (captures[2]),
1406 0 : MAX (TYPE_PRECISION (TREE_TYPE (captures[2])),
1407 : TYPE_PRECISION (TREE_TYPE (captures[1]))),
1408 0 : TYPE_SIGN (TREE_TYPE (captures[2]))),
1409 0 : 0, TREE_OVERFLOW (captures[2]));
1410 0 : tree _r;
1411 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1412 0 : if (TREE_SIDE_EFFECTS (captures[3]))
1413 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
1414 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 399, __FILE__, __LINE__, true);
1415 0 : return _r;
1416 : }
1417 : next_after_fail490:;
1418 : }
1419 : else
1420 : {
1421 716670 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail491;
1422 621614 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail491;
1423 621614 : {
1424 621614 : tree res_op0;
1425 621614 : res_op0 = captures[1];
1426 621614 : tree res_op1;
1427 621614 : {
1428 621614 : tree _o1[1], _r1;
1429 621614 : _o1[0] = captures[2];
1430 621614 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
1431 : {
1432 621492 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
1433 : }
1434 : else
1435 : _r1 = _o1[0];
1436 621614 : res_op1 = _r1;
1437 : }
1438 621614 : tree _r;
1439 621614 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1440 621614 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 400, __FILE__, __LINE__, true);
1441 621614 : return _r;
1442 : }
1443 : next_after_fail491:;
1444 : }
1445 : }
1446 : else
1447 : {
1448 1893665 : if (TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (TREE_TYPE (captures[1]))
1449 : )
1450 : {
1451 714876 : if ((cmp == EQ_EXPR || cmp == NE_EXPR
1452 232922 : || TYPE_UNSIGNED (TREE_TYPE (captures[0])) == TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1453 121154 : || (!TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1454 120066 : && TYPE_UNSIGNED (TREE_TYPE (captures[1]))))
1455 946710 : && (types_match (TREE_TYPE (captures[3]), TREE_TYPE (captures[1]))
1456 118281 : || ((TYPE_PRECISION (TREE_TYPE (captures[1]))
1457 118281 : >= TYPE_PRECISION (TREE_TYPE (captures[3])))
1458 51516 : && (TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1459 51516 : == TYPE_UNSIGNED (TREE_TYPE (captures[3]))))
1460 78614 : || (TREE_CODE (captures[2]) == INTEGER_CST
1461 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1462 0 : && int_fits_type_p (captures[2], TREE_TYPE (captures[1]))))
1463 : )
1464 : {
1465 635174 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail492;
1466 635174 : {
1467 635174 : tree res_op0;
1468 635174 : res_op0 = captures[1];
1469 635174 : tree res_op1;
1470 635174 : {
1471 635174 : tree _o1[1], _r1;
1472 635174 : _o1[0] = captures[3];
1473 635174 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
1474 : {
1475 138554 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
1476 : }
1477 : else
1478 : _r1 = _o1[0];
1479 635174 : res_op1 = _r1;
1480 : }
1481 635174 : tree _r;
1482 635174 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1483 635174 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 401, __FILE__, __LINE__, true);
1484 635174 : return _r;
1485 : }
1486 0 : next_after_fail492:;
1487 : }
1488 : else
1489 : {
1490 79702 : if (TREE_CODE (captures[2]) == INTEGER_CST
1491 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1492 79702 : && !int_fits_type_p (captures[2], TREE_TYPE (captures[1]))
1493 : )
1494 : {
1495 0 : {
1496 0 : tree min = lower_bound_in_type (TREE_TYPE (captures[3]), TREE_TYPE (captures[1]));
1497 0 : tree max = upper_bound_in_type (TREE_TYPE (captures[3]), TREE_TYPE (captures[1]));
1498 0 : bool above = integer_nonzerop (const_binop (LT_EXPR, type, max, captures[2]));
1499 0 : bool below = integer_nonzerop (const_binop (LT_EXPR, type, captures[2], min));
1500 0 : if (above || below
1501 : )
1502 : {
1503 0 : if (cmp == EQ_EXPR || cmp == NE_EXPR
1504 : )
1505 : {
1506 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail493;
1507 0 : {
1508 0 : tree _r;
1509 0 : _r = constant_boolean_node (cmp != EQ_EXPR, type);
1510 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1511 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1512 0 : if (TREE_SIDE_EFFECTS (captures[3]))
1513 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
1514 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 402, __FILE__, __LINE__, true);
1515 0 : return _r;
1516 : }
1517 0 : next_after_fail493:;
1518 : }
1519 : else
1520 : {
1521 0 : if (cmp == LT_EXPR || cmp == LE_EXPR
1522 : )
1523 : {
1524 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail494;
1525 0 : {
1526 0 : tree _r;
1527 0 : _r = constant_boolean_node (above, type);
1528 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1529 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1530 0 : if (TREE_SIDE_EFFECTS (captures[3]))
1531 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
1532 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 403, __FILE__, __LINE__, true);
1533 0 : return _r;
1534 : }
1535 0 : next_after_fail494:;
1536 : }
1537 : else
1538 : {
1539 0 : if (cmp == GT_EXPR || cmp == GE_EXPR
1540 : )
1541 : {
1542 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail495;
1543 0 : {
1544 0 : tree _r;
1545 0 : _r = constant_boolean_node (!above, type);
1546 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1547 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1548 0 : if (TREE_SIDE_EFFECTS (captures[3]))
1549 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
1550 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 404, __FILE__, __LINE__, true);
1551 0 : return _r;
1552 : }
1553 0 : next_after_fail495:;
1554 : }
1555 : }
1556 : }
1557 : }
1558 : }
1559 : }
1560 : }
1561 : }
1562 : else
1563 : {
1564 2357559 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1565 1062704 : && (TYPE_PRECISION (TREE_TYPE (captures[0]))
1566 1062704 : < TYPE_PRECISION (TREE_TYPE (captures[1])))
1567 53068 : && (cmp == EQ_EXPR || cmp == NE_EXPR)
1568 1180849 : && types_match (TREE_TYPE (captures[1]),
1569 2060 : TREE_TYPE (captures[3]))
1570 : )
1571 : {
1572 1646 : {
1573 1646 : tree itype = TREE_TYPE (captures[0]);
1574 1646 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail496;
1575 1646 : {
1576 1646 : tree res_op0;
1577 1646 : {
1578 1646 : tree _o1[1], _r1;
1579 1646 : {
1580 1646 : tree _o2[2], _r2;
1581 1646 : _o2[0] = captures[1];
1582 1646 : _o2[1] = captures[3];
1583 1646 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
1584 1646 : _o1[0] = _r2;
1585 : }
1586 1646 : if (TREE_TYPE (_o1[0]) != itype)
1587 : {
1588 1646 : _r1 = fold_build1_loc (loc, NOP_EXPR, itype, _o1[0]);
1589 : }
1590 : else
1591 : _r1 = _o1[0];
1592 1646 : res_op0 = _r1;
1593 : }
1594 1646 : tree res_op1;
1595 1646 : res_op1 = build_zero_cst (itype);
1596 1646 : tree _r;
1597 1646 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1598 1646 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 405, __FILE__, __LINE__, true);
1599 1646 : return _r;
1600 : }
1601 0 : next_after_fail496:;
1602 : }
1603 : }
1604 : }
1605 : }
1606 : }
1607 : else
1608 : {
1609 10774054 : if (FLOAT_TYPE_P (TREE_TYPE (captures[1]))
1610 88278 : && (DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1611 44139 : == DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[1])))
1612 5497326 : && (DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1613 44135 : == DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[3])))
1614 : )
1615 : {
1616 44131 : {
1617 44131 : tree type1 = TREE_TYPE (captures[3]);
1618 44131 : if (TREE_CODE (captures[3]) == REAL_CST && !DECIMAL_FLOAT_TYPE_P (type1))
1619 : {
1620 0 : REAL_VALUE_TYPE orig = TREE_REAL_CST (captures[3]);
1621 0 : if (TYPE_PRECISION (type1) > TYPE_PRECISION (float_type_node)
1622 0 : && exact_real_truncate (TYPE_MODE (float_type_node), &orig))
1623 0 : type1 = float_type_node;
1624 0 : if (TYPE_PRECISION (type1) > TYPE_PRECISION (double_type_node)
1625 0 : && exact_real_truncate (TYPE_MODE (double_type_node), &orig))
1626 0 : type1 = double_type_node;
1627 : }
1628 44131 : tree newtype
1629 44131 : = (element_precision (TREE_TYPE (captures[1])) > element_precision (type1)
1630 44131 : ? TREE_TYPE (captures[1]) : type1);
1631 44131 : if (element_precision (TREE_TYPE (captures[0])) > element_precision (newtype)
1632 44131 : && (!VECTOR_TYPE_P (type) || is_truth_type_for (newtype, type))
1633 : )
1634 : {
1635 1527 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail497;
1636 1527 : {
1637 1527 : tree res_op0;
1638 1527 : {
1639 1527 : tree _o1[1], _r1;
1640 1527 : _o1[0] = captures[1];
1641 1527 : if (TREE_TYPE (_o1[0]) != newtype)
1642 : {
1643 9 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
1644 : }
1645 : else
1646 : _r1 = _o1[0];
1647 1527 : res_op0 = _r1;
1648 : }
1649 1527 : tree res_op1;
1650 1527 : {
1651 1527 : tree _o1[1], _r1;
1652 1527 : _o1[0] = captures[3];
1653 1527 : if (TREE_TYPE (_o1[0]) != newtype)
1654 : {
1655 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
1656 : }
1657 : else
1658 : _r1 = _o1[0];
1659 1527 : res_op1 = _r1;
1660 : }
1661 1527 : tree _r;
1662 1527 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1663 1527 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 406, __FILE__, __LINE__, true);
1664 1527 : return _r;
1665 : }
1666 0 : next_after_fail497:;
1667 : }
1668 : }
1669 : }
1670 : }
1671 : return NULL_TREE;
1672 : }
1673 :
1674 : tree
1675 0 : generic_simplify_302 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1676 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1677 : const enum tree_code ARG_UNUSED (op))
1678 : {
1679 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1680 0 : {
1681 0 : HOST_WIDE_INT zero_val = tree_to_shwi (captures[2]);
1682 0 : tree type0 = TREE_TYPE (captures[1]);
1683 0 : int prec = TYPE_PRECISION (type0);
1684 0 : if (prec <= MAX_FIXED_MODE_SIZE
1685 : )
1686 : {
1687 0 : if (tree_int_cst_sgn (captures[3]) < 0 || wi::to_widest (captures[3]) >= prec
1688 : )
1689 : {
1690 0 : if (zero_val != wi::to_widest (captures[3])
1691 : )
1692 : {
1693 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail567;
1694 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail567;
1695 0 : {
1696 0 : tree _r;
1697 0 : _r = constant_boolean_node (op != EQ_EXPR, type);
1698 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1699 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1700 0 : if (TREE_SIDE_EFFECTS (captures[3]))
1701 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
1702 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 458, __FILE__, __LINE__, true);
1703 0 : return _r;
1704 : }
1705 0 : next_after_fail567:;
1706 : }
1707 : }
1708 : else
1709 : {
1710 0 : if (zero_val < 0 || zero_val >= prec
1711 : )
1712 : {
1713 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail568;
1714 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail568;
1715 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail568;
1716 0 : {
1717 0 : tree res_op0;
1718 0 : {
1719 0 : tree _o1[2], _r1;
1720 0 : _o1[0] = captures[1];
1721 0 : _o1[1] = wide_int_to_tree (type0,
1722 0 : wi::mask (tree_to_uhwi (captures[3]) + 1,
1723 : false, prec));
1724 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1725 0 : res_op0 = _r1;
1726 : }
1727 0 : tree res_op1;
1728 0 : res_op1 = wide_int_to_tree (type0,
1729 0 : wi::shifted_mask (tree_to_uhwi (captures[3]), 1,
1730 : false, prec));
1731 0 : tree _r;
1732 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1733 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 459, __FILE__, __LINE__, true);
1734 0 : return _r;
1735 : }
1736 0 : next_after_fail568:;
1737 : }
1738 : }
1739 : }
1740 : }
1741 0 : return NULL_TREE;
1742 : }
1743 :
1744 : tree
1745 2238 : generic_simplify_317 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1746 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1747 : const enum tree_code ARG_UNUSED (div))
1748 : {
1749 2238 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1750 2238 : if (!integer_zerop (captures[1])
1751 : )
1752 : {
1753 1737 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail588;
1754 1737 : {
1755 1737 : tree _r;
1756 1737 : _r = captures[0];
1757 1737 : if (TREE_SIDE_EFFECTS (captures[1]))
1758 59 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1759 1737 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 477, __FILE__, __LINE__, true);
1760 1737 : return _r;
1761 : }
1762 0 : next_after_fail588:;
1763 : }
1764 : return NULL_TREE;
1765 : }
1766 :
1767 : tree
1768 9342 : generic_simplify_323 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1769 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1770 : const enum tree_code ARG_UNUSED (div))
1771 : {
1772 9342 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1773 9342 : {
1774 9342 : wi::overflow_type overflow;
1775 9342 : wide_int mul = wi::mul (wi::to_wide (captures[2]), wi::to_wide (captures[3]),
1776 18684 : TYPE_SIGN (type), &overflow);
1777 9342 : if (div == EXACT_DIV_EXPR
1778 9342 : || optimize_successive_divisions_p (captures[3], captures[0])
1779 : )
1780 : {
1781 0 : if (!overflow
1782 : )
1783 : {
1784 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail594;
1785 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail594;
1786 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail594;
1787 0 : {
1788 0 : tree res_op0;
1789 0 : res_op0 = captures[1];
1790 0 : tree res_op1;
1791 0 : res_op1 = wide_int_to_tree (type, mul);
1792 0 : tree _r;
1793 0 : _r = fold_build2_loc (loc, div, type, res_op0, res_op1);
1794 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 483, __FILE__, __LINE__, true);
1795 0 : return _r;
1796 : }
1797 9342 : next_after_fail594:;
1798 : }
1799 : else
1800 : {
1801 0 : if (TYPE_UNSIGNED (type)
1802 0 : || mul != wi::min_value (TYPE_PRECISION (type), SIGNED)
1803 : )
1804 : {
1805 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail595;
1806 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail595;
1807 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail595;
1808 0 : {
1809 0 : tree _r;
1810 0 : _r = build_zero_cst (type);
1811 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1812 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1813 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 484, __FILE__, __LINE__, true);
1814 0 : return _r;
1815 : }
1816 9342 : next_after_fail595:;
1817 : }
1818 : }
1819 : }
1820 0 : }
1821 9342 : return NULL_TREE;
1822 : }
1823 :
1824 : tree
1825 2 : generic_simplify_336 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1826 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
1827 : {
1828 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1829 0 : if (FLOAT_TYPE_P (type)
1830 2 : && ! HONOR_NANS (type)
1831 2 : && ! HONOR_INFINITIES (type)
1832 : )
1833 : {
1834 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail608;
1835 0 : {
1836 0 : tree _r;
1837 0 : _r = build_minus_one_cst (type);
1838 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1839 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1840 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 497, __FILE__, __LINE__, true);
1841 0 : return _r;
1842 : }
1843 0 : next_after_fail608:;
1844 : }
1845 : return NULL_TREE;
1846 : }
1847 :
1848 : tree
1849 4 : generic_simplify_345 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1850 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1851 : const combined_fn ARG_UNUSED (POW))
1852 : {
1853 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1854 4 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1855 : )
1856 : {
1857 4 : if (!TREE_OVERFLOW (captures[2])
1858 : )
1859 : {
1860 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail619;
1861 4 : {
1862 4 : tree res_op0;
1863 4 : res_op0 = captures[1];
1864 4 : tree res_op1;
1865 4 : {
1866 4 : tree _o1[2], _r1;
1867 4 : _o1[0] = captures[2];
1868 4 : _o1[1] = build_one_cst (type);
1869 4 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1870 4 : res_op1 = _r1;
1871 : }
1872 4 : tree _r;
1873 4 : _r = maybe_build_call_expr_loc (loc, POW, type, 2, res_op0, res_op1);
1874 4 : if (!_r)
1875 0 : goto next_after_fail619;
1876 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 508, __FILE__, __LINE__, true);
1877 4 : return _r;
1878 : }
1879 : next_after_fail619:;
1880 : }
1881 : }
1882 : return NULL_TREE;
1883 : }
1884 :
1885 : tree
1886 0 : generic_simplify_352 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1887 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1888 : const enum tree_code ARG_UNUSED (cmp),
1889 : const enum tree_code ARG_UNUSED (minmax))
1890 : {
1891 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1892 0 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1893 0 : && TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1894 : )
1895 : {
1896 0 : {
1897 0 : tree_code code;
1898 0 : widest_int c1 = wi::mask<widest_int>(TYPE_PRECISION (type) - 1, 0);
1899 0 : tree_code ncmp = cmp == GE_EXPR ? LE_EXPR : GT_EXPR;
1900 0 : code = minmax_from_comparison (ncmp, captures[0], c1, wi::to_widest (captures[4]));
1901 0 : if (ncmp == LE_EXPR
1902 0 : && code == MIN_EXPR
1903 0 : && wi::le_p (wi::to_wide (captures[3]),
1904 0 : wi::to_wide (captures[4]),
1905 0 : TYPE_SIGN (type))
1906 : )
1907 : {
1908 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail631;
1909 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail631;
1910 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail631;
1911 0 : {
1912 0 : tree res_op0;
1913 0 : res_op0 = captures[2];
1914 0 : tree res_op1;
1915 0 : res_op1 = captures[4];
1916 0 : tree _r;
1917 0 : _r = fold_build2_loc (loc, MIN_EXPR, type, res_op0, res_op1);
1918 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1919 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1920 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 520, __FILE__, __LINE__, true);
1921 0 : return _r;
1922 : }
1923 0 : next_after_fail631:;
1924 : }
1925 : else
1926 : {
1927 0 : if (ncmp == GT_EXPR
1928 0 : && code == MAX_EXPR
1929 0 : && wi::ge_p (wi::to_wide (captures[3]),
1930 0 : wi::to_wide (captures[4]),
1931 0 : TYPE_SIGN (type))
1932 : )
1933 : {
1934 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail632;
1935 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail632;
1936 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail632;
1937 0 : {
1938 0 : tree res_op0;
1939 0 : res_op0 = captures[2];
1940 0 : tree res_op1;
1941 0 : res_op1 = captures[4];
1942 0 : tree _r;
1943 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
1944 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1945 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1946 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 521, __FILE__, __LINE__, true);
1947 0 : return _r;
1948 : }
1949 0 : next_after_fail632:;
1950 : }
1951 : }
1952 0 : }
1953 : }
1954 : return NULL_TREE;
1955 : }
1956 :
1957 : tree
1958 0 : generic_simplify_370 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1959 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1960 : const enum tree_code ARG_UNUSED (cmp))
1961 : {
1962 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1963 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail650;
1964 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail650;
1965 0 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail650;
1966 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail650;
1967 0 : {
1968 0 : tree _r;
1969 0 : _r = captures[3];
1970 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 539, __FILE__, __LINE__, true);
1971 : return _r;
1972 : }
1973 : next_after_fail650:;
1974 : return NULL_TREE;
1975 : }
1976 :
1977 : tree
1978 2011 : generic_simplify_377 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1979 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures))
1980 : {
1981 2011 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1982 2011 : if (INTEGRAL_TYPE_P (type)
1983 : )
1984 : {
1985 2011 : {
1986 2011 : tree itype = TREE_TYPE (captures[2]);
1987 2011 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail658;
1988 2011 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail658;
1989 2011 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail658;
1990 2011 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail658;
1991 2011 : {
1992 2011 : tree res_op0;
1993 2011 : {
1994 2011 : tree _o1[2], _r1;
1995 2011 : _o1[0] = captures[2];
1996 2011 : {
1997 2011 : tree _o2[1], _r2;
1998 2011 : _o2[0] = captures[0];
1999 2011 : if (TREE_TYPE (_o2[0]) != itype)
2000 : {
2001 2011 : _r2 = fold_build1_loc (loc, NOP_EXPR, itype, _o2[0]);
2002 : }
2003 : else
2004 : _r2 = _o2[0];
2005 2011 : _o1[1] = _r2;
2006 : }
2007 2011 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2008 2011 : res_op0 = _r1;
2009 : }
2010 2011 : tree _r;
2011 2011 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2012 2011 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 545, __FILE__, __LINE__, true);
2013 2011 : return _r;
2014 : }
2015 : next_after_fail658:;
2016 : }
2017 : }
2018 : return NULL_TREE;
2019 : }
2020 :
2021 : tree
2022 976 : generic_simplify_386 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2023 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2024 : const enum tree_code ARG_UNUSED (op))
2025 : {
2026 976 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2027 1952 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2028 1952 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
2029 : )
2030 : {
2031 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail671;
2032 0 : {
2033 0 : tree res_op0;
2034 0 : res_op0 = captures[0];
2035 0 : tree res_op1;
2036 0 : res_op1 = captures[2];
2037 0 : tree _r;
2038 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2039 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2040 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2041 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 558, __FILE__, __LINE__, true);
2042 0 : return _r;
2043 : }
2044 0 : next_after_fail671:;
2045 : }
2046 : return NULL_TREE;
2047 : }
2048 :
2049 : tree
2050 6 : generic_simplify_391 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2051 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2052 : const enum tree_code ARG_UNUSED (minmax),
2053 : const enum tree_code ARG_UNUSED (cmp))
2054 : {
2055 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2056 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail677;
2057 6 : {
2058 6 : tree _r;
2059 6 : _r = constant_boolean_node (cmp == GE_EXPR || cmp == LE_EXPR, type);
2060 6 : if (TREE_SIDE_EFFECTS (captures[0]))
2061 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2062 6 : if (TREE_SIDE_EFFECTS (captures[1]))
2063 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2064 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 564, __FILE__, __LINE__, true);
2065 : return _r;
2066 : }
2067 0 : next_after_fail677:;
2068 0 : return NULL_TREE;
2069 : }
2070 :
2071 : tree
2072 181 : generic_simplify_401 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2073 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2074 : const enum tree_code ARG_UNUSED (cmp),
2075 : const enum tree_code ARG_UNUSED (out))
2076 : {
2077 181 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2078 181 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))
2079 181 : && types_match (TREE_TYPE (captures[3]), TREE_TYPE (captures[0]))
2080 106 : && tree_nop_conversion_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[3]))
2081 181 : && wi::to_wide (captures[4]) != 0
2082 0 : && single_use (captures[1])
2083 : )
2084 : {
2085 106 : {
2086 106 : unsigned int prec = TYPE_PRECISION (TREE_TYPE (captures[3]));
2087 106 : signop sign = TYPE_SIGN (TREE_TYPE (captures[3]));
2088 106 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail719;
2089 106 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail719;
2090 106 : {
2091 106 : tree res_op0;
2092 106 : res_op0 = captures[3];
2093 106 : tree res_op1;
2094 106 : res_op1 = wide_int_to_tree (TREE_TYPE (captures[3]),
2095 106 : wi::max_value (prec, sign)
2096 318 : - wi::to_wide (captures[4]));
2097 106 : tree _r;
2098 106 : _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
2099 106 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 569, __FILE__, __LINE__, true);
2100 106 : return _r;
2101 : }
2102 : next_after_fail719:;
2103 : }
2104 : }
2105 : return NULL_TREE;
2106 : }
2107 :
2108 : tree
2109 50 : generic_simplify_409 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2110 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2111 : const enum tree_code ARG_UNUSED (op),
2112 : const enum tree_code ARG_UNUSED (cmp),
2113 : const combined_fn ARG_UNUSED (ctz))
2114 : {
2115 50 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2116 50 : {
2117 50 : bool ok = true;
2118 50 : HOST_WIDE_INT val = 0;
2119 50 : if (sanitize_flags_p (SANITIZE_BUILTIN)
2120 50 : && (!cfun
2121 32 : || (cfun->curr_properties & PROP_ssa) == 0))
2122 : ok = false;
2123 18 : else if (!tree_fits_shwi_p (captures[2]))
2124 : ok = false;
2125 : else
2126 : {
2127 18 : val = tree_to_shwi (captures[2]);
2128 18 : if (op == GT_EXPR || op == LE_EXPR)
2129 : {
2130 10 : if (val == HOST_WIDE_INT_MAX)
2131 : ok = false;
2132 : else
2133 10 : val++;
2134 : }
2135 : }
2136 50 : tree type0 = TREE_TYPE (captures[1]);
2137 50 : int prec = TYPE_PRECISION (type0);
2138 68 : if (ok && prec <= MAX_FIXED_MODE_SIZE
2139 : )
2140 : {
2141 18 : if (val <= 0
2142 : )
2143 : {
2144 8 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail730;
2145 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail730;
2146 8 : {
2147 8 : tree _r;
2148 8 : _r = constant_boolean_node (cmp == EQ_EXPR, type);
2149 8 : if (TREE_SIDE_EFFECTS (captures[1]))
2150 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2151 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 600, __FILE__, __LINE__, true);
2152 8 : return _r;
2153 : }
2154 : next_after_fail730:;
2155 : }
2156 : else
2157 : {
2158 10 : if (val >= prec
2159 : )
2160 : {
2161 5 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail731;
2162 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail731;
2163 5 : {
2164 5 : tree _r;
2165 5 : _r = constant_boolean_node (cmp != EQ_EXPR, type);
2166 5 : if (TREE_SIDE_EFFECTS (captures[1]))
2167 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2168 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 601, __FILE__, __LINE__, true);
2169 5 : return _r;
2170 : }
2171 : next_after_fail731:;
2172 : }
2173 : else
2174 : {
2175 5 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail732;
2176 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail732;
2177 5 : {
2178 5 : tree res_op0;
2179 5 : {
2180 5 : tree _o1[2], _r1;
2181 5 : _o1[0] = captures[1];
2182 5 : _o1[1] = wide_int_to_tree (type0,
2183 5 : wi::mask (val, false, prec));
2184 5 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2185 5 : res_op0 = _r1;
2186 : }
2187 5 : tree res_op1;
2188 5 : res_op1 = build_zero_cst (type0);
2189 5 : tree _r;
2190 5 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2191 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 602, __FILE__, __LINE__, true);
2192 5 : return _r;
2193 : }
2194 : next_after_fail732:;
2195 : }
2196 : }
2197 : }
2198 : }
2199 : return NULL_TREE;
2200 : }
2201 :
2202 : tree
2203 94 : generic_simplify_422 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2204 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2205 : {
2206 94 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2207 188 : if (INTEGRAL_TYPE_P (type)
2208 93 : && !TYPE_UNSIGNED (type)
2209 93 : && !TYPE_OVERFLOW_TRAPS (type)
2210 93 : && tree_nop_conversion_p (type, TREE_TYPE (captures[2]))
2211 281 : && (expr_not_equal_to (captures[0], wi::to_wide (TYPE_MIN_VALUE (type)))
2212 187 : || expr_not_equal_to (captures[2], wi::minus_one (TYPE_PRECISION
2213 : (TREE_TYPE (captures[2]))),
2214 : gimple_match_ctx (captures[1])))
2215 : )
2216 : {
2217 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail751;
2218 0 : {
2219 0 : tree res_op0;
2220 0 : res_op0 = captures[0];
2221 0 : tree res_op1;
2222 0 : {
2223 0 : tree _o1[1], _r1;
2224 0 : _o1[0] = captures[2];
2225 0 : if (TREE_TYPE (_o1[0]) != type)
2226 : {
2227 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2228 : }
2229 : else
2230 : _r1 = _o1[0];
2231 0 : res_op1 = _r1;
2232 : }
2233 0 : tree _r;
2234 0 : _r = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, res_op0, res_op1);
2235 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 617, __FILE__, __LINE__, true);
2236 0 : return _r;
2237 : }
2238 0 : next_after_fail751:;
2239 : }
2240 : return NULL_TREE;
2241 : }
2242 :
2243 : tree
2244 0 : generic_simplify_428 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2245 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2246 : const enum tree_code ARG_UNUSED (shiftrotate))
2247 : {
2248 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2249 0 : {
2250 0 : tree tem = uniform_vector_p (captures[1]);
2251 0 : if (tem
2252 : )
2253 : {
2254 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail757;
2255 0 : {
2256 0 : tree res_op0;
2257 0 : res_op0 = captures[0];
2258 0 : tree res_op1;
2259 0 : res_op1 = tem;
2260 0 : tree _r;
2261 0 : _r = fold_build2_loc (loc, shiftrotate, type, res_op0, res_op1);
2262 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2263 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2264 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 623, __FILE__, __LINE__, true);
2265 0 : return _r;
2266 : }
2267 0 : next_after_fail757:;
2268 : }
2269 : }
2270 : return NULL_TREE;
2271 : }
2272 :
2273 : tree
2274 3756942 : generic_simplify_435 (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 (bitop))
2277 : {
2278 3756942 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2279 3756942 : if (0
2280 : && TREE_CODE (captures[3]) != INTEGER_CST
2281 : && tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
2282 : && types_match (type, captures[2])
2283 : && !POINTER_TYPE_P (TREE_TYPE (captures[2]))
2284 : && TREE_CODE (TREE_TYPE (captures[2])) != OFFSET_TYPE
2285 : )
2286 : {
2287 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail771;
2288 : {
2289 : tree res_op0;
2290 : res_op0 = captures[2];
2291 : tree res_op1;
2292 : {
2293 : tree _o1[1], _r1;
2294 : _o1[0] = captures[3];
2295 : if (TREE_TYPE (_o1[0]) != type)
2296 : {
2297 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2298 : }
2299 : else
2300 : _r1 = _o1[0];
2301 : res_op1 = _r1;
2302 : }
2303 : tree _r;
2304 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
2305 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 635, __FILE__, __LINE__, true);
2306 : return _r;
2307 : }
2308 : next_after_fail771:;
2309 : }
2310 3756942 : return NULL_TREE;
2311 : }
2312 :
2313 : tree
2314 7340 : generic_simplify_439 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2315 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2316 : const enum tree_code ARG_UNUSED (minmax))
2317 : {
2318 7340 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2319 7340 : if (INTEGRAL_TYPE_P (type)
2320 7340 : && types_match (captures[1], type) && int_fits_type_p (captures[2], type)
2321 639 : && TYPE_SIGN (TREE_TYPE (captures[0])) == TYPE_SIGN (type)
2322 7340 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (type)
2323 : )
2324 : {
2325 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail777;
2326 0 : {
2327 0 : tree res_op0;
2328 0 : res_op0 = captures[1];
2329 0 : tree res_op1;
2330 0 : {
2331 0 : tree _o1[1], _r1;
2332 0 : _o1[0] = captures[2];
2333 0 : if (TREE_TYPE (_o1[0]) != type)
2334 : {
2335 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2336 : }
2337 : else
2338 : _r1 = _o1[0];
2339 0 : res_op1 = _r1;
2340 : }
2341 0 : tree _r;
2342 0 : _r = fold_build2_loc (loc, minmax, type, res_op0, res_op1);
2343 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 641, __FILE__, __LINE__, true);
2344 0 : return _r;
2345 : }
2346 0 : next_after_fail777:;
2347 : }
2348 : return NULL_TREE;
2349 : }
2350 :
2351 : tree
2352 4955861 : generic_simplify_444 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2353 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2354 : {
2355 4955861 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2356 4955861 : if (INTEGRAL_TYPE_P (type)
2357 2750471 : && TYPE_PRECISION (type) == 1
2358 4969662 : && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[0]))
2359 : )
2360 : {
2361 13801 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail794;
2362 13801 : {
2363 13801 : tree res_op0;
2364 13801 : res_op0 = captures[0];
2365 13801 : tree _r;
2366 13801 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2367 13801 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 646, __FILE__, __LINE__, true);
2368 13801 : return _r;
2369 : }
2370 0 : next_after_fail794:;
2371 : }
2372 : return NULL_TREE;
2373 : }
2374 :
2375 : tree
2376 0 : generic_simplify_447 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2377 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2378 : const combined_fn ARG_UNUSED (coshs),
2379 : const combined_fn ARG_UNUSED (atanhs),
2380 : const combined_fn ARG_UNUSED (sqrts))
2381 : {
2382 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2383 0 : if (!flag_errno_math
2384 : )
2385 : {
2386 0 : {
2387 0 : tree t_one = build_one_cst (type);
2388 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail797;
2389 0 : {
2390 0 : if (! tree_invariant_p (captures[1])) goto next_after_fail797;
2391 0 : tree res_op0;
2392 0 : res_op0 = t_one;
2393 0 : tree res_op1;
2394 0 : {
2395 0 : tree _o1[1], _r1;
2396 0 : {
2397 0 : tree _o2[2], _r2;
2398 0 : {
2399 0 : tree _o3[2], _r3;
2400 0 : _o3[0] = t_one;
2401 0 : _o3[1] = unshare_expr (captures[1]);
2402 0 : _r3 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
2403 0 : _o2[0] = _r3;
2404 : }
2405 0 : {
2406 0 : tree _o3[2], _r3;
2407 0 : _o3[0] = t_one;
2408 0 : _o3[1] = captures[1];
2409 0 : _r3 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
2410 0 : _o2[1] = _r3;
2411 : }
2412 0 : _r2 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
2413 0 : _o1[0] = _r2;
2414 : }
2415 0 : _r1 = maybe_build_call_expr_loc (loc, sqrts, TREE_TYPE (_o1[0]), 1, _o1[0]);
2416 0 : if (!_r1)
2417 0 : goto next_after_fail797;
2418 0 : res_op1 = _r1;
2419 : }
2420 0 : tree _r;
2421 0 : _r = fold_build2_loc (loc, RDIV_EXPR, type, res_op0, res_op1);
2422 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 649, __FILE__, __LINE__, true);
2423 0 : return _r;
2424 : }
2425 : next_after_fail797:;
2426 : }
2427 : }
2428 : return NULL_TREE;
2429 : }
2430 :
2431 : tree
2432 0 : generic_simplify_451 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2433 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2434 : const combined_fn ARG_UNUSED (POW))
2435 : {
2436 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2437 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail801;
2438 0 : {
2439 0 : tree _r;
2440 0 : _r = captures[0];
2441 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2442 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2443 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 653, __FILE__, __LINE__, true);
2444 : return _r;
2445 : }
2446 0 : next_after_fail801:;
2447 0 : return NULL_TREE;
2448 : }
2449 :
2450 : tree
2451 0 : generic_simplify_455 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2452 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2453 : const combined_fn ARG_UNUSED (HYPOT))
2454 : {
2455 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2456 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail805;
2457 0 : {
2458 0 : tree res_op0;
2459 0 : res_op0 = captures[0];
2460 0 : tree _r;
2461 0 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
2462 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2463 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2464 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 657, __FILE__, __LINE__, true);
2465 : return _r;
2466 : }
2467 0 : next_after_fail805:;
2468 0 : return NULL_TREE;
2469 : }
2470 :
2471 : tree
2472 5192924 : generic_simplify_457 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2473 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2474 : {
2475 5192924 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2476 5192924 : {
2477 5192924 : bool wascmp;
2478 5192924 : if (types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
2479 5192924 : && bitwise_inverted_equal_p (captures[0], captures[1], wascmp)
2480 : )
2481 : {
2482 115 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail807;
2483 115 : {
2484 115 : tree _r;
2485 115 : _r = wascmp ? constant_boolean_node (false, type) : build_zero_cst (type);
2486 115 : if (TREE_SIDE_EFFECTS (captures[0]))
2487 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2488 115 : if (TREE_SIDE_EFFECTS (captures[1]))
2489 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2490 115 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 659, __FILE__, __LINE__, true);
2491 115 : return _r;
2492 : }
2493 0 : next_after_fail807:;
2494 : }
2495 : }
2496 5192809 : return NULL_TREE;
2497 : }
2498 :
2499 : tree
2500 355 : generic_simplify_466 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2501 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2502 : const enum tree_code ARG_UNUSED (bitop),
2503 : const enum tree_code ARG_UNUSED (op))
2504 : {
2505 355 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2506 355 : {
2507 355 : tree pmop[2];
2508 355 : tree utype = fold_bit_and_mask (TREE_TYPE (captures[1]), captures[5], op, captures[1], ERROR_MARK,
2509 : NULL_TREE, NULL_TREE, captures[2], bitop, captures[3],
2510 : captures[4], pmop);
2511 355 : if (utype
2512 : )
2513 : {
2514 354 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail816;
2515 354 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail816;
2516 354 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail816;
2517 354 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail816;
2518 354 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail816;
2519 354 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail816;
2520 354 : {
2521 354 : tree res_op0;
2522 354 : {
2523 354 : tree _o1[2], _r1;
2524 354 : {
2525 354 : tree _o2[2], _r2;
2526 354 : {
2527 354 : tree _o3[1], _r3;
2528 354 : _o3[0] = pmop[0];
2529 354 : if (TREE_TYPE (_o3[0]) != utype)
2530 : {
2531 14 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
2532 : }
2533 : else
2534 : _r3 = _o3[0];
2535 354 : _o2[0] = _r3;
2536 : }
2537 354 : {
2538 354 : tree _o3[1], _r3;
2539 354 : _o3[0] = pmop[1];
2540 354 : if (TREE_TYPE (_o3[0]) != utype)
2541 : {
2542 74 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
2543 : }
2544 : else
2545 : _r3 = _o3[0];
2546 354 : _o2[1] = _r3;
2547 : }
2548 354 : _r2 = fold_build2_loc (loc, op, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
2549 354 : _o1[0] = _r2;
2550 : }
2551 354 : {
2552 354 : tree _o2[1], _r2;
2553 354 : _o2[0] = captures[5];
2554 354 : if (TREE_TYPE (_o2[0]) != utype)
2555 : {
2556 14 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2557 : }
2558 : else
2559 : _r2 = _o2[0];
2560 354 : _o1[1] = _r2;
2561 : }
2562 354 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2563 354 : res_op0 = _r1;
2564 : }
2565 354 : tree _r;
2566 354 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2567 354 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 667, __FILE__, __LINE__, true);
2568 354 : return _r;
2569 : }
2570 1 : next_after_fail816:;
2571 : }
2572 : }
2573 1 : return NULL_TREE;
2574 : }
2575 :
2576 : tree
2577 162 : generic_simplify_482 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2578 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2579 : const enum tree_code ARG_UNUSED (code2),
2580 : const enum tree_code ARG_UNUSED (code1))
2581 : {
2582 162 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2583 162 : if ((TREE_CODE (captures[2]) == INTEGER_CST
2584 50 : && TREE_CODE (captures[4]) == INTEGER_CST)
2585 162 : || ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2586 14 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[2]))
2587 10 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[2])))
2588 4 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, code2))
2589 10 : || POINTER_TYPE_P (TREE_TYPE (captures[2])))
2590 102 : && operand_equal_p (captures[2], captures[4]))
2591 : )
2592 : {
2593 54 : {
2594 54 : int cmp = 0;
2595 54 : if (TREE_CODE (captures[2]) == INTEGER_CST
2596 50 : && TREE_CODE (captures[4]) == INTEGER_CST)
2597 50 : cmp = tree_int_cst_compare (captures[2], captures[4]);
2598 54 : if ((code1 == LT_EXPR || code1 == LE_EXPR)
2599 4 : && (code2 == LT_EXPR || code2 == LE_EXPR)
2600 : )
2601 : {
2602 0 : if ((cmp < 0) || (cmp == 0 && code1 == LT_EXPR)
2603 : )
2604 : {
2605 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail846;
2606 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail846;
2607 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail846;
2608 0 : {
2609 0 : tree _r;
2610 0 : _r = captures[0];
2611 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 689, __FILE__, __LINE__, true);
2612 0 : return _r;
2613 : }
2614 : next_after_fail846:;
2615 : }
2616 : else
2617 : {
2618 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail847;
2619 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail847;
2620 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail847;
2621 0 : {
2622 0 : tree _r;
2623 0 : _r = captures[3];
2624 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 690, __FILE__, __LINE__, true);
2625 0 : return _r;
2626 : }
2627 : next_after_fail847:;
2628 : }
2629 : }
2630 : else
2631 : {
2632 54 : if ((code1 == GT_EXPR || code1 == GE_EXPR)
2633 50 : && (code2 == GT_EXPR || code2 == GE_EXPR)
2634 : )
2635 : {
2636 0 : if ((cmp > 0) || (cmp == 0 && code1 == GT_EXPR)
2637 : )
2638 : {
2639 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail848;
2640 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail848;
2641 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail848;
2642 0 : {
2643 0 : tree _r;
2644 0 : _r = captures[0];
2645 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 691, __FILE__, __LINE__, true);
2646 0 : return _r;
2647 : }
2648 : next_after_fail848:;
2649 : }
2650 : else
2651 : {
2652 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail849;
2653 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail849;
2654 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail849;
2655 0 : {
2656 0 : tree _r;
2657 0 : _r = captures[3];
2658 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 692, __FILE__, __LINE__, true);
2659 0 : return _r;
2660 : }
2661 : next_after_fail849:;
2662 : }
2663 : }
2664 : else
2665 : {
2666 54 : if (cmp == 0
2667 4 : && ((code1 == LE_EXPR && code2 == GE_EXPR)
2668 4 : || (code1 == GE_EXPR && code2 == LE_EXPR))
2669 : )
2670 : {
2671 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail850;
2672 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail850;
2673 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail850;
2674 0 : {
2675 0 : tree res_op0;
2676 0 : res_op0 = captures[1];
2677 0 : tree res_op1;
2678 0 : res_op1 = captures[2];
2679 0 : tree _r;
2680 0 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
2681 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 693, __FILE__, __LINE__, true);
2682 0 : return _r;
2683 : }
2684 : next_after_fail850:;
2685 : }
2686 : else
2687 : {
2688 54 : if (cmp <= 0
2689 53 : && (code1 == LT_EXPR || code1 == LE_EXPR)
2690 4 : && (code2 == GT_EXPR || code2 == GE_EXPR)
2691 : )
2692 : {
2693 4 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail851;
2694 4 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail851;
2695 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail851;
2696 4 : {
2697 4 : tree _r;
2698 4 : _r = constant_boolean_node (false, type);
2699 4 : if (TREE_SIDE_EFFECTS (captures[1]))
2700 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2701 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 694, __FILE__, __LINE__, true);
2702 4 : return _r;
2703 : }
2704 : next_after_fail851:;
2705 : }
2706 : else
2707 : {
2708 49 : if (cmp >= 0
2709 1 : && (code1 == GT_EXPR || code1 == GE_EXPR)
2710 1 : && (code2 == LT_EXPR || code2 == LE_EXPR)
2711 : )
2712 : {
2713 1 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail852;
2714 1 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail852;
2715 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail852;
2716 1 : {
2717 1 : tree _r;
2718 1 : _r = constant_boolean_node (false, type);
2719 1 : if (TREE_SIDE_EFFECTS (captures[1]))
2720 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2721 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 695, __FILE__, __LINE__, true);
2722 1 : return _r;
2723 : }
2724 : next_after_fail852:;
2725 : }
2726 : }
2727 : }
2728 : }
2729 : }
2730 : }
2731 : }
2732 : return NULL_TREE;
2733 : }
2734 :
2735 : tree
2736 34 : generic_simplify_499 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2737 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2738 : const combined_fn ARG_UNUSED (bswap))
2739 : {
2740 34 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2741 34 : if (BITS_PER_UNIT == 8
2742 34 : && tree_fits_uhwi_p (captures[2])
2743 34 : && tree_to_uhwi (captures[2]) < 256
2744 : )
2745 : {
2746 32 : {
2747 32 : unsigned HOST_WIDE_INT prec = TYPE_PRECISION (TREE_TYPE (captures[0]));
2748 32 : tree utype = unsigned_type_for (TREE_TYPE (captures[1]));
2749 32 : tree nst = build_int_cst (integer_type_node, prec - 8);
2750 32 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail892;
2751 32 : {
2752 32 : tree res_op0;
2753 32 : {
2754 32 : tree _o1[1], _r1;
2755 32 : {
2756 32 : tree _o2[2], _r2;
2757 32 : {
2758 32 : tree _o3[1], _r3;
2759 32 : _o3[0] = captures[1];
2760 32 : if (TREE_TYPE (_o3[0]) != utype)
2761 : {
2762 0 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
2763 : }
2764 : else
2765 : _r3 = _o3[0];
2766 32 : _o2[0] = _r3;
2767 : }
2768 32 : _o2[1] = nst;
2769 32 : _r2 = fold_build2_loc (loc, RSHIFT_EXPR, utype, _o2[0], _o2[1]);
2770 32 : _o1[0] = _r2;
2771 : }
2772 32 : if (TREE_TYPE (_o1[0]) != type)
2773 : {
2774 18 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2775 : }
2776 : else
2777 : _r1 = _o1[0];
2778 32 : res_op0 = _r1;
2779 : }
2780 32 : tree res_op1;
2781 32 : res_op1 = captures[2];
2782 32 : tree _r;
2783 32 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2784 32 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 705, __FILE__, __LINE__, true);
2785 32 : return _r;
2786 : }
2787 0 : next_after_fail892:;
2788 : }
2789 : }
2790 : return NULL_TREE;
2791 : }
2792 :
2793 : tree
2794 0 : generic_simplify_502 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2795 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2796 : {
2797 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2798 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail895;
2799 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail895;
2800 0 : {
2801 0 : tree _r;
2802 0 : _r = captures[1];
2803 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 707, __FILE__, __LINE__, true);
2804 : return _r;
2805 : }
2806 : next_after_fail895:;
2807 : return NULL_TREE;
2808 : }
2809 :
2810 : tree
2811 28 : generic_simplify_507 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2812 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2813 : {
2814 28 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2815 28 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[0]))
2816 28 : || !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
2817 : )
2818 : {
2819 28 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail901;
2820 28 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail901;
2821 28 : {
2822 28 : tree res_op0;
2823 28 : {
2824 28 : tree _o1[1], _r1;
2825 28 : _o1[0] = captures[0];
2826 28 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2827 28 : res_op0 = _r1;
2828 : }
2829 28 : tree _r;
2830 28 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2831 28 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 713, __FILE__, __LINE__, true);
2832 28 : return _r;
2833 : }
2834 : next_after_fail901:;
2835 : }
2836 : return NULL_TREE;
2837 : }
2838 :
2839 : tree
2840 0 : generic_simplify_515 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2841 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2842 : const enum tree_code ARG_UNUSED (rotate))
2843 : {
2844 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2845 0 : if ((element_precision (TREE_TYPE (captures[2]))
2846 0 : <= element_precision (TREE_TYPE (captures[3]))
2847 0 : || !TYPE_UNSIGNED (TREE_TYPE (captures[3])))
2848 0 : && (element_precision (type) <= element_precision (TREE_TYPE (captures[2]))
2849 0 : || !TYPE_UNSIGNED (TREE_TYPE (captures[2])))
2850 : )
2851 : {
2852 0 : {
2853 0 : tree rotate_type = TREE_TYPE (captures[2]);
2854 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail909;
2855 0 : {
2856 0 : tree res_op0;
2857 0 : {
2858 0 : tree _o1[2], _r1;
2859 0 : {
2860 0 : tree _o2[1], _r2;
2861 0 : _o2[0] = captures[3];
2862 0 : if (TREE_TYPE (_o2[0]) != rotate_type)
2863 : {
2864 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, rotate_type, _o2[0]);
2865 : }
2866 : else
2867 : _r2 = _o2[0];
2868 0 : _o1[0] = _r2;
2869 : }
2870 0 : _o1[1] = captures[4];
2871 0 : _r1 = fold_build2_loc (loc, rotate, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2872 0 : res_op0 = _r1;
2873 : }
2874 0 : tree _r;
2875 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2876 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 720, __FILE__, __LINE__, true);
2877 0 : return _r;
2878 : }
2879 0 : next_after_fail909:;
2880 : }
2881 : }
2882 : return NULL_TREE;
2883 : }
2884 :
2885 : tree
2886 16 : generic_simplify_525 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2887 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2888 : const combined_fn ARG_UNUSED (fmas))
2889 : {
2890 16 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2891 16 : if (canonicalize_math_after_vectorization_p ()
2892 : )
2893 : {
2894 : if (!HONOR_SIGN_DEPENDENT_ROUNDING (type) && single_use (captures[0])
2895 : )
2896 : {
2897 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail921;
2898 : {
2899 : tree res_op0;
2900 : res_op0 = captures[1];
2901 : tree res_op1;
2902 : res_op1 = captures[2];
2903 : tree res_op2;
2904 : res_op2 = captures[3];
2905 : tree _r;
2906 : _r = maybe_build_call_expr_loc (loc, CFN_FNMS, type, 3, res_op0, res_op1, res_op2);
2907 : if (!_r)
2908 : goto next_after_fail921;
2909 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 731, __FILE__, __LINE__, true);
2910 : return _r;
2911 : }
2912 16 : next_after_fail921:;
2913 : }
2914 : }
2915 16 : return NULL_TREE;
2916 : }
2917 :
2918 : tree
2919 0 : generic_simplify_538 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2920 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2921 : const enum tree_code ARG_UNUSED (minmax),
2922 : const enum tree_code ARG_UNUSED (cmp))
2923 : {
2924 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2925 0 : {
2926 0 : poly_int64 off0, off1;
2927 0 : tree base0, base1;
2928 0 : int equal = address_compare (cmp, TREE_TYPE (captures[0]), captures[1], captures[3], base0, base1,
2929 : off0, off1,
2930 : 1
2931 : );
2932 0 : if (equal == 1
2933 : )
2934 : {
2935 0 : if (minmax == MIN_EXPR
2936 : )
2937 : {
2938 0 : if (known_le (off0, off1)
2939 : )
2940 : {
2941 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail942;
2942 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail942;
2943 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail942;
2944 0 : {
2945 0 : tree _r;
2946 0 : _r = captures[0];
2947 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 743, __FILE__, __LINE__, true);
2948 0 : return _r;
2949 : }
2950 0 : next_after_fail942:;
2951 : }
2952 : else
2953 : {
2954 0 : if (known_gt (off0, off1)
2955 : )
2956 : {
2957 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail943;
2958 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail943;
2959 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail943;
2960 0 : {
2961 0 : tree _r;
2962 0 : _r = captures[2];
2963 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 744, __FILE__, __LINE__, true);
2964 0 : return _r;
2965 : }
2966 0 : next_after_fail943:;
2967 : }
2968 : }
2969 : }
2970 : else
2971 : {
2972 0 : if (known_ge (off0, off1)
2973 : )
2974 : {
2975 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail944;
2976 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail944;
2977 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail944;
2978 0 : {
2979 0 : tree _r;
2980 0 : _r = captures[0];
2981 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 745, __FILE__, __LINE__, true);
2982 0 : return _r;
2983 : }
2984 0 : next_after_fail944:;
2985 : }
2986 : else
2987 : {
2988 0 : if (known_lt (off0, off1)
2989 : )
2990 : {
2991 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail945;
2992 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail945;
2993 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail945;
2994 0 : {
2995 0 : tree _r;
2996 0 : _r = captures[2];
2997 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 746, __FILE__, __LINE__, true);
2998 0 : return _r;
2999 : }
3000 0 : next_after_fail945:;
3001 : }
3002 : }
3003 : }
3004 : }
3005 : }
3006 0 : return NULL_TREE;
3007 : }
3008 :
3009 : tree
3010 0 : generic_simplify_558 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3011 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
3012 : const combined_fn ARG_UNUSED (cond_op))
3013 : {
3014 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3015 0 : {
3016 0 : tree op_type = TREE_TYPE (captures[6]);
3017 0 : if (inverse_conditions_p (captures[0], captures[2])
3018 0 : && element_precision (type) == element_precision (op_type)
3019 : )
3020 : {
3021 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail968;
3022 0 : {
3023 0 : tree res_op0;
3024 0 : {
3025 0 : tree _o1[5], _r1;
3026 0 : _o1[0] = captures[2];
3027 0 : _o1[1] = captures[3];
3028 0 : _o1[2] = captures[4];
3029 0 : _o1[3] = captures[5];
3030 0 : {
3031 0 : tree _o2[1], _r2;
3032 0 : _o2[0] = captures[1];
3033 0 : if (TREE_TYPE (_o2[0]) != op_type)
3034 : {
3035 0 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
3036 : }
3037 : else
3038 : _r2 = _o2[0];
3039 0 : _o1[4] = _r2;
3040 : }
3041 0 : _r1 = maybe_build_call_expr_loc (loc, cond_op, TREE_TYPE (_o1[1]), 5, _o1[0], _o1[1], _o1[2], _o1[3], _o1[4]);
3042 0 : if (!_r1)
3043 0 : goto next_after_fail968;
3044 0 : res_op0 = _r1;
3045 : }
3046 0 : tree _r;
3047 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3048 0 : if (TREE_SIDE_EFFECTS (captures[0]))
3049 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3050 0 : if (TREE_SIDE_EFFECTS (captures[6]))
3051 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[6]), _r);
3052 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 760, __FILE__, __LINE__, true);
3053 0 : return _r;
3054 : }
3055 : next_after_fail968:;
3056 : }
3057 : }
3058 : return NULL_TREE;
3059 : }
3060 :
3061 : tree
3062 0 : generic_simplify_570 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3063 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3064 : const combined_fn ARG_UNUSED (bswap))
3065 : {
3066 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3067 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail983;
3068 0 : {
3069 0 : tree res_op0;
3070 0 : res_op0 = captures[0];
3071 0 : tree _r;
3072 0 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
3073 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 775, __FILE__, __LINE__, true);
3074 : return _r;
3075 : }
3076 0 : next_after_fail983:;
3077 0 : return NULL_TREE;
3078 : }
3079 :
3080 : tree
3081 0 : generic_simplify_577 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3082 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3083 : const combined_fn ARG_UNUSED (logs))
3084 : {
3085 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3086 0 : if (flag_unsafe_math_optimizations
3087 : )
3088 : {
3089 0 : if (! HONOR_SIGN_DEPENDENT_ROUNDING (type)
3090 0 : && ! HONOR_NANS (type) && ! HONOR_INFINITIES (type)
3091 0 : && ! flag_trapping_math
3092 0 : && ! flag_errno_math
3093 : )
3094 : {
3095 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail990;
3096 0 : {
3097 0 : tree res_op0;
3098 0 : {
3099 0 : tree _o1[1], _r1;
3100 0 : _o1[0] = captures[2];
3101 0 : _r1 = maybe_build_call_expr_loc (loc, logs, TREE_TYPE (_o1[0]), 1, _o1[0]);
3102 0 : if (!_r1)
3103 0 : goto next_after_fail990;
3104 0 : res_op0 = _r1;
3105 : }
3106 0 : tree _r;
3107 0 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
3108 0 : if (TREE_SIDE_EFFECTS (captures[1]))
3109 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3110 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 782, __FILE__, __LINE__, true);
3111 0 : return _r;
3112 : }
3113 : next_after_fail990:;
3114 : }
3115 : }
3116 : return NULL_TREE;
3117 : }
3118 :
3119 : tree
3120 0 : generic_simplify_586 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3121 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3122 : const combined_fn ARG_UNUSED (froms),
3123 : const combined_fn ARG_UNUSED (tos))
3124 : {
3125 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3126 0 : if (optimize && canonicalize_math_p ()
3127 : )
3128 : {
3129 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail999;
3130 0 : {
3131 0 : tree res_op0;
3132 0 : {
3133 0 : tree _o1[1], _r1;
3134 0 : _o1[0] = captures[0];
3135 0 : _r1 = maybe_build_call_expr_loc (loc, tos, TREE_TYPE (_o1[0]), 1, _o1[0]);
3136 0 : if (!_r1)
3137 0 : goto next_after_fail999;
3138 0 : res_op0 = _r1;
3139 : }
3140 0 : tree _r;
3141 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3142 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 791, __FILE__, __LINE__, true);
3143 0 : return _r;
3144 : }
3145 : next_after_fail999:;
3146 : }
3147 : return NULL_TREE;
3148 : }
3149 :
3150 : tree
3151 0 : generic_simplify_596 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3152 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3153 : const combined_fn ARG_UNUSED (rints))
3154 : {
3155 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3156 0 : if (canonicalize_math_p ()
3157 : )
3158 : {
3159 0 : if (!flag_errno_math
3160 : )
3161 : {
3162 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1009;
3163 0 : {
3164 0 : tree res_op0;
3165 0 : res_op0 = captures[0];
3166 0 : tree _r;
3167 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3168 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 801, __FILE__, __LINE__, true);
3169 0 : return _r;
3170 : }
3171 0 : next_after_fail1009:;
3172 : }
3173 : }
3174 : return NULL_TREE;
3175 : }
3176 :
3177 : tree
3178 0 : generic_simplify_602 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3179 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
3180 : const combined_fn ARG_UNUSED (fmas))
3181 : {
3182 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3183 0 : if (canonicalize_math_after_vectorization_p ()
3184 : )
3185 : {
3186 : {
3187 : tree t = TREE_TYPE (captures[0]);
3188 : if ((!ANY_INTEGRAL_TYPE_P (type)
3189 : || TYPE_UNSIGNED (type)
3190 : || !TYPE_OVERFLOW_SANITIZED (type))
3191 : && (!ANY_INTEGRAL_TYPE_P (t)
3192 : || TYPE_UNSIGNED (t)
3193 : || !TYPE_OVERFLOW_SANITIZED (type))
3194 : )
3195 : {
3196 : {
3197 : tree utype = unsigned_type_for (type);
3198 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1015;
3199 : {
3200 : tree res_op0;
3201 : {
3202 : tree _o1[3], _r1;
3203 : {
3204 : tree _o2[1], _r2;
3205 : _o2[0] = captures[0];
3206 : if (TREE_TYPE (_o2[0]) != utype)
3207 : {
3208 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
3209 : }
3210 : else
3211 : _r2 = _o2[0];
3212 : _o1[0] = _r2;
3213 : }
3214 : {
3215 : tree _o2[1], _r2;
3216 : _o2[0] = captures[1];
3217 : if (TREE_TYPE (_o2[0]) != utype)
3218 : {
3219 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
3220 : }
3221 : else
3222 : _r2 = _o2[0];
3223 : _o1[1] = _r2;
3224 : }
3225 : {
3226 : tree _o2[1], _r2;
3227 : _o2[0] = captures[2];
3228 : if (TREE_TYPE (_o2[0]) != utype)
3229 : {
3230 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
3231 : }
3232 : else
3233 : _r2 = _o2[0];
3234 : _o1[2] = _r2;
3235 : }
3236 : _r1 = maybe_build_call_expr_loc (loc, CFN_FNMA, TREE_TYPE (_o1[0]), 3, _o1[0], _o1[1], _o1[2]);
3237 : if (!_r1)
3238 : goto next_after_fail1015;
3239 : res_op0 = _r1;
3240 : }
3241 : tree _r;
3242 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3243 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 807, __FILE__, __LINE__, true);
3244 : return _r;
3245 : }
3246 0 : next_after_fail1015:;
3247 : }
3248 : }
3249 : }
3250 : }
3251 0 : return NULL_TREE;
3252 : }
3253 :
3254 : tree
3255 0 : generic_simplify_624 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3256 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3257 : const combined_fn ARG_UNUSED (bswap),
3258 : const combined_fn ARG_UNUSED (popcount))
3259 : {
3260 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3261 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3262 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
3263 : )
3264 : {
3265 0 : {
3266 0 : tree type0 = TREE_TYPE (captures[0]);
3267 0 : tree type1 = TREE_TYPE (captures[1]);
3268 0 : unsigned int prec0 = TYPE_PRECISION (type0);
3269 0 : unsigned int prec1 = TYPE_PRECISION (type1);
3270 0 : if (prec0 == prec1 || (prec0 > prec1 && TYPE_UNSIGNED (type1))
3271 : )
3272 : {
3273 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1037;
3274 0 : {
3275 0 : tree res_op0;
3276 0 : {
3277 0 : tree _o1[1], _r1;
3278 0 : {
3279 0 : tree _o2[1], _r2;
3280 0 : _o2[0] = captures[2];
3281 0 : if (TREE_TYPE (_o2[0]) != type1)
3282 : {
3283 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, type1, _o2[0]);
3284 : }
3285 : else
3286 : _r2 = _o2[0];
3287 0 : _o1[0] = _r2;
3288 : }
3289 0 : if (TREE_TYPE (_o1[0]) != type0)
3290 : {
3291 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type0, _o1[0]);
3292 : }
3293 : else
3294 : _r1 = _o1[0];
3295 0 : res_op0 = _r1;
3296 : }
3297 0 : tree _r;
3298 0 : _r = maybe_build_call_expr_loc (loc, popcount, type, 1, res_op0);
3299 0 : if (!_r)
3300 0 : goto next_after_fail1037;
3301 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 823, __FILE__, __LINE__, true);
3302 0 : return _r;
3303 : }
3304 : next_after_fail1037:;
3305 : }
3306 : }
3307 : }
3308 : return NULL_TREE;
3309 : }
3310 :
3311 : tree
3312 3230809 : generic_simplify_ABS_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0)
3313 : {
3314 3230809 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3315 3230809 : switch (TREE_CODE (_p0))
3316 : {
3317 212229 : CASE_CONVERT:
3318 212229 : {
3319 212229 : tree _q20 = TREE_OPERAND (_p0, 0);
3320 212229 : {
3321 212229 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3322 424456 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3323 913 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
3324 841 : && element_precision (type) > element_precision (TREE_TYPE (captures[0]))
3325 212455 : && (!VECTOR_TYPE_P (type)
3326 0 : || target_supports_op_p (TREE_TYPE (captures[0]), ABSU_EXPR, optab_vector))
3327 : )
3328 : {
3329 226 : {
3330 226 : tree utype = unsigned_type_for (TREE_TYPE (captures[0]));
3331 226 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1052;
3332 226 : {
3333 226 : tree res_op0;
3334 226 : {
3335 226 : tree _o1[1], _r1;
3336 226 : _o1[0] = captures[0];
3337 226 : _r1 = fold_build1_loc (loc, ABSU_EXPR, utype, _o1[0]);
3338 226 : res_op0 = _r1;
3339 : }
3340 226 : tree _r;
3341 226 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3342 226 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 837, __FILE__, __LINE__, true);
3343 226 : return _r;
3344 : }
3345 0 : next_after_fail1052:;
3346 : }
3347 : }
3348 : }
3349 : break;
3350 : }
3351 12 : case ABS_EXPR:
3352 12 : {
3353 12 : tree _q20 = TREE_OPERAND (_p0, 0);
3354 12 : {
3355 12 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3356 12 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1053;
3357 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1053;
3358 12 : {
3359 12 : tree _r;
3360 12 : _r = captures[0];
3361 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 838, __FILE__, __LINE__, true);
3362 12 : return _r;
3363 : }
3364 0 : next_after_fail1053:;
3365 : }
3366 0 : break;
3367 : }
3368 57 : case NEGATE_EXPR:
3369 57 : {
3370 57 : tree _q20 = TREE_OPERAND (_p0, 0);
3371 57 : {
3372 57 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3373 57 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1054;
3374 57 : {
3375 57 : tree res_op0;
3376 57 : res_op0 = captures[0];
3377 57 : tree _r;
3378 57 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
3379 57 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 839, __FILE__, __LINE__, true);
3380 3230809 : return _r;
3381 : }
3382 0 : next_after_fail1054:;
3383 : }
3384 0 : break;
3385 : }
3386 317 : case PLUS_EXPR:
3387 317 : {
3388 317 : tree _q20 = TREE_OPERAND (_p0, 0);
3389 317 : tree _q21 = TREE_OPERAND (_p0, 1);
3390 317 : if (real_zerop (_q21))
3391 : {
3392 3 : {
3393 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3394 3 : tree res = generic_simplify_1 (loc, type, _p0, captures, PLUS_EXPR);
3395 3 : if (res) return res;
3396 : }
3397 : }
3398 : break;
3399 : }
3400 7907 : case MINUS_EXPR:
3401 7907 : {
3402 7907 : tree _q20 = TREE_OPERAND (_p0, 0);
3403 7907 : tree _q21 = TREE_OPERAND (_p0, 1);
3404 7907 : if (real_zerop (_q21))
3405 : {
3406 0 : {
3407 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3408 0 : tree res = generic_simplify_1 (loc, type, _p0, captures, MINUS_EXPR);
3409 0 : if (res) return res;
3410 : }
3411 : }
3412 : break;
3413 : }
3414 0 : case VEC_COND_EXPR:
3415 0 : {
3416 0 : tree _q20 = TREE_OPERAND (_p0, 0);
3417 0 : tree _q21 = TREE_OPERAND (_p0, 1);
3418 0 : tree _q22 = TREE_OPERAND (_p0, 2);
3419 0 : {
3420 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
3421 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1055;
3422 0 : {
3423 0 : tree res_op0;
3424 0 : res_op0 = captures[1];
3425 0 : tree res_op1;
3426 0 : {
3427 0 : tree _o1[1], _r1;
3428 0 : _o1[0] = captures[2];
3429 0 : _r1 = fold_build1_loc (loc, ABS_EXPR, type, _o1[0]);
3430 0 : if (EXPR_P (_r1))
3431 0 : goto next_after_fail1055;
3432 0 : res_op1 = _r1;
3433 : }
3434 0 : tree res_op2;
3435 0 : {
3436 0 : tree _o1[1], _r1;
3437 0 : _o1[0] = captures[3];
3438 0 : _r1 = fold_build1_loc (loc, ABS_EXPR, type, _o1[0]);
3439 0 : if (EXPR_P (_r1))
3440 0 : goto next_after_fail1055;
3441 0 : res_op2 = _r1;
3442 : }
3443 0 : tree _r;
3444 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
3445 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 840, __FILE__, __LINE__, true);
3446 0 : return _r;
3447 : }
3448 0 : next_after_fail1055:;
3449 : }
3450 0 : break;
3451 : }
3452 716 : case CALL_EXPR:
3453 716 : switch (get_call_combined_fn (_p0))
3454 : {
3455 0 : case CFN_BUILT_IN_COPYSIGNF16:
3456 0 : if (call_expr_nargs (_p0) == 2)
3457 : {
3458 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3459 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3460 0 : {
3461 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3462 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF16);
3463 0 : if (res) return res;
3464 : }
3465 : }
3466 : break;
3467 0 : case CFN_BUILT_IN_COPYSIGNF32:
3468 0 : if (call_expr_nargs (_p0) == 2)
3469 : {
3470 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3471 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3472 0 : {
3473 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3474 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF32);
3475 0 : if (res) return res;
3476 : }
3477 : }
3478 : break;
3479 0 : case CFN_BUILT_IN_COPYSIGNF64:
3480 0 : if (call_expr_nargs (_p0) == 2)
3481 : {
3482 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3483 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3484 0 : {
3485 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3486 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF64);
3487 0 : if (res) return res;
3488 : }
3489 : }
3490 : break;
3491 0 : case CFN_BUILT_IN_COPYSIGNF128X:
3492 0 : if (call_expr_nargs (_p0) == 2)
3493 : {
3494 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3495 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3496 0 : {
3497 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3498 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF128X);
3499 0 : if (res) return res;
3500 : }
3501 : }
3502 : break;
3503 0 : case CFN_BUILT_IN_COPYSIGNF128:
3504 0 : if (call_expr_nargs (_p0) == 2)
3505 : {
3506 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3507 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3508 0 : {
3509 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3510 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF128);
3511 0 : if (res) return res;
3512 : }
3513 : }
3514 : break;
3515 0 : case CFN_BUILT_IN_COPYSIGNF32X:
3516 0 : if (call_expr_nargs (_p0) == 2)
3517 : {
3518 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3519 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3520 0 : {
3521 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3522 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF32X);
3523 0 : if (res) return res;
3524 : }
3525 : }
3526 : break;
3527 0 : case CFN_BUILT_IN_COPYSIGNF64X:
3528 0 : if (call_expr_nargs (_p0) == 2)
3529 : {
3530 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3531 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3532 0 : {
3533 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3534 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF64X);
3535 0 : if (res) return res;
3536 : }
3537 : }
3538 : break;
3539 0 : case CFN_BUILT_IN_COPYSIGN:
3540 0 : if (call_expr_nargs (_p0) == 2)
3541 : {
3542 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3543 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3544 0 : {
3545 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3546 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGN);
3547 0 : if (res) return res;
3548 : }
3549 : }
3550 : break;
3551 1 : case CFN_BUILT_IN_COPYSIGNF:
3552 1 : if (call_expr_nargs (_p0) == 2)
3553 : {
3554 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3555 1 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3556 1 : {
3557 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3558 1 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF);
3559 1 : if (res) return res;
3560 : }
3561 : }
3562 : break;
3563 0 : case CFN_BUILT_IN_COPYSIGNL:
3564 0 : if (call_expr_nargs (_p0) == 2)
3565 : {
3566 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3567 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3568 0 : {
3569 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3570 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNL);
3571 0 : if (res) return res;
3572 : }
3573 : }
3574 : break;
3575 0 : case CFN_COPYSIGN:
3576 0 : if (call_expr_nargs (_p0) == 2)
3577 : {
3578 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3579 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3580 0 : {
3581 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3582 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_COPYSIGN);
3583 0 : if (res) return res;
3584 : }
3585 : }
3586 : break;
3587 : default:;
3588 : }
3589 : break;
3590 3230511 : default:;
3591 : }
3592 3230511 : if (tree_expr_nonnegative_p (_p0))
3593 : {
3594 548 : {
3595 548 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3596 548 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1056;
3597 548 : {
3598 548 : tree _r;
3599 548 : _r = captures[0];
3600 548 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 841, __FILE__, __LINE__, true);
3601 548 : return _r;
3602 : }
3603 0 : next_after_fail1056:;
3604 : }
3605 : }
3606 : return NULL_TREE;
3607 : }
3608 :
3609 : tree
3610 1049770 : 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)
3611 : {
3612 1049770 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3613 1049770 : switch (TREE_CODE (_p0))
3614 : {
3615 102 : case MINUS_EXPR:
3616 102 : {
3617 102 : tree _q20 = TREE_OPERAND (_p0, 0);
3618 102 : tree _q21 = TREE_OPERAND (_p0, 1);
3619 102 : switch (TREE_CODE (_q21))
3620 : {
3621 22 : CASE_CONVERT:
3622 22 : {
3623 22 : tree _q40 = TREE_OPERAND (_q21, 0);
3624 22 : switch (TREE_CODE (_q40))
3625 : {
3626 0 : case LT_EXPR:
3627 0 : {
3628 0 : tree _q50 = TREE_OPERAND (_q40, 0);
3629 0 : tree _q51 = TREE_OPERAND (_q40, 1);
3630 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
3631 : {
3632 0 : if (integer_zerop (_q51))
3633 : {
3634 0 : switch (TREE_CODE (_p1))
3635 : {
3636 0 : case NEGATE_EXPR:
3637 0 : {
3638 0 : tree _q80 = TREE_OPERAND (_p1, 0);
3639 0 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
3640 : {
3641 0 : {
3642 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3643 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3644 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
3645 : )
3646 : {
3647 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1175;
3648 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1175;
3649 0 : {
3650 0 : tree res_op0;
3651 0 : res_op0 = captures[0];
3652 0 : tree _r;
3653 0 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
3654 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 898, __FILE__, __LINE__, true);
3655 0 : return _r;
3656 : }
3657 0 : next_after_fail1175:;
3658 : }
3659 : }
3660 : }
3661 : break;
3662 : }
3663 : default:;
3664 : }
3665 : }
3666 : }
3667 : break;
3668 : }
3669 : default:;
3670 : }
3671 : break;
3672 : }
3673 : default:;
3674 : }
3675 : break;
3676 : }
3677 151 : case NEGATE_EXPR:
3678 151 : {
3679 151 : tree _q20 = TREE_OPERAND (_p0, 0);
3680 151 : switch (TREE_CODE (_p1))
3681 : {
3682 0 : case MINUS_EXPR:
3683 0 : {
3684 0 : tree _q40 = TREE_OPERAND (_p1, 0);
3685 0 : tree _q41 = TREE_OPERAND (_p1, 1);
3686 0 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
3687 : {
3688 0 : switch (TREE_CODE (_q41))
3689 : {
3690 0 : CASE_CONVERT:
3691 0 : {
3692 0 : tree _q70 = TREE_OPERAND (_q41, 0);
3693 0 : switch (TREE_CODE (_q70))
3694 : {
3695 0 : case LT_EXPR:
3696 0 : {
3697 0 : tree _q80 = TREE_OPERAND (_q70, 0);
3698 0 : tree _q81 = TREE_OPERAND (_q70, 1);
3699 0 : if ((_q80 == _q40 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q40, 0) && types_match (_q80, _q40)))
3700 : {
3701 0 : if (integer_zerop (_q81))
3702 : {
3703 0 : {
3704 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
3705 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3706 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
3707 : )
3708 : {
3709 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1176;
3710 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1176;
3711 0 : {
3712 0 : tree res_op0;
3713 0 : res_op0 = captures[0];
3714 0 : tree _r;
3715 0 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
3716 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 898, __FILE__, __LINE__, true);
3717 0 : return _r;
3718 : }
3719 0 : next_after_fail1176:;
3720 : }
3721 : }
3722 : }
3723 : }
3724 : break;
3725 : }
3726 : default:;
3727 : }
3728 : break;
3729 : }
3730 : default:;
3731 : }
3732 : }
3733 : break;
3734 : }
3735 : default:;
3736 : }
3737 : break;
3738 : }
3739 1049770 : default:;
3740 : }
3741 1049770 : if (integer_zerop (_p1))
3742 : {
3743 567 : {
3744 567 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3745 567 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1177;
3746 567 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1177;
3747 567 : {
3748 567 : tree res_op0;
3749 567 : res_op0 = captures[0];
3750 567 : tree _r;
3751 567 : _r = non_lvalue_loc (loc, res_op0);
3752 567 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 899, __FILE__, __LINE__, true);
3753 567 : return _r;
3754 : }
3755 : next_after_fail1177:;
3756 : }
3757 : }
3758 1049203 : switch (TREE_CODE (_p0))
3759 : {
3760 2970 : case LSHIFT_EXPR:
3761 2970 : {
3762 2970 : tree _q20 = TREE_OPERAND (_p0, 0);
3763 2970 : tree _q21 = TREE_OPERAND (_p0, 1);
3764 2970 : switch (TREE_CODE (_p1))
3765 : {
3766 10 : case LSHIFT_EXPR:
3767 10 : {
3768 10 : tree _q50 = TREE_OPERAND (_p1, 0);
3769 10 : tree _q51 = TREE_OPERAND (_p1, 1);
3770 10 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
3771 : {
3772 1 : {
3773 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
3774 1 : tree res = generic_simplify_3 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3775 1 : if (res) return res;
3776 : }
3777 : }
3778 : break;
3779 : }
3780 : default:;
3781 : }
3782 : break;
3783 : }
3784 22912 : case RSHIFT_EXPR:
3785 22912 : {
3786 22912 : tree _q20 = TREE_OPERAND (_p0, 0);
3787 22912 : tree _q21 = TREE_OPERAND (_p0, 1);
3788 22912 : switch (TREE_CODE (_p1))
3789 : {
3790 20 : case RSHIFT_EXPR:
3791 20 : {
3792 20 : tree _q50 = TREE_OPERAND (_p1, 0);
3793 20 : tree _q51 = TREE_OPERAND (_p1, 1);
3794 20 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
3795 : {
3796 10 : {
3797 10 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
3798 10 : tree res = generic_simplify_4 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3799 10 : if (res) return res;
3800 : }
3801 : }
3802 : break;
3803 : }
3804 : default:;
3805 : }
3806 : break;
3807 : }
3808 4116 : case BIT_AND_EXPR:
3809 4116 : {
3810 4116 : tree _q20 = TREE_OPERAND (_p0, 0);
3811 4116 : tree _q21 = TREE_OPERAND (_p0, 1);
3812 4116 : switch (TREE_CODE (_p1))
3813 : {
3814 354 : case BIT_AND_EXPR:
3815 354 : {
3816 354 : tree _q50 = TREE_OPERAND (_p1, 0);
3817 354 : tree _q51 = TREE_OPERAND (_p1, 1);
3818 354 : {
3819 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51 };
3820 354 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3821 354 : if (res) return res;
3822 : }
3823 354 : {
3824 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q51, _q50 };
3825 354 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3826 354 : if (res) return res;
3827 : }
3828 354 : {
3829 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q50, _q51 };
3830 354 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3831 354 : if (res) return res;
3832 : }
3833 354 : {
3834 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q51, _q50 };
3835 354 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3836 354 : if (res) return res;
3837 : }
3838 354 : break;
3839 : }
3840 4116 : default:;
3841 : }
3842 4116 : switch (TREE_CODE (_q21))
3843 : {
3844 41 : case BIT_NOT_EXPR:
3845 41 : {
3846 41 : tree _q40 = TREE_OPERAND (_q21, 0);
3847 41 : switch (TREE_CODE (_p1))
3848 : {
3849 0 : case BIT_NOT_EXPR:
3850 0 : {
3851 0 : tree _q60 = TREE_OPERAND (_p1, 0);
3852 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
3853 : {
3854 0 : {
3855 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
3856 0 : tree res = generic_simplify_6 (loc, type, _p0, _p1, captures);
3857 0 : if (res) return res;
3858 : }
3859 : }
3860 : break;
3861 : }
3862 : default:;
3863 : }
3864 : break;
3865 : }
3866 4116 : default:;
3867 : }
3868 4116 : switch (TREE_CODE (_q20))
3869 : {
3870 90 : case BIT_NOT_EXPR:
3871 90 : {
3872 90 : tree _q30 = TREE_OPERAND (_q20, 0);
3873 90 : switch (TREE_CODE (_p1))
3874 : {
3875 0 : case BIT_NOT_EXPR:
3876 0 : {
3877 0 : tree _q60 = TREE_OPERAND (_p1, 0);
3878 0 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
3879 : {
3880 0 : {
3881 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q30 };
3882 0 : tree res = generic_simplify_6 (loc, type, _p0, _p1, captures);
3883 0 : if (res) return res;
3884 : }
3885 : }
3886 : break;
3887 : }
3888 90 : default:;
3889 : }
3890 90 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
3891 : {
3892 0 : {
3893 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q21 };
3894 0 : tree res = generic_simplify_7 (loc, type, _p0, _p1, captures);
3895 0 : if (res) return res;
3896 : }
3897 : }
3898 : break;
3899 : }
3900 4116 : default:;
3901 : }
3902 4116 : switch (TREE_CODE (_q21))
3903 : {
3904 41 : case BIT_NOT_EXPR:
3905 41 : {
3906 41 : tree _q40 = TREE_OPERAND (_q21, 0);
3907 41 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
3908 : {
3909 0 : {
3910 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q20 };
3911 0 : tree res = generic_simplify_7 (loc, type, _p0, _p1, captures);
3912 0 : if (res) return res;
3913 : }
3914 : }
3915 : break;
3916 : }
3917 : default:;
3918 : }
3919 : break;
3920 : }
3921 505 : case BIT_NOT_EXPR:
3922 505 : {
3923 505 : tree _q20 = TREE_OPERAND (_p0, 0);
3924 505 : switch (TREE_CODE (_p1))
3925 : {
3926 51 : case BIT_AND_EXPR:
3927 51 : {
3928 51 : tree _q40 = TREE_OPERAND (_p1, 0);
3929 51 : tree _q41 = TREE_OPERAND (_p1, 1);
3930 51 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
3931 : {
3932 0 : switch (TREE_CODE (_q41))
3933 : {
3934 0 : case BIT_NOT_EXPR:
3935 0 : {
3936 0 : tree _q60 = TREE_OPERAND (_q41, 0);
3937 0 : {
3938 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q20, _q60 };
3939 0 : tree res = generic_simplify_6 (loc, type, _p0, _p1, captures);
3940 0 : if (res) return res;
3941 : }
3942 0 : break;
3943 : }
3944 : default:;
3945 : }
3946 : }
3947 51 : switch (TREE_CODE (_q40))
3948 : {
3949 7 : case BIT_NOT_EXPR:
3950 7 : {
3951 7 : tree _q50 = TREE_OPERAND (_q40, 0);
3952 7 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
3953 : {
3954 0 : {
3955 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q20, _q50 };
3956 0 : tree res = generic_simplify_6 (loc, type, _p0, _p1, captures);
3957 0 : if (res) return res;
3958 : }
3959 : }
3960 : break;
3961 : }
3962 : default:;
3963 : }
3964 : break;
3965 : }
3966 : default:;
3967 : }
3968 : break;
3969 : }
3970 1049192 : default:;
3971 : }
3972 1049192 : switch (TREE_CODE (_p1))
3973 : {
3974 884 : case BIT_AND_EXPR:
3975 884 : {
3976 884 : tree _q30 = TREE_OPERAND (_p1, 0);
3977 884 : tree _q31 = TREE_OPERAND (_p1, 1);
3978 884 : switch (TREE_CODE (_q30))
3979 : {
3980 57 : case BIT_NOT_EXPR:
3981 57 : {
3982 57 : tree _q40 = TREE_OPERAND (_q30, 0);
3983 57 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
3984 : {
3985 0 : {
3986 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q31 };
3987 0 : tree res = generic_simplify_7 (loc, type, _p0, _p1, captures);
3988 0 : if (res) return res;
3989 : }
3990 : }
3991 : break;
3992 : }
3993 884 : default:;
3994 : }
3995 884 : switch (TREE_CODE (_q31))
3996 : {
3997 8 : case BIT_NOT_EXPR:
3998 8 : {
3999 8 : tree _q50 = TREE_OPERAND (_q31, 0);
4000 8 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
4001 : {
4002 0 : {
4003 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q30 };
4004 0 : tree res = generic_simplify_7 (loc, type, _p0, _p1, captures);
4005 0 : if (res) return res;
4006 : }
4007 : }
4008 : break;
4009 : }
4010 : default:;
4011 : }
4012 : break;
4013 : }
4014 1049192 : default:;
4015 : }
4016 1049192 : switch (TREE_CODE (_p0))
4017 : {
4018 21605 : case PLUS_EXPR:
4019 21605 : {
4020 21605 : tree _q20 = TREE_OPERAND (_p0, 0);
4021 21605 : tree _q21 = TREE_OPERAND (_p0, 1);
4022 21605 : if (integer_minus_onep (_q21))
4023 : {
4024 10456 : switch (TREE_CODE (_p1))
4025 : {
4026 11 : case NEGATE_EXPR:
4027 11 : {
4028 11 : tree _q50 = TREE_OPERAND (_p1, 0);
4029 11 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4030 : {
4031 11 : {
4032 11 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4033 11 : tree res = generic_simplify_8 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4034 11 : if (res) return res;
4035 : }
4036 : }
4037 : break;
4038 : }
4039 : default:;
4040 : }
4041 : }
4042 : break;
4043 : }
4044 151 : case NEGATE_EXPR:
4045 151 : {
4046 151 : tree _q20 = TREE_OPERAND (_p0, 0);
4047 151 : switch (TREE_CODE (_p1))
4048 : {
4049 0 : case PLUS_EXPR:
4050 0 : {
4051 0 : tree _q40 = TREE_OPERAND (_p1, 0);
4052 0 : tree _q41 = TREE_OPERAND (_p1, 1);
4053 0 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
4054 : {
4055 0 : if (integer_minus_onep (_q41))
4056 : {
4057 0 : {
4058 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q41 };
4059 0 : tree res = generic_simplify_8 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4060 0 : if (res) return res;
4061 : }
4062 : }
4063 : }
4064 : break;
4065 : }
4066 0 : case MINUS_EXPR:
4067 0 : {
4068 0 : tree _q40 = TREE_OPERAND (_p1, 0);
4069 0 : tree _q41 = TREE_OPERAND (_p1, 1);
4070 0 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
4071 : {
4072 0 : if (integer_onep (_q41))
4073 : {
4074 0 : {
4075 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4076 0 : tree res = generic_simplify_9 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4077 0 : if (res) return res;
4078 : }
4079 : }
4080 : }
4081 : break;
4082 : }
4083 : default:;
4084 : }
4085 : break;
4086 : }
4087 102 : case MINUS_EXPR:
4088 102 : {
4089 102 : tree _q20 = TREE_OPERAND (_p0, 0);
4090 102 : tree _q21 = TREE_OPERAND (_p0, 1);
4091 102 : if (integer_onep (_q21))
4092 : {
4093 0 : switch (TREE_CODE (_p1))
4094 : {
4095 0 : case NEGATE_EXPR:
4096 0 : {
4097 0 : tree _q50 = TREE_OPERAND (_p1, 0);
4098 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4099 : {
4100 0 : {
4101 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4102 0 : tree res = generic_simplify_10 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4103 0 : if (res) return res;
4104 : }
4105 : }
4106 : break;
4107 : }
4108 : default:;
4109 : }
4110 : }
4111 : break;
4112 : }
4113 1310 : case BIT_IOR_EXPR:
4114 1310 : {
4115 1310 : tree _q20 = TREE_OPERAND (_p0, 0);
4116 1310 : tree _q21 = TREE_OPERAND (_p0, 1);
4117 1310 : switch (TREE_CODE (_p1))
4118 : {
4119 65 : case BIT_AND_EXPR:
4120 65 : {
4121 65 : tree _q50 = TREE_OPERAND (_p1, 0);
4122 65 : tree _q51 = TREE_OPERAND (_p1, 1);
4123 65 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4124 : {
4125 15 : {
4126 15 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4127 15 : tree res = generic_simplify_11 (loc, type, _p0, _p1, captures);
4128 15 : if (res) return res;
4129 : }
4130 : }
4131 65 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4132 : {
4133 12 : {
4134 12 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
4135 12 : tree res = generic_simplify_11 (loc, type, _p0, _p1, captures);
4136 12 : if (res) return res;
4137 : }
4138 : }
4139 65 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4140 : {
4141 3 : {
4142 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
4143 3 : tree res = generic_simplify_11 (loc, type, _p0, _p1, captures);
4144 3 : if (res) return res;
4145 : }
4146 : }
4147 65 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4148 : {
4149 6 : {
4150 6 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
4151 6 : tree res = generic_simplify_11 (loc, type, _p0, _p1, captures);
4152 6 : if (res) return res;
4153 : }
4154 : }
4155 : break;
4156 : }
4157 1310 : default:;
4158 : }
4159 1310 : switch (TREE_CODE (_q20))
4160 : {
4161 481 : case BIT_NOT_EXPR:
4162 481 : {
4163 481 : tree _q30 = TREE_OPERAND (_q20, 0);
4164 481 : {
4165 481 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _p1 };
4166 481 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4167 481 : if (res) return res;
4168 : }
4169 480 : break;
4170 : }
4171 1309 : default:;
4172 : }
4173 1309 : switch (TREE_CODE (_q21))
4174 : {
4175 62 : case BIT_NOT_EXPR:
4176 62 : {
4177 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4178 62 : {
4179 62 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20, _p1 };
4180 62 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4181 62 : if (res) return res;
4182 : }
4183 62 : break;
4184 : }
4185 : default:;
4186 : }
4187 : break;
4188 : }
4189 4116 : case BIT_AND_EXPR:
4190 4116 : {
4191 4116 : tree _q20 = TREE_OPERAND (_p0, 0);
4192 4116 : tree _q21 = TREE_OPERAND (_p0, 1);
4193 4116 : switch (TREE_CODE (_p1))
4194 : {
4195 74 : case BIT_IOR_EXPR:
4196 74 : {
4197 74 : tree _q50 = TREE_OPERAND (_p1, 0);
4198 74 : tree _q51 = TREE_OPERAND (_p1, 1);
4199 74 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4200 : {
4201 18 : {
4202 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q21, _q20 };
4203 18 : tree res = generic_simplify_11 (loc, type, _p0, _p1, captures);
4204 18 : if (res) return res;
4205 : }
4206 : }
4207 74 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4208 : {
4209 9 : {
4210 9 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q20, _q21 };
4211 9 : tree res = generic_simplify_11 (loc, type, _p0, _p1, captures);
4212 9 : if (res) return res;
4213 : }
4214 : }
4215 74 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4216 : {
4217 9 : {
4218 9 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q21, _q20 };
4219 9 : tree res = generic_simplify_11 (loc, type, _p0, _p1, captures);
4220 9 : if (res) return res;
4221 : }
4222 : }
4223 74 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4224 : {
4225 18 : {
4226 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q20, _q21 };
4227 18 : tree res = generic_simplify_11 (loc, type, _p0, _p1, captures);
4228 18 : if (res) return res;
4229 : }
4230 : }
4231 : break;
4232 : }
4233 : default:;
4234 : }
4235 : break;
4236 : }
4237 1049180 : default:;
4238 : }
4239 1049180 : switch (TREE_CODE (_p1))
4240 : {
4241 521 : case BIT_IOR_EXPR:
4242 521 : {
4243 521 : tree _q30 = TREE_OPERAND (_p1, 0);
4244 521 : tree _q31 = TREE_OPERAND (_p1, 1);
4245 521 : switch (TREE_CODE (_q30))
4246 : {
4247 21 : case BIT_NOT_EXPR:
4248 21 : {
4249 21 : tree _q40 = TREE_OPERAND (_q30, 0);
4250 21 : {
4251 21 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _q31, _p0 };
4252 21 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4253 21 : if (res) return res;
4254 : }
4255 21 : break;
4256 : }
4257 521 : default:;
4258 : }
4259 521 : switch (TREE_CODE (_q31))
4260 : {
4261 25 : case BIT_NOT_EXPR:
4262 25 : {
4263 25 : tree _q50 = TREE_OPERAND (_q31, 0);
4264 25 : {
4265 25 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q31, _q50, _q30, _p0 };
4266 25 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4267 25 : if (res) return res;
4268 : }
4269 25 : break;
4270 : }
4271 : default:;
4272 : }
4273 : break;
4274 : }
4275 1049180 : default:;
4276 : }
4277 1049180 : switch (TREE_CODE (_p0))
4278 : {
4279 4116 : case BIT_AND_EXPR:
4280 4116 : {
4281 4116 : tree _q20 = TREE_OPERAND (_p0, 0);
4282 4116 : tree _q21 = TREE_OPERAND (_p0, 1);
4283 4116 : switch (TREE_CODE (_q20))
4284 : {
4285 90 : case BIT_NOT_EXPR:
4286 90 : {
4287 90 : tree _q30 = TREE_OPERAND (_q20, 0);
4288 90 : {
4289 90 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _p1 };
4290 90 : tree res = generic_simplify_13 (loc, type, _p0, _p1, captures);
4291 90 : if (res) return res;
4292 : }
4293 89 : break;
4294 : }
4295 4115 : default:;
4296 : }
4297 4115 : switch (TREE_CODE (_q21))
4298 : {
4299 41 : case BIT_NOT_EXPR:
4300 41 : {
4301 41 : tree _q40 = TREE_OPERAND (_q21, 0);
4302 41 : {
4303 41 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20, _p1 };
4304 41 : tree res = generic_simplify_13 (loc, type, _p0, _p1, captures);
4305 41 : if (res) return res;
4306 : }
4307 41 : break;
4308 : }
4309 : default:;
4310 : }
4311 : break;
4312 : }
4313 1049179 : default:;
4314 : }
4315 1049179 : switch (TREE_CODE (_p1))
4316 : {
4317 884 : case BIT_AND_EXPR:
4318 884 : {
4319 884 : tree _q30 = TREE_OPERAND (_p1, 0);
4320 884 : tree _q31 = TREE_OPERAND (_p1, 1);
4321 884 : switch (TREE_CODE (_q30))
4322 : {
4323 57 : case BIT_NOT_EXPR:
4324 57 : {
4325 57 : tree _q40 = TREE_OPERAND (_q30, 0);
4326 57 : {
4327 57 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _q31, _p0 };
4328 57 : tree res = generic_simplify_13 (loc, type, _p0, _p1, captures);
4329 57 : if (res) return res;
4330 : }
4331 57 : break;
4332 : }
4333 884 : default:;
4334 : }
4335 884 : switch (TREE_CODE (_q31))
4336 : {
4337 8 : case BIT_NOT_EXPR:
4338 8 : {
4339 8 : tree _q50 = TREE_OPERAND (_q31, 0);
4340 8 : {
4341 8 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q31, _q50, _q30, _p0 };
4342 8 : tree res = generic_simplify_13 (loc, type, _p0, _p1, captures);
4343 8 : if (res) return res;
4344 : }
4345 8 : break;
4346 : }
4347 : default:;
4348 : }
4349 : break;
4350 : }
4351 1049179 : default:;
4352 : }
4353 1049179 : switch (TREE_CODE (_p0))
4354 : {
4355 676432 : CASE_CONVERT:
4356 676432 : {
4357 676432 : tree _q20 = TREE_OPERAND (_p0, 0);
4358 676432 : switch (TREE_CODE (_p1))
4359 : {
4360 672232 : CASE_CONVERT:
4361 672232 : {
4362 672232 : tree _q40 = TREE_OPERAND (_p1, 0);
4363 672232 : {
4364 672232 : tree _q40_pops[1];
4365 672232 : if (tree_maybe_bit_not (_q40, _q40_pops))
4366 : {
4367 0 : tree _q50 = _q40_pops[0];
4368 0 : {
4369 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
4370 0 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4371 0 : if (res) return res;
4372 : }
4373 : }
4374 : }
4375 672232 : break;
4376 : }
4377 676432 : default:;
4378 : }
4379 676432 : {
4380 676432 : tree _q20_pops[1];
4381 676432 : if (tree_maybe_bit_not (_q20, _q20_pops))
4382 : {
4383 63325 : tree _q30 = _q20_pops[0];
4384 63325 : switch (TREE_CODE (_p1))
4385 : {
4386 63275 : CASE_CONVERT:
4387 63275 : {
4388 63275 : tree _q50 = TREE_OPERAND (_p1, 0);
4389 63275 : {
4390 63275 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
4391 63275 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4392 63275 : if (res) return res;
4393 : }
4394 63275 : break;
4395 : }
4396 : default:;
4397 : }
4398 : }
4399 : }
4400 676432 : break;
4401 : }
4402 1049179 : default:;
4403 : }
4404 1049179 : {
4405 1049179 : tree _p1_pops[1];
4406 1049179 : if (tree_maybe_bit_not (_p1, _p1_pops))
4407 : {
4408 10219 : tree _q30 = _p1_pops[0];
4409 10219 : {
4410 10219 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
4411 10219 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4412 10219 : if (res) return res;
4413 : }
4414 : }
4415 : }
4416 1049179 : {
4417 1049179 : tree _p0_pops[1];
4418 1049179 : if (tree_maybe_bit_not (_p0, _p0_pops))
4419 : {
4420 1052 : tree _q20 = _p0_pops[0];
4421 1052 : {
4422 1052 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _q20 };
4423 1052 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4424 1052 : if (res) return res;
4425 : }
4426 : }
4427 : }
4428 1049158 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
4429 : {
4430 149 : {
4431 149 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4432 149 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1178;
4433 149 : {
4434 149 : tree _r;
4435 149 : _r = build_zero_cst (type);
4436 149 : if (TREE_SIDE_EFFECTS (captures[0]))
4437 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4438 149 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 900, __FILE__, __LINE__, true);
4439 149 : return _r;
4440 : }
4441 0 : next_after_fail1178:;
4442 : }
4443 : }
4444 1049009 : if (integer_all_onesp (_p1))
4445 : {
4446 1086 : {
4447 1086 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4448 1086 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1179;
4449 1086 : {
4450 1086 : tree res_op0;
4451 1086 : res_op0 = captures[0];
4452 1086 : tree _r;
4453 1086 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
4454 1086 : if (TREE_SIDE_EFFECTS (captures[1]))
4455 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4456 1086 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 901, __FILE__, __LINE__, true);
4457 1086 : return _r;
4458 : }
4459 0 : next_after_fail1179:;
4460 : }
4461 : }
4462 1047923 : switch (TREE_CODE (_p0))
4463 : {
4464 1302 : case BIT_IOR_EXPR:
4465 1302 : {
4466 1302 : tree _q20 = TREE_OPERAND (_p0, 0);
4467 1302 : tree _q21 = TREE_OPERAND (_p0, 1);
4468 1302 : switch (TREE_CODE (_p1))
4469 : {
4470 179 : case BIT_IOR_EXPR:
4471 179 : {
4472 179 : tree _q50 = TREE_OPERAND (_p1, 0);
4473 179 : tree _q51 = TREE_OPERAND (_p1, 1);
4474 179 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4475 : {
4476 0 : switch (TREE_CODE (_q51))
4477 : {
4478 0 : case BIT_NOT_EXPR:
4479 0 : {
4480 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4481 0 : if ((_q70 == _q21 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q21, 0) && types_match (_q70, _q21)))
4482 : {
4483 0 : {
4484 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4485 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures);
4486 0 : if (res) return res;
4487 : }
4488 : }
4489 : break;
4490 : }
4491 : default:;
4492 : }
4493 : }
4494 179 : switch (TREE_CODE (_q50))
4495 : {
4496 20 : case BIT_NOT_EXPR:
4497 20 : {
4498 20 : tree _q60 = TREE_OPERAND (_q50, 0);
4499 20 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
4500 : {
4501 2 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4502 : {
4503 1 : {
4504 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4505 1 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures);
4506 1 : if (res) return res;
4507 : }
4508 : }
4509 : }
4510 19 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4511 : {
4512 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4513 : {
4514 0 : {
4515 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
4516 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures);
4517 0 : if (res) return res;
4518 : }
4519 : }
4520 : }
4521 : break;
4522 : }
4523 178 : default:;
4524 : }
4525 178 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4526 : {
4527 0 : switch (TREE_CODE (_q51))
4528 : {
4529 0 : case BIT_NOT_EXPR:
4530 0 : {
4531 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4532 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4533 : {
4534 0 : {
4535 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
4536 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures);
4537 0 : if (res) return res;
4538 : }
4539 : }
4540 : break;
4541 : }
4542 : default:;
4543 : }
4544 : }
4545 : break;
4546 : }
4547 1301 : default:;
4548 : }
4549 1301 : switch (TREE_CODE (_q21))
4550 : {
4551 62 : case BIT_NOT_EXPR:
4552 62 : {
4553 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4554 62 : switch (TREE_CODE (_p1))
4555 : {
4556 9 : case BIT_IOR_EXPR:
4557 9 : {
4558 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4559 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4560 9 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4561 : {
4562 0 : if ((_q61 == _q40 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q40, 0) && types_match (_q61, _q40)))
4563 : {
4564 0 : {
4565 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
4566 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures);
4567 0 : if (res) return res;
4568 : }
4569 : }
4570 : }
4571 : break;
4572 : }
4573 : default:;
4574 : }
4575 : break;
4576 : }
4577 1301 : default:;
4578 : }
4579 1301 : switch (TREE_CODE (_q20))
4580 : {
4581 480 : case BIT_NOT_EXPR:
4582 480 : {
4583 480 : tree _q30 = TREE_OPERAND (_q20, 0);
4584 480 : switch (TREE_CODE (_p1))
4585 : {
4586 28 : case BIT_IOR_EXPR:
4587 28 : {
4588 28 : tree _q60 = TREE_OPERAND (_p1, 0);
4589 28 : tree _q61 = TREE_OPERAND (_p1, 1);
4590 28 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
4591 : {
4592 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
4593 : {
4594 0 : {
4595 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q30 };
4596 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures);
4597 0 : if (res) return res;
4598 : }
4599 : }
4600 : }
4601 28 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
4602 : {
4603 9 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
4604 : {
4605 0 : {
4606 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q30 };
4607 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures);
4608 0 : if (res) return res;
4609 : }
4610 : }
4611 9 : switch (TREE_CODE (_q61))
4612 : {
4613 0 : case BIT_NOT_EXPR:
4614 0 : {
4615 0 : tree _q80 = TREE_OPERAND (_q61, 0);
4616 0 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
4617 : {
4618 0 : {
4619 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q21 };
4620 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4621 0 : if (res) return res;
4622 : }
4623 : }
4624 : break;
4625 : }
4626 : default:;
4627 : }
4628 : }
4629 28 : switch (TREE_CODE (_q60))
4630 : {
4631 1 : case BIT_NOT_EXPR:
4632 1 : {
4633 1 : tree _q70 = TREE_OPERAND (_q60, 0);
4634 1 : if ((_q70 == _q21 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q21, 0) && types_match (_q70, _q21)))
4635 : {
4636 1 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
4637 : {
4638 1 : {
4639 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q21 };
4640 1 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4641 1 : if (res) return res;
4642 : }
4643 : }
4644 : }
4645 : break;
4646 : }
4647 : default:;
4648 : }
4649 : break;
4650 : }
4651 9 : case BIT_XOR_EXPR:
4652 9 : {
4653 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4654 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4655 9 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
4656 : {
4657 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
4658 : {
4659 0 : {
4660 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q21, _p1 };
4661 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
4662 0 : if (res) return res;
4663 : }
4664 : }
4665 : }
4666 : break;
4667 : }
4668 479 : default:;
4669 : }
4670 479 : {
4671 479 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q21, _p1 };
4672 479 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
4673 479 : if (res) return res;
4674 : }
4675 431 : break;
4676 : }
4677 1252 : default:;
4678 : }
4679 1252 : switch (TREE_CODE (_q21))
4680 : {
4681 62 : case BIT_NOT_EXPR:
4682 62 : {
4683 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4684 62 : switch (TREE_CODE (_p1))
4685 : {
4686 9 : case BIT_IOR_EXPR:
4687 9 : {
4688 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4689 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4690 9 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
4691 : {
4692 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
4693 : {
4694 0 : {
4695 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
4696 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures);
4697 0 : if (res) return res;
4698 : }
4699 : }
4700 : }
4701 : break;
4702 : }
4703 9 : case BIT_XOR_EXPR:
4704 9 : {
4705 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4706 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4707 9 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
4708 : {
4709 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
4710 : {
4711 0 : {
4712 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q40, _q20, _p1 };
4713 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
4714 0 : if (res) return res;
4715 : }
4716 : }
4717 : }
4718 : break;
4719 : }
4720 : default:;
4721 : }
4722 : break;
4723 : }
4724 1252 : default:;
4725 : }
4726 1252 : switch (TREE_CODE (_p1))
4727 : {
4728 65 : case BIT_AND_EXPR:
4729 65 : {
4730 65 : tree _q50 = TREE_OPERAND (_p1, 0);
4731 65 : tree _q51 = TREE_OPERAND (_p1, 1);
4732 65 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4733 : {
4734 6 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4735 : {
4736 0 : {
4737 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4738 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_XOR_EXPR);
4739 0 : if (res) return res;
4740 : }
4741 : }
4742 : }
4743 : break;
4744 : }
4745 36 : case BIT_XOR_EXPR:
4746 36 : {
4747 36 : tree _q50 = TREE_OPERAND (_p1, 0);
4748 36 : tree _q51 = TREE_OPERAND (_p1, 1);
4749 36 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4750 : {
4751 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4752 : {
4753 0 : {
4754 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4755 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
4756 0 : if (res) return res;
4757 : }
4758 : }
4759 : }
4760 : break;
4761 : }
4762 1252 : default:;
4763 : }
4764 1252 : switch (TREE_CODE (_q21))
4765 : {
4766 62 : case BIT_NOT_EXPR:
4767 62 : {
4768 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4769 62 : switch (TREE_CODE (_p1))
4770 : {
4771 9 : case BIT_IOR_EXPR:
4772 9 : {
4773 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4774 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4775 9 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
4776 : {
4777 0 : switch (TREE_CODE (_q61))
4778 : {
4779 0 : case BIT_NOT_EXPR:
4780 0 : {
4781 0 : tree _q80 = TREE_OPERAND (_q61, 0);
4782 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
4783 : {
4784 0 : {
4785 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
4786 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4787 0 : if (res) return res;
4788 : }
4789 : }
4790 : break;
4791 : }
4792 : default:;
4793 : }
4794 : }
4795 9 : switch (TREE_CODE (_q60))
4796 : {
4797 0 : case BIT_NOT_EXPR:
4798 0 : {
4799 0 : tree _q70 = TREE_OPERAND (_q60, 0);
4800 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4801 : {
4802 0 : if ((_q61 == _q40 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q40, 0) && types_match (_q61, _q40)))
4803 : {
4804 0 : {
4805 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
4806 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4807 0 : if (res) return res;
4808 : }
4809 : }
4810 : }
4811 : break;
4812 : }
4813 : default:;
4814 : }
4815 : break;
4816 : }
4817 : default:;
4818 : }
4819 : break;
4820 : }
4821 1252 : default:;
4822 : }
4823 1252 : switch (TREE_CODE (_p1))
4824 : {
4825 24 : CASE_CONVERT:
4826 24 : {
4827 24 : tree _q50 = TREE_OPERAND (_p1, 0);
4828 24 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
4829 : {
4830 0 : {
4831 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q20 };
4832 0 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
4833 0 : if (res) return res;
4834 : }
4835 : }
4836 24 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q21, 0))
4837 : {
4838 0 : {
4839 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q21 };
4840 0 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
4841 0 : if (res) return res;
4842 : }
4843 : }
4844 : break;
4845 : }
4846 1252 : default:;
4847 : }
4848 1252 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q20, 0))
4849 : {
4850 3 : {
4851 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q20 };
4852 3 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
4853 3 : if (res) return res;
4854 : }
4855 : }
4856 1249 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q21, 0))
4857 : {
4858 3 : {
4859 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q21 };
4860 3 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
4861 3 : if (res) return res;
4862 : }
4863 : }
4864 1246 : {
4865 1246 : tree _q20_pops[1];
4866 1246 : if (tree_nop_convert (_q20, _q20_pops))
4867 : {
4868 8 : tree _q30 = _q20_pops[0];
4869 8 : switch (TREE_CODE (_q30))
4870 : {
4871 8 : case BIT_NOT_EXPR:
4872 8 : {
4873 8 : tree _q40 = TREE_OPERAND (_q30, 0);
4874 8 : {
4875 8 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q21, _p1 };
4876 8 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
4877 8 : if (res) return res;
4878 : }
4879 0 : break;
4880 : }
4881 : default:;
4882 : }
4883 : }
4884 : }
4885 1238 : switch (TREE_CODE (_q21))
4886 : {
4887 62 : case BIT_NOT_EXPR:
4888 62 : {
4889 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4890 62 : {
4891 62 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q20, _p1 };
4892 62 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
4893 62 : if (res) return res;
4894 : }
4895 54 : break;
4896 : }
4897 1230 : default:;
4898 : }
4899 1230 : {
4900 1230 : tree _q21_pops[1];
4901 1230 : if (tree_nop_convert (_q21, _q21_pops))
4902 : {
4903 0 : tree _q40 = _q21_pops[0];
4904 0 : switch (TREE_CODE (_q40))
4905 : {
4906 0 : case BIT_NOT_EXPR:
4907 0 : {
4908 0 : tree _q50 = TREE_OPERAND (_q40, 0);
4909 0 : {
4910 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q20, _p1 };
4911 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
4912 0 : if (res) return res;
4913 : }
4914 0 : break;
4915 : }
4916 : default:;
4917 : }
4918 : }
4919 : }
4920 1230 : break;
4921 : }
4922 4064 : case BIT_XOR_EXPR:
4923 4064 : {
4924 4064 : tree _q20 = TREE_OPERAND (_p0, 0);
4925 4064 : tree _q21 = TREE_OPERAND (_p0, 1);
4926 4064 : switch (TREE_CODE (_p1))
4927 : {
4928 203 : case BIT_IOR_EXPR:
4929 203 : {
4930 203 : tree _q50 = TREE_OPERAND (_p1, 0);
4931 203 : tree _q51 = TREE_OPERAND (_p1, 1);
4932 203 : switch (TREE_CODE (_q50))
4933 : {
4934 1 : case BIT_NOT_EXPR:
4935 1 : {
4936 1 : tree _q60 = TREE_OPERAND (_q50, 0);
4937 1 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4938 : {
4939 1 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4940 : {
4941 1 : {
4942 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q20, _q21, _p0 };
4943 1 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
4944 1 : if (res) return res;
4945 : }
4946 : }
4947 : }
4948 : break;
4949 : }
4950 202 : default:;
4951 : }
4952 202 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4953 : {
4954 0 : switch (TREE_CODE (_q51))
4955 : {
4956 0 : case BIT_NOT_EXPR:
4957 0 : {
4958 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4959 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4960 : {
4961 0 : {
4962 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q20, _q21, _p0 };
4963 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
4964 0 : if (res) return res;
4965 : }
4966 : }
4967 : break;
4968 : }
4969 : default:;
4970 : }
4971 : }
4972 202 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4973 : {
4974 1 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4975 : {
4976 0 : {
4977 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4978 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
4979 0 : if (res) return res;
4980 : }
4981 : }
4982 : }
4983 : break;
4984 : }
4985 41 : case BIT_AND_EXPR:
4986 41 : {
4987 41 : tree _q50 = TREE_OPERAND (_p1, 0);
4988 41 : tree _q51 = TREE_OPERAND (_p1, 1);
4989 41 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4990 : {
4991 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4992 : {
4993 0 : {
4994 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4995 0 : tree res = generic_simplify_21 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4996 0 : if (res) return res;
4997 : }
4998 : }
4999 : }
5000 : break;
5001 : }
5002 202 : CASE_CONVERT:
5003 202 : {
5004 202 : tree _q50 = TREE_OPERAND (_p1, 0);
5005 202 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q21, 0))
5006 : {
5007 0 : {
5008 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q21 };
5009 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5010 0 : if (res) return res;
5011 : }
5012 : }
5013 202 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
5014 : {
5015 0 : {
5016 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q20 };
5017 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5018 0 : if (res) return res;
5019 : }
5020 : }
5021 : break;
5022 : }
5023 4063 : default:;
5024 : }
5025 4063 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q21, 0))
5026 : {
5027 0 : {
5028 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q21 };
5029 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5030 0 : if (res) return res;
5031 : }
5032 : }
5033 4063 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q20, 0))
5034 : {
5035 11 : {
5036 11 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q20 };
5037 11 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5038 11 : if (res) return res;
5039 : }
5040 : }
5041 : break;
5042 : }
5043 4115 : case BIT_AND_EXPR:
5044 4115 : {
5045 4115 : tree _q20 = TREE_OPERAND (_p0, 0);
5046 4115 : tree _q21 = TREE_OPERAND (_p0, 1);
5047 4115 : switch (TREE_CODE (_p1))
5048 : {
5049 74 : case BIT_IOR_EXPR:
5050 74 : {
5051 74 : tree _q50 = TREE_OPERAND (_p1, 0);
5052 74 : tree _q51 = TREE_OPERAND (_p1, 1);
5053 74 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5054 : {
5055 18 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5056 : {
5057 0 : {
5058 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5059 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_XOR_EXPR);
5060 0 : if (res) return res;
5061 : }
5062 : }
5063 : }
5064 : break;
5065 : }
5066 30 : case BIT_XOR_EXPR:
5067 30 : {
5068 30 : tree _q50 = TREE_OPERAND (_p1, 0);
5069 30 : tree _q51 = TREE_OPERAND (_p1, 1);
5070 30 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5071 : {
5072 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5073 : {
5074 0 : {
5075 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5076 0 : tree res = generic_simplify_21 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5077 0 : if (res) return res;
5078 : }
5079 : }
5080 : }
5081 : break;
5082 : }
5083 4115 : default:;
5084 : }
5085 4115 : switch (TREE_CODE (_q21))
5086 : {
5087 2290 : case INTEGER_CST:
5088 2290 : {
5089 2290 : switch (TREE_CODE (_p1))
5090 : {
5091 15 : CASE_CONVERT:
5092 15 : {
5093 15 : tree _q50 = TREE_OPERAND (_p1, 0);
5094 15 : switch (TREE_CODE (_q50))
5095 : {
5096 0 : case BIT_AND_EXPR:
5097 0 : {
5098 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5099 0 : tree _q61 = TREE_OPERAND (_q50, 1);
5100 0 : switch (TREE_CODE (_q61))
5101 : {
5102 0 : case INTEGER_CST:
5103 0 : {
5104 0 : {
5105 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50, _q60, _q61 };
5106 0 : tree res = generic_simplify_23 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5107 0 : if (res) return res;
5108 : }
5109 0 : break;
5110 : }
5111 : default:;
5112 : }
5113 : break;
5114 : }
5115 : default:;
5116 : }
5117 : break;
5118 : }
5119 210 : case BIT_AND_EXPR:
5120 210 : {
5121 210 : tree _q50 = TREE_OPERAND (_p1, 0);
5122 210 : tree _q51 = TREE_OPERAND (_p1, 1);
5123 210 : switch (TREE_CODE (_q51))
5124 : {
5125 210 : case INTEGER_CST:
5126 210 : {
5127 210 : {
5128 210 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50, _q51 };
5129 210 : tree res = generic_simplify_23 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5130 210 : if (res) return res;
5131 : }
5132 209 : break;
5133 : }
5134 : default:;
5135 : }
5136 : break;
5137 : }
5138 : default:;
5139 : }
5140 : break;
5141 : }
5142 : default:;
5143 : }
5144 : break;
5145 : }
5146 676275 : CASE_CONVERT:
5147 676275 : {
5148 676275 : tree _q20 = TREE_OPERAND (_p0, 0);
5149 676275 : switch (TREE_CODE (_q20))
5150 : {
5151 80 : case BIT_AND_EXPR:
5152 80 : {
5153 80 : tree _q30 = TREE_OPERAND (_q20, 0);
5154 80 : tree _q31 = TREE_OPERAND (_q20, 1);
5155 80 : switch (TREE_CODE (_q31))
5156 : {
5157 0 : case INTEGER_CST:
5158 0 : {
5159 0 : switch (TREE_CODE (_p1))
5160 : {
5161 0 : CASE_CONVERT:
5162 0 : {
5163 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5164 0 : switch (TREE_CODE (_q60))
5165 : {
5166 0 : case BIT_AND_EXPR:
5167 0 : {
5168 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5169 0 : tree _q71 = TREE_OPERAND (_q60, 1);
5170 0 : switch (TREE_CODE (_q71))
5171 : {
5172 0 : case INTEGER_CST:
5173 0 : {
5174 0 : {
5175 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q60, _q70, _q71 };
5176 0 : tree res = generic_simplify_23 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5177 0 : if (res) return res;
5178 : }
5179 0 : break;
5180 : }
5181 : default:;
5182 : }
5183 : break;
5184 : }
5185 : default:;
5186 : }
5187 : break;
5188 : }
5189 0 : case BIT_AND_EXPR:
5190 0 : {
5191 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5192 0 : tree _q61 = TREE_OPERAND (_p1, 1);
5193 0 : switch (TREE_CODE (_q61))
5194 : {
5195 0 : case INTEGER_CST:
5196 0 : {
5197 0 : {
5198 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _p1, _q60, _q61 };
5199 0 : tree res = generic_simplify_23 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5200 0 : if (res) return res;
5201 : }
5202 0 : break;
5203 : }
5204 : default:;
5205 : }
5206 : break;
5207 : }
5208 : default:;
5209 : }
5210 : break;
5211 : }
5212 : default:;
5213 : }
5214 : break;
5215 : }
5216 24 : case BIT_IOR_EXPR:
5217 24 : {
5218 24 : tree _q30 = TREE_OPERAND (_q20, 0);
5219 24 : tree _q31 = TREE_OPERAND (_q20, 1);
5220 24 : switch (TREE_CODE (_p1))
5221 : {
5222 16 : CASE_CONVERT:
5223 16 : {
5224 16 : tree _q60 = TREE_OPERAND (_p1, 0);
5225 16 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q30, 0))
5226 : {
5227 0 : {
5228 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q30 };
5229 0 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
5230 0 : if (res) return res;
5231 : }
5232 : }
5233 16 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q31, 0))
5234 : {
5235 0 : {
5236 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q31 };
5237 0 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
5238 0 : if (res) return res;
5239 : }
5240 : }
5241 : break;
5242 : }
5243 24 : default:;
5244 : }
5245 24 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q30, 0))
5246 : {
5247 0 : {
5248 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q30 };
5249 0 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
5250 0 : if (res) return res;
5251 : }
5252 : }
5253 24 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q31, 0))
5254 : {
5255 0 : {
5256 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q31 };
5257 0 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
5258 0 : if (res) return res;
5259 : }
5260 : }
5261 : break;
5262 : }
5263 676275 : default:;
5264 : }
5265 676275 : switch (TREE_CODE (_p1))
5266 : {
5267 672225 : CASE_CONVERT:
5268 672225 : {
5269 672225 : tree _q40 = TREE_OPERAND (_p1, 0);
5270 672225 : switch (TREE_CODE (_q40))
5271 : {
5272 0 : case BIT_IOR_EXPR:
5273 0 : {
5274 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5275 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5276 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
5277 : {
5278 0 : {
5279 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
5280 0 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
5281 0 : if (res) return res;
5282 : }
5283 : }
5284 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
5285 : {
5286 0 : {
5287 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q50, _q20 };
5288 0 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
5289 0 : if (res) return res;
5290 : }
5291 : }
5292 : break;
5293 : }
5294 : default:;
5295 : }
5296 : break;
5297 : }
5298 26 : case BIT_IOR_EXPR:
5299 26 : {
5300 26 : tree _q40 = TREE_OPERAND (_p1, 0);
5301 26 : tree _q41 = TREE_OPERAND (_p1, 1);
5302 26 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _q20, 0))
5303 : {
5304 0 : {
5305 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q20 };
5306 0 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
5307 0 : if (res) return res;
5308 : }
5309 : }
5310 26 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _q20, 0))
5311 : {
5312 0 : {
5313 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q20 };
5314 0 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
5315 0 : if (res) return res;
5316 : }
5317 : }
5318 : break;
5319 : }
5320 : default:;
5321 : }
5322 : break;
5323 : }
5324 1047838 : default:;
5325 : }
5326 1047838 : switch (TREE_CODE (_p1))
5327 : {
5328 806655 : CASE_CONVERT:
5329 806655 : {
5330 806655 : tree _q30 = TREE_OPERAND (_p1, 0);
5331 806655 : switch (TREE_CODE (_q30))
5332 : {
5333 6 : case BIT_IOR_EXPR:
5334 6 : {
5335 6 : tree _q40 = TREE_OPERAND (_q30, 0);
5336 6 : tree _q41 = TREE_OPERAND (_q30, 1);
5337 6 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _p0, 0))
5338 : {
5339 0 : {
5340 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _p0 };
5341 0 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
5342 0 : if (res) return res;
5343 : }
5344 : }
5345 6 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _p0, 0))
5346 : {
5347 0 : {
5348 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _p0 };
5349 0 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
5350 0 : if (res) return res;
5351 : }
5352 : }
5353 : break;
5354 : }
5355 : default:;
5356 : }
5357 : break;
5358 : }
5359 518 : case BIT_IOR_EXPR:
5360 518 : {
5361 518 : tree _q30 = TREE_OPERAND (_p1, 0);
5362 518 : tree _q31 = TREE_OPERAND (_p1, 1);
5363 518 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || operand_equal_p (_q30, _p0, 0))
5364 : {
5365 1 : {
5366 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
5367 1 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
5368 1 : if (res) return res;
5369 : }
5370 : }
5371 517 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || operand_equal_p (_q31, _p0, 0))
5372 : {
5373 1 : {
5374 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _p0 };
5375 1 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
5376 1 : if (res) return res;
5377 : }
5378 : }
5379 : break;
5380 : }
5381 1047836 : default:;
5382 : }
5383 1047836 : {
5384 1047836 : tree _p0_pops[1];
5385 1047836 : if (tree_nop_convert (_p0, _p0_pops))
5386 : {
5387 541986 : tree _q20 = _p0_pops[0];
5388 541986 : switch (TREE_CODE (_q20))
5389 : {
5390 16 : case BIT_IOR_EXPR:
5391 16 : {
5392 16 : tree _q30 = TREE_OPERAND (_q20, 0);
5393 16 : tree _q31 = TREE_OPERAND (_q20, 1);
5394 16 : {
5395 16 : tree _q30_pops[1];
5396 16 : if (tree_nop_convert (_q30, _q30_pops))
5397 : {
5398 0 : tree _q40 = _q30_pops[0];
5399 0 : switch (TREE_CODE (_q40))
5400 : {
5401 0 : case BIT_NOT_EXPR:
5402 0 : {
5403 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5404 0 : {
5405 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q31, _p1 };
5406 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
5407 0 : if (res) return res;
5408 : }
5409 0 : break;
5410 : }
5411 : default:;
5412 : }
5413 : }
5414 : }
5415 16 : {
5416 16 : tree _q31_pops[1];
5417 16 : if (tree_nop_convert (_q31, _q31_pops))
5418 : {
5419 0 : tree _q50 = _q31_pops[0];
5420 0 : switch (TREE_CODE (_q50))
5421 : {
5422 0 : case BIT_NOT_EXPR:
5423 0 : {
5424 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5425 0 : {
5426 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q30, _p1 };
5427 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
5428 0 : if (res) return res;
5429 : }
5430 0 : break;
5431 : }
5432 : default:;
5433 : }
5434 : }
5435 : }
5436 16 : switch (TREE_CODE (_q30))
5437 : {
5438 16 : case BIT_NOT_EXPR:
5439 16 : {
5440 16 : tree _q40 = TREE_OPERAND (_q30, 0);
5441 16 : {
5442 16 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q31, _p1 };
5443 16 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
5444 16 : if (res) return res;
5445 : }
5446 0 : break;
5447 : }
5448 0 : default:;
5449 : }
5450 0 : switch (TREE_CODE (_q31))
5451 : {
5452 0 : case BIT_NOT_EXPR:
5453 0 : {
5454 0 : tree _q50 = TREE_OPERAND (_q31, 0);
5455 0 : {
5456 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q30, _p1 };
5457 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
5458 0 : if (res) return res;
5459 : }
5460 0 : break;
5461 : }
5462 : default:;
5463 : }
5464 : break;
5465 : }
5466 : default:;
5467 : }
5468 : }
5469 : }
5470 1047820 : switch (TREE_CODE (_p1))
5471 : {
5472 516 : case BIT_IOR_EXPR:
5473 516 : {
5474 516 : tree _q30 = TREE_OPERAND (_p1, 0);
5475 516 : tree _q31 = TREE_OPERAND (_p1, 1);
5476 516 : {
5477 516 : tree _q30_pops[1];
5478 516 : if (tree_nop_convert (_q30, _q30_pops))
5479 : {
5480 2 : tree _q40 = _q30_pops[0];
5481 2 : switch (TREE_CODE (_q40))
5482 : {
5483 0 : case BIT_NOT_EXPR:
5484 0 : {
5485 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5486 0 : {
5487 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q31, _p0 };
5488 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
5489 0 : if (res) return res;
5490 : }
5491 0 : break;
5492 : }
5493 : default:;
5494 : }
5495 : }
5496 : }
5497 516 : {
5498 516 : tree _q31_pops[1];
5499 516 : if (tree_nop_convert (_q31, _q31_pops))
5500 : {
5501 2 : tree _q50 = _q31_pops[0];
5502 2 : switch (TREE_CODE (_q50))
5503 : {
5504 0 : case BIT_NOT_EXPR:
5505 0 : {
5506 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5507 0 : {
5508 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q30, _p0 };
5509 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
5510 0 : if (res) return res;
5511 : }
5512 0 : break;
5513 : }
5514 : default:;
5515 : }
5516 : }
5517 : }
5518 516 : switch (TREE_CODE (_q30))
5519 : {
5520 18 : case BIT_NOT_EXPR:
5521 18 : {
5522 18 : tree _q40 = TREE_OPERAND (_q30, 0);
5523 18 : {
5524 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q31, _p0 };
5525 18 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
5526 18 : if (res) return res;
5527 : }
5528 18 : break;
5529 : }
5530 516 : default:;
5531 : }
5532 516 : switch (TREE_CODE (_q31))
5533 : {
5534 25 : case BIT_NOT_EXPR:
5535 25 : {
5536 25 : tree _q50 = TREE_OPERAND (_q31, 0);
5537 25 : {
5538 25 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q30, _p0 };
5539 25 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
5540 25 : if (res) return res;
5541 : }
5542 17 : break;
5543 : }
5544 : default:;
5545 : }
5546 : break;
5547 : }
5548 1047812 : default:;
5549 : }
5550 1047812 : {
5551 1047812 : tree _p1_pops[1];
5552 1047812 : if (tree_nop_convert (_p1, _p1_pops))
5553 : {
5554 674934 : tree _q30 = _p1_pops[0];
5555 674934 : switch (TREE_CODE (_q30))
5556 : {
5557 0 : case BIT_IOR_EXPR:
5558 0 : {
5559 0 : tree _q40 = TREE_OPERAND (_q30, 0);
5560 0 : tree _q41 = TREE_OPERAND (_q30, 1);
5561 0 : {
5562 0 : tree _q40_pops[1];
5563 0 : if (tree_nop_convert (_q40, _q40_pops))
5564 : {
5565 0 : tree _q50 = _q40_pops[0];
5566 0 : switch (TREE_CODE (_q50))
5567 : {
5568 0 : case BIT_NOT_EXPR:
5569 0 : {
5570 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5571 0 : {
5572 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q41, _p0 };
5573 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
5574 0 : if (res) return res;
5575 : }
5576 0 : break;
5577 : }
5578 : default:;
5579 : }
5580 : }
5581 : }
5582 0 : {
5583 0 : tree _q41_pops[1];
5584 0 : if (tree_nop_convert (_q41, _q41_pops))
5585 : {
5586 0 : tree _q60 = _q41_pops[0];
5587 0 : switch (TREE_CODE (_q60))
5588 : {
5589 0 : case BIT_NOT_EXPR:
5590 0 : {
5591 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5592 0 : {
5593 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q70, _q40, _p0 };
5594 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
5595 0 : if (res) return res;
5596 : }
5597 0 : break;
5598 : }
5599 : default:;
5600 : }
5601 : }
5602 : }
5603 0 : switch (TREE_CODE (_q40))
5604 : {
5605 0 : case BIT_NOT_EXPR:
5606 0 : {
5607 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5608 0 : {
5609 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q41, _p0 };
5610 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
5611 0 : if (res) return res;
5612 : }
5613 0 : break;
5614 : }
5615 0 : default:;
5616 : }
5617 0 : switch (TREE_CODE (_q41))
5618 : {
5619 0 : case BIT_NOT_EXPR:
5620 0 : {
5621 0 : tree _q60 = TREE_OPERAND (_q41, 0);
5622 0 : {
5623 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q40, _p0 };
5624 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
5625 0 : if (res) return res;
5626 : }
5627 0 : break;
5628 : }
5629 : default:;
5630 : }
5631 : break;
5632 : }
5633 : default:;
5634 : }
5635 : }
5636 : }
5637 1047812 : switch (TREE_CODE (_p0))
5638 : {
5639 676251 : CASE_CONVERT:
5640 676251 : {
5641 676251 : tree _q20 = TREE_OPERAND (_p0, 0);
5642 676251 : switch (TREE_CODE (_q20))
5643 : {
5644 50 : case BIT_NOT_EXPR:
5645 50 : {
5646 50 : tree _q30 = TREE_OPERAND (_q20, 0);
5647 50 : switch (TREE_CODE (_p1))
5648 : {
5649 0 : CASE_CONVERT:
5650 0 : {
5651 0 : tree _q50 = TREE_OPERAND (_p1, 0);
5652 0 : switch (TREE_CODE (_q50))
5653 : {
5654 0 : case BIT_NOT_EXPR:
5655 0 : {
5656 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5657 0 : {
5658 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q60 };
5659 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5660 0 : if (res) return res;
5661 : }
5662 0 : break;
5663 : }
5664 : default:;
5665 : }
5666 : break;
5667 : }
5668 0 : case BIT_NOT_EXPR:
5669 0 : {
5670 0 : tree _q50 = TREE_OPERAND (_p1, 0);
5671 0 : {
5672 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q50 };
5673 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5674 0 : if (res) return res;
5675 : }
5676 0 : break;
5677 : }
5678 26 : case INTEGER_CST:
5679 26 : {
5680 26 : {
5681 26 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p1 };
5682 26 : tree res = generic_simplify_25 (loc, type, _p0, _p1, captures);
5683 26 : if (res) return res;
5684 : }
5685 24 : break;
5686 : }
5687 : default:;
5688 : }
5689 : break;
5690 : }
5691 : default:;
5692 : }
5693 : break;
5694 : }
5695 484 : case BIT_NOT_EXPR:
5696 484 : {
5697 484 : tree _q20 = TREE_OPERAND (_p0, 0);
5698 484 : switch (TREE_CODE (_p1))
5699 : {
5700 18 : CASE_CONVERT:
5701 18 : {
5702 18 : tree _q40 = TREE_OPERAND (_p1, 0);
5703 18 : switch (TREE_CODE (_q40))
5704 : {
5705 0 : case BIT_NOT_EXPR:
5706 0 : {
5707 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5708 0 : {
5709 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
5710 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5711 0 : if (res) return res;
5712 : }
5713 0 : break;
5714 : }
5715 : default:;
5716 : }
5717 : break;
5718 : }
5719 10 : case BIT_NOT_EXPR:
5720 10 : {
5721 10 : tree _q40 = TREE_OPERAND (_p1, 0);
5722 10 : {
5723 10 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
5724 10 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5725 10 : if (res) return res;
5726 : }
5727 0 : break;
5728 : }
5729 31 : case INTEGER_CST:
5730 31 : {
5731 31 : {
5732 31 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
5733 31 : tree res = generic_simplify_25 (loc, type, _p0, _p1, captures);
5734 31 : if (res) return res;
5735 : }
5736 0 : break;
5737 : }
5738 443 : default:;
5739 : }
5740 443 : {
5741 443 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _p1 };
5742 443 : tree res = generic_simplify_26 (loc, type, _p0, _p1, captures);
5743 443 : if (res) return res;
5744 : }
5745 0 : break;
5746 : }
5747 4112 : case BIT_AND_EXPR:
5748 4112 : {
5749 4112 : tree _q20 = TREE_OPERAND (_p0, 0);
5750 4112 : tree _q21 = TREE_OPERAND (_p0, 1);
5751 4112 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5752 : {
5753 75 : {
5754 75 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
5755 75 : tree res = generic_simplify_27 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5756 75 : if (res) return res;
5757 : }
5758 : }
5759 4037 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5760 : {
5761 3 : {
5762 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
5763 3 : tree res = generic_simplify_27 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5764 3 : if (res) return res;
5765 : }
5766 : }
5767 4034 : switch (TREE_CODE (_p1))
5768 : {
5769 353 : case BIT_AND_EXPR:
5770 353 : {
5771 353 : tree _q50 = TREE_OPERAND (_p1, 0);
5772 353 : tree _q51 = TREE_OPERAND (_p1, 1);
5773 353 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
5774 : {
5775 21 : {
5776 21 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q51, _q20 };
5777 21 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5778 21 : if (res) return res;
5779 : }
5780 : }
5781 332 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
5782 : {
5783 0 : {
5784 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q20 };
5785 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5786 0 : if (res) return res;
5787 : }
5788 : }
5789 332 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q21, 0))
5790 : {
5791 0 : {
5792 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q51, _q21 };
5793 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5794 0 : if (res) return res;
5795 : }
5796 : }
5797 332 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q21, 0))
5798 : {
5799 201 : {
5800 201 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q50, _q21 };
5801 201 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5802 201 : if (res) return res;
5803 : }
5804 : }
5805 : break;
5806 : }
5807 : default:;
5808 : }
5809 : break;
5810 : }
5811 1047026 : default:;
5812 : }
5813 1047026 : switch (TREE_CODE (_p1))
5814 : {
5815 608 : case BIT_AND_EXPR:
5816 608 : {
5817 608 : tree _q30 = TREE_OPERAND (_p1, 0);
5818 608 : tree _q31 = TREE_OPERAND (_p1, 1);
5819 608 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5820 : {
5821 0 : {
5822 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
5823 0 : tree res = generic_simplify_27 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5824 0 : if (res) return res;
5825 : }
5826 : }
5827 608 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5828 : {
5829 1 : {
5830 1 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q31, _p0 };
5831 1 : tree res = generic_simplify_27 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5832 1 : if (res) return res;
5833 : }
5834 : }
5835 : break;
5836 : }
5837 1047025 : default:;
5838 : }
5839 1047025 : switch (TREE_CODE (_p0))
5840 : {
5841 676248 : CASE_CONVERT:
5842 676248 : {
5843 676248 : tree _q20 = TREE_OPERAND (_p0, 0);
5844 676248 : switch (TREE_CODE (_q20))
5845 : {
5846 80 : case BIT_AND_EXPR:
5847 80 : {
5848 80 : tree _q30 = TREE_OPERAND (_q20, 0);
5849 80 : tree _q31 = TREE_OPERAND (_q20, 1);
5850 80 : switch (TREE_CODE (_p1))
5851 : {
5852 8 : CASE_CONVERT:
5853 8 : {
5854 8 : tree _q60 = TREE_OPERAND (_p1, 0);
5855 8 : switch (TREE_CODE (_q60))
5856 : {
5857 0 : case BIT_AND_EXPR:
5858 0 : {
5859 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5860 0 : tree _q71 = TREE_OPERAND (_q60, 1);
5861 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || operand_equal_p (_q70, _q30, 0))
5862 : {
5863 0 : {
5864 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q71, _q30 };
5865 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5866 0 : if (res) return res;
5867 : }
5868 : }
5869 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || operand_equal_p (_q71, _q30, 0))
5870 : {
5871 0 : {
5872 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q70, _q30 };
5873 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5874 0 : if (res) return res;
5875 : }
5876 : }
5877 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || operand_equal_p (_q70, _q31, 0))
5878 : {
5879 0 : {
5880 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q31, _q30, _q71, _q31 };
5881 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5882 0 : if (res) return res;
5883 : }
5884 : }
5885 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || operand_equal_p (_q71, _q31, 0))
5886 : {
5887 0 : {
5888 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q31, _q30, _q70, _q31 };
5889 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5890 0 : if (res) return res;
5891 : }
5892 : }
5893 : break;
5894 : }
5895 : default:;
5896 : }
5897 : break;
5898 : }
5899 : default:;
5900 : }
5901 : break;
5902 : }
5903 63399 : case BIT_XOR_EXPR:
5904 63399 : {
5905 63399 : tree _q30 = TREE_OPERAND (_q20, 0);
5906 63399 : tree _q31 = TREE_OPERAND (_q20, 1);
5907 63399 : switch (TREE_CODE (_p1))
5908 : {
5909 63327 : CASE_CONVERT:
5910 63327 : {
5911 63327 : tree _q60 = TREE_OPERAND (_p1, 0);
5912 63327 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q31, 0))
5913 : {
5914 0 : {
5915 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q31 };
5916 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5917 0 : if (res) return res;
5918 : }
5919 : }
5920 63327 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q30, 0))
5921 : {
5922 0 : {
5923 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q30 };
5924 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5925 0 : if (res) return res;
5926 : }
5927 : }
5928 : break;
5929 : }
5930 63399 : default:;
5931 : }
5932 63399 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q31, 0))
5933 : {
5934 0 : {
5935 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q31 };
5936 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5937 0 : if (res) return res;
5938 : }
5939 : }
5940 63399 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q30, 0))
5941 : {
5942 0 : {
5943 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q30 };
5944 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5945 0 : if (res) return res;
5946 : }
5947 : }
5948 : break;
5949 : }
5950 676248 : default:;
5951 : }
5952 676248 : switch (TREE_CODE (_p1))
5953 : {
5954 672209 : CASE_CONVERT:
5955 672209 : {
5956 672209 : tree _q40 = TREE_OPERAND (_p1, 0);
5957 672209 : switch (TREE_CODE (_q40))
5958 : {
5959 0 : case BIT_XOR_EXPR:
5960 0 : {
5961 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5962 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5963 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
5964 : {
5965 0 : {
5966 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
5967 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5968 0 : if (res) return res;
5969 : }
5970 : }
5971 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
5972 : {
5973 0 : {
5974 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q50, _q20 };
5975 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5976 0 : if (res) return res;
5977 : }
5978 : }
5979 : break;
5980 : }
5981 : default:;
5982 : }
5983 : break;
5984 : }
5985 2 : case BIT_XOR_EXPR:
5986 2 : {
5987 2 : tree _q40 = TREE_OPERAND (_p1, 0);
5988 2 : tree _q41 = TREE_OPERAND (_p1, 1);
5989 2 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _q20, 0))
5990 : {
5991 0 : {
5992 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q20 };
5993 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5994 0 : if (res) return res;
5995 : }
5996 : }
5997 2 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _q20, 0))
5998 : {
5999 0 : {
6000 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q20 };
6001 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
6002 0 : if (res) return res;
6003 : }
6004 : }
6005 : break;
6006 : }
6007 : default:;
6008 : }
6009 : break;
6010 : }
6011 1047025 : default:;
6012 : }
6013 1047025 : switch (TREE_CODE (_p1))
6014 : {
6015 806621 : CASE_CONVERT:
6016 806621 : {
6017 806621 : tree _q30 = TREE_OPERAND (_p1, 0);
6018 806621 : switch (TREE_CODE (_q30))
6019 : {
6020 8 : case BIT_XOR_EXPR:
6021 8 : {
6022 8 : tree _q40 = TREE_OPERAND (_q30, 0);
6023 8 : tree _q41 = TREE_OPERAND (_q30, 1);
6024 8 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _p0, 0))
6025 : {
6026 0 : {
6027 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _p0 };
6028 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
6029 0 : if (res) return res;
6030 : }
6031 : }
6032 8 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _p0, 0))
6033 : {
6034 0 : {
6035 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _p0 };
6036 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
6037 0 : if (res) return res;
6038 : }
6039 : }
6040 : break;
6041 : }
6042 : default:;
6043 : }
6044 : break;
6045 : }
6046 86 : case BIT_XOR_EXPR:
6047 86 : {
6048 86 : tree _q30 = TREE_OPERAND (_p1, 0);
6049 86 : tree _q31 = TREE_OPERAND (_p1, 1);
6050 86 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || operand_equal_p (_q31, _p0, 0))
6051 : {
6052 0 : {
6053 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
6054 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
6055 0 : if (res) return res;
6056 : }
6057 : }
6058 86 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || operand_equal_p (_q30, _p0, 0))
6059 : {
6060 0 : {
6061 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _p0 };
6062 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
6063 0 : if (res) return res;
6064 : }
6065 : }
6066 : break;
6067 : }
6068 1047025 : default:;
6069 : }
6070 1047025 : switch (TREE_CODE (_p0))
6071 : {
6072 676248 : CASE_CONVERT:
6073 676248 : {
6074 676248 : tree _q20 = TREE_OPERAND (_p0, 0);
6075 676248 : switch (TREE_CODE (_q20))
6076 : {
6077 63399 : case BIT_XOR_EXPR:
6078 63399 : {
6079 63399 : tree _q30 = TREE_OPERAND (_q20, 0);
6080 63399 : tree _q31 = TREE_OPERAND (_q20, 1);
6081 63399 : switch (TREE_CODE (_p1))
6082 : {
6083 63327 : CASE_CONVERT:
6084 63327 : {
6085 63327 : tree _q60 = TREE_OPERAND (_p1, 0);
6086 63327 : switch (TREE_CODE (_q60))
6087 : {
6088 0 : case BIT_XOR_EXPR:
6089 0 : {
6090 0 : tree _q70 = TREE_OPERAND (_q60, 0);
6091 0 : tree _q71 = TREE_OPERAND (_q60, 1);
6092 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
6093 : {
6094 0 : {
6095 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q71 };
6096 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures);
6097 0 : if (res) return res;
6098 : }
6099 : }
6100 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
6101 : {
6102 0 : {
6103 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q70 };
6104 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures);
6105 0 : if (res) return res;
6106 : }
6107 : }
6108 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
6109 : {
6110 0 : {
6111 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q71 };
6112 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures);
6113 0 : if (res) return res;
6114 : }
6115 : }
6116 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
6117 : {
6118 0 : {
6119 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q70 };
6120 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures);
6121 0 : if (res) return res;
6122 : }
6123 : }
6124 : break;
6125 : }
6126 : default:;
6127 : }
6128 : break;
6129 : }
6130 0 : case BIT_XOR_EXPR:
6131 0 : {
6132 0 : tree _q60 = TREE_OPERAND (_p1, 0);
6133 0 : tree _q61 = TREE_OPERAND (_p1, 1);
6134 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
6135 : {
6136 0 : {
6137 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q61 };
6138 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures);
6139 0 : if (res) return res;
6140 : }
6141 : }
6142 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
6143 : {
6144 0 : {
6145 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q60 };
6146 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures);
6147 0 : if (res) return res;
6148 : }
6149 : }
6150 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
6151 : {
6152 0 : {
6153 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q61 };
6154 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures);
6155 0 : if (res) return res;
6156 : }
6157 : }
6158 0 : if ((_q61 == _q31 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q31, 0) && types_match (_q61, _q31)))
6159 : {
6160 0 : {
6161 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q60 };
6162 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures);
6163 0 : if (res) return res;
6164 : }
6165 : }
6166 : break;
6167 : }
6168 : default:;
6169 : }
6170 : break;
6171 : }
6172 676248 : default:;
6173 : }
6174 676248 : switch (TREE_CODE (_p1))
6175 : {
6176 672209 : CASE_CONVERT:
6177 672209 : {
6178 672209 : tree _q40 = TREE_OPERAND (_p1, 0);
6179 672209 : {
6180 672209 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
6181 672209 : tree res = generic_simplify_30 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
6182 672209 : if (res) return res;
6183 : }
6184 580641 : break;
6185 : }
6186 584680 : default:;
6187 : }
6188 584680 : {
6189 584680 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
6190 584680 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
6191 584680 : if (res) return res;
6192 : }
6193 584572 : break;
6194 : }
6195 4052 : case BIT_XOR_EXPR:
6196 4052 : {
6197 4052 : tree _q20 = TREE_OPERAND (_p0, 0);
6198 4052 : tree _q21 = TREE_OPERAND (_p0, 1);
6199 4052 : switch (TREE_CODE (_p1))
6200 : {
6201 202 : CASE_CONVERT:
6202 202 : {
6203 202 : tree _q50 = TREE_OPERAND (_p1, 0);
6204 202 : switch (TREE_CODE (_q50))
6205 : {
6206 0 : case BIT_XOR_EXPR:
6207 0 : {
6208 0 : tree _q60 = TREE_OPERAND (_q50, 0);
6209 0 : tree _q61 = TREE_OPERAND (_q50, 1);
6210 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6211 : {
6212 0 : {
6213 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q61 };
6214 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures);
6215 0 : if (res) return res;
6216 : }
6217 : }
6218 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
6219 : {
6220 0 : {
6221 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q60 };
6222 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures);
6223 0 : if (res) return res;
6224 : }
6225 : }
6226 0 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
6227 : {
6228 0 : {
6229 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q61 };
6230 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures);
6231 0 : if (res) return res;
6232 : }
6233 : }
6234 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
6235 : {
6236 0 : {
6237 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q60 };
6238 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures);
6239 0 : if (res) return res;
6240 : }
6241 : }
6242 : break;
6243 : }
6244 : default:;
6245 : }
6246 : break;
6247 : }
6248 18 : case BIT_XOR_EXPR:
6249 18 : {
6250 18 : tree _q50 = TREE_OPERAND (_p1, 0);
6251 18 : tree _q51 = TREE_OPERAND (_p1, 1);
6252 18 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6253 : {
6254 0 : {
6255 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
6256 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures);
6257 0 : if (res) return res;
6258 : }
6259 : }
6260 18 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6261 : {
6262 0 : {
6263 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
6264 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures);
6265 0 : if (res) return res;
6266 : }
6267 : }
6268 18 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6269 : {
6270 0 : {
6271 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
6272 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures);
6273 0 : if (res) return res;
6274 : }
6275 : }
6276 18 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6277 : {
6278 0 : {
6279 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
6280 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures);
6281 0 : if (res) return res;
6282 : }
6283 : }
6284 : break;
6285 : }
6286 : default:;
6287 : }
6288 : break;
6289 : }
6290 3812 : case BIT_AND_EXPR:
6291 3812 : {
6292 3812 : tree _q20 = TREE_OPERAND (_p0, 0);
6293 3812 : tree _q21 = TREE_OPERAND (_p0, 1);
6294 3812 : {
6295 3812 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6296 3812 : tree res = generic_simplify_32 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR, BIT_IOR_EXPR);
6297 3812 : if (res) return res;
6298 : }
6299 3812 : {
6300 3812 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _p1 };
6301 3812 : tree res = generic_simplify_32 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR, BIT_IOR_EXPR);
6302 3812 : if (res) return res;
6303 : }
6304 3812 : if (tree_truth_valued_p (_q20))
6305 : {
6306 0 : if (tree_truth_valued_p (_q21))
6307 : {
6308 0 : switch (TREE_CODE (_p1))
6309 : {
6310 0 : case EQ_EXPR:
6311 0 : {
6312 0 : tree _q50 = TREE_OPERAND (_p1, 0);
6313 0 : tree _q51 = TREE_OPERAND (_p1, 1);
6314 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6315 : {
6316 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6317 : {
6318 0 : {
6319 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6320 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6321 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
6322 : )
6323 : {
6324 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1180;
6325 0 : {
6326 0 : tree res_op0;
6327 0 : {
6328 0 : tree _o1[1], _r1;
6329 0 : {
6330 0 : tree _o2[2], _r2;
6331 0 : _o2[0] = captures[0];
6332 0 : _o2[1] = captures[1];
6333 0 : _r2 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
6334 0 : _o1[0] = _r2;
6335 : }
6336 0 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
6337 0 : res_op0 = _r1;
6338 : }
6339 0 : tree _r;
6340 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
6341 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 902, __FILE__, __LINE__, true);
6342 0 : return _r;
6343 : }
6344 0 : next_after_fail1180:;
6345 : }
6346 : else
6347 : {
6348 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1181;
6349 0 : {
6350 0 : tree res_op0;
6351 0 : {
6352 0 : tree _o1[2], _r1;
6353 0 : {
6354 0 : tree _o2[2], _r2;
6355 0 : _o2[0] = captures[0];
6356 0 : _o2[1] = captures[1];
6357 0 : _r2 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
6358 0 : _o1[0] = _r2;
6359 : }
6360 0 : _o1[1] = build_one_cst (TREE_TYPE (captures[0]));
6361 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
6362 0 : res_op0 = _r1;
6363 : }
6364 0 : tree _r;
6365 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
6366 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 903, __FILE__, __LINE__, true);
6367 0 : return _r;
6368 : }
6369 0 : next_after_fail1181:;
6370 : }
6371 : }
6372 : }
6373 : }
6374 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6375 : {
6376 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6377 : {
6378 0 : {
6379 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6380 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6381 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
6382 : )
6383 : {
6384 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1182;
6385 0 : {
6386 0 : tree res_op0;
6387 0 : {
6388 0 : tree _o1[1], _r1;
6389 0 : {
6390 0 : tree _o2[2], _r2;
6391 0 : _o2[0] = captures[0];
6392 0 : _o2[1] = captures[1];
6393 0 : _r2 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
6394 0 : _o1[0] = _r2;
6395 : }
6396 0 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
6397 0 : res_op0 = _r1;
6398 : }
6399 0 : tree _r;
6400 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
6401 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 902, __FILE__, __LINE__, true);
6402 0 : return _r;
6403 : }
6404 0 : next_after_fail1182:;
6405 : }
6406 : else
6407 : {
6408 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1183;
6409 0 : {
6410 0 : tree res_op0;
6411 0 : {
6412 0 : tree _o1[2], _r1;
6413 0 : {
6414 0 : tree _o2[2], _r2;
6415 0 : _o2[0] = captures[0];
6416 0 : _o2[1] = captures[1];
6417 0 : _r2 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
6418 0 : _o1[0] = _r2;
6419 : }
6420 0 : _o1[1] = build_one_cst (TREE_TYPE (captures[0]));
6421 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
6422 0 : res_op0 = _r1;
6423 : }
6424 0 : tree _r;
6425 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
6426 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 903, __FILE__, __LINE__, true);
6427 0 : return _r;
6428 : }
6429 0 : next_after_fail1183:;
6430 : }
6431 : }
6432 : }
6433 : }
6434 : break;
6435 : }
6436 : default:;
6437 : }
6438 : }
6439 : }
6440 : break;
6441 : }
6442 955349 : default:;
6443 : }
6444 955349 : switch (TREE_CODE (_p1))
6445 : {
6446 607 : case BIT_AND_EXPR:
6447 607 : {
6448 607 : tree _q30 = TREE_OPERAND (_p1, 0);
6449 607 : tree _q31 = TREE_OPERAND (_p1, 1);
6450 607 : {
6451 607 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
6452 607 : tree res = generic_simplify_32 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR, BIT_IOR_EXPR);
6453 607 : if (res) return res;
6454 : }
6455 607 : {
6456 607 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _p0 };
6457 607 : tree res = generic_simplify_32 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR, BIT_IOR_EXPR);
6458 607 : if (res) return res;
6459 : }
6460 607 : break;
6461 : }
6462 955349 : default:;
6463 : }
6464 955349 : switch (TREE_CODE (_p0))
6465 : {
6466 4052 : case BIT_XOR_EXPR:
6467 4052 : {
6468 4052 : tree _q20 = TREE_OPERAND (_p0, 0);
6469 4052 : tree _q21 = TREE_OPERAND (_p0, 1);
6470 4052 : if (CONSTANT_CLASS_P (_q21))
6471 : {
6472 49 : if (CONSTANT_CLASS_P (_p1))
6473 : {
6474 30 : {
6475 30 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6476 30 : tree res = generic_simplify_33 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
6477 30 : if (res) return res;
6478 : }
6479 : }
6480 : }
6481 : break;
6482 : }
6483 70 : case COND_EXPR:
6484 70 : {
6485 70 : tree _q20 = TREE_OPERAND (_p0, 0);
6486 70 : tree _q21 = TREE_OPERAND (_p0, 1);
6487 70 : tree _q22 = TREE_OPERAND (_p0, 2);
6488 70 : if (integer_zerop (_q22))
6489 : {
6490 70 : switch (TREE_CODE (_p1))
6491 : {
6492 4 : case COND_EXPR:
6493 4 : {
6494 4 : tree _q60 = TREE_OPERAND (_p1, 0);
6495 4 : tree _q61 = TREE_OPERAND (_p1, 1);
6496 4 : tree _q62 = TREE_OPERAND (_p1, 2);
6497 4 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6498 : {
6499 0 : if (integer_zerop (_q61))
6500 : {
6501 0 : {
6502 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q62 };
6503 0 : const enum tree_code op = BIT_XOR_EXPR;
6504 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1184;
6505 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1184;
6506 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1184;
6507 0 : {
6508 0 : tree res_op0;
6509 0 : res_op0 = captures[1];
6510 0 : tree res_op1;
6511 0 : res_op1 = captures[2];
6512 0 : tree res_op2;
6513 0 : res_op2 = captures[4];
6514 0 : tree _r;
6515 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
6516 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 904, __FILE__, __LINE__, true);
6517 0 : return _r;
6518 : }
6519 0 : next_after_fail1184:;
6520 : }
6521 : }
6522 : }
6523 : break;
6524 : }
6525 : default:;
6526 : }
6527 : }
6528 70 : if (integer_zerop (_q21))
6529 : {
6530 0 : switch (TREE_CODE (_p1))
6531 : {
6532 0 : case COND_EXPR:
6533 0 : {
6534 0 : tree _q60 = TREE_OPERAND (_p1, 0);
6535 0 : tree _q61 = TREE_OPERAND (_p1, 1);
6536 0 : tree _q62 = TREE_OPERAND (_p1, 2);
6537 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6538 : {
6539 0 : if (integer_zerop (_q62))
6540 : {
6541 0 : {
6542 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q20, _q61, _p0, _q22 };
6543 0 : const enum tree_code op = BIT_XOR_EXPR;
6544 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1185;
6545 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1185;
6546 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1185;
6547 0 : {
6548 0 : tree res_op0;
6549 0 : res_op0 = captures[1];
6550 0 : tree res_op1;
6551 0 : res_op1 = captures[2];
6552 0 : tree res_op2;
6553 0 : res_op2 = captures[4];
6554 0 : tree _r;
6555 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
6556 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 904, __FILE__, __LINE__, true);
6557 0 : return _r;
6558 : }
6559 0 : next_after_fail1185:;
6560 : }
6561 : }
6562 : }
6563 : break;
6564 : }
6565 : default:;
6566 : }
6567 : }
6568 70 : switch (TREE_CODE (_q20))
6569 : {
6570 0 : case LT_EXPR:
6571 0 : {
6572 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6573 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6574 0 : if (zerop (_q22))
6575 : {
6576 0 : switch (TREE_CODE (_p1))
6577 : {
6578 0 : case COND_EXPR:
6579 0 : {
6580 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6581 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6582 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6583 0 : switch (TREE_CODE (_q80))
6584 : {
6585 0 : case GE_EXPR:
6586 0 : {
6587 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6588 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6589 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6590 : {
6591 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6592 : {
6593 0 : if (zerop (_q82))
6594 : {
6595 0 : {
6596 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6597 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LT_EXPR, GE_EXPR);
6598 0 : if (res) return res;
6599 : }
6600 : }
6601 : }
6602 : }
6603 : break;
6604 : }
6605 : default:;
6606 : }
6607 : break;
6608 : }
6609 : default:;
6610 : }
6611 : }
6612 : break;
6613 : }
6614 38 : case LE_EXPR:
6615 38 : {
6616 38 : tree _q30 = TREE_OPERAND (_q20, 0);
6617 38 : tree _q31 = TREE_OPERAND (_q20, 1);
6618 38 : if (zerop (_q22))
6619 : {
6620 38 : switch (TREE_CODE (_p1))
6621 : {
6622 0 : case COND_EXPR:
6623 0 : {
6624 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6625 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6626 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6627 0 : switch (TREE_CODE (_q80))
6628 : {
6629 0 : case GT_EXPR:
6630 0 : {
6631 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6632 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6633 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6634 : {
6635 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6636 : {
6637 0 : if (zerop (_q82))
6638 : {
6639 0 : {
6640 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6641 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LE_EXPR, GT_EXPR);
6642 0 : if (res) return res;
6643 : }
6644 : }
6645 : }
6646 : }
6647 : break;
6648 : }
6649 : default:;
6650 : }
6651 : break;
6652 : }
6653 : default:;
6654 : }
6655 : }
6656 : break;
6657 : }
6658 0 : case EQ_EXPR:
6659 0 : {
6660 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6661 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6662 0 : if (zerop (_q22))
6663 : {
6664 0 : switch (TREE_CODE (_p1))
6665 : {
6666 0 : case COND_EXPR:
6667 0 : {
6668 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6669 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6670 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6671 0 : switch (TREE_CODE (_q80))
6672 : {
6673 0 : case NE_EXPR:
6674 0 : {
6675 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6676 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6677 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6678 : {
6679 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6680 : {
6681 0 : if (zerop (_q82))
6682 : {
6683 0 : {
6684 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6685 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, EQ_EXPR, NE_EXPR);
6686 0 : if (res) return res;
6687 : }
6688 : }
6689 : }
6690 : }
6691 : break;
6692 : }
6693 : default:;
6694 : }
6695 : break;
6696 : }
6697 : default:;
6698 : }
6699 : }
6700 : break;
6701 : }
6702 32 : case NE_EXPR:
6703 32 : {
6704 32 : tree _q30 = TREE_OPERAND (_q20, 0);
6705 32 : tree _q31 = TREE_OPERAND (_q20, 1);
6706 32 : if (zerop (_q22))
6707 : {
6708 32 : switch (TREE_CODE (_p1))
6709 : {
6710 4 : case COND_EXPR:
6711 4 : {
6712 4 : tree _q80 = TREE_OPERAND (_p1, 0);
6713 4 : tree _q81 = TREE_OPERAND (_p1, 1);
6714 4 : tree _q82 = TREE_OPERAND (_p1, 2);
6715 4 : switch (TREE_CODE (_q80))
6716 : {
6717 0 : case EQ_EXPR:
6718 0 : {
6719 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6720 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6721 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6722 : {
6723 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6724 : {
6725 0 : if (zerop (_q82))
6726 : {
6727 0 : {
6728 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6729 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, NE_EXPR, EQ_EXPR);
6730 0 : if (res) return res;
6731 : }
6732 : }
6733 : }
6734 : }
6735 : break;
6736 : }
6737 : default:;
6738 : }
6739 : break;
6740 : }
6741 : default:;
6742 : }
6743 : }
6744 : break;
6745 : }
6746 0 : case GE_EXPR:
6747 0 : {
6748 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6749 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6750 0 : if (zerop (_q22))
6751 : {
6752 0 : switch (TREE_CODE (_p1))
6753 : {
6754 0 : case COND_EXPR:
6755 0 : {
6756 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6757 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6758 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6759 0 : switch (TREE_CODE (_q80))
6760 : {
6761 0 : case LT_EXPR:
6762 0 : {
6763 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6764 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6765 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6766 : {
6767 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6768 : {
6769 0 : if (zerop (_q82))
6770 : {
6771 0 : {
6772 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6773 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GE_EXPR, LT_EXPR);
6774 0 : if (res) return res;
6775 : }
6776 : }
6777 : }
6778 : }
6779 : break;
6780 : }
6781 : default:;
6782 : }
6783 : break;
6784 : }
6785 : default:;
6786 : }
6787 : }
6788 : break;
6789 : }
6790 0 : case GT_EXPR:
6791 0 : {
6792 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6793 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6794 0 : if (zerop (_q22))
6795 : {
6796 0 : switch (TREE_CODE (_p1))
6797 : {
6798 0 : case COND_EXPR:
6799 0 : {
6800 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6801 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6802 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6803 0 : switch (TREE_CODE (_q80))
6804 : {
6805 0 : case LE_EXPR:
6806 0 : {
6807 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6808 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6809 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6810 : {
6811 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6812 : {
6813 0 : if (zerop (_q82))
6814 : {
6815 0 : {
6816 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6817 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GT_EXPR, LE_EXPR);
6818 0 : if (res) return res;
6819 : }
6820 : }
6821 : }
6822 : }
6823 : break;
6824 : }
6825 : default:;
6826 : }
6827 : break;
6828 : }
6829 : default:;
6830 : }
6831 : }
6832 : break;
6833 : }
6834 0 : case UNORDERED_EXPR:
6835 0 : {
6836 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6837 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6838 0 : if (zerop (_q22))
6839 : {
6840 0 : switch (TREE_CODE (_p1))
6841 : {
6842 0 : case COND_EXPR:
6843 0 : {
6844 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6845 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6846 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6847 0 : switch (TREE_CODE (_q80))
6848 : {
6849 0 : case ORDERED_EXPR:
6850 0 : {
6851 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6852 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6853 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6854 : {
6855 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6856 : {
6857 0 : if (zerop (_q82))
6858 : {
6859 0 : {
6860 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6861 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNORDERED_EXPR, ORDERED_EXPR);
6862 0 : if (res) return res;
6863 : }
6864 : }
6865 : }
6866 : }
6867 : break;
6868 : }
6869 : default:;
6870 : }
6871 : break;
6872 : }
6873 : default:;
6874 : }
6875 : }
6876 : break;
6877 : }
6878 0 : case ORDERED_EXPR:
6879 0 : {
6880 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6881 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6882 0 : if (zerop (_q22))
6883 : {
6884 0 : switch (TREE_CODE (_p1))
6885 : {
6886 0 : case COND_EXPR:
6887 0 : {
6888 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6889 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6890 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6891 0 : switch (TREE_CODE (_q80))
6892 : {
6893 0 : case UNORDERED_EXPR:
6894 0 : {
6895 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6896 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6897 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6898 : {
6899 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6900 : {
6901 0 : if (zerop (_q82))
6902 : {
6903 0 : {
6904 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6905 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, ORDERED_EXPR, UNORDERED_EXPR);
6906 0 : if (res) return res;
6907 : }
6908 : }
6909 : }
6910 : }
6911 : break;
6912 : }
6913 : default:;
6914 : }
6915 : break;
6916 : }
6917 : default:;
6918 : }
6919 : }
6920 : break;
6921 : }
6922 0 : case UNLT_EXPR:
6923 0 : {
6924 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6925 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6926 0 : if (zerop (_q22))
6927 : {
6928 0 : switch (TREE_CODE (_p1))
6929 : {
6930 0 : case COND_EXPR:
6931 0 : {
6932 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6933 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6934 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6935 0 : switch (TREE_CODE (_q80))
6936 : {
6937 0 : case GE_EXPR:
6938 0 : {
6939 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6940 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6941 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6942 : {
6943 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6944 : {
6945 0 : if (zerop (_q82))
6946 : {
6947 0 : {
6948 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6949 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLT_EXPR, GE_EXPR);
6950 0 : if (res) return res;
6951 : }
6952 : }
6953 : }
6954 : }
6955 : break;
6956 : }
6957 : default:;
6958 : }
6959 : break;
6960 : }
6961 : default:;
6962 : }
6963 : }
6964 : break;
6965 : }
6966 0 : case UNLE_EXPR:
6967 0 : {
6968 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6969 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6970 0 : if (zerop (_q22))
6971 : {
6972 0 : switch (TREE_CODE (_p1))
6973 : {
6974 0 : case COND_EXPR:
6975 0 : {
6976 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6977 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6978 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6979 0 : switch (TREE_CODE (_q80))
6980 : {
6981 0 : case GT_EXPR:
6982 0 : {
6983 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6984 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6985 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6986 : {
6987 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6988 : {
6989 0 : if (zerop (_q82))
6990 : {
6991 0 : {
6992 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6993 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLE_EXPR, GT_EXPR);
6994 0 : if (res) return res;
6995 : }
6996 : }
6997 : }
6998 : }
6999 : break;
7000 : }
7001 : default:;
7002 : }
7003 : break;
7004 : }
7005 : default:;
7006 : }
7007 : }
7008 : break;
7009 : }
7010 0 : case UNGT_EXPR:
7011 0 : {
7012 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7013 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7014 0 : if (zerop (_q22))
7015 : {
7016 0 : switch (TREE_CODE (_p1))
7017 : {
7018 0 : case COND_EXPR:
7019 0 : {
7020 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7021 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7022 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7023 0 : switch (TREE_CODE (_q80))
7024 : {
7025 0 : case LE_EXPR:
7026 0 : {
7027 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7028 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7029 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7030 : {
7031 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7032 : {
7033 0 : if (zerop (_q82))
7034 : {
7035 0 : {
7036 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7037 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGT_EXPR, LE_EXPR);
7038 0 : if (res) return res;
7039 : }
7040 : }
7041 : }
7042 : }
7043 : break;
7044 : }
7045 : default:;
7046 : }
7047 : break;
7048 : }
7049 : default:;
7050 : }
7051 : }
7052 : break;
7053 : }
7054 0 : case UNGE_EXPR:
7055 0 : {
7056 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7057 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7058 0 : if (zerop (_q22))
7059 : {
7060 0 : switch (TREE_CODE (_p1))
7061 : {
7062 0 : case COND_EXPR:
7063 0 : {
7064 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7065 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7066 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7067 0 : switch (TREE_CODE (_q80))
7068 : {
7069 0 : case LT_EXPR:
7070 0 : {
7071 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7072 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7073 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7074 : {
7075 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7076 : {
7077 0 : if (zerop (_q82))
7078 : {
7079 0 : {
7080 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7081 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGE_EXPR, LT_EXPR);
7082 0 : if (res) return res;
7083 : }
7084 : }
7085 : }
7086 : }
7087 : break;
7088 : }
7089 : default:;
7090 : }
7091 : break;
7092 : }
7093 : default:;
7094 : }
7095 : }
7096 : break;
7097 : }
7098 0 : case UNEQ_EXPR:
7099 0 : {
7100 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7101 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7102 0 : if (zerop (_q22))
7103 : {
7104 0 : switch (TREE_CODE (_p1))
7105 : {
7106 0 : case COND_EXPR:
7107 0 : {
7108 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7109 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7110 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7111 0 : switch (TREE_CODE (_q80))
7112 : {
7113 0 : case LTGT_EXPR:
7114 0 : {
7115 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7116 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7117 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7118 : {
7119 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7120 : {
7121 0 : if (zerop (_q82))
7122 : {
7123 0 : {
7124 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7125 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNEQ_EXPR, LTGT_EXPR);
7126 0 : if (res) return res;
7127 : }
7128 : }
7129 : }
7130 : }
7131 : break;
7132 : }
7133 : default:;
7134 : }
7135 : break;
7136 : }
7137 : default:;
7138 : }
7139 : }
7140 : break;
7141 : }
7142 0 : case LTGT_EXPR:
7143 0 : {
7144 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7145 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7146 0 : if (zerop (_q22))
7147 : {
7148 0 : switch (TREE_CODE (_p1))
7149 : {
7150 0 : case COND_EXPR:
7151 0 : {
7152 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7153 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7154 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7155 0 : switch (TREE_CODE (_q80))
7156 : {
7157 0 : case UNEQ_EXPR:
7158 0 : {
7159 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7160 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7161 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7162 : {
7163 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7164 : {
7165 0 : if (zerop (_q82))
7166 : {
7167 0 : {
7168 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7169 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LTGT_EXPR, UNEQ_EXPR);
7170 0 : if (res) return res;
7171 : }
7172 : }
7173 : }
7174 : }
7175 : break;
7176 : }
7177 : default:;
7178 : }
7179 : break;
7180 : }
7181 : default:;
7182 : }
7183 : }
7184 : break;
7185 : }
7186 : default:;
7187 : }
7188 : break;
7189 : }
7190 1 : case VEC_COND_EXPR:
7191 1 : {
7192 1 : tree _q20 = TREE_OPERAND (_p0, 0);
7193 1 : tree _q21 = TREE_OPERAND (_p0, 1);
7194 1 : tree _q22 = TREE_OPERAND (_p0, 2);
7195 1 : if (integer_zerop (_q22))
7196 : {
7197 1 : switch (TREE_CODE (_p1))
7198 : {
7199 0 : case VEC_COND_EXPR:
7200 0 : {
7201 0 : tree _q60 = TREE_OPERAND (_p1, 0);
7202 0 : tree _q61 = TREE_OPERAND (_p1, 1);
7203 0 : tree _q62 = TREE_OPERAND (_p1, 2);
7204 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7205 : {
7206 0 : if (integer_zerop (_q61))
7207 : {
7208 0 : {
7209 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q62 };
7210 0 : const enum tree_code op = BIT_XOR_EXPR;
7211 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1186;
7212 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1186;
7213 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1186;
7214 0 : {
7215 0 : tree res_op0;
7216 0 : res_op0 = captures[1];
7217 0 : tree res_op1;
7218 0 : res_op1 = captures[2];
7219 0 : tree res_op2;
7220 0 : res_op2 = captures[4];
7221 0 : tree _r;
7222 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7223 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 904, __FILE__, __LINE__, true);
7224 0 : return _r;
7225 : }
7226 0 : next_after_fail1186:;
7227 : }
7228 : }
7229 : }
7230 : break;
7231 : }
7232 : default:;
7233 : }
7234 : }
7235 1 : if (integer_zerop (_q21))
7236 : {
7237 0 : switch (TREE_CODE (_p1))
7238 : {
7239 0 : case VEC_COND_EXPR:
7240 0 : {
7241 0 : tree _q60 = TREE_OPERAND (_p1, 0);
7242 0 : tree _q61 = TREE_OPERAND (_p1, 1);
7243 0 : tree _q62 = TREE_OPERAND (_p1, 2);
7244 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7245 : {
7246 0 : if (integer_zerop (_q62))
7247 : {
7248 0 : {
7249 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q20, _q61, _p0, _q22 };
7250 0 : const enum tree_code op = BIT_XOR_EXPR;
7251 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1187;
7252 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1187;
7253 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1187;
7254 0 : {
7255 0 : tree res_op0;
7256 0 : res_op0 = captures[1];
7257 0 : tree res_op1;
7258 0 : res_op1 = captures[2];
7259 0 : tree res_op2;
7260 0 : res_op2 = captures[4];
7261 0 : tree _r;
7262 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7263 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 904, __FILE__, __LINE__, true);
7264 0 : return _r;
7265 : }
7266 0 : next_after_fail1187:;
7267 : }
7268 : }
7269 : }
7270 : break;
7271 : }
7272 : default:;
7273 : }
7274 : }
7275 1 : switch (TREE_CODE (_q20))
7276 : {
7277 0 : case LT_EXPR:
7278 0 : {
7279 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7280 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7281 0 : if (integer_zerop (_q22))
7282 : {
7283 0 : switch (TREE_CODE (_p1))
7284 : {
7285 0 : case VEC_COND_EXPR:
7286 0 : {
7287 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7288 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7289 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7290 0 : switch (TREE_CODE (_q80))
7291 : {
7292 0 : case GE_EXPR:
7293 0 : {
7294 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7295 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7296 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7297 : {
7298 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7299 : {
7300 0 : if (integer_zerop (_q82))
7301 : {
7302 0 : {
7303 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7304 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LT_EXPR, GE_EXPR);
7305 0 : if (res) return res;
7306 : }
7307 : }
7308 : }
7309 : }
7310 : break;
7311 : }
7312 : default:;
7313 : }
7314 : break;
7315 : }
7316 : default:;
7317 : }
7318 : }
7319 : break;
7320 : }
7321 0 : case LE_EXPR:
7322 0 : {
7323 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7324 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7325 0 : if (integer_zerop (_q22))
7326 : {
7327 0 : switch (TREE_CODE (_p1))
7328 : {
7329 0 : case VEC_COND_EXPR:
7330 0 : {
7331 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7332 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7333 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7334 0 : switch (TREE_CODE (_q80))
7335 : {
7336 0 : case GT_EXPR:
7337 0 : {
7338 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7339 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7340 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7341 : {
7342 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7343 : {
7344 0 : if (integer_zerop (_q82))
7345 : {
7346 0 : {
7347 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7348 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LE_EXPR, GT_EXPR);
7349 0 : if (res) return res;
7350 : }
7351 : }
7352 : }
7353 : }
7354 : break;
7355 : }
7356 : default:;
7357 : }
7358 : break;
7359 : }
7360 : default:;
7361 : }
7362 : }
7363 : break;
7364 : }
7365 0 : case EQ_EXPR:
7366 0 : {
7367 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7368 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7369 0 : if (integer_zerop (_q22))
7370 : {
7371 0 : switch (TREE_CODE (_p1))
7372 : {
7373 0 : case VEC_COND_EXPR:
7374 0 : {
7375 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7376 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7377 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7378 0 : switch (TREE_CODE (_q80))
7379 : {
7380 0 : case NE_EXPR:
7381 0 : {
7382 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7383 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7384 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7385 : {
7386 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7387 : {
7388 0 : if (integer_zerop (_q82))
7389 : {
7390 0 : {
7391 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7392 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, EQ_EXPR, NE_EXPR);
7393 0 : if (res) return res;
7394 : }
7395 : }
7396 : }
7397 : }
7398 : break;
7399 : }
7400 : default:;
7401 : }
7402 : break;
7403 : }
7404 : default:;
7405 : }
7406 : }
7407 : break;
7408 : }
7409 1 : case NE_EXPR:
7410 1 : {
7411 1 : tree _q30 = TREE_OPERAND (_q20, 0);
7412 1 : tree _q31 = TREE_OPERAND (_q20, 1);
7413 1 : if (integer_zerop (_q22))
7414 : {
7415 1 : switch (TREE_CODE (_p1))
7416 : {
7417 0 : case VEC_COND_EXPR:
7418 0 : {
7419 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7420 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7421 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7422 0 : switch (TREE_CODE (_q80))
7423 : {
7424 0 : case EQ_EXPR:
7425 0 : {
7426 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7427 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7428 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7429 : {
7430 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7431 : {
7432 0 : if (integer_zerop (_q82))
7433 : {
7434 0 : {
7435 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7436 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, NE_EXPR, EQ_EXPR);
7437 0 : if (res) return res;
7438 : }
7439 : }
7440 : }
7441 : }
7442 : break;
7443 : }
7444 : default:;
7445 : }
7446 : break;
7447 : }
7448 : default:;
7449 : }
7450 : }
7451 : break;
7452 : }
7453 0 : case GE_EXPR:
7454 0 : {
7455 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7456 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7457 0 : if (integer_zerop (_q22))
7458 : {
7459 0 : switch (TREE_CODE (_p1))
7460 : {
7461 0 : case VEC_COND_EXPR:
7462 0 : {
7463 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7464 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7465 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7466 0 : switch (TREE_CODE (_q80))
7467 : {
7468 0 : case LT_EXPR:
7469 0 : {
7470 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7471 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7472 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7473 : {
7474 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7475 : {
7476 0 : if (integer_zerop (_q82))
7477 : {
7478 0 : {
7479 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7480 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GE_EXPR, LT_EXPR);
7481 0 : if (res) return res;
7482 : }
7483 : }
7484 : }
7485 : }
7486 : break;
7487 : }
7488 : default:;
7489 : }
7490 : break;
7491 : }
7492 : default:;
7493 : }
7494 : }
7495 : break;
7496 : }
7497 0 : case GT_EXPR:
7498 0 : {
7499 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7500 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7501 0 : if (integer_zerop (_q22))
7502 : {
7503 0 : switch (TREE_CODE (_p1))
7504 : {
7505 0 : case VEC_COND_EXPR:
7506 0 : {
7507 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7508 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7509 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7510 0 : switch (TREE_CODE (_q80))
7511 : {
7512 0 : case LE_EXPR:
7513 0 : {
7514 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7515 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7516 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7517 : {
7518 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7519 : {
7520 0 : if (integer_zerop (_q82))
7521 : {
7522 0 : {
7523 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7524 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GT_EXPR, LE_EXPR);
7525 0 : if (res) return res;
7526 : }
7527 : }
7528 : }
7529 : }
7530 : break;
7531 : }
7532 : default:;
7533 : }
7534 : break;
7535 : }
7536 : default:;
7537 : }
7538 : }
7539 : break;
7540 : }
7541 0 : case UNORDERED_EXPR:
7542 0 : {
7543 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7544 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7545 0 : if (integer_zerop (_q22))
7546 : {
7547 0 : switch (TREE_CODE (_p1))
7548 : {
7549 0 : case VEC_COND_EXPR:
7550 0 : {
7551 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7552 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7553 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7554 0 : switch (TREE_CODE (_q80))
7555 : {
7556 0 : case ORDERED_EXPR:
7557 0 : {
7558 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7559 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7560 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7561 : {
7562 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7563 : {
7564 0 : if (integer_zerop (_q82))
7565 : {
7566 0 : {
7567 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7568 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNORDERED_EXPR, ORDERED_EXPR);
7569 0 : if (res) return res;
7570 : }
7571 : }
7572 : }
7573 : }
7574 : break;
7575 : }
7576 : default:;
7577 : }
7578 : break;
7579 : }
7580 : default:;
7581 : }
7582 : }
7583 : break;
7584 : }
7585 0 : case ORDERED_EXPR:
7586 0 : {
7587 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7588 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7589 0 : if (integer_zerop (_q22))
7590 : {
7591 0 : switch (TREE_CODE (_p1))
7592 : {
7593 0 : case VEC_COND_EXPR:
7594 0 : {
7595 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7596 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7597 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7598 0 : switch (TREE_CODE (_q80))
7599 : {
7600 0 : case UNORDERED_EXPR:
7601 0 : {
7602 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7603 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7604 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7605 : {
7606 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7607 : {
7608 0 : if (integer_zerop (_q82))
7609 : {
7610 0 : {
7611 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7612 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, ORDERED_EXPR, UNORDERED_EXPR);
7613 0 : if (res) return res;
7614 : }
7615 : }
7616 : }
7617 : }
7618 : break;
7619 : }
7620 : default:;
7621 : }
7622 : break;
7623 : }
7624 : default:;
7625 : }
7626 : }
7627 : break;
7628 : }
7629 0 : case UNLT_EXPR:
7630 0 : {
7631 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7632 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7633 0 : if (integer_zerop (_q22))
7634 : {
7635 0 : switch (TREE_CODE (_p1))
7636 : {
7637 0 : case VEC_COND_EXPR:
7638 0 : {
7639 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7640 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7641 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7642 0 : switch (TREE_CODE (_q80))
7643 : {
7644 0 : case GE_EXPR:
7645 0 : {
7646 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7647 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7648 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7649 : {
7650 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7651 : {
7652 0 : if (integer_zerop (_q82))
7653 : {
7654 0 : {
7655 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7656 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLT_EXPR, GE_EXPR);
7657 0 : if (res) return res;
7658 : }
7659 : }
7660 : }
7661 : }
7662 : break;
7663 : }
7664 : default:;
7665 : }
7666 : break;
7667 : }
7668 : default:;
7669 : }
7670 : }
7671 : break;
7672 : }
7673 0 : case UNLE_EXPR:
7674 0 : {
7675 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7676 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7677 0 : if (integer_zerop (_q22))
7678 : {
7679 0 : switch (TREE_CODE (_p1))
7680 : {
7681 0 : case VEC_COND_EXPR:
7682 0 : {
7683 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7684 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7685 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7686 0 : switch (TREE_CODE (_q80))
7687 : {
7688 0 : case GT_EXPR:
7689 0 : {
7690 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7691 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7692 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7693 : {
7694 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7695 : {
7696 0 : if (integer_zerop (_q82))
7697 : {
7698 0 : {
7699 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7700 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLE_EXPR, GT_EXPR);
7701 0 : if (res) return res;
7702 : }
7703 : }
7704 : }
7705 : }
7706 : break;
7707 : }
7708 : default:;
7709 : }
7710 : break;
7711 : }
7712 : default:;
7713 : }
7714 : }
7715 : break;
7716 : }
7717 0 : case UNGT_EXPR:
7718 0 : {
7719 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7720 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7721 0 : if (integer_zerop (_q22))
7722 : {
7723 0 : switch (TREE_CODE (_p1))
7724 : {
7725 0 : case VEC_COND_EXPR:
7726 0 : {
7727 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7728 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7729 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7730 0 : switch (TREE_CODE (_q80))
7731 : {
7732 0 : case LE_EXPR:
7733 0 : {
7734 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7735 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7736 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7737 : {
7738 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7739 : {
7740 0 : if (integer_zerop (_q82))
7741 : {
7742 0 : {
7743 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7744 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGT_EXPR, LE_EXPR);
7745 0 : if (res) return res;
7746 : }
7747 : }
7748 : }
7749 : }
7750 : break;
7751 : }
7752 : default:;
7753 : }
7754 : break;
7755 : }
7756 : default:;
7757 : }
7758 : }
7759 : break;
7760 : }
7761 0 : case UNGE_EXPR:
7762 0 : {
7763 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7764 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7765 0 : if (integer_zerop (_q22))
7766 : {
7767 0 : switch (TREE_CODE (_p1))
7768 : {
7769 0 : case VEC_COND_EXPR:
7770 0 : {
7771 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7772 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7773 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7774 0 : switch (TREE_CODE (_q80))
7775 : {
7776 0 : case LT_EXPR:
7777 0 : {
7778 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7779 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7780 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7781 : {
7782 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7783 : {
7784 0 : if (integer_zerop (_q82))
7785 : {
7786 0 : {
7787 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7788 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGE_EXPR, LT_EXPR);
7789 0 : if (res) return res;
7790 : }
7791 : }
7792 : }
7793 : }
7794 : break;
7795 : }
7796 : default:;
7797 : }
7798 : break;
7799 : }
7800 : default:;
7801 : }
7802 : }
7803 : break;
7804 : }
7805 0 : case UNEQ_EXPR:
7806 0 : {
7807 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7808 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7809 0 : if (integer_zerop (_q22))
7810 : {
7811 0 : switch (TREE_CODE (_p1))
7812 : {
7813 0 : case VEC_COND_EXPR:
7814 0 : {
7815 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7816 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7817 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7818 0 : switch (TREE_CODE (_q80))
7819 : {
7820 0 : case LTGT_EXPR:
7821 0 : {
7822 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7823 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7824 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7825 : {
7826 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7827 : {
7828 0 : if (integer_zerop (_q82))
7829 : {
7830 0 : {
7831 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7832 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNEQ_EXPR, LTGT_EXPR);
7833 0 : if (res) return res;
7834 : }
7835 : }
7836 : }
7837 : }
7838 : break;
7839 : }
7840 : default:;
7841 : }
7842 : break;
7843 : }
7844 : default:;
7845 : }
7846 : }
7847 : break;
7848 : }
7849 0 : case LTGT_EXPR:
7850 0 : {
7851 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7852 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7853 0 : if (integer_zerop (_q22))
7854 : {
7855 0 : switch (TREE_CODE (_p1))
7856 : {
7857 0 : case VEC_COND_EXPR:
7858 0 : {
7859 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7860 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7861 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7862 0 : switch (TREE_CODE (_q80))
7863 : {
7864 0 : case UNEQ_EXPR:
7865 0 : {
7866 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7867 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7868 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7869 : {
7870 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7871 : {
7872 0 : if (integer_zerop (_q82))
7873 : {
7874 0 : {
7875 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7876 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LTGT_EXPR, UNEQ_EXPR);
7877 0 : if (res) return res;
7878 : }
7879 : }
7880 : }
7881 : }
7882 : break;
7883 : }
7884 : default:;
7885 : }
7886 : break;
7887 : }
7888 : default:;
7889 : }
7890 : }
7891 : break;
7892 : }
7893 : default:;
7894 : }
7895 : break;
7896 : }
7897 119 : case EQ_EXPR:
7898 119 : {
7899 119 : tree _q20 = TREE_OPERAND (_p0, 0);
7900 119 : tree _q21 = TREE_OPERAND (_p0, 1);
7901 119 : switch (TREE_CODE (_p1))
7902 : {
7903 0 : case BIT_AND_EXPR:
7904 0 : {
7905 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7906 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7907 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7908 : {
7909 0 : if (tree_truth_valued_p (_q50))
7910 : {
7911 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7912 : {
7913 0 : if (tree_truth_valued_p (_q51))
7914 : {
7915 0 : {
7916 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7917 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
7918 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
7919 : )
7920 : {
7921 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1188;
7922 0 : {
7923 0 : tree res_op0;
7924 0 : {
7925 0 : tree _o1[1], _r1;
7926 0 : {
7927 0 : tree _o2[2], _r2;
7928 0 : _o2[0] = captures[0];
7929 0 : _o2[1] = captures[1];
7930 0 : _r2 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
7931 0 : _o1[0] = _r2;
7932 : }
7933 0 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
7934 0 : res_op0 = _r1;
7935 : }
7936 0 : tree _r;
7937 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
7938 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 902, __FILE__, __LINE__, true);
7939 0 : return _r;
7940 : }
7941 0 : next_after_fail1188:;
7942 : }
7943 : else
7944 : {
7945 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1189;
7946 0 : {
7947 0 : tree res_op0;
7948 0 : {
7949 0 : tree _o1[2], _r1;
7950 0 : {
7951 0 : tree _o2[2], _r2;
7952 0 : _o2[0] = captures[0];
7953 0 : _o2[1] = captures[1];
7954 0 : _r2 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
7955 0 : _o1[0] = _r2;
7956 : }
7957 0 : _o1[1] = build_one_cst (TREE_TYPE (captures[0]));
7958 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
7959 0 : res_op0 = _r1;
7960 : }
7961 0 : tree _r;
7962 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
7963 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 903, __FILE__, __LINE__, true);
7964 0 : return _r;
7965 : }
7966 0 : next_after_fail1189:;
7967 : }
7968 : }
7969 : }
7970 : }
7971 : }
7972 : }
7973 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7974 : {
7975 0 : if (tree_truth_valued_p (_q50))
7976 : {
7977 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7978 : {
7979 0 : if (tree_truth_valued_p (_q51))
7980 : {
7981 0 : {
7982 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7983 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
7984 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
7985 : )
7986 : {
7987 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1190;
7988 0 : {
7989 0 : tree res_op0;
7990 0 : {
7991 0 : tree _o1[1], _r1;
7992 0 : {
7993 0 : tree _o2[2], _r2;
7994 0 : _o2[0] = captures[0];
7995 0 : _o2[1] = captures[1];
7996 0 : _r2 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
7997 0 : _o1[0] = _r2;
7998 : }
7999 0 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
8000 0 : res_op0 = _r1;
8001 : }
8002 0 : tree _r;
8003 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
8004 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 902, __FILE__, __LINE__, true);
8005 0 : return _r;
8006 : }
8007 0 : next_after_fail1190:;
8008 : }
8009 : else
8010 : {
8011 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1191;
8012 0 : {
8013 0 : tree res_op0;
8014 0 : {
8015 0 : tree _o1[2], _r1;
8016 0 : {
8017 0 : tree _o2[2], _r2;
8018 0 : _o2[0] = captures[0];
8019 0 : _o2[1] = captures[1];
8020 0 : _r2 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8021 0 : _o1[0] = _r2;
8022 : }
8023 0 : _o1[1] = build_one_cst (TREE_TYPE (captures[0]));
8024 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8025 0 : res_op0 = _r1;
8026 : }
8027 0 : tree _r;
8028 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
8029 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 903, __FILE__, __LINE__, true);
8030 0 : return _r;
8031 : }
8032 0 : next_after_fail1191:;
8033 : }
8034 : }
8035 : }
8036 : }
8037 : }
8038 : }
8039 : break;
8040 : }
8041 : default:;
8042 : }
8043 : break;
8044 : }
8045 955319 : default:;
8046 : }
8047 955319 : {
8048 955319 : tree _p0_pops[1];
8049 955319 : if (tree_logical_inverted_value (_p0, _p0_pops))
8050 : {
8051 52 : tree _q20 = _p0_pops[0];
8052 52 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
8053 : {
8054 4 : if (tree_truth_valued_p (_p1))
8055 : {
8056 4 : {
8057 4 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8058 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1192;
8059 4 : {
8060 4 : tree _r;
8061 4 : _r = constant_boolean_node (BIT_XOR_EXPR != EQ_EXPR, type);
8062 4 : if (TREE_SIDE_EFFECTS (captures[0]))
8063 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
8064 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 905, __FILE__, __LINE__, true);
8065 4 : return _r;
8066 : }
8067 0 : next_after_fail1192:;
8068 : }
8069 : }
8070 : }
8071 : }
8072 : }
8073 955315 : {
8074 955315 : tree _p0_pops[1];
8075 955315 : if (tree_nop_convert (_p0, _p0_pops))
8076 : {
8077 541968 : tree _q20 = _p0_pops[0];
8078 541968 : switch (TREE_CODE (_q20))
8079 : {
8080 24 : case BIT_NOT_EXPR:
8081 24 : {
8082 24 : tree _q30 = TREE_OPERAND (_q20, 0);
8083 24 : {
8084 24 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _p1 };
8085 24 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures);
8086 24 : if (res) return res;
8087 : }
8088 0 : break;
8089 : }
8090 20 : case MULT_EXPR:
8091 20 : {
8092 20 : tree _q30 = TREE_OPERAND (_q20, 0);
8093 20 : tree _q31 = TREE_OPERAND (_q20, 1);
8094 20 : {
8095 20 : tree _q30_pops[1];
8096 20 : if (tree_nop_convert (_q30, _q30_pops))
8097 : {
8098 0 : tree _q40 = _q30_pops[0];
8099 0 : switch (TREE_CODE (_q31))
8100 : {
8101 0 : case INTEGER_CST:
8102 0 : {
8103 0 : switch (TREE_CODE (_p1))
8104 : {
8105 0 : case LSHIFT_EXPR:
8106 0 : {
8107 0 : tree _q70 = TREE_OPERAND (_p1, 0);
8108 0 : tree _q71 = TREE_OPERAND (_p1, 1);
8109 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
8110 : {
8111 0 : switch (TREE_CODE (_q71))
8112 : {
8113 0 : case INTEGER_CST:
8114 0 : {
8115 0 : {
8116 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31, _p1, _q71 };
8117 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
8118 0 : if (res) return res;
8119 : }
8120 0 : break;
8121 : }
8122 : default:;
8123 : }
8124 : }
8125 : break;
8126 : }
8127 0 : default:;
8128 : }
8129 0 : {
8130 0 : tree _p1_pops[1];
8131 0 : if (tree_nop_convert (_p1, _p1_pops))
8132 : {
8133 0 : tree _q70 = _p1_pops[0];
8134 0 : switch (TREE_CODE (_q70))
8135 : {
8136 0 : case MULT_EXPR:
8137 0 : {
8138 0 : tree _q80 = TREE_OPERAND (_q70, 0);
8139 0 : tree _q81 = TREE_OPERAND (_q70, 1);
8140 0 : {
8141 0 : tree _q80_pops[1];
8142 0 : if (tree_nop_convert (_q80, _q80_pops))
8143 : {
8144 0 : tree _q90 = _q80_pops[0];
8145 0 : switch (TREE_CODE (_q81))
8146 : {
8147 0 : case INTEGER_CST:
8148 0 : {
8149 0 : {
8150 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31, _p1, _q70, _q90, _q81 };
8151 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
8152 0 : if (res) return res;
8153 : }
8154 0 : break;
8155 : }
8156 : default:;
8157 : }
8158 : }
8159 : }
8160 0 : break;
8161 : }
8162 : default:;
8163 : }
8164 : }
8165 : }
8166 0 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
8167 : {
8168 0 : {
8169 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31 };
8170 0 : tree res = generic_simplify_39 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
8171 0 : if (res) return res;
8172 : }
8173 : }
8174 : break;
8175 : }
8176 : default:;
8177 : }
8178 : }
8179 : }
8180 20 : break;
8181 : }
8182 : default:;
8183 : }
8184 : }
8185 : }
8186 955291 : if (tree_truth_valued_p (_p0))
8187 : {
8188 141958 : {
8189 141958 : tree _p1_pops[1];
8190 141958 : if (tree_logical_inverted_value (_p1, _p1_pops))
8191 : {
8192 13 : tree _q30 = _p1_pops[0];
8193 13 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
8194 : {
8195 0 : {
8196 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8197 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1193;
8198 0 : {
8199 0 : tree _r;
8200 0 : _r = constant_boolean_node (BIT_XOR_EXPR != EQ_EXPR, type);
8201 0 : if (TREE_SIDE_EFFECTS (captures[0]))
8202 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
8203 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 905, __FILE__, __LINE__, true);
8204 0 : return _r;
8205 : }
8206 0 : next_after_fail1193:;
8207 : }
8208 : }
8209 : }
8210 : }
8211 : }
8212 955291 : switch (TREE_CODE (_p1))
8213 : {
8214 288 : case BIT_NOT_EXPR:
8215 288 : {
8216 288 : tree _q30 = TREE_OPERAND (_p1, 0);
8217 288 : {
8218 288 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0 };
8219 288 : tree res = generic_simplify_26 (loc, type, _p0, _p1, captures);
8220 288 : if (res) return res;
8221 : }
8222 0 : break;
8223 : }
8224 955003 : default:;
8225 : }
8226 955003 : {
8227 955003 : tree _p1_pops[1];
8228 955003 : if (tree_nop_convert (_p1, _p1_pops))
8229 : {
8230 674925 : tree _q30 = _p1_pops[0];
8231 674925 : switch (TREE_CODE (_q30))
8232 : {
8233 0 : case BIT_NOT_EXPR:
8234 0 : {
8235 0 : tree _q40 = TREE_OPERAND (_q30, 0);
8236 0 : {
8237 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0 };
8238 0 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures);
8239 0 : if (res) return res;
8240 : }
8241 0 : break;
8242 : }
8243 : default:;
8244 : }
8245 : }
8246 : }
8247 955003 : switch (TREE_CODE (_p0))
8248 : {
8249 1131 : case BIT_IOR_EXPR:
8250 1131 : {
8251 1131 : tree _q20 = TREE_OPERAND (_p0, 0);
8252 1131 : tree _q21 = TREE_OPERAND (_p0, 1);
8253 1131 : switch (TREE_CODE (_q21))
8254 : {
8255 23 : case INTEGER_CST:
8256 23 : {
8257 23 : switch (TREE_CODE (_p1))
8258 : {
8259 23 : case INTEGER_CST:
8260 23 : {
8261 23 : {
8262 23 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
8263 23 : tree res = generic_simplify_40 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_XOR_EXPR);
8264 23 : if (res) return res;
8265 : }
8266 23 : break;
8267 : }
8268 : default:;
8269 : }
8270 : break;
8271 : }
8272 : default:;
8273 : }
8274 : break;
8275 : }
8276 90 : case LT_EXPR:
8277 90 : {
8278 90 : tree _q20 = TREE_OPERAND (_p0, 0);
8279 90 : tree _q21 = TREE_OPERAND (_p0, 1);
8280 90 : switch (TREE_CODE (_p1))
8281 : {
8282 0 : case GT_EXPR:
8283 0 : {
8284 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8285 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8286 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8287 : {
8288 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8289 : {
8290 0 : {
8291 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8292 0 : const enum tree_code cmp1 = LT_EXPR;
8293 0 : const enum tree_code cmp2 = GT_EXPR;
8294 0 : const enum tree_code rcmp = NE_EXPR;
8295 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8296 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8297 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8298 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8299 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8300 : )
8301 : {
8302 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1194;
8303 0 : {
8304 0 : tree res_op0;
8305 0 : res_op0 = captures[0];
8306 0 : tree res_op1;
8307 0 : res_op1 = captures[1];
8308 0 : tree _r;
8309 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8310 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
8311 0 : return _r;
8312 : }
8313 0 : next_after_fail1194:;
8314 : }
8315 : }
8316 : }
8317 : }
8318 : break;
8319 : }
8320 0 : case EQ_EXPR:
8321 0 : {
8322 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8323 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8324 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8325 : {
8326 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
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 = EQ_EXPR;
8332 0 : const enum tree_code rcmp = LE_EXPR;
8333 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8334 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8335 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8336 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8337 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8338 : )
8339 : {
8340 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1195;
8341 0 : {
8342 0 : tree res_op0;
8343 0 : res_op0 = captures[0];
8344 0 : tree res_op1;
8345 0 : res_op1 = captures[1];
8346 0 : tree _r;
8347 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8348 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
8349 0 : return _r;
8350 : }
8351 0 : next_after_fail1195:;
8352 : }
8353 : }
8354 : }
8355 : }
8356 : break;
8357 : }
8358 0 : case NE_EXPR:
8359 0 : {
8360 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8361 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8362 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8363 : {
8364 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8365 : {
8366 0 : {
8367 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8368 0 : const enum tree_code cmp1 = LT_EXPR;
8369 0 : const enum tree_code cmp2 = NE_EXPR;
8370 0 : const enum tree_code rcmp = GT_EXPR;
8371 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8372 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8373 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8374 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8375 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8376 : )
8377 : {
8378 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1196;
8379 0 : {
8380 0 : tree res_op0;
8381 0 : res_op0 = captures[0];
8382 0 : tree res_op1;
8383 0 : res_op1 = captures[1];
8384 0 : tree _r;
8385 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8386 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
8387 0 : return _r;
8388 : }
8389 0 : next_after_fail1196:;
8390 : }
8391 : }
8392 : }
8393 : }
8394 : break;
8395 : }
8396 : default:;
8397 : }
8398 : break;
8399 : }
8400 85 : case LE_EXPR:
8401 85 : {
8402 85 : tree _q20 = TREE_OPERAND (_p0, 0);
8403 85 : tree _q21 = TREE_OPERAND (_p0, 1);
8404 85 : switch (TREE_CODE (_p1))
8405 : {
8406 0 : case GE_EXPR:
8407 0 : {
8408 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8409 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8410 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8411 : {
8412 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8413 : {
8414 0 : {
8415 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8416 0 : const enum tree_code cmp1 = LE_EXPR;
8417 0 : const enum tree_code cmp2 = GE_EXPR;
8418 0 : const enum tree_code rcmp = NE_EXPR;
8419 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8420 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8421 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8422 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8423 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8424 : )
8425 : {
8426 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1197;
8427 0 : {
8428 0 : tree res_op0;
8429 0 : res_op0 = captures[0];
8430 0 : tree res_op1;
8431 0 : res_op1 = captures[1];
8432 0 : tree _r;
8433 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8434 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
8435 0 : return _r;
8436 : }
8437 0 : next_after_fail1197:;
8438 : }
8439 : }
8440 : }
8441 : }
8442 : break;
8443 : }
8444 0 : case EQ_EXPR:
8445 0 : {
8446 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8447 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8448 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8449 : {
8450 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8451 : {
8452 0 : {
8453 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8454 0 : const enum tree_code cmp1 = LE_EXPR;
8455 0 : const enum tree_code cmp2 = EQ_EXPR;
8456 0 : const enum tree_code rcmp = LT_EXPR;
8457 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8458 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8459 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8460 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8461 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8462 : )
8463 : {
8464 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1198;
8465 0 : {
8466 0 : tree res_op0;
8467 0 : res_op0 = captures[0];
8468 0 : tree res_op1;
8469 0 : res_op1 = captures[1];
8470 0 : tree _r;
8471 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8472 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
8473 0 : return _r;
8474 : }
8475 0 : next_after_fail1198:;
8476 : }
8477 : }
8478 : }
8479 : }
8480 : break;
8481 : }
8482 0 : case NE_EXPR:
8483 0 : {
8484 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8485 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8486 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8487 : {
8488 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8489 : {
8490 0 : {
8491 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8492 0 : const enum tree_code cmp1 = LE_EXPR;
8493 0 : const enum tree_code cmp2 = NE_EXPR;
8494 0 : const enum tree_code rcmp = GE_EXPR;
8495 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8496 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8497 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8498 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8499 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8500 : )
8501 : {
8502 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1199;
8503 0 : {
8504 0 : tree res_op0;
8505 0 : res_op0 = captures[0];
8506 0 : tree res_op1;
8507 0 : res_op1 = captures[1];
8508 0 : tree _r;
8509 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8510 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
8511 0 : return _r;
8512 : }
8513 0 : next_after_fail1199:;
8514 : }
8515 : }
8516 : }
8517 : }
8518 : break;
8519 : }
8520 : default:;
8521 : }
8522 : break;
8523 : }
8524 100 : case GT_EXPR:
8525 100 : {
8526 100 : tree _q20 = TREE_OPERAND (_p0, 0);
8527 100 : tree _q21 = TREE_OPERAND (_p0, 1);
8528 100 : switch (TREE_CODE (_p1))
8529 : {
8530 0 : case GT_EXPR:
8531 0 : {
8532 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8533 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8534 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8535 : {
8536 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8537 : {
8538 0 : {
8539 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8540 0 : const enum tree_code cmp1 = LT_EXPR;
8541 0 : const enum tree_code cmp2 = GT_EXPR;
8542 0 : const enum tree_code rcmp = NE_EXPR;
8543 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8544 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8545 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8546 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8547 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8548 : )
8549 : {
8550 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1200;
8551 0 : {
8552 0 : tree res_op0;
8553 0 : res_op0 = captures[0];
8554 0 : tree res_op1;
8555 0 : res_op1 = captures[1];
8556 0 : tree _r;
8557 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8558 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
8559 0 : return _r;
8560 : }
8561 0 : next_after_fail1200:;
8562 : }
8563 : }
8564 0 : {
8565 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8566 0 : const enum tree_code cmp1 = LT_EXPR;
8567 0 : const enum tree_code cmp2 = GT_EXPR;
8568 0 : const enum tree_code rcmp = NE_EXPR;
8569 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8570 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8571 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8572 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8573 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8574 : )
8575 : {
8576 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1201;
8577 0 : {
8578 0 : tree res_op0;
8579 0 : res_op0 = captures[0];
8580 0 : tree res_op1;
8581 0 : res_op1 = captures[1];
8582 0 : tree _r;
8583 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8584 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
8585 0 : return _r;
8586 : }
8587 0 : next_after_fail1201:;
8588 : }
8589 : }
8590 : }
8591 : }
8592 : break;
8593 : }
8594 0 : case EQ_EXPR:
8595 0 : {
8596 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8597 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8598 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8599 : {
8600 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8601 : {
8602 0 : {
8603 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8604 0 : const enum tree_code cmp1 = LT_EXPR;
8605 0 : const enum tree_code cmp2 = EQ_EXPR;
8606 0 : const enum tree_code rcmp = LE_EXPR;
8607 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8608 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8609 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8610 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8611 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8612 : )
8613 : {
8614 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1202;
8615 0 : {
8616 0 : tree res_op0;
8617 0 : res_op0 = captures[0];
8618 0 : tree res_op1;
8619 0 : res_op1 = captures[1];
8620 0 : tree _r;
8621 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8622 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
8623 0 : return _r;
8624 : }
8625 0 : next_after_fail1202:;
8626 : }
8627 : }
8628 : }
8629 : }
8630 : break;
8631 : }
8632 12 : case NE_EXPR:
8633 12 : {
8634 12 : tree _q50 = TREE_OPERAND (_p1, 0);
8635 12 : tree _q51 = TREE_OPERAND (_p1, 1);
8636 12 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8637 : {
8638 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8639 : {
8640 0 : {
8641 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8642 0 : const enum tree_code cmp1 = LT_EXPR;
8643 0 : const enum tree_code cmp2 = NE_EXPR;
8644 0 : const enum tree_code rcmp = GT_EXPR;
8645 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8646 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8647 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8648 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8649 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8650 : )
8651 : {
8652 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1203;
8653 0 : {
8654 0 : tree res_op0;
8655 0 : res_op0 = captures[0];
8656 0 : tree res_op1;
8657 0 : res_op1 = captures[1];
8658 0 : tree _r;
8659 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8660 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
8661 0 : return _r;
8662 : }
8663 0 : next_after_fail1203:;
8664 : }
8665 : }
8666 : }
8667 : }
8668 : break;
8669 : }
8670 0 : case LT_EXPR:
8671 0 : {
8672 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8673 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8674 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8675 : {
8676 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8677 : {
8678 0 : {
8679 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8680 0 : const enum tree_code cmp1 = LT_EXPR;
8681 0 : const enum tree_code cmp2 = GT_EXPR;
8682 0 : const enum tree_code rcmp = NE_EXPR;
8683 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8684 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8685 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8686 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8687 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8688 : )
8689 : {
8690 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1204;
8691 0 : {
8692 0 : tree res_op0;
8693 0 : res_op0 = captures[0];
8694 0 : tree res_op1;
8695 0 : res_op1 = captures[1];
8696 0 : tree _r;
8697 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8698 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
8699 0 : return _r;
8700 : }
8701 0 : next_after_fail1204:;
8702 : }
8703 : }
8704 : }
8705 : }
8706 : break;
8707 : }
8708 : default:;
8709 : }
8710 : break;
8711 : }
8712 62 : case GE_EXPR:
8713 62 : {
8714 62 : tree _q20 = TREE_OPERAND (_p0, 0);
8715 62 : tree _q21 = TREE_OPERAND (_p0, 1);
8716 62 : switch (TREE_CODE (_p1))
8717 : {
8718 1 : case GE_EXPR:
8719 1 : {
8720 1 : tree _q50 = TREE_OPERAND (_p1, 0);
8721 1 : tree _q51 = TREE_OPERAND (_p1, 1);
8722 1 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8723 : {
8724 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8725 : {
8726 0 : {
8727 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8728 0 : const enum tree_code cmp1 = LE_EXPR;
8729 0 : const enum tree_code cmp2 = GE_EXPR;
8730 0 : const enum tree_code rcmp = NE_EXPR;
8731 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8732 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8733 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8734 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8735 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8736 : )
8737 : {
8738 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1205;
8739 0 : {
8740 0 : tree res_op0;
8741 0 : res_op0 = captures[0];
8742 0 : tree res_op1;
8743 0 : res_op1 = captures[1];
8744 0 : tree _r;
8745 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8746 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
8747 0 : return _r;
8748 : }
8749 0 : next_after_fail1205:;
8750 : }
8751 : }
8752 0 : {
8753 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8754 0 : const enum tree_code cmp1 = LE_EXPR;
8755 0 : const enum tree_code cmp2 = GE_EXPR;
8756 0 : const enum tree_code rcmp = NE_EXPR;
8757 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8758 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8759 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8760 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8761 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8762 : )
8763 : {
8764 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1206;
8765 0 : {
8766 0 : tree res_op0;
8767 0 : res_op0 = captures[0];
8768 0 : tree res_op1;
8769 0 : res_op1 = captures[1];
8770 0 : tree _r;
8771 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8772 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
8773 0 : return _r;
8774 : }
8775 0 : next_after_fail1206:;
8776 : }
8777 : }
8778 : }
8779 : }
8780 : break;
8781 : }
8782 0 : case EQ_EXPR:
8783 0 : {
8784 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8785 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8786 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8787 : {
8788 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8789 : {
8790 0 : {
8791 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8792 0 : const enum tree_code cmp1 = LE_EXPR;
8793 0 : const enum tree_code cmp2 = EQ_EXPR;
8794 0 : const enum tree_code rcmp = LT_EXPR;
8795 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8796 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8797 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8798 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8799 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8800 : )
8801 : {
8802 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1207;
8803 0 : {
8804 0 : tree res_op0;
8805 0 : res_op0 = captures[0];
8806 0 : tree res_op1;
8807 0 : res_op1 = captures[1];
8808 0 : tree _r;
8809 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8810 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
8811 0 : return _r;
8812 : }
8813 0 : next_after_fail1207:;
8814 : }
8815 : }
8816 : }
8817 : }
8818 : break;
8819 : }
8820 8 : case NE_EXPR:
8821 8 : {
8822 8 : tree _q50 = TREE_OPERAND (_p1, 0);
8823 8 : tree _q51 = TREE_OPERAND (_p1, 1);
8824 8 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8825 : {
8826 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8827 : {
8828 0 : {
8829 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8830 0 : const enum tree_code cmp1 = LE_EXPR;
8831 0 : const enum tree_code cmp2 = NE_EXPR;
8832 0 : const enum tree_code rcmp = GE_EXPR;
8833 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8834 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8835 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8836 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8837 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8838 : )
8839 : {
8840 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1208;
8841 0 : {
8842 0 : tree res_op0;
8843 0 : res_op0 = captures[0];
8844 0 : tree res_op1;
8845 0 : res_op1 = captures[1];
8846 0 : tree _r;
8847 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8848 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
8849 0 : return _r;
8850 : }
8851 0 : next_after_fail1208:;
8852 : }
8853 : }
8854 : }
8855 : }
8856 : break;
8857 : }
8858 0 : case LE_EXPR:
8859 0 : {
8860 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8861 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8862 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8863 : {
8864 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8865 : {
8866 0 : {
8867 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8868 0 : const enum tree_code cmp1 = LE_EXPR;
8869 0 : const enum tree_code cmp2 = GE_EXPR;
8870 0 : const enum tree_code rcmp = NE_EXPR;
8871 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8872 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8873 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8874 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8875 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8876 : )
8877 : {
8878 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1209;
8879 0 : {
8880 0 : tree res_op0;
8881 0 : res_op0 = captures[0];
8882 0 : tree res_op1;
8883 0 : res_op1 = captures[1];
8884 0 : tree _r;
8885 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8886 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
8887 0 : return _r;
8888 : }
8889 0 : next_after_fail1209:;
8890 : }
8891 : }
8892 : }
8893 : }
8894 : break;
8895 : }
8896 : default:;
8897 : }
8898 : break;
8899 : }
8900 119 : case EQ_EXPR:
8901 119 : {
8902 119 : tree _q20 = TREE_OPERAND (_p0, 0);
8903 119 : tree _q21 = TREE_OPERAND (_p0, 1);
8904 119 : switch (TREE_CODE (_p1))
8905 : {
8906 0 : case LT_EXPR:
8907 0 : {
8908 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8909 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8910 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8911 : {
8912 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8913 : {
8914 0 : {
8915 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8916 0 : const enum tree_code cmp1 = LT_EXPR;
8917 0 : const enum tree_code cmp2 = EQ_EXPR;
8918 0 : const enum tree_code rcmp = LE_EXPR;
8919 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8920 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8921 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8922 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8923 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8924 : )
8925 : {
8926 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1210;
8927 0 : {
8928 0 : tree res_op0;
8929 0 : res_op0 = captures[0];
8930 0 : tree res_op1;
8931 0 : res_op1 = captures[1];
8932 0 : tree _r;
8933 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8934 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
8935 0 : return _r;
8936 : }
8937 0 : next_after_fail1210:;
8938 : }
8939 : }
8940 : }
8941 : }
8942 : break;
8943 : }
8944 0 : case LE_EXPR:
8945 0 : {
8946 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8947 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8948 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8949 : {
8950 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8951 : {
8952 0 : {
8953 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8954 0 : const enum tree_code cmp1 = LE_EXPR;
8955 0 : const enum tree_code cmp2 = EQ_EXPR;
8956 0 : const enum tree_code rcmp = LT_EXPR;
8957 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8958 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8959 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8960 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8961 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8962 : )
8963 : {
8964 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1211;
8965 0 : {
8966 0 : tree res_op0;
8967 0 : res_op0 = captures[0];
8968 0 : tree res_op1;
8969 0 : res_op1 = captures[1];
8970 0 : tree _r;
8971 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8972 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
8973 0 : return _r;
8974 : }
8975 0 : next_after_fail1211:;
8976 : }
8977 : }
8978 : }
8979 : }
8980 : break;
8981 : }
8982 0 : case GT_EXPR:
8983 0 : {
8984 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8985 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8986 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8987 : {
8988 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8989 : {
8990 0 : {
8991 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8992 0 : const enum tree_code cmp1 = LT_EXPR;
8993 0 : const enum tree_code cmp2 = EQ_EXPR;
8994 0 : const enum tree_code rcmp = LE_EXPR;
8995 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8996 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8997 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8998 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8999 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9000 : )
9001 : {
9002 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1212;
9003 0 : {
9004 0 : tree res_op0;
9005 0 : res_op0 = captures[0];
9006 0 : tree res_op1;
9007 0 : res_op1 = captures[1];
9008 0 : tree _r;
9009 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9010 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
9011 0 : return _r;
9012 : }
9013 0 : next_after_fail1212:;
9014 : }
9015 : }
9016 : }
9017 : }
9018 : break;
9019 : }
9020 8 : case GE_EXPR:
9021 8 : {
9022 8 : tree _q50 = TREE_OPERAND (_p1, 0);
9023 8 : tree _q51 = TREE_OPERAND (_p1, 1);
9024 8 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9025 : {
9026 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9027 : {
9028 0 : {
9029 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9030 0 : const enum tree_code cmp1 = LE_EXPR;
9031 0 : const enum tree_code cmp2 = EQ_EXPR;
9032 0 : const enum tree_code rcmp = LT_EXPR;
9033 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9034 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9035 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9036 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9037 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9038 : )
9039 : {
9040 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1213;
9041 0 : {
9042 0 : tree res_op0;
9043 0 : res_op0 = captures[0];
9044 0 : tree res_op1;
9045 0 : res_op1 = captures[1];
9046 0 : tree _r;
9047 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9048 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
9049 0 : return _r;
9050 : }
9051 0 : next_after_fail1213:;
9052 : }
9053 : }
9054 : }
9055 : }
9056 : break;
9057 : }
9058 : default:;
9059 : }
9060 : break;
9061 : }
9062 113 : case NE_EXPR:
9063 113 : {
9064 113 : tree _q20 = TREE_OPERAND (_p0, 0);
9065 113 : tree _q21 = TREE_OPERAND (_p0, 1);
9066 113 : switch (TREE_CODE (_p1))
9067 : {
9068 0 : case LT_EXPR:
9069 0 : {
9070 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9071 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9072 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9073 : {
9074 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9075 : {
9076 0 : {
9077 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9078 0 : const enum tree_code cmp1 = LT_EXPR;
9079 0 : const enum tree_code cmp2 = NE_EXPR;
9080 0 : const enum tree_code rcmp = GT_EXPR;
9081 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9082 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9083 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9084 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9085 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9086 : )
9087 : {
9088 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1214;
9089 0 : {
9090 0 : tree res_op0;
9091 0 : res_op0 = captures[0];
9092 0 : tree res_op1;
9093 0 : res_op1 = captures[1];
9094 0 : tree _r;
9095 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9096 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
9097 0 : return _r;
9098 : }
9099 0 : next_after_fail1214:;
9100 : }
9101 : }
9102 : }
9103 : }
9104 : break;
9105 : }
9106 0 : case LE_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 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9113 : {
9114 0 : {
9115 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9116 0 : const enum tree_code cmp1 = LE_EXPR;
9117 0 : const enum tree_code cmp2 = NE_EXPR;
9118 0 : const enum tree_code rcmp = GE_EXPR;
9119 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9120 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9121 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9122 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9123 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9124 : )
9125 : {
9126 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1215;
9127 0 : {
9128 0 : tree res_op0;
9129 0 : res_op0 = captures[0];
9130 0 : tree res_op1;
9131 0 : res_op1 = captures[1];
9132 0 : tree _r;
9133 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9134 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
9135 0 : return _r;
9136 : }
9137 0 : next_after_fail1215:;
9138 : }
9139 : }
9140 : }
9141 : }
9142 : break;
9143 : }
9144 0 : case GT_EXPR:
9145 0 : {
9146 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9147 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9148 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9149 : {
9150 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9151 : {
9152 0 : {
9153 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9154 0 : const enum tree_code cmp1 = LT_EXPR;
9155 0 : const enum tree_code cmp2 = NE_EXPR;
9156 0 : const enum tree_code rcmp = GT_EXPR;
9157 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9158 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9159 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9160 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9161 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9162 : )
9163 : {
9164 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1216;
9165 0 : {
9166 0 : tree res_op0;
9167 0 : res_op0 = captures[0];
9168 0 : tree res_op1;
9169 0 : res_op1 = captures[1];
9170 0 : tree _r;
9171 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9172 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
9173 0 : return _r;
9174 : }
9175 0 : next_after_fail1216:;
9176 : }
9177 : }
9178 : }
9179 : }
9180 : break;
9181 : }
9182 6 : case GE_EXPR:
9183 6 : {
9184 6 : tree _q50 = TREE_OPERAND (_p1, 0);
9185 6 : tree _q51 = TREE_OPERAND (_p1, 1);
9186 6 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9187 : {
9188 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9189 : {
9190 0 : {
9191 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9192 0 : const enum tree_code cmp1 = LE_EXPR;
9193 0 : const enum tree_code cmp2 = NE_EXPR;
9194 0 : const enum tree_code rcmp = GE_EXPR;
9195 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9196 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9197 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9198 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9199 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9200 : )
9201 : {
9202 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1217;
9203 0 : {
9204 0 : tree res_op0;
9205 0 : res_op0 = captures[0];
9206 0 : tree res_op1;
9207 0 : res_op1 = captures[1];
9208 0 : tree _r;
9209 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9210 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
9211 0 : return _r;
9212 : }
9213 0 : next_after_fail1217:;
9214 : }
9215 : }
9216 : }
9217 : }
9218 : break;
9219 : }
9220 : default:;
9221 : }
9222 : break;
9223 : }
9224 524 : case MULT_EXPR:
9225 524 : {
9226 524 : tree _q20 = TREE_OPERAND (_p0, 0);
9227 524 : tree _q21 = TREE_OPERAND (_p0, 1);
9228 524 : switch (TREE_CODE (_q21))
9229 : {
9230 498 : case INTEGER_CST:
9231 498 : {
9232 498 : switch (TREE_CODE (_p1))
9233 : {
9234 12 : case MULT_EXPR:
9235 12 : {
9236 12 : tree _q50 = TREE_OPERAND (_p1, 0);
9237 12 : tree _q51 = TREE_OPERAND (_p1, 1);
9238 12 : switch (TREE_CODE (_q51))
9239 : {
9240 12 : case INTEGER_CST:
9241 12 : {
9242 12 : {
9243 12 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1, _p1, _q50, _q51 };
9244 12 : tree res = generic_simplify_41 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9245 12 : if (res) return res;
9246 : }
9247 12 : break;
9248 : }
9249 : default:;
9250 : }
9251 : break;
9252 : }
9253 0 : case LSHIFT_EXPR:
9254 0 : {
9255 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9256 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9257 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9258 : {
9259 0 : switch (TREE_CODE (_q51))
9260 : {
9261 0 : case INTEGER_CST:
9262 0 : {
9263 0 : {
9264 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1, _q51 };
9265 0 : tree res = generic_simplify_42 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9266 0 : if (res) return res;
9267 : }
9268 0 : break;
9269 : }
9270 : default:;
9271 : }
9272 : }
9273 : break;
9274 : }
9275 498 : default:;
9276 : }
9277 498 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9278 : {
9279 18 : {
9280 18 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
9281 18 : tree res = generic_simplify_43 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9282 18 : if (res) return res;
9283 : }
9284 : }
9285 : break;
9286 : }
9287 524 : default:;
9288 : }
9289 524 : switch (TREE_CODE (_q20))
9290 : {
9291 0 : case BIT_XOR_EXPR:
9292 0 : {
9293 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9294 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9295 0 : if (tree_zero_one_valued_p (_q21))
9296 : {
9297 0 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
9298 : {
9299 0 : {
9300 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q21 };
9301 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
9302 0 : if (res) return res;
9303 : }
9304 : }
9305 0 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
9306 : {
9307 0 : {
9308 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q21 };
9309 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
9310 0 : if (res) return res;
9311 : }
9312 : }
9313 : }
9314 : break;
9315 : }
9316 524 : default:;
9317 : }
9318 524 : if (tree_zero_one_valued_p (_q20))
9319 : {
9320 8 : switch (TREE_CODE (_q21))
9321 : {
9322 2 : case BIT_XOR_EXPR:
9323 2 : {
9324 2 : tree _q40 = TREE_OPERAND (_q21, 0);
9325 2 : tree _q41 = TREE_OPERAND (_q21, 1);
9326 2 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
9327 : {
9328 2 : {
9329 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q20 };
9330 2 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
9331 2 : if (res) return res;
9332 : }
9333 : }
9334 0 : if ((_p1 == _q41 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q41, 0) && types_match (_p1, _q41)))
9335 : {
9336 0 : {
9337 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q20 };
9338 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
9339 0 : if (res) return res;
9340 : }
9341 : }
9342 : break;
9343 : }
9344 : default:;
9345 : }
9346 : }
9347 : break;
9348 : }
9349 2503 : case LSHIFT_EXPR:
9350 2503 : {
9351 2503 : tree _q20 = TREE_OPERAND (_p0, 0);
9352 2503 : tree _q21 = TREE_OPERAND (_p0, 1);
9353 2503 : switch (TREE_CODE (_q21))
9354 : {
9355 1122 : case INTEGER_CST:
9356 1122 : {
9357 1122 : switch (TREE_CODE (_p1))
9358 : {
9359 0 : case MULT_EXPR:
9360 0 : {
9361 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9362 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9363 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9364 : {
9365 0 : switch (TREE_CODE (_q51))
9366 : {
9367 0 : case INTEGER_CST:
9368 0 : {
9369 0 : {
9370 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _p1, _q20, _q51, _p0, _q21 };
9371 0 : tree res = generic_simplify_42 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9372 0 : if (res) return res;
9373 : }
9374 0 : break;
9375 : }
9376 : default:;
9377 : }
9378 : }
9379 : break;
9380 : }
9381 1122 : default:;
9382 : }
9383 1122 : {
9384 1122 : tree _p1_pops[1];
9385 1122 : if (tree_nop_convert (_p1, _p1_pops))
9386 : {
9387 23 : tree _q50 = _p1_pops[0];
9388 23 : switch (TREE_CODE (_q50))
9389 : {
9390 0 : case MULT_EXPR:
9391 0 : {
9392 0 : tree _q60 = TREE_OPERAND (_q50, 0);
9393 0 : tree _q61 = TREE_OPERAND (_q50, 1);
9394 0 : {
9395 0 : tree _q60_pops[1];
9396 0 : if (tree_nop_convert (_q60, _q60_pops))
9397 : {
9398 0 : tree _q70 = _q60_pops[0];
9399 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
9400 : {
9401 0 : switch (TREE_CODE (_q61))
9402 : {
9403 0 : case INTEGER_CST:
9404 0 : {
9405 0 : {
9406 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _q50, _q20, _q61, _p0, _q21 };
9407 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9408 0 : if (res) return res;
9409 : }
9410 0 : break;
9411 : }
9412 : default:;
9413 : }
9414 : }
9415 : }
9416 : }
9417 0 : break;
9418 : }
9419 : default:;
9420 : }
9421 : }
9422 : }
9423 1122 : break;
9424 : }
9425 : default:;
9426 : }
9427 : break;
9428 : }
9429 955001 : default:;
9430 : }
9431 955001 : switch (TREE_CODE (_p1))
9432 : {
9433 244 : case MULT_EXPR:
9434 244 : {
9435 244 : tree _q30 = TREE_OPERAND (_p1, 0);
9436 244 : tree _q31 = TREE_OPERAND (_p1, 1);
9437 244 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9438 : {
9439 0 : switch (TREE_CODE (_q31))
9440 : {
9441 0 : case INTEGER_CST:
9442 0 : {
9443 0 : {
9444 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _p0, _q31 };
9445 0 : tree res = generic_simplify_43 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9446 0 : if (res) return res;
9447 : }
9448 0 : break;
9449 : }
9450 : default:;
9451 : }
9452 : }
9453 : break;
9454 : }
9455 955001 : default:;
9456 : }
9457 955001 : {
9458 955001 : tree _p1_pops[1];
9459 955001 : if (tree_nop_convert (_p1, _p1_pops))
9460 : {
9461 674925 : tree _q30 = _p1_pops[0];
9462 674925 : switch (TREE_CODE (_q30))
9463 : {
9464 17 : case MULT_EXPR:
9465 17 : {
9466 17 : tree _q40 = TREE_OPERAND (_q30, 0);
9467 17 : tree _q41 = TREE_OPERAND (_q30, 1);
9468 17 : {
9469 17 : tree _q40_pops[1];
9470 17 : if (tree_nop_convert (_q40, _q40_pops))
9471 : {
9472 0 : tree _q50 = _q40_pops[0];
9473 0 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
9474 : {
9475 0 : switch (TREE_CODE (_q41))
9476 : {
9477 0 : case INTEGER_CST:
9478 0 : {
9479 0 : {
9480 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _p0, _q41 };
9481 0 : tree res = generic_simplify_39 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9482 0 : if (res) return res;
9483 : }
9484 0 : break;
9485 : }
9486 : default:;
9487 : }
9488 : }
9489 : }
9490 : }
9491 17 : break;
9492 : }
9493 : default:;
9494 : }
9495 : }
9496 : }
9497 955001 : switch (TREE_CODE (_p0))
9498 : {
9499 2503 : case LSHIFT_EXPR:
9500 2503 : {
9501 2503 : tree _q20 = TREE_OPERAND (_p0, 0);
9502 2503 : tree _q21 = TREE_OPERAND (_p0, 1);
9503 2503 : switch (TREE_CODE (_q21))
9504 : {
9505 1122 : case INTEGER_CST:
9506 1122 : {
9507 1122 : switch (TREE_CODE (_p1))
9508 : {
9509 9 : case LSHIFT_EXPR:
9510 9 : {
9511 9 : tree _q50 = TREE_OPERAND (_p1, 0);
9512 9 : tree _q51 = TREE_OPERAND (_p1, 1);
9513 9 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9514 : {
9515 3 : switch (TREE_CODE (_q51))
9516 : {
9517 3 : case INTEGER_CST:
9518 3 : {
9519 3 : {
9520 3 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
9521 3 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9522 3 : if (res) return res;
9523 : }
9524 1 : break;
9525 : }
9526 : default:;
9527 : }
9528 : }
9529 : break;
9530 : }
9531 1120 : default:;
9532 : }
9533 1120 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9534 : {
9535 57 : {
9536 57 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
9537 57 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9538 57 : if (res) return res;
9539 : }
9540 : }
9541 : break;
9542 : }
9543 : default:;
9544 : }
9545 : break;
9546 : }
9547 954999 : default:;
9548 : }
9549 954999 : switch (TREE_CODE (_p1))
9550 : {
9551 2000 : case LSHIFT_EXPR:
9552 2000 : {
9553 2000 : tree _q30 = TREE_OPERAND (_p1, 0);
9554 2000 : tree _q31 = TREE_OPERAND (_p1, 1);
9555 2000 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9556 : {
9557 3 : switch (TREE_CODE (_q31))
9558 : {
9559 3 : case INTEGER_CST:
9560 3 : {
9561 3 : {
9562 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q31 };
9563 3 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9564 3 : if (res) return res;
9565 : }
9566 0 : break;
9567 : }
9568 : default:;
9569 : }
9570 : }
9571 : break;
9572 : }
9573 954996 : default:;
9574 : }
9575 954996 : switch (TREE_CODE (_p0))
9576 : {
9577 0 : case MIN_EXPR:
9578 0 : {
9579 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9580 0 : tree _q21 = TREE_OPERAND (_p0, 1);
9581 0 : switch (TREE_CODE (_p1))
9582 : {
9583 0 : case MAX_EXPR:
9584 0 : {
9585 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9586 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9587 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9588 : {
9589 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9590 : {
9591 0 : {
9592 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9593 0 : if (!HONOR_NANS (captures[0])
9594 : )
9595 : {
9596 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1218;
9597 0 : {
9598 0 : tree res_op0;
9599 0 : res_op0 = captures[0];
9600 0 : tree res_op1;
9601 0 : res_op1 = captures[1];
9602 0 : tree _r;
9603 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
9604 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 907, __FILE__, __LINE__, true);
9605 0 : return _r;
9606 : }
9607 0 : next_after_fail1218:;
9608 : }
9609 : }
9610 : }
9611 : }
9612 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9613 : {
9614 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9615 : {
9616 0 : {
9617 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9618 0 : if (!HONOR_NANS (captures[0])
9619 : )
9620 : {
9621 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1219;
9622 0 : {
9623 0 : tree res_op0;
9624 0 : res_op0 = captures[0];
9625 0 : tree res_op1;
9626 0 : res_op1 = captures[1];
9627 0 : tree _r;
9628 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
9629 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 907, __FILE__, __LINE__, true);
9630 0 : return _r;
9631 : }
9632 0 : next_after_fail1219:;
9633 : }
9634 : }
9635 : }
9636 : }
9637 : break;
9638 : }
9639 : default:;
9640 : }
9641 : break;
9642 : }
9643 144 : case MAX_EXPR:
9644 144 : {
9645 144 : tree _q20 = TREE_OPERAND (_p0, 0);
9646 144 : tree _q21 = TREE_OPERAND (_p0, 1);
9647 144 : switch (TREE_CODE (_p1))
9648 : {
9649 0 : case MIN_EXPR:
9650 0 : {
9651 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9652 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9653 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9654 : {
9655 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9656 : {
9657 0 : {
9658 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9659 0 : if (!HONOR_NANS (captures[0])
9660 : )
9661 : {
9662 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1220;
9663 0 : {
9664 0 : tree res_op0;
9665 0 : res_op0 = captures[0];
9666 0 : tree res_op1;
9667 0 : res_op1 = captures[1];
9668 0 : tree _r;
9669 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
9670 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 907, __FILE__, __LINE__, true);
9671 0 : return _r;
9672 : }
9673 0 : next_after_fail1220:;
9674 : }
9675 : }
9676 : }
9677 : }
9678 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9679 : {
9680 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9681 : {
9682 0 : {
9683 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9684 0 : if (!HONOR_NANS (captures[0])
9685 : )
9686 : {
9687 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1221;
9688 0 : {
9689 0 : tree res_op0;
9690 0 : res_op0 = captures[0];
9691 0 : tree res_op1;
9692 0 : res_op1 = captures[1];
9693 0 : tree _r;
9694 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
9695 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 907, __FILE__, __LINE__, true);
9696 0 : return _r;
9697 : }
9698 0 : next_after_fail1221:;
9699 : }
9700 : }
9701 : }
9702 : }
9703 : break;
9704 : }
9705 : default:;
9706 : }
9707 : break;
9708 : }
9709 954996 : default:;
9710 : }
9711 954996 : switch (TREE_CODE (_p1))
9712 : {
9713 244 : case MULT_EXPR:
9714 244 : {
9715 244 : tree _q30 = TREE_OPERAND (_p1, 0);
9716 244 : tree _q31 = TREE_OPERAND (_p1, 1);
9717 244 : switch (TREE_CODE (_q30))
9718 : {
9719 0 : case BIT_XOR_EXPR:
9720 0 : {
9721 0 : tree _q40 = TREE_OPERAND (_q30, 0);
9722 0 : tree _q41 = TREE_OPERAND (_q30, 1);
9723 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
9724 : {
9725 0 : if (tree_zero_one_valued_p (_q31))
9726 : {
9727 0 : {
9728 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q31 };
9729 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
9730 0 : if (res) return res;
9731 : }
9732 : }
9733 : }
9734 0 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
9735 : {
9736 0 : if (tree_zero_one_valued_p (_q31))
9737 : {
9738 0 : {
9739 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q31 };
9740 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
9741 0 : if (res) return res;
9742 : }
9743 : }
9744 : }
9745 : break;
9746 : }
9747 244 : default:;
9748 : }
9749 244 : if (tree_zero_one_valued_p (_q30))
9750 : {
9751 17 : switch (TREE_CODE (_q31))
9752 : {
9753 0 : case BIT_XOR_EXPR:
9754 0 : {
9755 0 : tree _q50 = TREE_OPERAND (_q31, 0);
9756 0 : tree _q51 = TREE_OPERAND (_q31, 1);
9757 0 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
9758 : {
9759 0 : {
9760 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q51, _q30 };
9761 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
9762 0 : if (res) return res;
9763 : }
9764 : }
9765 0 : if ((_q51 == _p0 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _p0, 0) && types_match (_q51, _p0)))
9766 : {
9767 0 : {
9768 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q50, _q30 };
9769 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
9770 0 : if (res) return res;
9771 : }
9772 : }
9773 : break;
9774 : }
9775 : default:;
9776 : }
9777 : }
9778 : break;
9779 : }
9780 954996 : default:;
9781 : }
9782 954996 : switch (TREE_CODE (_p0))
9783 : {
9784 1 : case VEC_COND_EXPR:
9785 1 : {
9786 1 : tree _q20 = TREE_OPERAND (_p0, 0);
9787 1 : tree _q21 = TREE_OPERAND (_p0, 1);
9788 1 : tree _q22 = TREE_OPERAND (_p0, 2);
9789 1 : switch (TREE_CODE (_p1))
9790 : {
9791 0 : case VEC_COND_EXPR:
9792 0 : {
9793 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9794 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9795 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9796 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9797 : {
9798 0 : {
9799 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
9800 0 : if (VECTOR_TYPE_P (type)
9801 0 : && (TREE_CODE_CLASS (BIT_XOR_EXPR) != tcc_comparison
9802 : || types_match (type, TREE_TYPE (captures[2]))
9803 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9804 : || (optimize_vectors_before_lowering_p ()
9805 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9806 : )
9807 : {
9808 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1222;
9809 0 : {
9810 0 : tree res_op0;
9811 0 : res_op0 = captures[1];
9812 0 : tree res_op1;
9813 0 : {
9814 0 : tree _o1[2], _r1;
9815 0 : _o1[0] = captures[2];
9816 0 : _o1[1] = captures[5];
9817 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
9818 0 : if (EXPR_P (_r1))
9819 0 : goto next_after_fail1222;
9820 0 : res_op1 = _r1;
9821 : }
9822 0 : tree res_op2;
9823 0 : {
9824 0 : tree _o1[2], _r1;
9825 0 : _o1[0] = captures[3];
9826 0 : _o1[1] = captures[6];
9827 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
9828 0 : if (EXPR_P (_r1))
9829 0 : goto next_after_fail1222;
9830 0 : res_op2 = _r1;
9831 : }
9832 0 : tree _r;
9833 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9834 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 908, __FILE__, __LINE__, true);
9835 0 : return _r;
9836 : }
9837 0 : next_after_fail1222:;
9838 : }
9839 : }
9840 : }
9841 : break;
9842 : }
9843 1 : default:;
9844 : }
9845 1 : if (integer_minus_onep (_q21))
9846 : {
9847 1 : if (integer_zerop (_q22))
9848 : {
9849 1 : switch (TREE_CODE (_p1))
9850 : {
9851 0 : case VEC_COND_EXPR:
9852 0 : {
9853 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9854 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9855 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9856 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
9857 : {
9858 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
9859 : {
9860 0 : {
9861 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9862 0 : const enum tree_code lop = BIT_XOR_EXPR;
9863 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9864 : )
9865 : {
9866 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1223;
9867 0 : {
9868 0 : tree res_op0;
9869 0 : {
9870 0 : tree _o1[2], _r1;
9871 0 : _o1[0] = captures[0];
9872 0 : _o1[1] = captures[3];
9873 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9874 0 : res_op0 = _r1;
9875 : }
9876 0 : tree res_op1;
9877 0 : res_op1 = captures[1];
9878 0 : tree res_op2;
9879 0 : res_op2 = captures[2];
9880 0 : tree _r;
9881 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9882 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
9883 0 : return _r;
9884 : }
9885 0 : next_after_fail1223:;
9886 : }
9887 : }
9888 0 : {
9889 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9890 0 : const enum tree_code lop = BIT_XOR_EXPR;
9891 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9892 : )
9893 : {
9894 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1224;
9895 0 : {
9896 0 : tree res_op0;
9897 0 : {
9898 0 : tree _o1[2], _r1;
9899 0 : _o1[0] = captures[0];
9900 0 : _o1[1] = captures[3];
9901 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9902 0 : res_op0 = _r1;
9903 : }
9904 0 : tree res_op1;
9905 0 : res_op1 = captures[1];
9906 0 : tree res_op2;
9907 0 : res_op2 = captures[2];
9908 0 : tree _r;
9909 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9910 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
9911 0 : return _r;
9912 : }
9913 0 : next_after_fail1224:;
9914 : }
9915 : }
9916 0 : {
9917 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9918 0 : const enum tree_code lop = BIT_XOR_EXPR;
9919 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9920 : )
9921 : {
9922 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1225;
9923 0 : {
9924 0 : tree res_op0;
9925 0 : {
9926 0 : tree _o1[2], _r1;
9927 0 : _o1[0] = captures[0];
9928 0 : _o1[1] = captures[3];
9929 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9930 0 : res_op0 = _r1;
9931 : }
9932 0 : tree res_op1;
9933 0 : res_op1 = captures[1];
9934 0 : tree res_op2;
9935 0 : res_op2 = captures[2];
9936 0 : tree _r;
9937 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9938 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
9939 0 : return _r;
9940 : }
9941 0 : next_after_fail1225:;
9942 : }
9943 : }
9944 0 : {
9945 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9946 0 : const enum tree_code lop = BIT_XOR_EXPR;
9947 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9948 : )
9949 : {
9950 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1226;
9951 0 : {
9952 0 : tree res_op0;
9953 0 : {
9954 0 : tree _o1[2], _r1;
9955 0 : _o1[0] = captures[0];
9956 0 : _o1[1] = captures[3];
9957 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9958 0 : res_op0 = _r1;
9959 : }
9960 0 : tree res_op1;
9961 0 : res_op1 = captures[1];
9962 0 : tree res_op2;
9963 0 : res_op2 = captures[2];
9964 0 : tree _r;
9965 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9966 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
9967 0 : return _r;
9968 : }
9969 0 : next_after_fail1226:;
9970 : }
9971 : }
9972 0 : {
9973 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9974 0 : const enum tree_code lop = BIT_XOR_EXPR;
9975 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9976 : )
9977 : {
9978 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1227;
9979 0 : {
9980 0 : tree res_op0;
9981 0 : {
9982 0 : tree _o1[2], _r1;
9983 0 : _o1[0] = captures[0];
9984 0 : _o1[1] = captures[3];
9985 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9986 0 : res_op0 = _r1;
9987 : }
9988 0 : tree res_op1;
9989 0 : res_op1 = captures[1];
9990 0 : tree res_op2;
9991 0 : res_op2 = captures[2];
9992 0 : tree _r;
9993 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9994 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
9995 0 : return _r;
9996 : }
9997 0 : next_after_fail1227:;
9998 : }
9999 : }
10000 0 : {
10001 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10002 0 : const enum tree_code lop = BIT_XOR_EXPR;
10003 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10004 : )
10005 : {
10006 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1228;
10007 0 : {
10008 0 : tree res_op0;
10009 0 : {
10010 0 : tree _o1[2], _r1;
10011 0 : _o1[0] = captures[0];
10012 0 : _o1[1] = captures[3];
10013 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10014 0 : res_op0 = _r1;
10015 : }
10016 0 : tree res_op1;
10017 0 : res_op1 = captures[1];
10018 0 : tree res_op2;
10019 0 : res_op2 = captures[2];
10020 0 : tree _r;
10021 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10022 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10023 0 : return _r;
10024 : }
10025 0 : next_after_fail1228:;
10026 : }
10027 : }
10028 0 : {
10029 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10030 0 : const enum tree_code lop = BIT_XOR_EXPR;
10031 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10032 : )
10033 : {
10034 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1229;
10035 0 : {
10036 0 : tree res_op0;
10037 0 : {
10038 0 : tree _o1[2], _r1;
10039 0 : _o1[0] = captures[0];
10040 0 : _o1[1] = captures[3];
10041 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10042 0 : res_op0 = _r1;
10043 : }
10044 0 : tree res_op1;
10045 0 : res_op1 = captures[1];
10046 0 : tree res_op2;
10047 0 : res_op2 = captures[2];
10048 0 : tree _r;
10049 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10050 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10051 0 : return _r;
10052 : }
10053 0 : next_after_fail1229:;
10054 : }
10055 : }
10056 0 : {
10057 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10058 0 : const enum tree_code lop = BIT_XOR_EXPR;
10059 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10060 : )
10061 : {
10062 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1230;
10063 0 : {
10064 0 : tree res_op0;
10065 0 : {
10066 0 : tree _o1[2], _r1;
10067 0 : _o1[0] = captures[0];
10068 0 : _o1[1] = captures[3];
10069 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10070 0 : res_op0 = _r1;
10071 : }
10072 0 : tree res_op1;
10073 0 : res_op1 = captures[1];
10074 0 : tree res_op2;
10075 0 : res_op2 = captures[2];
10076 0 : tree _r;
10077 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10078 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10079 0 : return _r;
10080 : }
10081 0 : next_after_fail1230:;
10082 : }
10083 : }
10084 0 : {
10085 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10086 0 : const enum tree_code lop = BIT_XOR_EXPR;
10087 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10088 : )
10089 : {
10090 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1231;
10091 0 : {
10092 0 : tree res_op0;
10093 0 : {
10094 0 : tree _o1[2], _r1;
10095 0 : _o1[0] = captures[0];
10096 0 : _o1[1] = captures[3];
10097 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10098 0 : res_op0 = _r1;
10099 : }
10100 0 : tree res_op1;
10101 0 : res_op1 = captures[1];
10102 0 : tree res_op2;
10103 0 : res_op2 = captures[2];
10104 0 : tree _r;
10105 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10106 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10107 0 : return _r;
10108 : }
10109 0 : next_after_fail1231:;
10110 : }
10111 : }
10112 0 : {
10113 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10114 0 : const enum tree_code lop = BIT_XOR_EXPR;
10115 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10116 : )
10117 : {
10118 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1232;
10119 0 : {
10120 0 : tree res_op0;
10121 0 : {
10122 0 : tree _o1[2], _r1;
10123 0 : _o1[0] = captures[0];
10124 0 : _o1[1] = captures[3];
10125 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10126 0 : res_op0 = _r1;
10127 : }
10128 0 : tree res_op1;
10129 0 : res_op1 = captures[1];
10130 0 : tree res_op2;
10131 0 : res_op2 = captures[2];
10132 0 : tree _r;
10133 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10134 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10135 0 : return _r;
10136 : }
10137 0 : next_after_fail1232:;
10138 : }
10139 : }
10140 0 : {
10141 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10142 0 : const enum tree_code lop = BIT_XOR_EXPR;
10143 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10144 : )
10145 : {
10146 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1233;
10147 0 : {
10148 0 : tree res_op0;
10149 0 : {
10150 0 : tree _o1[2], _r1;
10151 0 : _o1[0] = captures[0];
10152 0 : _o1[1] = captures[3];
10153 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10154 0 : res_op0 = _r1;
10155 : }
10156 0 : tree res_op1;
10157 0 : res_op1 = captures[1];
10158 0 : tree res_op2;
10159 0 : res_op2 = captures[2];
10160 0 : tree _r;
10161 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10162 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10163 0 : return _r;
10164 : }
10165 0 : next_after_fail1233:;
10166 : }
10167 : }
10168 0 : {
10169 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10170 0 : const enum tree_code lop = BIT_XOR_EXPR;
10171 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10172 : )
10173 : {
10174 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1234;
10175 0 : {
10176 0 : tree res_op0;
10177 0 : {
10178 0 : tree _o1[2], _r1;
10179 0 : _o1[0] = captures[0];
10180 0 : _o1[1] = captures[3];
10181 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10182 0 : res_op0 = _r1;
10183 : }
10184 0 : tree res_op1;
10185 0 : res_op1 = captures[1];
10186 0 : tree res_op2;
10187 0 : res_op2 = captures[2];
10188 0 : tree _r;
10189 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10190 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10191 0 : return _r;
10192 : }
10193 0 : next_after_fail1234:;
10194 : }
10195 : }
10196 0 : {
10197 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10198 0 : const enum tree_code lop = BIT_XOR_EXPR;
10199 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10200 : )
10201 : {
10202 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1235;
10203 0 : {
10204 0 : tree res_op0;
10205 0 : {
10206 0 : tree _o1[2], _r1;
10207 0 : _o1[0] = captures[0];
10208 0 : _o1[1] = captures[3];
10209 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10210 0 : res_op0 = _r1;
10211 : }
10212 0 : tree res_op1;
10213 0 : res_op1 = captures[1];
10214 0 : tree res_op2;
10215 0 : res_op2 = captures[2];
10216 0 : tree _r;
10217 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10218 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10219 0 : return _r;
10220 : }
10221 0 : next_after_fail1235:;
10222 : }
10223 : }
10224 0 : {
10225 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10226 0 : const enum tree_code lop = BIT_XOR_EXPR;
10227 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10228 : )
10229 : {
10230 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1236;
10231 0 : {
10232 0 : tree res_op0;
10233 0 : {
10234 0 : tree _o1[2], _r1;
10235 0 : _o1[0] = captures[0];
10236 0 : _o1[1] = captures[3];
10237 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10238 0 : res_op0 = _r1;
10239 : }
10240 0 : tree res_op1;
10241 0 : res_op1 = captures[1];
10242 0 : tree res_op2;
10243 0 : res_op2 = captures[2];
10244 0 : tree _r;
10245 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10246 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10247 0 : return _r;
10248 : }
10249 0 : next_after_fail1236:;
10250 : }
10251 : }
10252 0 : {
10253 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10254 0 : const enum tree_code lop = BIT_XOR_EXPR;
10255 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10256 : )
10257 : {
10258 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1237;
10259 0 : {
10260 0 : tree res_op0;
10261 0 : {
10262 0 : tree _o1[2], _r1;
10263 0 : _o1[0] = captures[0];
10264 0 : _o1[1] = captures[3];
10265 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10266 0 : res_op0 = _r1;
10267 : }
10268 0 : tree res_op1;
10269 0 : res_op1 = captures[1];
10270 0 : tree res_op2;
10271 0 : res_op2 = captures[2];
10272 0 : tree _r;
10273 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10274 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10275 0 : return _r;
10276 : }
10277 0 : next_after_fail1237:;
10278 : }
10279 : }
10280 0 : {
10281 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10282 0 : const enum tree_code lop = BIT_XOR_EXPR;
10283 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10284 : )
10285 : {
10286 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1238;
10287 0 : {
10288 0 : tree res_op0;
10289 0 : {
10290 0 : tree _o1[2], _r1;
10291 0 : _o1[0] = captures[0];
10292 0 : _o1[1] = captures[3];
10293 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10294 0 : res_op0 = _r1;
10295 : }
10296 0 : tree res_op1;
10297 0 : res_op1 = captures[1];
10298 0 : tree res_op2;
10299 0 : res_op2 = captures[2];
10300 0 : tree _r;
10301 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10302 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10303 0 : return _r;
10304 : }
10305 0 : next_after_fail1238:;
10306 : }
10307 : }
10308 0 : {
10309 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10310 0 : const enum tree_code lop = BIT_XOR_EXPR;
10311 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10312 : )
10313 : {
10314 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1239;
10315 0 : {
10316 0 : tree res_op0;
10317 0 : {
10318 0 : tree _o1[2], _r1;
10319 0 : _o1[0] = captures[0];
10320 0 : _o1[1] = captures[3];
10321 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10322 0 : res_op0 = _r1;
10323 : }
10324 0 : tree res_op1;
10325 0 : res_op1 = captures[1];
10326 0 : tree res_op2;
10327 0 : res_op2 = captures[2];
10328 0 : tree _r;
10329 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10330 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10331 0 : return _r;
10332 : }
10333 0 : next_after_fail1239:;
10334 : }
10335 : }
10336 0 : {
10337 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10338 0 : const enum tree_code lop = BIT_XOR_EXPR;
10339 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10340 : )
10341 : {
10342 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1240;
10343 0 : {
10344 0 : tree res_op0;
10345 0 : {
10346 0 : tree _o1[2], _r1;
10347 0 : _o1[0] = captures[0];
10348 0 : _o1[1] = captures[3];
10349 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10350 0 : res_op0 = _r1;
10351 : }
10352 0 : tree res_op1;
10353 0 : res_op1 = captures[1];
10354 0 : tree res_op2;
10355 0 : res_op2 = captures[2];
10356 0 : tree _r;
10357 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10358 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10359 0 : return _r;
10360 : }
10361 0 : next_after_fail1240:;
10362 : }
10363 : }
10364 0 : {
10365 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10366 0 : const enum tree_code lop = BIT_XOR_EXPR;
10367 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10368 : )
10369 : {
10370 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1241;
10371 0 : {
10372 0 : tree res_op0;
10373 0 : {
10374 0 : tree _o1[2], _r1;
10375 0 : _o1[0] = captures[0];
10376 0 : _o1[1] = captures[3];
10377 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10378 0 : res_op0 = _r1;
10379 : }
10380 0 : tree res_op1;
10381 0 : res_op1 = captures[1];
10382 0 : tree res_op2;
10383 0 : res_op2 = captures[2];
10384 0 : tree _r;
10385 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10386 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10387 0 : return _r;
10388 : }
10389 0 : next_after_fail1241:;
10390 : }
10391 : }
10392 0 : {
10393 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10394 0 : const enum tree_code lop = BIT_XOR_EXPR;
10395 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10396 : )
10397 : {
10398 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1242;
10399 0 : {
10400 0 : tree res_op0;
10401 0 : {
10402 0 : tree _o1[2], _r1;
10403 0 : _o1[0] = captures[0];
10404 0 : _o1[1] = captures[3];
10405 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10406 0 : res_op0 = _r1;
10407 : }
10408 0 : tree res_op1;
10409 0 : res_op1 = captures[1];
10410 0 : tree res_op2;
10411 0 : res_op2 = captures[2];
10412 0 : tree _r;
10413 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10414 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10415 0 : return _r;
10416 : }
10417 0 : next_after_fail1242:;
10418 : }
10419 : }
10420 0 : {
10421 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10422 0 : const enum tree_code lop = BIT_XOR_EXPR;
10423 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10424 : )
10425 : {
10426 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1243;
10427 0 : {
10428 0 : tree res_op0;
10429 0 : {
10430 0 : tree _o1[2], _r1;
10431 0 : _o1[0] = captures[0];
10432 0 : _o1[1] = captures[3];
10433 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10434 0 : res_op0 = _r1;
10435 : }
10436 0 : tree res_op1;
10437 0 : res_op1 = captures[1];
10438 0 : tree res_op2;
10439 0 : res_op2 = captures[2];
10440 0 : tree _r;
10441 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10442 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10443 0 : return _r;
10444 : }
10445 0 : next_after_fail1243:;
10446 : }
10447 : }
10448 0 : {
10449 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10450 0 : const enum tree_code lop = BIT_XOR_EXPR;
10451 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10452 : )
10453 : {
10454 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1244;
10455 0 : {
10456 0 : tree res_op0;
10457 0 : {
10458 0 : tree _o1[2], _r1;
10459 0 : _o1[0] = captures[0];
10460 0 : _o1[1] = captures[3];
10461 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10462 0 : res_op0 = _r1;
10463 : }
10464 0 : tree res_op1;
10465 0 : res_op1 = captures[1];
10466 0 : tree res_op2;
10467 0 : res_op2 = captures[2];
10468 0 : tree _r;
10469 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10470 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10471 0 : return _r;
10472 : }
10473 0 : next_after_fail1244:;
10474 : }
10475 : }
10476 0 : {
10477 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10478 0 : const enum tree_code lop = BIT_XOR_EXPR;
10479 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10480 : )
10481 : {
10482 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1245;
10483 0 : {
10484 0 : tree res_op0;
10485 0 : {
10486 0 : tree _o1[2], _r1;
10487 0 : _o1[0] = captures[0];
10488 0 : _o1[1] = captures[3];
10489 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10490 0 : res_op0 = _r1;
10491 : }
10492 0 : tree res_op1;
10493 0 : res_op1 = captures[1];
10494 0 : tree res_op2;
10495 0 : res_op2 = captures[2];
10496 0 : tree _r;
10497 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10498 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10499 0 : return _r;
10500 : }
10501 0 : next_after_fail1245:;
10502 : }
10503 : }
10504 0 : {
10505 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10506 0 : const enum tree_code lop = BIT_XOR_EXPR;
10507 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10508 : )
10509 : {
10510 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1246;
10511 0 : {
10512 0 : tree res_op0;
10513 0 : {
10514 0 : tree _o1[2], _r1;
10515 0 : _o1[0] = captures[0];
10516 0 : _o1[1] = captures[3];
10517 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10518 0 : res_op0 = _r1;
10519 : }
10520 0 : tree res_op1;
10521 0 : res_op1 = captures[1];
10522 0 : tree res_op2;
10523 0 : res_op2 = captures[2];
10524 0 : tree _r;
10525 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10526 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10527 0 : return _r;
10528 : }
10529 0 : next_after_fail1246:;
10530 : }
10531 : }
10532 0 : {
10533 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10534 0 : const enum tree_code lop = BIT_XOR_EXPR;
10535 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10536 : )
10537 : {
10538 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1247;
10539 0 : {
10540 0 : tree res_op0;
10541 0 : {
10542 0 : tree _o1[2], _r1;
10543 0 : _o1[0] = captures[0];
10544 0 : _o1[1] = captures[3];
10545 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10546 0 : res_op0 = _r1;
10547 : }
10548 0 : tree res_op1;
10549 0 : res_op1 = captures[1];
10550 0 : tree res_op2;
10551 0 : res_op2 = captures[2];
10552 0 : tree _r;
10553 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10554 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10555 0 : return _r;
10556 : }
10557 0 : next_after_fail1247:;
10558 : }
10559 : }
10560 0 : {
10561 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10562 0 : const enum tree_code lop = BIT_XOR_EXPR;
10563 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10564 : )
10565 : {
10566 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1248;
10567 0 : {
10568 0 : tree res_op0;
10569 0 : {
10570 0 : tree _o1[2], _r1;
10571 0 : _o1[0] = captures[0];
10572 0 : _o1[1] = captures[3];
10573 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10574 0 : res_op0 = _r1;
10575 : }
10576 0 : tree res_op1;
10577 0 : res_op1 = captures[1];
10578 0 : tree res_op2;
10579 0 : res_op2 = captures[2];
10580 0 : tree _r;
10581 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10582 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10583 0 : return _r;
10584 : }
10585 0 : next_after_fail1248:;
10586 : }
10587 : }
10588 0 : {
10589 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10590 0 : const enum tree_code lop = BIT_XOR_EXPR;
10591 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10592 : )
10593 : {
10594 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1249;
10595 0 : {
10596 0 : tree res_op0;
10597 0 : {
10598 0 : tree _o1[2], _r1;
10599 0 : _o1[0] = captures[0];
10600 0 : _o1[1] = captures[3];
10601 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10602 0 : res_op0 = _r1;
10603 : }
10604 0 : tree res_op1;
10605 0 : res_op1 = captures[1];
10606 0 : tree res_op2;
10607 0 : res_op2 = captures[2];
10608 0 : tree _r;
10609 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10610 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10611 0 : return _r;
10612 : }
10613 0 : next_after_fail1249:;
10614 : }
10615 : }
10616 0 : {
10617 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10618 0 : const enum tree_code lop = BIT_XOR_EXPR;
10619 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10620 : )
10621 : {
10622 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1250;
10623 0 : {
10624 0 : tree res_op0;
10625 0 : {
10626 0 : tree _o1[2], _r1;
10627 0 : _o1[0] = captures[0];
10628 0 : _o1[1] = captures[3];
10629 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10630 0 : res_op0 = _r1;
10631 : }
10632 0 : tree res_op1;
10633 0 : res_op1 = captures[1];
10634 0 : tree res_op2;
10635 0 : res_op2 = captures[2];
10636 0 : tree _r;
10637 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10638 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10639 0 : return _r;
10640 : }
10641 0 : next_after_fail1250:;
10642 : }
10643 : }
10644 0 : {
10645 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10646 0 : const enum tree_code lop = BIT_XOR_EXPR;
10647 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10648 : )
10649 : {
10650 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1251;
10651 0 : {
10652 0 : tree res_op0;
10653 0 : {
10654 0 : tree _o1[2], _r1;
10655 0 : _o1[0] = captures[0];
10656 0 : _o1[1] = captures[3];
10657 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10658 0 : res_op0 = _r1;
10659 : }
10660 0 : tree res_op1;
10661 0 : res_op1 = captures[1];
10662 0 : tree res_op2;
10663 0 : res_op2 = captures[2];
10664 0 : tree _r;
10665 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10666 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10667 0 : return _r;
10668 : }
10669 0 : next_after_fail1251:;
10670 : }
10671 : }
10672 0 : {
10673 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10674 0 : const enum tree_code lop = BIT_XOR_EXPR;
10675 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10676 : )
10677 : {
10678 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1252;
10679 0 : {
10680 0 : tree res_op0;
10681 0 : {
10682 0 : tree _o1[2], _r1;
10683 0 : _o1[0] = captures[0];
10684 0 : _o1[1] = captures[3];
10685 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10686 0 : res_op0 = _r1;
10687 : }
10688 0 : tree res_op1;
10689 0 : res_op1 = captures[1];
10690 0 : tree res_op2;
10691 0 : res_op2 = captures[2];
10692 0 : tree _r;
10693 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10694 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10695 0 : return _r;
10696 : }
10697 0 : next_after_fail1252:;
10698 : }
10699 : }
10700 0 : {
10701 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10702 0 : const enum tree_code lop = BIT_XOR_EXPR;
10703 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10704 : )
10705 : {
10706 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1253;
10707 0 : {
10708 0 : tree res_op0;
10709 0 : {
10710 0 : tree _o1[2], _r1;
10711 0 : _o1[0] = captures[0];
10712 0 : _o1[1] = captures[3];
10713 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10714 0 : res_op0 = _r1;
10715 : }
10716 0 : tree res_op1;
10717 0 : res_op1 = captures[1];
10718 0 : tree res_op2;
10719 0 : res_op2 = captures[2];
10720 0 : tree _r;
10721 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10722 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10723 0 : return _r;
10724 : }
10725 0 : next_after_fail1253:;
10726 : }
10727 : }
10728 0 : {
10729 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10730 0 : const enum tree_code lop = BIT_XOR_EXPR;
10731 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10732 : )
10733 : {
10734 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1254;
10735 0 : {
10736 0 : tree res_op0;
10737 0 : {
10738 0 : tree _o1[2], _r1;
10739 0 : _o1[0] = captures[0];
10740 0 : _o1[1] = captures[3];
10741 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10742 0 : res_op0 = _r1;
10743 : }
10744 0 : tree res_op1;
10745 0 : res_op1 = captures[1];
10746 0 : tree res_op2;
10747 0 : res_op2 = captures[2];
10748 0 : tree _r;
10749 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10750 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10751 0 : return _r;
10752 : }
10753 0 : next_after_fail1254:;
10754 : }
10755 : }
10756 0 : {
10757 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10758 0 : const enum tree_code lop = BIT_XOR_EXPR;
10759 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10760 : )
10761 : {
10762 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1255;
10763 0 : {
10764 0 : tree res_op0;
10765 0 : {
10766 0 : tree _o1[2], _r1;
10767 0 : _o1[0] = captures[0];
10768 0 : _o1[1] = captures[3];
10769 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10770 0 : res_op0 = _r1;
10771 : }
10772 0 : tree res_op1;
10773 0 : res_op1 = captures[1];
10774 0 : tree res_op2;
10775 0 : res_op2 = captures[2];
10776 0 : tree _r;
10777 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10778 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10779 0 : return _r;
10780 : }
10781 0 : next_after_fail1255:;
10782 : }
10783 : }
10784 0 : {
10785 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10786 0 : const enum tree_code lop = BIT_XOR_EXPR;
10787 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10788 : )
10789 : {
10790 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1256;
10791 0 : {
10792 0 : tree res_op0;
10793 0 : {
10794 0 : tree _o1[2], _r1;
10795 0 : _o1[0] = captures[0];
10796 0 : _o1[1] = captures[3];
10797 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10798 0 : res_op0 = _r1;
10799 : }
10800 0 : tree res_op1;
10801 0 : res_op1 = captures[1];
10802 0 : tree res_op2;
10803 0 : res_op2 = captures[2];
10804 0 : tree _r;
10805 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10806 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
10807 0 : return _r;
10808 : }
10809 0 : next_after_fail1256:;
10810 : }
10811 : }
10812 : }
10813 : }
10814 : break;
10815 : }
10816 : default:;
10817 : }
10818 : }
10819 : }
10820 1 : {
10821 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
10822 1 : if (VECTOR_TYPE_P (type)
10823 1 : && (TREE_CODE_CLASS (BIT_XOR_EXPR) != tcc_comparison
10824 : || types_match (type, TREE_TYPE (captures[2]))
10825 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10826 : || (optimize_vectors_before_lowering_p ()
10827 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10828 : )
10829 : {
10830 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1257;
10831 1 : {
10832 1 : if (! tree_invariant_p (captures[4])) goto next_after_fail1257;
10833 0 : tree res_op0;
10834 0 : res_op0 = captures[1];
10835 0 : tree res_op1;
10836 0 : {
10837 0 : tree _o1[2], _r1;
10838 0 : _o1[0] = captures[2];
10839 0 : _o1[1] = unshare_expr (captures[4]);
10840 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
10841 0 : if (EXPR_P (_r1))
10842 0 : goto next_after_fail1257;
10843 0 : res_op1 = _r1;
10844 : }
10845 0 : tree res_op2;
10846 0 : {
10847 0 : tree _o1[2], _r1;
10848 0 : _o1[0] = captures[3];
10849 0 : _o1[1] = captures[4];
10850 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
10851 0 : if (EXPR_P (_r1))
10852 0 : goto next_after_fail1257;
10853 0 : res_op2 = _r1;
10854 : }
10855 0 : tree _r;
10856 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10857 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 910, __FILE__, __LINE__, true);
10858 0 : return _r;
10859 : }
10860 1 : next_after_fail1257:;
10861 : }
10862 : }
10863 1 : break;
10864 : }
10865 954996 : default:;
10866 : }
10867 954996 : switch (TREE_CODE (_p1))
10868 : {
10869 0 : case VEC_COND_EXPR:
10870 0 : {
10871 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10872 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10873 0 : tree _q32 = TREE_OPERAND (_p1, 2);
10874 0 : {
10875 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
10876 0 : if (VECTOR_TYPE_P (type)
10877 0 : && (TREE_CODE_CLASS (BIT_XOR_EXPR) != tcc_comparison
10878 : || types_match (type, TREE_TYPE (captures[3]))
10879 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
10880 : || (optimize_vectors_before_lowering_p ()
10881 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
10882 : )
10883 : {
10884 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1258;
10885 0 : {
10886 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1258;
10887 0 : tree res_op0;
10888 0 : res_op0 = captures[2];
10889 0 : tree res_op1;
10890 0 : {
10891 0 : tree _o1[2], _r1;
10892 0 : _o1[0] = unshare_expr (captures[0]);
10893 0 : _o1[1] = captures[3];
10894 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
10895 0 : if (EXPR_P (_r1))
10896 0 : goto next_after_fail1258;
10897 0 : res_op1 = _r1;
10898 : }
10899 0 : tree res_op2;
10900 0 : {
10901 0 : tree _o1[2], _r1;
10902 0 : _o1[0] = captures[0];
10903 0 : _o1[1] = captures[4];
10904 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
10905 0 : if (EXPR_P (_r1))
10906 0 : goto next_after_fail1258;
10907 0 : res_op2 = _r1;
10908 : }
10909 0 : tree _r;
10910 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10911 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 911, __FILE__, __LINE__, true);
10912 0 : return _r;
10913 : }
10914 0 : next_after_fail1258:;
10915 : }
10916 : }
10917 0 : break;
10918 : }
10919 954996 : default:;
10920 : }
10921 954996 : switch (TREE_CODE (_p0))
10922 : {
10923 90 : case LT_EXPR:
10924 90 : {
10925 90 : tree _q20 = TREE_OPERAND (_p0, 0);
10926 90 : tree _q21 = TREE_OPERAND (_p0, 1);
10927 90 : if (integer_truep (_p1))
10928 : {
10929 14 : {
10930 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10931 14 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures, LT_EXPR, GE_EXPR, UNGE_EXPR);
10932 14 : if (res) return res;
10933 : }
10934 : }
10935 76 : if (integer_zerop (_q21))
10936 : {
10937 24 : switch (TREE_CODE (_p1))
10938 : {
10939 17 : case LT_EXPR:
10940 17 : {
10941 17 : tree _q50 = TREE_OPERAND (_p1, 0);
10942 17 : tree _q51 = TREE_OPERAND (_p1, 1);
10943 17 : if (integer_zerop (_q51))
10944 : {
10945 17 : {
10946 17 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q50 };
10947 17 : tree res = generic_simplify_48 (loc, type, _p0, _p1, captures, LT_EXPR);
10948 17 : if (res) return res;
10949 : }
10950 : }
10951 : break;
10952 : }
10953 0 : case GE_EXPR:
10954 0 : {
10955 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10956 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10957 0 : if (integer_zerop (_q51))
10958 : {
10959 0 : {
10960 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q50 };
10961 0 : tree res = generic_simplify_49 (loc, type, _p0, _p1, captures);
10962 0 : if (res) return res;
10963 : }
10964 : }
10965 : break;
10966 : }
10967 : default:;
10968 : }
10969 : }
10970 : break;
10971 : }
10972 85 : case LE_EXPR:
10973 85 : {
10974 85 : tree _q20 = TREE_OPERAND (_p0, 0);
10975 85 : tree _q21 = TREE_OPERAND (_p0, 1);
10976 85 : if (integer_truep (_p1))
10977 : {
10978 15 : {
10979 15 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10980 15 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR, UNGT_EXPR);
10981 15 : if (res) return res;
10982 : }
10983 : }
10984 : break;
10985 : }
10986 119 : case EQ_EXPR:
10987 119 : {
10988 119 : tree _q20 = TREE_OPERAND (_p0, 0);
10989 119 : tree _q21 = TREE_OPERAND (_p0, 1);
10990 119 : if (integer_truep (_p1))
10991 : {
10992 14 : {
10993 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10994 14 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR, NE_EXPR);
10995 14 : if (res) return res;
10996 : }
10997 : }
10998 : break;
10999 : }
11000 113 : case NE_EXPR:
11001 113 : {
11002 113 : tree _q20 = TREE_OPERAND (_p0, 0);
11003 113 : tree _q21 = TREE_OPERAND (_p0, 1);
11004 113 : if (integer_truep (_p1))
11005 : {
11006 7 : {
11007 7 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11008 7 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR, EQ_EXPR);
11009 7 : if (res) return res;
11010 : }
11011 : }
11012 : break;
11013 : }
11014 62 : case GE_EXPR:
11015 62 : {
11016 62 : tree _q20 = TREE_OPERAND (_p0, 0);
11017 62 : tree _q21 = TREE_OPERAND (_p0, 1);
11018 62 : if (integer_truep (_p1))
11019 : {
11020 0 : {
11021 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11022 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures, GE_EXPR, LT_EXPR, UNLT_EXPR);
11023 0 : if (res) return res;
11024 : }
11025 : }
11026 62 : if (integer_zerop (_q21))
11027 : {
11028 26 : switch (TREE_CODE (_p1))
11029 : {
11030 1 : case GE_EXPR:
11031 1 : {
11032 1 : tree _q50 = TREE_OPERAND (_p1, 0);
11033 1 : tree _q51 = TREE_OPERAND (_p1, 1);
11034 1 : if (integer_zerop (_q51))
11035 : {
11036 1 : {
11037 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q50 };
11038 1 : tree res = generic_simplify_48 (loc, type, _p0, _p1, captures, GE_EXPR);
11039 1 : if (res) return res;
11040 : }
11041 : }
11042 : break;
11043 : }
11044 5 : case LT_EXPR:
11045 5 : {
11046 5 : tree _q50 = TREE_OPERAND (_p1, 0);
11047 5 : tree _q51 = TREE_OPERAND (_p1, 1);
11048 5 : if (integer_zerop (_q51))
11049 : {
11050 5 : {
11051 5 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q50, _p0, _q20 };
11052 5 : tree res = generic_simplify_49 (loc, type, _p0, _p1, captures);
11053 5 : if (res) return res;
11054 : }
11055 : }
11056 : break;
11057 : }
11058 : default:;
11059 : }
11060 : }
11061 : break;
11062 : }
11063 100 : case GT_EXPR:
11064 100 : {
11065 100 : tree _q20 = TREE_OPERAND (_p0, 0);
11066 100 : tree _q21 = TREE_OPERAND (_p0, 1);
11067 100 : if (integer_truep (_p1))
11068 : {
11069 14 : {
11070 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11071 14 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures, GT_EXPR, LE_EXPR, UNLE_EXPR);
11072 14 : if (res) return res;
11073 : }
11074 : }
11075 : break;
11076 : }
11077 0 : case UNORDERED_EXPR:
11078 0 : {
11079 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11080 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11081 0 : if (integer_truep (_p1))
11082 : {
11083 0 : {
11084 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11085 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR);
11086 0 : if (res) return res;
11087 : }
11088 : }
11089 : break;
11090 : }
11091 0 : case ORDERED_EXPR:
11092 0 : {
11093 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11094 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11095 0 : if (integer_truep (_p1))
11096 : {
11097 0 : {
11098 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11099 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR);
11100 0 : if (res) return res;
11101 : }
11102 : }
11103 : break;
11104 : }
11105 0 : case UNLT_EXPR:
11106 0 : {
11107 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11108 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11109 0 : if (integer_truep (_p1))
11110 : {
11111 0 : {
11112 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11113 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures, UNLT_EXPR, GE_EXPR, GE_EXPR);
11114 0 : if (res) return res;
11115 : }
11116 : }
11117 : break;
11118 : }
11119 0 : case UNLE_EXPR:
11120 0 : {
11121 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11122 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11123 0 : if (integer_truep (_p1))
11124 : {
11125 0 : {
11126 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11127 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures, UNLE_EXPR, GT_EXPR, GT_EXPR);
11128 0 : if (res) return res;
11129 : }
11130 : }
11131 : break;
11132 : }
11133 0 : case UNGT_EXPR:
11134 0 : {
11135 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11136 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11137 0 : if (integer_truep (_p1))
11138 : {
11139 0 : {
11140 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11141 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures, UNGT_EXPR, LE_EXPR, LE_EXPR);
11142 0 : if (res) return res;
11143 : }
11144 : }
11145 : break;
11146 : }
11147 0 : case UNGE_EXPR:
11148 0 : {
11149 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11150 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11151 0 : if (integer_truep (_p1))
11152 : {
11153 0 : {
11154 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11155 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures, UNGE_EXPR, LT_EXPR, LT_EXPR);
11156 0 : if (res) return res;
11157 : }
11158 : }
11159 : break;
11160 : }
11161 0 : case UNEQ_EXPR:
11162 0 : {
11163 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11164 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11165 0 : if (integer_truep (_p1))
11166 : {
11167 0 : {
11168 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11169 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR);
11170 0 : if (res) return res;
11171 : }
11172 : }
11173 : break;
11174 : }
11175 0 : case LTGT_EXPR:
11176 0 : {
11177 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11178 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11179 0 : if (integer_truep (_p1))
11180 : {
11181 0 : {
11182 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11183 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR);
11184 0 : if (res) return res;
11185 : }
11186 : }
11187 : break;
11188 : }
11189 7 : case VEC_PERM_EXPR:
11190 7 : {
11191 7 : tree _q20 = TREE_OPERAND (_p0, 0);
11192 7 : tree _q21 = TREE_OPERAND (_p0, 1);
11193 7 : tree _q22 = TREE_OPERAND (_p0, 2);
11194 7 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
11195 : {
11196 0 : switch (TREE_CODE (_p1))
11197 : {
11198 0 : case VEC_PERM_EXPR:
11199 0 : {
11200 0 : tree _q60 = TREE_OPERAND (_p1, 0);
11201 0 : tree _q61 = TREE_OPERAND (_p1, 1);
11202 0 : tree _q62 = TREE_OPERAND (_p1, 2);
11203 0 : if ((_q61 == _q60 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q60, 0) && types_match (_q61, _q60)))
11204 : {
11205 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
11206 : {
11207 0 : {
11208 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q22, _q60 };
11209 0 : if (VECTOR_INTEGER_TYPE_P (type)
11210 : )
11211 : {
11212 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1259;
11213 0 : {
11214 0 : tree res_op0;
11215 0 : {
11216 0 : tree _o1[2], _r1;
11217 0 : _o1[0] = captures[0];
11218 0 : _o1[1] = captures[2];
11219 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
11220 0 : captures[3] = _r1;
11221 : }
11222 0 : res_op0 = unshare_expr (captures[3]);
11223 0 : tree res_op1;
11224 0 : res_op1 = captures[3];
11225 0 : tree res_op2;
11226 0 : res_op2 = captures[1];
11227 0 : tree _r;
11228 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
11229 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 912, __FILE__, __LINE__, true);
11230 0 : return _r;
11231 : }
11232 0 : next_after_fail1259:;
11233 : }
11234 : }
11235 : }
11236 : }
11237 : break;
11238 : }
11239 : default:;
11240 : }
11241 : }
11242 : break;
11243 : }
11244 3289 : case CALL_EXPR:
11245 3289 : switch (get_call_combined_fn (_p0))
11246 : {
11247 1 : case CFN_PARITY:
11248 1 : if (call_expr_nargs (_p0) == 1)
11249 : {
11250 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11251 1 : switch (TREE_CODE (_p1))
11252 : {
11253 1 : case CALL_EXPR:
11254 1 : switch (get_call_combined_fn (_p1))
11255 : {
11256 1 : case CFN_PARITY:
11257 1 : if (call_expr_nargs (_p1) == 1)
11258 : {
11259 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11260 1 : {
11261 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11262 1 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, CFN_PARITY);
11263 1 : if (res) return res;
11264 : }
11265 : }
11266 : break;
11267 : default:;
11268 : }
11269 : break;
11270 : default:;
11271 : }
11272 : }
11273 : break;
11274 1 : case CFN_BUILT_IN_PARITYL:
11275 1 : if (call_expr_nargs (_p0) == 1)
11276 : {
11277 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11278 1 : switch (TREE_CODE (_p1))
11279 : {
11280 1 : case CALL_EXPR:
11281 1 : switch (get_call_combined_fn (_p1))
11282 : {
11283 1 : case CFN_BUILT_IN_PARITYL:
11284 1 : if (call_expr_nargs (_p1) == 1)
11285 : {
11286 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11287 1 : {
11288 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11289 1 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITYL);
11290 1 : if (res) return res;
11291 : }
11292 : }
11293 : break;
11294 : default:;
11295 : }
11296 : break;
11297 : default:;
11298 : }
11299 : }
11300 : break;
11301 0 : case CFN_BUILT_IN_PARITYIMAX:
11302 0 : if (call_expr_nargs (_p0) == 1)
11303 : {
11304 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11305 0 : switch (TREE_CODE (_p1))
11306 : {
11307 0 : case CALL_EXPR:
11308 0 : switch (get_call_combined_fn (_p1))
11309 : {
11310 0 : case CFN_BUILT_IN_PARITYIMAX:
11311 0 : if (call_expr_nargs (_p1) == 1)
11312 : {
11313 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11314 0 : {
11315 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11316 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITYIMAX);
11317 0 : if (res) return res;
11318 : }
11319 : }
11320 : break;
11321 : default:;
11322 : }
11323 : break;
11324 : default:;
11325 : }
11326 : }
11327 : break;
11328 1 : case CFN_BUILT_IN_PARITY:
11329 1 : if (call_expr_nargs (_p0) == 1)
11330 : {
11331 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11332 1 : switch (TREE_CODE (_p1))
11333 : {
11334 1 : case CALL_EXPR:
11335 1 : switch (get_call_combined_fn (_p1))
11336 : {
11337 1 : case CFN_BUILT_IN_PARITY:
11338 1 : if (call_expr_nargs (_p1) == 1)
11339 : {
11340 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11341 1 : {
11342 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11343 1 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITY);
11344 1 : if (res) return res;
11345 : }
11346 : }
11347 : break;
11348 : default:;
11349 : }
11350 : break;
11351 : default:;
11352 : }
11353 : }
11354 : break;
11355 8 : case CFN_BUILT_IN_PARITYLL:
11356 8 : if (call_expr_nargs (_p0) == 1)
11357 : {
11358 8 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11359 8 : switch (TREE_CODE (_p1))
11360 : {
11361 8 : case CALL_EXPR:
11362 8 : switch (get_call_combined_fn (_p1))
11363 : {
11364 8 : case CFN_BUILT_IN_PARITYLL:
11365 8 : if (call_expr_nargs (_p1) == 1)
11366 : {
11367 8 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11368 8 : {
11369 8 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11370 8 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITYLL);
11371 8 : if (res) return res;
11372 : }
11373 : }
11374 : break;
11375 : default:;
11376 : }
11377 : break;
11378 : default:;
11379 : }
11380 : }
11381 : break;
11382 : default:;
11383 : }
11384 : break;
11385 : default:;
11386 : }
11387 : return NULL_TREE;
11388 : }
11389 :
11390 : tree
11391 45473682 : generic_simplify (location_t loc, enum tree_code code, const tree type ATTRIBUTE_UNUSED, tree _p0, tree _p1, tree _p2)
11392 : {
11393 45473682 : switch (code)
11394 : {
11395 12982605 : case COND_EXPR:
11396 12982605 : return generic_simplify_COND_EXPR (loc, code, type, _p0, _p1, _p2);
11397 465150 : case VEC_COND_EXPR:
11398 465150 : return generic_simplify_VEC_COND_EXPR (loc, code, type, _p0, _p1, _p2);
11399 935840 : case BIT_FIELD_REF:
11400 935840 : return generic_simplify_BIT_FIELD_REF (loc, code, type, _p0, _p1, _p2);
11401 16035 : case BIT_INSERT_EXPR:
11402 16035 : return generic_simplify_BIT_INSERT_EXPR (loc, code, type, _p0, _p1, _p2);
11403 834667 : case VEC_PERM_EXPR:
11404 834667 : return generic_simplify_VEC_PERM_EXPR (loc, code, type, _p0, _p1, _p2);
11405 : default:;
11406 : }
11407 : return NULL_TREE;
11408 : }
11409 :
11410 : tree
11411 0 : generic_simplify (location_t, enum tree_code,
11412 : const tree, tree, tree, tree, tree)
11413 : {
11414 0 : return NULL_TREE;
11415 : }
11416 :
11417 : tree
11418 0 : generic_simplify (location_t, enum tree_code,
11419 : const tree, tree, tree, tree, tree, tree)
11420 : {
11421 0 : return NULL_TREE;
11422 : }
11423 :
11424 : tree
11425 0 : generic_simplify (location_t, enum tree_code,
11426 : const tree, tree, tree, tree, tree, tree, tree)
11427 : {
11428 0 : return NULL_TREE;
11429 : }
11430 :
11431 : tree
11432 0 : generic_simplify (location_t, enum tree_code,
11433 : const tree, tree, tree, tree, tree, tree, tree, tree)
11434 : {
11435 0 : return NULL_TREE;
11436 : }
11437 : void
11438 18366 : generic_dump_logs (const char *file1, int line1_id, const char *file2, int line2, bool simplify)
11439 : {
11440 18366 : static int dbg_line_numbers[1126] = {
11441 : /* 0 */ 159, 162, 171, 173, 176, 179, 181, 187, 195, 193,
11442 : /* 10 */ 197, 199, 995, 997, 2224, 2230, 2232, 2235, 2240, 2243,
11443 : /* 20 */ 2497, 2501, 2503, 2505, 2507, 2509, 2511, 2513, 2536, 2552,
11444 : /* 30 */ 2560, 2542, 3161, 3163, 3165, 3172, 3169, 3179, 3181, 3188,
11445 : /* 40 */ 3185, 3396, 3406, 5922, 9436, 9457, 11943, 11946, 11951, 2191,
11446 : /* 50 */ 9256, 1377, 1381, 1556, 1571, 1576, 1623, 1624, 1628, 1629,
11447 : /* 60 */ 1671, 1694, 1699, 1809, 1942, 2022, 1955, 2086, 1963, 2080,
11448 : /* 70 */ 1971, 2132, 2074, 2093, 2099, 2769, 2106, 2120, 2166, 2389,
11449 : /* 80 */ 2455, 2478, 2489, 2492, 2631, 2663, 4459, 4472, 4482, 3238,
11450 : /* 90 */ 3240, 4846, 4496, 4508, 7344, 7346, 7411, 7419, 10854, 10860,
11451 : /* 100 */ 246, 289, 316, 317, 528, 1371, 1925, 1976, 2033, 3954,
11452 : /* 110 */ 3892, 3997, 3998, 4002, 4003, 4013, 4017, 4021, 4036, 4039,
11453 : /* 120 */ 4043, 3969, 3972, 3977, 4123, 4129, 4135, 4315, 4316, 4345,
11454 : /* 130 */ 4366, 4385, 4834, 4854, 5820, 7275, 7360, 7362, 8884, 8959,
11455 : /* 140 */ 10685, 10732, 10746, 11970, 12407, 979, 985, 1536, 1545, 2051,
11456 : /* 150 */ 1986, 2042, 1991, 1999, 2795, 3905, 3945, 3950, 3951, 3959,
11457 : /* 160 */ 3960, 3963, 3980, 4055, 4058, 4062, 4143, 4165, 4203, 4214,
11458 : /* 170 */ 4253, 4268, 4840, 7285, 8964, 10742, 11974, 1503, 1504, 1522,
11459 : /* 180 */ 1531, 1561, 1566, 1608, 1593, 1600, 1650, 2128, 1655, 1662,
11460 : /* 190 */ 1689, 1833, 1932, 1937, 1950, 2061, 2148, 2158, 2160, 2425,
11461 : /* 200 */ 2430, 2435, 2441, 2442, 2464, 2614, 2643, 2645, 2650, 2652,
11462 : /* 210 */ 2788, 3452, 3467, 3485, 3687, 3688, 3689, 3697, 3705, 3714,
11463 : /* 220 */ 3723, 3823, 3825, 3755, 3756, 3761, 3762, 3767, 3772, 3776,
11464 : /* 230 */ 3857, 3870, 3457, 3476, 3478, 3462, 7980, 9857, 12568, 12583,
11465 : /* 240 */ 496, 502, 534, 1316, 1336, 1341, 2216, 2217, 2254, 2804,
11466 : /* 250 */ 2589, 5505, 5806, 5813, 5863, 5866, 5917, 8877, 9291, 9121,
11467 : /* 260 */ 9128, 9285, 9330, 9335, 364, 941, 1389, 3081, 2877, 2883,
11468 : /* 270 */ 2886, 2891, 2698, 2699, 2783, 2578, 2718, 2965, 2828, 2838,
11469 : /* 280 */ 2907, 2909, 2910, 2913, 2915, 2916, 2918, 2920, 2922, 2924,
11470 : /* 290 */ 2926, 2928, 2942, 2943, 2999, 3087, 3112, 3028, 3055, 3095,
11471 : /* 300 */ 3100, 3124, 3131, 3197, 3805, 4767, 4775, 4778, 4784, 4787,
11472 : /* 310 */ 4813, 5292, 5293, 5331, 5335, 5466, 5302, 5303, 5349, 5352,
11473 : /* 320 */ 5353, 5358, 5361, 5364, 5365, 5317, 5320, 5538, 5542, 5547,
11474 : /* 330 */ 5831, 5984, 5988, 7371, 7387, 7389, 7401, 7431, 7437, 7438,
11475 : /* 340 */ 7453, 7454, 7458, 7476, 7481, 7513, 7521, 7531, 7540, 7544,
11476 : /* 350 */ 7550, 7557, 7573, 7577, 7581, 7588, 7589, 7594, 7595, 7602,
11477 : /* 360 */ 7603, 7605, 7606, 7622, 7633, 7645, 7649, 7651, 7656, 7659,
11478 : /* 370 */ 7662, 7670, 7732, 7733, 7737, 7738, 7745, 7749, 7753, 7756,
11479 : /* 380 */ 7762, 7763, 7767, 7770, 7777, 7807, 7810, 7813, 7816, 7885,
11480 : /* 390 */ 7888, 7895, 7901, 7907, 7915, 7924, 7925, 8023, 8033, 8072,
11481 : /* 400 */ 8078, 8094, 8107, 8109, 8111, 8122, 8150, 8192, 8171, 8172,
11482 : /* 410 */ 8179, 8181, 8197, 8203, 8208, 8217, 8223, 8229, 8234, 8239,
11483 : /* 420 */ 8271, 8334, 8253, 8263, 8363, 8382, 8384, 8386, 8388, 8390,
11484 : /* 430 */ 8392, 8396, 8398, 8421, 8444, 8555, 8562, 8563, 8571, 8572,
11485 : /* 440 */ 8773, 9921, 9923, 10001, 10003, 10004, 10010, 10026, 10028, 10030,
11486 : /* 450 */ 10048, 10049, 10470, 10473, 10487, 10496, 10560, 10561, 10615, 10617,
11487 : /* 460 */ 10693, 11285, 11287, 11289, 11723, 7367, 7378, 7380, 7488, 508,
11488 : /* 470 */ 1289, 1310, 9241, 9246, 9251, 568, 569, 580, 585, 592,
11489 : /* 480 */ 601, 609, 618, 664, 667, 876, 1030, 1058, 1089, 629,
11490 : /* 490 */ 906, 910, 915, 921, 925, 933, 1022, 780, 790, 792,
11491 : /* 500 */ 794, 8871, 9296, 9318, 9301, 9306, 9311, 9325, 9359, 9364,
11492 : /* 510 */ 851, 6636, 6638, 6640, 6740, 6743, 6926, 6928, 6942, 6946,
11493 : /* 520 */ 6969, 6975, 6986, 7048, 7063, 4878, 4898, 4905, 4911, 4917,
11494 : /* 530 */ 4923, 7054, 4891, 4934, 4947, 6547, 6850, 6854, 6862, 7214,
11495 : /* 540 */ 9874, 9875, 7224, 10914, 10922, 12632, 8287, 8288, 8302, 8303,
11496 : /* 550 */ 863, 866, 1784, 2851, 2854, 2973, 2985, 3070, 3014, 3041,
11497 : /* 560 */ 3152, 3155, 4637, 4648, 4797, 4805, 4824, 5118, 7309, 8699,
11498 : /* 570 */ 7937, 7940, 7966, 7967, 8469, 8471, 8473, 8475, 8479, 8481,
11499 : /* 580 */ 8483, 8485, 8489, 8494, 8501, 8506, 8526, 8528, 8530, 8532,
11500 : /* 590 */ 8712, 8725, 8735, 8743, 8753, 8898, 8900, 9935, 9944, 9984,
11501 : /* 600 */ 10538, 10540, 10541, 10596, 10599, 10601, 2867, 7299, 8010, 8797,
11502 : /* 610 */ 8972, 8977, 11306, 11308, 11310, 11312, 11316, 968, 1004, 1361,
11503 : /* 620 */ 4982, 5069, 5072, 5080, 5233, 5235, 5236, 5237, 5477, 5033,
11504 : /* 630 */ 5042, 6039, 6042, 6043, 6051, 2400, 2410, 2417, 3836, 3841,
11505 : /* 640 */ 4602, 4709, 9740, 9742, 9773, 9808, 12351, 1253, 9189, 9210,
11506 : /* 650 */ 1262, 8933, 8939, 9236, 9687, 1276, 1280, 9231, 9414, 1489,
11507 : /* 660 */ 1588, 1636, 1581, 1613, 1644, 1684, 1725, 1736, 1747, 1759,
11508 : /* 670 */ 2675, 2004, 2012, 2017, 2140, 2519, 2810, 3392, 3422, 3424,
11509 : /* 680 */ 3434, 3436, 3544, 3545, 3546, 3554, 3562, 3571, 3580, 3615,
11510 : /* 690 */ 3616, 3621, 3622, 3627, 3632, 3636, 3442, 3447, 3492, 4859,
11511 : /* 700 */ 5435, 5453, 5454, 6010, 6016, 6064, 7503, 7983, 9843, 9845,
11512 : /* 710 */ 10727, 12603, 1679, 2748, 1864, 2753, 5516, 2725, 2759, 2763,
11513 : /* 720 */ 5530, 4752, 7336, 7338, 2261, 2275, 2730, 3930, 2300, 2323,
11514 : /* 730 */ 2324, 10324, 2818, 4515, 4519, 4529, 4547, 4578, 4587, 4661,
11515 : /* 740 */ 4664, 4673, 4674, 4692, 4694, 4696, 4698, 4747, 9865, 10448,
11516 : /* 750 */ 10455, 4533, 4540, 4525, 4719, 4728, 4731, 11515, 11521, 11529,
11517 : /* 760 */ 11535, 11544, 11550, 11558, 11564, 11610, 11618, 4969, 5205, 5215,
11518 : /* 770 */ 8826, 8829, 8848, 5960, 5972, 5975, 5979, 8587, 7496, 7492,
11519 : /* 780 */ 8807, 8814, 8949, 8954, 9055, 9152, 9169, 9201, 9221, 9226,
11520 : /* 790 */ 9477, 9454, 9433, 9262, 9266, 9580, 9590, 9597, 9606, 9624,
11521 : /* 800 */ 9631, 9612, 9900, 9906, 10314, 10320, 10317, 10337, 10342, 10348,
11522 : /* 810 */ 10356, 10362, 10370, 10376, 10386, 10392, 10400, 10406, 10414, 10420,
11523 : /* 820 */ 10428, 10434, 10505, 10707, 10722, 10758, 11013, 11016, 10821, 10822,
11524 : /* 830 */ 10835, 10848, 11692, 11707, 11798, 11799, 12460, 219, 2172, 2182,
11525 : /* 840 */ 6096, 2200, 1196, 2686, 3373, 5558, 5560, 5570, 5687, 5698,
11526 : /* 850 */ 5711, 5734, 5744, 5753, 5765, 5791, 6106, 6553, 1861, 1875,
11527 : /* 860 */ 1882, 1913, 1920, 2530, 2776, 2177, 2195, 2204, 2270, 2306,
11528 : /* 870 */ 2312, 3917, 7262, 3925, 10396, 10410, 10352, 10424, 10438, 10366,
11529 : /* 880 */ 10380, 5575, 5585, 5594, 5621, 5631, 5637, 6117, 5646, 5643,
11530 : /* 890 */ 5930, 5938, 5946, 5950, 5933, 5941, 5954, 5966, 237, 272,
11531 : /* 900 */ 1817, 1822, 2740, 2741, 2599, 2525, 3792, 4627, 6135, 6144,
11532 : /* 910 */ 6155, 6164, 12366, 762, 5878, 5884, 5887, 3245, 3249, 277,
11533 : /* 920 */ 3266, 3270, 3301, 3309, 3282, 3296, 295, 332, 1540, 1870,
11534 : /* 930 */ 2281, 3317, 3329, 3323, 3335, 2292, 2994, 3022, 3049, 3033,
11535 : /* 940 */ 3060, 4177, 4149, 4224, 4233, 4276, 4287, 5059, 5892, 5903,
11536 : /* 950 */ 12332, 12333, 1776, 1789, 1794, 7973, 11669, 11673, 282, 335,
11537 : /* 960 */ 3003, 3006, 3342, 3349, 3356, 3362, 4186, 3367, 4242, 4296,
11538 : /* 970 */ 5895, 408, 339, 376, 385, 393, 467, 482, 490, 681,
11539 : /* 980 */ 721, 1039, 1234, 1239, 1344, 1347, 1481, 2584, 5908, 8906,
11540 : /* 990 */ 8912, 9103, 9353, 6343, 6353, 8040, 8619, 8679, 8680, 8613,
11541 : /* 1000 */ 644, 647, 771, 800, 806, 812, 820, 825, 830, 894,
11542 : /* 1010 */ 898, 8918, 8924, 8537, 952, 1436, 4998, 1425, 1428, 1460,
11543 : /* 1020 */ 1471, 4975, 5064, 5266, 1510, 1706, 1799, 1827, 2469, 5272,
11544 : /* 1030 */ 5273, 7977, 12339, 4554, 4558, 4619, 4620, 4740, 4565, 4569,
11545 : /* 1040 */ 4610, 4611, 5186, 5927, 8595, 8597, 8604, 8606, 7500, 7070,
11546 : /* 1050 */ 4865, 6175, 4962, 6184, 6869, 6874, 7021, 7023, 7029, 7038,
11547 : /* 1060 */ 7039, 6082, 6084, 7076, 7079, 7088, 7092, 7097, 7112, 7140,
11548 : /* 1070 */ 7145, 7211, 7119, 7153, 7158, 7221, 8317, 8319, 7177, 7178,
11549 : /* 1080 */ 7179, 7234, 7201, 7202, 7203, 7249, 7250, 8348, 8353, 7105,
11550 : /* 1090 */ 6088, 6090, 6364, 6366, 10056, 10062, 10067, 10076, 10078, 10098,
11551 : /* 1100 */ 10143, 10146, 10147, 10179, 10185, 10187, 10188, 10244, 10245, 10266,
11552 : /* 1110 */ 10271, 10276, 10306, 12523, 11823, 11825, 11860, 11935, 11938, 12019,
11553 : /* 1120 */ 11958, 11964, 12085, 12087, 12146, 12148
11554 : };
11555 :
11556 27432 : fprintf (dump_file, "%s %s:%d, %s:%d\n",
11557 : simplify ? "Applying pattern" : "Matching expression", file1, dbg_line_numbers[line1_id], file2, line2);
11558 18366 : }
11559 :
11560 : #pragma GCC diagnostic pop
|
