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 175330648 : tree_truth_valued_p (tree t)
11 : {
12 175330648 : const tree type = TREE_TYPE (t);
13 175330648 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 175330648 : if (TREE_SIDE_EFFECTS (t)) return false;
15 169088074 : {
16 169088074 : tree captures[1] ATTRIBUTE_UNUSED = { t };
17 169088074 : if (INTEGRAL_TYPE_P (type) && TYPE_PRECISION (type) == 1
18 : )
19 : {
20 6685384 : {
21 6685384 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 20, __FILE__, __LINE__, false);
22 6685384 : return true;
23 : }
24 : }
25 : }
26 162402690 : switch (TREE_CODE (t))
27 : {
28 821 : case LT_EXPR:
29 821 : {
30 821 : tree _p0 = TREE_OPERAND (t, 0);
31 821 : tree _p1 = TREE_OPERAND (t, 1);
32 821 : {
33 821 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
34 821 : {
35 821 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
36 821 : return true;
37 : }
38 : }
39 700 : break;
40 : }
41 700 : case LE_EXPR:
42 700 : {
43 700 : tree _p0 = TREE_OPERAND (t, 0);
44 700 : tree _p1 = TREE_OPERAND (t, 1);
45 700 : {
46 700 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
47 700 : {
48 700 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
49 700 : return true;
50 : }
51 : }
52 11559 : break;
53 : }
54 11559 : case EQ_EXPR:
55 11559 : {
56 11559 : tree _p0 = TREE_OPERAND (t, 0);
57 11559 : tree _p1 = TREE_OPERAND (t, 1);
58 11559 : {
59 11559 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
60 11559 : {
61 11559 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
62 11559 : return true;
63 : }
64 : }
65 4510 : break;
66 : }
67 4510 : case NE_EXPR:
68 4510 : {
69 4510 : tree _p0 = TREE_OPERAND (t, 0);
70 4510 : tree _p1 = TREE_OPERAND (t, 1);
71 4510 : {
72 4510 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
73 4510 : {
74 4510 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
75 4510 : return true;
76 : }
77 : }
78 378 : break;
79 : }
80 378 : case GE_EXPR:
81 378 : {
82 378 : tree _p0 = TREE_OPERAND (t, 0);
83 378 : tree _p1 = TREE_OPERAND (t, 1);
84 378 : {
85 378 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
86 378 : {
87 378 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
88 378 : return true;
89 : }
90 : }
91 218857 : break;
92 : }
93 218857 : case GT_EXPR:
94 218857 : {
95 218857 : tree _p0 = TREE_OPERAND (t, 0);
96 218857 : tree _p1 = TREE_OPERAND (t, 1);
97 218857 : {
98 218857 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
99 218857 : {
100 218857 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
101 218857 : return true;
102 : }
103 : }
104 125675 : break;
105 : }
106 125675 : case UNORDERED_EXPR:
107 125675 : {
108 125675 : tree _p0 = TREE_OPERAND (t, 0);
109 125675 : tree _p1 = TREE_OPERAND (t, 1);
110 125675 : {
111 125675 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
112 125675 : {
113 125675 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
114 125675 : 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 79 : break;
131 : }
132 79 : case UNLT_EXPR:
133 79 : {
134 79 : tree _p0 = TREE_OPERAND (t, 0);
135 79 : tree _p1 = TREE_OPERAND (t, 1);
136 79 : {
137 79 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
138 79 : {
139 79 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
140 79 : return true;
141 : }
142 : }
143 1166 : break;
144 : }
145 1166 : case UNLE_EXPR:
146 1166 : {
147 1166 : tree _p0 = TREE_OPERAND (t, 0);
148 1166 : tree _p1 = TREE_OPERAND (t, 1);
149 1166 : {
150 1166 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
151 1166 : {
152 1166 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
153 1166 : return true;
154 : }
155 : }
156 79 : break;
157 : }
158 79 : case UNGT_EXPR:
159 79 : {
160 79 : tree _p0 = TREE_OPERAND (t, 0);
161 79 : tree _p1 = TREE_OPERAND (t, 1);
162 79 : {
163 79 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
164 79 : {
165 79 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
166 79 : return true;
167 : }
168 : }
169 79 : break;
170 : }
171 79 : case UNGE_EXPR:
172 79 : {
173 79 : tree _p0 = TREE_OPERAND (t, 0);
174 79 : tree _p1 = TREE_OPERAND (t, 1);
175 79 : {
176 79 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
177 79 : {
178 79 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
179 79 : return true;
180 : }
181 : }
182 95 : break;
183 : }
184 95 : case UNEQ_EXPR:
185 95 : {
186 95 : tree _p0 = TREE_OPERAND (t, 0);
187 95 : tree _p1 = TREE_OPERAND (t, 1);
188 95 : {
189 95 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
190 95 : {
191 95 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
192 95 : return true;
193 : }
194 : }
195 27 : break;
196 : }
197 27 : case LTGT_EXPR:
198 27 : {
199 27 : tree _p0 = TREE_OPERAND (t, 0);
200 27 : tree _p1 = TREE_OPERAND (t, 1);
201 27 : {
202 27 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
203 27 : {
204 27 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
205 27 : return true;
206 : }
207 : }
208 102 : break;
209 : }
210 102 : case TRUTH_AND_EXPR:
211 102 : {
212 102 : tree _p0 = TREE_OPERAND (t, 0);
213 102 : tree _p1 = TREE_OPERAND (t, 1);
214 102 : {
215 102 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
216 102 : {
217 102 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
218 102 : return true;
219 : }
220 : }
221 516 : break;
222 : }
223 516 : case TRUTH_ANDIF_EXPR:
224 516 : {
225 516 : tree _p0 = TREE_OPERAND (t, 0);
226 516 : tree _p1 = TREE_OPERAND (t, 1);
227 516 : {
228 516 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
229 516 : {
230 516 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
231 516 : return true;
232 : }
233 : }
234 43 : break;
235 : }
236 43 : case TRUTH_OR_EXPR:
237 43 : {
238 43 : tree _p0 = TREE_OPERAND (t, 0);
239 43 : tree _p1 = TREE_OPERAND (t, 1);
240 43 : {
241 43 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
242 43 : {
243 43 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
244 43 : return true;
245 : }
246 : }
247 1405 : break;
248 : }
249 1405 : case TRUTH_ORIF_EXPR:
250 1405 : {
251 1405 : tree _p0 = TREE_OPERAND (t, 0);
252 1405 : tree _p1 = TREE_OPERAND (t, 1);
253 1405 : {
254 1405 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
255 1405 : {
256 1405 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
257 1405 : 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 665796 : break;
274 : }
275 665796 : case TRUTH_NOT_EXPR:
276 665796 : {
277 665796 : tree _p0 = TREE_OPERAND (t, 0);
278 665796 : {
279 665796 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
280 665796 : {
281 665796 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
282 665796 : return true;
283 : }
284 : }
285 : break;
286 : }
287 : default:;
288 : }
289 : return false;
290 : }
291 :
292 : tree
293 116 : generic_simplify_35 (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 combined_fn ARG_UNUSED (POPCOUNT))
296 : {
297 116 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
298 232 : if (INTEGRAL_TYPE_P (type)
299 580 : && (wi::bit_and (widest_int::from (tree_nonzero_bits (captures[1]), UNSIGNED),
300 464 : widest_int::from (tree_nonzero_bits (captures[3]), UNSIGNED))
301 348 : == 0)
302 : )
303 : {
304 1 : {
305 1 : tree utype = TREE_TYPE (captures[1]);
306 1 : if (TYPE_PRECISION (utype) < TYPE_PRECISION (TREE_TYPE (captures[3])))
307 0 : utype = TREE_TYPE (captures[3]);
308 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail117;
309 1 : {
310 1 : tree res_op0;
311 1 : {
312 1 : tree _o1[2], _r1;
313 1 : {
314 1 : tree _o2[1], _r2;
315 1 : _o2[0] = captures[1];
316 1 : if (TREE_TYPE (_o2[0]) != utype)
317 : {
318 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
319 : }
320 : else
321 : _r2 = _o2[0];
322 1 : _o1[0] = _r2;
323 : }
324 1 : {
325 1 : tree _o2[1], _r2;
326 1 : _o2[0] = captures[3];
327 1 : if (TREE_TYPE (_o2[0]) != utype)
328 : {
329 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
330 : }
331 : else
332 : _r2 = _o2[0];
333 1 : _o1[1] = _r2;
334 : }
335 1 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
336 1 : res_op0 = _r1;
337 : }
338 1 : tree _r;
339 1 : _r = maybe_build_call_expr_loc (loc, POPCOUNT, type, 1, res_op0);
340 1 : if (!_r)
341 0 : goto next_after_fail117;
342 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 94, __FILE__, __LINE__, true);
343 1 : return _r;
344 : }
345 : next_after_fail117:;
346 : }
347 : }
348 : return NULL_TREE;
349 : }
350 :
351 : tree
352 5 : generic_simplify_46 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
353 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
354 : {
355 5 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
356 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail128;
357 5 : {
358 5 : tree res_op0;
359 5 : res_op0 = captures[1];
360 5 : tree res_op1;
361 5 : {
362 5 : tree _o1[1], _r1;
363 5 : _o1[0] = captures[2];
364 5 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
365 5 : res_op1 = _r1;
366 : }
367 5 : tree _r;
368 5 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
369 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 105, __FILE__, __LINE__, true);
370 : return _r;
371 : }
372 0 : next_after_fail128:;
373 0 : return NULL_TREE;
374 : }
375 :
376 : tree
377 136 : generic_simplify_53 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
378 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
379 : {
380 136 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
381 136 : if (!TYPE_SATURATING (type)
382 : )
383 : {
384 136 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
385 272 : && !FIXED_POINT_TYPE_P (type)
386 : )
387 : {
388 136 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail137;
389 136 : {
390 136 : tree res_op0;
391 136 : res_op0 = captures[1];
392 136 : tree _r;
393 136 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
394 136 : if (TREE_SIDE_EFFECTS (captures[0]))
395 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
396 136 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 113, __FILE__, __LINE__, true);
397 136 : return _r;
398 : }
399 0 : next_after_fail137:;
400 : }
401 : }
402 : return NULL_TREE;
403 : }
404 :
405 : tree
406 151877 : generic_simplify_59 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
407 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
408 : {
409 151877 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
410 151877 : if (!TYPE_SATURATING (type)
411 : )
412 : {
413 151877 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
414 303754 : && !FIXED_POINT_TYPE_P (type)
415 : )
416 : {
417 151877 : if (INTEGRAL_TYPE_P (type)
418 151877 : && TYPE_OVERFLOW_UNDEFINED (type)
419 49 : && element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
420 151926 : && element_precision (type) <= element_precision (TREE_TYPE (captures[2]))
421 : )
422 : {
423 49 : {
424 49 : tree utype = unsigned_type_for (type);
425 49 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail146;
426 49 : {
427 49 : tree res_op0;
428 49 : {
429 49 : tree _o1[2], _r1;
430 49 : {
431 49 : tree _o2[1], _r2;
432 49 : _o2[0] = captures[1];
433 49 : if (TREE_TYPE (_o2[0]) != utype)
434 : {
435 41 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
436 : }
437 : else
438 : _r2 = _o2[0];
439 49 : _o1[0] = _r2;
440 : }
441 49 : {
442 49 : tree _o2[1], _r2;
443 49 : _o2[0] = captures[2];
444 49 : if (TREE_TYPE (_o2[0]) != utype)
445 : {
446 40 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
447 : }
448 : else
449 : _r2 = _o2[0];
450 49 : _o1[1] = _r2;
451 : }
452 49 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
453 49 : res_op0 = _r1;
454 : }
455 49 : tree _r;
456 49 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
457 49 : if (TREE_SIDE_EFFECTS (captures[3]))
458 2 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
459 49 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 122, __FILE__, __LINE__, true);
460 49 : return _r;
461 : }
462 0 : next_after_fail146:;
463 : }
464 : }
465 : else
466 : {
467 151828 : if (((element_precision (type) <= element_precision (TREE_TYPE (captures[1])))
468 151828 : == (element_precision (type) <= element_precision (TREE_TYPE (captures[2]))))
469 151828 : && (element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
470 53 : || (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
471 53 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
472 53 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
473 53 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))))
474 : )
475 : {
476 135163 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail147;
477 135163 : {
478 135163 : tree res_op0;
479 135163 : {
480 135163 : tree _o1[1], _r1;
481 135163 : _o1[0] = captures[1];
482 135163 : if (TREE_TYPE (_o1[0]) != type)
483 : {
484 135163 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
485 : }
486 : else
487 : _r1 = _o1[0];
488 135163 : res_op0 = _r1;
489 : }
490 135163 : tree res_op1;
491 135163 : {
492 135163 : tree _o1[1], _r1;
493 135163 : _o1[0] = captures[2];
494 135163 : if (TREE_TYPE (_o1[0]) != type)
495 : {
496 135163 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
497 : }
498 : else
499 : _r1 = _o1[0];
500 135163 : res_op1 = _r1;
501 : }
502 135163 : tree _r;
503 135163 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
504 135163 : if (TREE_SIDE_EFFECTS (captures[3]))
505 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
506 135163 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 123, __FILE__, __LINE__, true);
507 135163 : return _r;
508 : }
509 0 : next_after_fail147:;
510 : }
511 : }
512 : }
513 : }
514 : return NULL_TREE;
515 : }
516 :
517 : tree
518 0 : generic_simplify_86 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
519 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
520 : {
521 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
522 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail178;
523 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail178;
524 0 : {
525 0 : tree _r;
526 0 : _r = captures[2];
527 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 144, __FILE__, __LINE__, true);
528 : return _r;
529 : }
530 : next_after_fail178:;
531 : return NULL_TREE;
532 : }
533 :
534 : tree
535 93 : generic_simplify_94 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
536 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
537 : const enum tree_code ARG_UNUSED (op),
538 : const enum tree_code ARG_UNUSED (rop))
539 : {
540 93 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
541 93 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[0]))
542 93 : && element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
543 : )
544 : {
545 61 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail186;
546 61 : {
547 61 : tree res_op0;
548 61 : {
549 61 : tree _o1[2], _r1;
550 61 : {
551 61 : tree _o2[1], _r2;
552 61 : _o2[0] = captures[0];
553 61 : if (TREE_TYPE (_o2[0]) != type)
554 : {
555 1 : _r2 = fold_build1_loc (loc, NOP_EXPR, type, _o2[0]);
556 : }
557 : else
558 : _r2 = _o2[0];
559 61 : _o1[0] = _r2;
560 : }
561 61 : {
562 61 : tree _o2[1], _r2;
563 61 : _o2[0] = captures[1];
564 61 : if (TREE_TYPE (_o2[0]) != type)
565 : {
566 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, type, _o2[0]);
567 : }
568 : else
569 : _r2 = _o2[0];
570 61 : _o1[1] = _r2;
571 : }
572 61 : _r1 = fold_build2_loc (loc, rop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
573 61 : res_op0 = _r1;
574 : }
575 61 : tree _r;
576 61 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
577 61 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 153, __FILE__, __LINE__, true);
578 61 : return _r;
579 : }
580 0 : next_after_fail186:;
581 : }
582 : return NULL_TREE;
583 : }
584 :
585 : tree
586 890207 : generic_simplify_106 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
587 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
588 : const enum tree_code ARG_UNUSED (bitop),
589 : const enum tree_code ARG_UNUSED (rbitop))
590 : {
591 890207 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
592 890207 : {
593 890207 : bool wascmp;
594 890207 : if (bitwise_inverted_equal_p (captures[2], captures[0], wascmp)
595 890207 : && (!wascmp || element_precision (type) == 1)
596 : )
597 : {
598 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail202;
599 12 : {
600 12 : tree res_op0;
601 12 : res_op0 = captures[2];
602 12 : tree res_op1;
603 12 : res_op1 = captures[1];
604 12 : tree _r;
605 12 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
606 12 : if (TREE_SIDE_EFFECTS (captures[0]))
607 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
608 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 160, __FILE__, __LINE__, true);
609 12 : return _r;
610 : }
611 0 : next_after_fail202:;
612 : }
613 : }
614 890195 : return NULL_TREE;
615 : }
616 :
617 : tree
618 0 : generic_simplify_112 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
619 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
620 : const enum tree_code ARG_UNUSED (bitop),
621 : const enum tree_code ARG_UNUSED (rbitop))
622 : {
623 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
624 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail208;
625 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail208;
626 0 : {
627 0 : tree res_op0;
628 0 : res_op0 = captures[0];
629 0 : tree res_op1;
630 0 : res_op1 = captures[2];
631 0 : tree _r;
632 0 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
633 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 162, __FILE__, __LINE__, true);
634 : return _r;
635 : }
636 : next_after_fail208:;
637 : return NULL_TREE;
638 : }
639 :
640 : tree
641 7 : generic_simplify_120 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
642 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
643 : const enum tree_code ARG_UNUSED (op))
644 : {
645 7 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
646 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail219;
647 7 : {
648 7 : tree _r;
649 7 : _r = constant_boolean_node (true, type);
650 7 : if (TREE_SIDE_EFFECTS (captures[0]))
651 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
652 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 172, __FILE__, __LINE__, true);
653 : return _r;
654 : }
655 0 : next_after_fail219:;
656 0 : return NULL_TREE;
657 : }
658 :
659 : tree
660 56 : generic_simplify_124 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
661 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
662 : const enum tree_code ARG_UNUSED (inner_op),
663 : const enum tree_code ARG_UNUSED (outer_op))
664 : {
665 56 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
666 56 : {
667 56 : bool fail = false;
668 56 : wide_int zero_mask_not;
669 56 : wide_int C0;
670 56 : wide_int cst_emit;
671 56 : if (TREE_CODE (captures[1]) == SSA_NAME)
672 0 : zero_mask_not = get_nonzero_bits (captures[1]);
673 : else
674 : fail = true;
675 56 : if (inner_op == BIT_XOR_EXPR)
676 : {
677 33 : C0 = wi::bit_and_not (wi::to_wide (captures[2]), wi::to_wide (captures[3]));
678 33 : cst_emit = C0 | wi::to_wide (captures[3]);
679 : }
680 : else
681 : {
682 23 : C0 = wi::to_wide (captures[2]);
683 23 : cst_emit = C0 ^ wi::to_wide (captures[3]);
684 : }
685 56 : if (!fail && (C0 & zero_mask_not) == 0
686 : )
687 : {
688 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail226;
689 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail226;
690 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail226;
691 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail226;
692 0 : {
693 0 : tree res_op0;
694 0 : res_op0 = captures[1];
695 0 : tree res_op1;
696 0 : res_op1 = wide_int_to_tree (type, cst_emit);
697 0 : tree _r;
698 0 : _r = fold_build2_loc (loc, outer_op, type, res_op0, res_op1);
699 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 179, __FILE__, __LINE__, true);
700 0 : return _r;
701 : }
702 56 : next_after_fail226:;
703 : }
704 : else
705 : {
706 56 : if (!fail && (wi::to_wide (captures[3]) & zero_mask_not) == 0
707 : )
708 : {
709 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail227;
710 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail227;
711 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail227;
712 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail227;
713 0 : {
714 0 : tree res_op0;
715 0 : res_op0 = captures[1];
716 0 : tree res_op1;
717 0 : res_op1 = wide_int_to_tree (type, cst_emit);
718 0 : tree _r;
719 0 : _r = fold_build2_loc (loc, inner_op, type, res_op0, res_op1);
720 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 180, __FILE__, __LINE__, true);
721 0 : return _r;
722 : }
723 56 : next_after_fail227:;
724 : }
725 : }
726 56 : }
727 56 : return NULL_TREE;
728 : }
729 :
730 : tree
731 4 : generic_simplify_141 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
732 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
733 : {
734 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
735 4 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail276;
736 4 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail276;
737 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail276;
738 4 : {
739 4 : tree _r;
740 4 : _r = captures[0];
741 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 203, __FILE__, __LINE__, true);
742 : return _r;
743 : }
744 : next_after_fail276:;
745 : return NULL_TREE;
746 : }
747 :
748 : tree
749 19 : generic_simplify_143 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
750 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
751 : const enum tree_code ARG_UNUSED (op))
752 : {
753 19 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
754 38 : if (INTEGRAL_TYPE_P (type)
755 19 : && operand_equal_p (captures[2], captures[6], 0)
756 38 : && (tree_nonzero_bits (captures[0]) & tree_nonzero_bits (captures[4])) == 0
757 : )
758 : {
759 0 : {
760 0 : tree t = type;
761 0 : if (!TYPE_OVERFLOW_WRAPS (t))
762 0 : t = unsigned_type_for (t);
763 0 : wide_int c = wi::add (wi::to_wide (captures[3]), wi::to_wide (captures[7]));
764 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail278;
765 0 : if (TREE_SIDE_EFFECTS (captures[7])) goto next_after_fail278;
766 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail278;
767 0 : {
768 0 : tree res_op0;
769 0 : {
770 0 : tree _o1[2], _r1;
771 0 : {
772 0 : tree _o2[1], _r2;
773 0 : _o2[0] = captures[2];
774 0 : if (TREE_TYPE (_o2[0]) != t)
775 : {
776 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, t, _o2[0]);
777 : }
778 : else
779 : _r2 = _o2[0];
780 0 : _o1[0] = _r2;
781 : }
782 0 : _o1[1] = wide_int_to_tree (t, c);
783 0 : _r1 = fold_build2_loc (loc, MULT_EXPR, t, _o1[0], _o1[1]);
784 0 : res_op0 = _r1;
785 : }
786 0 : tree _r;
787 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
788 0 : if (TREE_SIDE_EFFECTS (captures[6]))
789 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[6]), _r);
790 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 166, __FILE__, __LINE__, true);
791 0 : return _r;
792 : }
793 0 : next_after_fail278:;
794 0 : }
795 : }
796 : return NULL_TREE;
797 : }
798 :
799 : tree
800 0 : generic_simplify_148 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
801 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
802 : {
803 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
804 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail283;
805 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail283;
806 0 : {
807 0 : tree _r;
808 0 : _r = captures[1];
809 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 206, __FILE__, __LINE__, true);
810 : return _r;
811 : }
812 : next_after_fail283:;
813 : return NULL_TREE;
814 : }
815 :
816 : tree
817 0 : generic_simplify_151 (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 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
821 0 : if (type_has_mode_precision_p (type)
822 0 : && tree_fits_uhwi_p (captures[1])
823 0 : && tree_fits_uhwi_p (captures[3])
824 0 : && tree_fits_uhwi_p (captures[4])
825 0 : && ((~((HOST_WIDE_INT_1U << tree_to_uhwi (captures[1])) - 1)) & tree_to_uhwi (captures[4])) == 0
826 0 : && (tree_to_uhwi (captures[1]) + tree_to_uhwi (captures[3])) == TYPE_PRECISION (type)
827 0 : && TYPE_UNSIGNED (type)
828 0 : && captures[0] == captures[2]
829 : )
830 : {
831 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail286;
832 0 : {
833 0 : tree res_op0;
834 0 : {
835 0 : tree _o1[2], _r1;
836 0 : _o1[0] = captures[0];
837 0 : _o1[1] = captures[3];
838 0 : _r1 = fold_build2_loc (loc, RROTATE_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
839 0 : res_op0 = _r1;
840 : }
841 0 : tree res_op1;
842 0 : res_op1 = captures[4];
843 0 : tree _r;
844 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
845 0 : if (TREE_SIDE_EFFECTS (captures[1]))
846 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
847 0 : if (TREE_SIDE_EFFECTS (captures[2]))
848 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
849 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 208, __FILE__, __LINE__, true);
850 0 : return _r;
851 : }
852 0 : next_after_fail286:;
853 : }
854 : return NULL_TREE;
855 : }
856 :
857 : tree
858 1 : generic_simplify_159 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
859 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
860 : {
861 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
862 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail294;
863 1 : {
864 1 : tree res_op0;
865 1 : res_op0 = captures[1];
866 1 : tree res_op1;
867 1 : {
868 1 : tree _o1[1], _r1;
869 1 : _o1[0] = captures[2];
870 1 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
871 1 : res_op1 = _r1;
872 : }
873 1 : tree _r;
874 1 : _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
875 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 216, __FILE__, __LINE__, true);
876 : return _r;
877 : }
878 0 : next_after_fail294:;
879 0 : return NULL_TREE;
880 : }
881 :
882 : tree
883 112 : generic_simplify_168 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
884 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
885 : const enum tree_code ARG_UNUSED (opo),
886 : const enum tree_code ARG_UNUSED (opi))
887 : {
888 112 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
889 112 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail303;
890 112 : {
891 112 : tree res_op0;
892 112 : {
893 112 : tree _o1[1], _r1;
894 112 : _o1[0] = captures[1];
895 112 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
896 112 : res_op0 = _r1;
897 : }
898 112 : tree res_op1;
899 112 : res_op1 = captures[2];
900 112 : tree _r;
901 112 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
902 112 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 225, __FILE__, __LINE__, true);
903 : return _r;
904 : }
905 0 : next_after_fail303:;
906 0 : return NULL_TREE;
907 : }
908 :
909 : tree
910 18 : generic_simplify_173 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
911 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
912 : const enum tree_code ARG_UNUSED (cmp))
913 : {
914 18 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
915 36 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
916 18 : && !TYPE_UNSIGNED (TREE_TYPE (captures[1]))
917 36 : && types_match (TREE_TYPE (captures[1]), TREE_TYPE (captures[3]))
918 : )
919 : {
920 18 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail309;
921 18 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail309;
922 18 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail309;
923 18 : {
924 18 : tree res_op0;
925 18 : {
926 18 : tree _o1[2], _r1;
927 18 : _o1[0] = captures[1];
928 18 : _o1[1] = captures[3];
929 18 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
930 18 : res_op0 = _r1;
931 : }
932 18 : tree res_op1;
933 18 : res_op1 = build_zero_cst (TREE_TYPE (captures[1]));
934 18 : tree _r;
935 18 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
936 18 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 230, __FILE__, __LINE__, true);
937 18 : return _r;
938 : }
939 : next_after_fail309:;
940 : }
941 : return NULL_TREE;
942 : }
943 :
944 : tree
945 6 : generic_simplify_185 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
946 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
947 : {
948 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
949 6 : if (INTEGRAL_TYPE_P (type)
950 6 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
951 12 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
952 : )
953 : {
954 6 : if (TYPE_UNSIGNED (type)
955 : )
956 : {
957 5 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail322;
958 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail322;
959 5 : {
960 5 : tree res_op0;
961 5 : res_op0 = captures[0];
962 5 : tree _r;
963 5 : _r = fold_build1_loc (loc, ABSU_EXPR, type, res_op0);
964 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 240, __FILE__, __LINE__, true);
965 5 : return _r;
966 : }
967 : next_after_fail322:;
968 : }
969 : else
970 : {
971 1 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail323;
972 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail323;
973 1 : {
974 1 : tree res_op0;
975 1 : res_op0 = captures[0];
976 1 : tree _r;
977 1 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
978 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 241, __FILE__, __LINE__, true);
979 1 : return _r;
980 : }
981 : next_after_fail323:;
982 : }
983 : }
984 : return NULL_TREE;
985 : }
986 :
987 : tree
988 6 : generic_simplify_197 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
989 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
990 : const combined_fn ARG_UNUSED (LDEXP))
991 : {
992 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
993 6 : if (flag_unsafe_math_optimizations
994 : )
995 : {
996 6 : {
997 6 : HOST_WIDE_INT tmp = 0;
998 6 : if (real_isinteger (&TREE_REAL_CST (captures[0]), &tmp)
999 6 : && tmp > 0 && pow2p_hwi (tmp)
1000 : )
1001 : {
1002 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail337;
1003 3 : {
1004 3 : tree res_op0;
1005 3 : res_op0 = captures[1];
1006 3 : tree res_op1;
1007 3 : {
1008 3 : tree _o1[2], _r1;
1009 3 : _o1[0] = build_int_cst (integer_type_node,
1010 6 : exact_log2 (tmp));
1011 3 : _o1[1] = captures[2];
1012 3 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1013 3 : res_op1 = _r1;
1014 : }
1015 3 : tree _r;
1016 3 : _r = maybe_build_call_expr_loc (loc, LDEXP, type, 2, res_op0, res_op1);
1017 3 : if (!_r)
1018 0 : goto next_after_fail337;
1019 3 : if (TREE_SIDE_EFFECTS (captures[0]))
1020 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1021 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 252, __FILE__, __LINE__, true);
1022 3 : return _r;
1023 : }
1024 3 : next_after_fail337:;
1025 : }
1026 : }
1027 : }
1028 : return NULL_TREE;
1029 : }
1030 :
1031 : tree
1032 4 : generic_simplify_209 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1033 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
1034 : {
1035 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1036 8 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1037 8 : && TYPE_PRECISION (TREE_TYPE (captures[1])) == 1
1038 : )
1039 : {
1040 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail352;
1041 0 : {
1042 0 : tree res_op0;
1043 0 : {
1044 0 : tree _o1[2], _r1;
1045 0 : _o1[0] = captures[1];
1046 0 : _o1[1] = captures[2];
1047 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1048 0 : res_op0 = _r1;
1049 : }
1050 0 : tree _r;
1051 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1052 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 266, __FILE__, __LINE__, true);
1053 0 : return _r;
1054 : }
1055 0 : next_after_fail352:;
1056 : }
1057 : return NULL_TREE;
1058 : }
1059 :
1060 : tree
1061 9220 : generic_simplify_214 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1062 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1063 : const enum tree_code ARG_UNUSED (neeq),
1064 : const enum tree_code ARG_UNUSED (ltge))
1065 : {
1066 9220 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1067 9220 : {
1068 9220 : tree itype = signed_type_for (TREE_TYPE (captures[1]));
1069 18227 : if (wi::to_wide (captures[2]) == element_precision (itype) - 1
1070 9220 : && (!VECTOR_TYPE_P (itype)
1071 11 : || (cfun
1072 11 : && cfun->after_inlining
1073 3 : && VECTOR_BOOLEAN_TYPE_P (type)
1074 0 : && (expand_vec_cmp_expr_p (itype, type, ltge)
1075 0 : || !expand_vec_cmp_expr_p (TREE_TYPE (captures[0]),
1076 : type, neeq))))
1077 : )
1078 : {
1079 213 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail370;
1080 213 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail370;
1081 213 : {
1082 213 : tree res_op0;
1083 213 : {
1084 213 : tree _o1[1], _r1;
1085 213 : _o1[0] = captures[1];
1086 213 : if (TREE_TYPE (_o1[0]) != itype)
1087 : {
1088 161 : _r1 = fold_build1_loc (loc, NOP_EXPR, itype, _o1[0]);
1089 : }
1090 : else
1091 : _r1 = _o1[0];
1092 213 : res_op0 = _r1;
1093 : }
1094 213 : tree res_op1;
1095 213 : res_op1 = build_zero_cst (itype);
1096 213 : tree _r;
1097 213 : _r = fold_build2_loc (loc, ltge, type, res_op0, res_op1);
1098 213 : if (TREE_SIDE_EFFECTS (captures[2]))
1099 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1100 213 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 284, __FILE__, __LINE__, true);
1101 213 : return _r;
1102 : }
1103 : next_after_fail370:;
1104 : }
1105 : }
1106 : return NULL_TREE;
1107 : }
1108 :
1109 : tree
1110 1063 : generic_simplify_227 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1111 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1112 : const enum tree_code ARG_UNUSED (minmax),
1113 : const enum tree_code ARG_UNUSED (cmp),
1114 : const enum tree_code ARG_UNUSED (out))
1115 : {
1116 1063 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1117 2126 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1118 1208 : && (!VECTOR_TYPE_P (TREE_TYPE (captures[0]))
1119 1 : || (VECTOR_TYPE_P (type)
1120 0 : && (!expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, cmp)
1121 0 : || expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, out))))
1122 : )
1123 : {
1124 144 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail383;
1125 144 : {
1126 144 : tree res_op0;
1127 144 : res_op0 = captures[0];
1128 144 : tree res_op1;
1129 144 : res_op1 = captures[1];
1130 144 : tree _r;
1131 144 : _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
1132 144 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 296, __FILE__, __LINE__, true);
1133 144 : return _r;
1134 : }
1135 0 : next_after_fail383:;
1136 : }
1137 : return NULL_TREE;
1138 : }
1139 :
1140 : tree
1141 644 : generic_simplify_235 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1142 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1143 : const enum tree_code ARG_UNUSED (cmp))
1144 : {
1145 644 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1146 644 : if (tree_fits_shwi_p (captures[3])
1147 644 : && tree_to_shwi (captures[3]) > 0
1148 1274 : && tree_to_shwi (captures[3]) < TYPE_PRECISION (TREE_TYPE (captures[2]))
1149 : )
1150 : {
1151 630 : {
1152 630 : tree t0 = TREE_TYPE (captures[2]);
1153 630 : unsigned int prec = TYPE_PRECISION (t0);
1154 630 : wide_int c1 = wi::to_wide (captures[3]);
1155 630 : wide_int c2 = wi::to_wide (captures[4]);
1156 630 : wide_int c3 = wi::to_wide (captures[5]);
1157 630 : wide_int sb = wi::set_bit_in_zero (prec - 1, prec);
1158 630 : if ((c2 & c3) != c3
1159 : )
1160 : {
1161 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail396;
1162 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail396;
1163 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail396;
1164 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail396;
1165 0 : {
1166 0 : tree _r;
1167 0 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1168 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1169 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1170 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 309, __FILE__, __LINE__, true);
1171 0 : return _r;
1172 : }
1173 0 : next_after_fail396:;
1174 : }
1175 : else
1176 : {
1177 630 : if (TYPE_UNSIGNED (t0)
1178 : )
1179 : {
1180 508 : if ((c3 & wi::arshift (sb, c1 - 1)) != 0
1181 : )
1182 : {
1183 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail397;
1184 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail397;
1185 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail397;
1186 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail397;
1187 0 : {
1188 0 : tree _r;
1189 0 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1190 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1191 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1192 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 310, __FILE__, __LINE__, true);
1193 0 : return _r;
1194 : }
1195 0 : next_after_fail397:;
1196 : }
1197 : else
1198 : {
1199 508 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail398;
1200 508 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail398;
1201 508 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail398;
1202 508 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail398;
1203 508 : {
1204 508 : tree res_op0;
1205 508 : {
1206 508 : tree _o1[2], _r1;
1207 508 : _o1[0] = captures[2];
1208 508 : _o1[1] = wide_int_to_tree (t0, c2 << c1);
1209 508 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1210 508 : res_op0 = _r1;
1211 : }
1212 508 : tree res_op1;
1213 508 : res_op1 = wide_int_to_tree (t0, c3 << c1);
1214 508 : tree _r;
1215 508 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1216 508 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 311, __FILE__, __LINE__, true);
1217 508 : return _r;
1218 : }
1219 0 : next_after_fail398:;
1220 : }
1221 : }
1222 : else
1223 : {
1224 122 : {
1225 122 : wide_int smask = wi::arshift (sb, c1);
1226 122 : if ((c2 & smask) == 0
1227 : )
1228 : {
1229 120 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail399;
1230 120 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail399;
1231 120 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail399;
1232 120 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail399;
1233 120 : {
1234 120 : tree res_op0;
1235 120 : {
1236 120 : tree _o1[2], _r1;
1237 120 : _o1[0] = captures[2];
1238 120 : _o1[1] = wide_int_to_tree (t0, c2 << c1);
1239 120 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1240 120 : res_op0 = _r1;
1241 : }
1242 120 : tree res_op1;
1243 120 : res_op1 = wide_int_to_tree (t0, c3 << c1);
1244 120 : tree _r;
1245 120 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1246 120 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 312, __FILE__, __LINE__, true);
1247 120 : return _r;
1248 : }
1249 0 : next_after_fail399:;
1250 : }
1251 : else
1252 : {
1253 2 : if ((c3 & smask) == 0
1254 : )
1255 : {
1256 2 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail400;
1257 2 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail400;
1258 2 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail400;
1259 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail400;
1260 2 : {
1261 2 : tree res_op0;
1262 2 : {
1263 2 : tree _o1[2], _r1;
1264 2 : _o1[0] = captures[2];
1265 2 : _o1[1] = wide_int_to_tree (t0, (c2 << c1) | sb);
1266 2 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1267 2 : res_op0 = _r1;
1268 : }
1269 2 : tree res_op1;
1270 2 : res_op1 = wide_int_to_tree (t0, c3 << c1);
1271 2 : tree _r;
1272 2 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1273 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 313, __FILE__, __LINE__, true);
1274 2 : return _r;
1275 : }
1276 0 : next_after_fail400:;
1277 : }
1278 : else
1279 : {
1280 0 : if ((c2 & smask) != (c3 & smask)
1281 : )
1282 : {
1283 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail401;
1284 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail401;
1285 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail401;
1286 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail401;
1287 0 : {
1288 0 : tree _r;
1289 0 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1290 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1291 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1292 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 314, __FILE__, __LINE__, true);
1293 0 : return _r;
1294 : }
1295 0 : next_after_fail401:;
1296 : }
1297 : else
1298 : {
1299 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail402;
1300 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail402;
1301 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail402;
1302 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail402;
1303 0 : {
1304 0 : tree res_op0;
1305 0 : {
1306 0 : tree _o1[2], _r1;
1307 0 : _o1[0] = captures[2];
1308 0 : _o1[1] = wide_int_to_tree (t0, (c2 << c1) | sb);
1309 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1310 0 : res_op0 = _r1;
1311 : }
1312 0 : tree res_op1;
1313 0 : res_op1 = wide_int_to_tree (t0, (c3 << c1) | sb);
1314 0 : tree _r;
1315 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1316 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 315, __FILE__, __LINE__, true);
1317 0 : return _r;
1318 : }
1319 0 : next_after_fail402:;
1320 : }
1321 : }
1322 : }
1323 122 : }
1324 : }
1325 : }
1326 630 : }
1327 : }
1328 : return NULL_TREE;
1329 : }
1330 :
1331 : tree
1332 1110620 : generic_simplify_267 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1333 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1334 : const enum tree_code ARG_UNUSED (cmp))
1335 : {
1336 1110620 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1337 1110620 : {
1338 1110620 : poly_int64 off; tree base;
1339 1110620 : tree addr = (TREE_CODE (captures[1]) == SSA_NAME
1340 1110620 : ? gimple_assign_rhs1 (SSA_NAME_DEF_STMT (captures[1])) : captures[1]);
1341 1110620 : if (SSA_NAME_IS_DEFAULT_DEF (captures[0])
1342 46952 : && TREE_CODE (SSA_NAME_VAR (captures[0])) == PARM_DECL
1343 46794 : && (base = get_base_address (TREE_OPERAND (addr, 0)))
1344 46794 : && TREE_CODE (base) == VAR_DECL
1345 1113838 : && auto_var_in_fn_p (base, current_function_decl)
1346 : )
1347 : {
1348 0 : if (cmp == NE_EXPR
1349 : )
1350 : {
1351 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail494;
1352 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail494;
1353 0 : {
1354 0 : tree _r;
1355 0 : _r = constant_boolean_node (true, type);
1356 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1357 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1358 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 398, __FILE__, __LINE__, true);
1359 2 : return _r;
1360 : }
1361 1110618 : next_after_fail494:;
1362 : }
1363 : else
1364 : {
1365 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail495;
1366 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail495;
1367 0 : {
1368 0 : tree _r;
1369 0 : _r = constant_boolean_node (false, type);
1370 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1371 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1372 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 399, __FILE__, __LINE__, true);
1373 0 : return _r;
1374 : }
1375 1110618 : next_after_fail495:;
1376 : }
1377 : }
1378 : else
1379 : {
1380 1110620 : if ((base = get_addr_base_and_unit_offset (TREE_OPERAND (addr, 0), &off))
1381 1108232 : && TREE_CODE (base) == MEM_REF
1382 1269087 : && TREE_OPERAND (base, 0) == captures[0]
1383 : )
1384 : {
1385 2 : {
1386 2 : off += mem_ref_offset (base).force_shwi ();
1387 2 : if (known_ne (off, 0)
1388 : )
1389 : {
1390 2 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail496;
1391 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail496;
1392 2 : {
1393 2 : tree _r;
1394 2 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1395 2 : if (TREE_SIDE_EFFECTS (captures[0]))
1396 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1397 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 400, __FILE__, __LINE__, true);
1398 2 : return _r;
1399 : }
1400 1110618 : next_after_fail496:;
1401 : }
1402 : else
1403 : {
1404 0 : if (known_eq (off, 0)
1405 : )
1406 : {
1407 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail497;
1408 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail497;
1409 0 : {
1410 0 : tree _r;
1411 0 : _r = constant_boolean_node (cmp == EQ_EXPR, type);
1412 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1413 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1414 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 401, __FILE__, __LINE__, true);
1415 0 : return _r;
1416 : }
1417 1110618 : next_after_fail497:;
1418 : }
1419 : }
1420 : }
1421 : }
1422 : }
1423 : }
1424 1110618 : return NULL_TREE;
1425 : }
1426 :
1427 : tree
1428 4 : generic_simplify_280 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1429 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1430 : const enum tree_code ARG_UNUSED (cmp),
1431 : const enum tree_code ARG_UNUSED (ncmp))
1432 : {
1433 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1434 8 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1435 4 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1436 8 : && types_match (captures[0], captures[2])
1437 : )
1438 : {
1439 4 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail510;
1440 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail510;
1441 4 : {
1442 4 : tree res_op0;
1443 4 : {
1444 4 : tree _o1[2], _r1;
1445 4 : _o1[0] = captures[0];
1446 4 : _o1[1] = captures[2];
1447 4 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1448 4 : res_op0 = _r1;
1449 : }
1450 4 : tree res_op1;
1451 4 : res_op1 = captures[1];
1452 4 : tree _r;
1453 4 : _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
1454 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 413, __FILE__, __LINE__, true);
1455 4 : return _r;
1456 : }
1457 : next_after_fail510:;
1458 : }
1459 : return NULL_TREE;
1460 : }
1461 :
1462 : tree
1463 1082456 : generic_simplify_286 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1464 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1465 : const enum tree_code ARG_UNUSED (cmp))
1466 : {
1467 1082456 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1468 1636089 : if (((POINTER_TYPE_P (TREE_TYPE (captures[0]))
1469 530650 : && !FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (captures[0])))
1470 493777 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1471 9220 : && !(
1472 : 1
1473 9192 : && TREE_CODE (TREE_TYPE (captures[0])) == REFERENCE_TYPE
1474 28 : && (flag_sanitize & (SANITIZE_NULL | SANITIZE_ALIGNMENT))))
1475 1073276 : || (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1476 551677 : && POINTER_TYPE_P (TREE_TYPE (captures[1]))
1477 2336 : && !FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (captures[1])))))
1478 1093524 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == TYPE_PRECISION (TREE_TYPE (captures[1]))
1479 : )
1480 : {
1481 10006 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail530;
1482 10006 : {
1483 10006 : tree res_op0;
1484 10006 : res_op0 = captures[0];
1485 10006 : tree res_op1;
1486 10006 : {
1487 10006 : tree _o1[1], _r1;
1488 10006 : _o1[0] = captures[1];
1489 10006 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
1490 : {
1491 10006 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
1492 : }
1493 : else
1494 : _r1 = _o1[0];
1495 10006 : res_op1 = _r1;
1496 : }
1497 10006 : tree _r;
1498 10006 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1499 10006 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 424, __FILE__, __LINE__, true);
1500 10006 : return _r;
1501 : }
1502 0 : next_after_fail530:;
1503 : }
1504 : return NULL_TREE;
1505 : }
1506 :
1507 : tree
1508 593262 : generic_simplify_290 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1509 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1510 : const enum tree_code ARG_UNUSED (cmp),
1511 : const enum tree_code ARG_UNUSED (rcmp))
1512 : {
1513 593262 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1514 1186524 : if (!TREE_OVERFLOW (captures[0]) && !TREE_OVERFLOW (captures[2])
1515 1186524 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
1516 : )
1517 : {
1518 4396 : {
1519 4396 : tree res = int_const_binop (MINUS_EXPR, captures[0], captures[2]);
1520 4396 : if (TREE_OVERFLOW (res)
1521 : )
1522 : {
1523 48 : if (cmp == NE_EXPR
1524 : )
1525 : {
1526 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail539;
1527 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail539;
1528 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail539;
1529 0 : {
1530 0 : tree _r;
1531 0 : _r = constant_boolean_node (true, type);
1532 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1533 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1534 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 433, __FILE__, __LINE__, true);
1535 0 : return _r;
1536 : }
1537 : next_after_fail539:;
1538 : }
1539 : else
1540 : {
1541 48 : if (cmp == EQ_EXPR
1542 : )
1543 : {
1544 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail540;
1545 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail540;
1546 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail540;
1547 0 : {
1548 0 : tree _r;
1549 0 : _r = constant_boolean_node (false, type);
1550 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1551 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1552 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 434, __FILE__, __LINE__, true);
1553 0 : return _r;
1554 : }
1555 : next_after_fail540:;
1556 : }
1557 : else
1558 : {
1559 48 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail541;
1560 48 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail541;
1561 48 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail541;
1562 48 : {
1563 48 : tree _r;
1564 48 : bool less = cmp == LE_EXPR || cmp == LT_EXPR;
1565 48 : bool ovf_high = wi::lt_p (wi::to_wide (captures[0]), 0,
1566 48 : TYPE_SIGN (TREE_TYPE (captures[0]))); _r =
1567 48 : constant_boolean_node (less == ovf_high, type);
1568 48 : if (TREE_SIDE_EFFECTS (captures[1]))
1569 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1570 48 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 435, __FILE__, __LINE__, true);
1571 48 : return _r;
1572 : }
1573 : next_after_fail541:;
1574 : }
1575 : }
1576 : }
1577 : else
1578 : {
1579 4348 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail542;
1580 4348 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail542;
1581 4348 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail542;
1582 4348 : {
1583 4348 : tree res_op0;
1584 4348 : res_op0 = captures[1];
1585 4348 : tree res_op1;
1586 4348 : res_op1 = res;
1587 4348 : tree _r;
1588 4348 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
1589 4348 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 436, __FILE__, __LINE__, true);
1590 4348 : return _r;
1591 : }
1592 : next_after_fail542:;
1593 : }
1594 : }
1595 : }
1596 : else
1597 : {
1598 588866 : if (TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1599 : )
1600 : {
1601 588760 : if (cmp == EQ_EXPR || cmp == NE_EXPR
1602 : )
1603 : {
1604 36724 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail543;
1605 36724 : {
1606 36724 : tree res_op0;
1607 36724 : res_op0 = captures[1];
1608 36724 : tree res_op1;
1609 36724 : {
1610 36724 : tree _o1[2], _r1;
1611 36724 : _o1[0] = captures[0];
1612 36724 : _o1[1] = captures[2];
1613 36724 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1614 36724 : res_op1 = _r1;
1615 : }
1616 36724 : tree _r;
1617 36724 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1618 36724 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 437, __FILE__, __LINE__, true);
1619 36724 : return _r;
1620 : }
1621 0 : next_after_fail543:;
1622 : }
1623 : else
1624 : {
1625 552036 : if (cmp == LE_EXPR || cmp == GT_EXPR
1626 : )
1627 : {
1628 552036 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail544;
1629 552036 : {
1630 552036 : if (! tree_invariant_p (captures[2])) goto next_after_fail544;
1631 552036 : tree res_op0;
1632 552036 : {
1633 552036 : tree _o1[2], _r1;
1634 552036 : _o1[0] = captures[1];
1635 552036 : {
1636 552036 : tree _o2[2], _r2;
1637 552036 : _o2[0] = unshare_expr (captures[2]);
1638 552036 : _o2[1] = captures[0];
1639 552036 : _r2 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
1640 552036 : _o1[1] = _r2;
1641 : }
1642 552036 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1643 552036 : res_op0 = _r1;
1644 : }
1645 552036 : tree res_op1;
1646 552036 : res_op1 = captures[2];
1647 552036 : tree _r;
1648 552036 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1649 552036 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 438, __FILE__, __LINE__, true);
1650 552036 : return _r;
1651 : }
1652 : next_after_fail544:;
1653 : }
1654 : else
1655 : {
1656 0 : if (cmp == LT_EXPR || cmp == GE_EXPR
1657 : )
1658 : {
1659 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail545;
1660 0 : {
1661 0 : if (! tree_invariant_p (captures[2])) goto next_after_fail545;
1662 0 : tree res_op0;
1663 0 : {
1664 0 : tree _o1[2], _r1;
1665 0 : _o1[0] = captures[1];
1666 0 : {
1667 0 : tree _o2[2], _r2;
1668 0 : _o2[0] = unshare_expr (captures[2]);
1669 0 : {
1670 0 : tree _o3[2], _r3;
1671 0 : _o3[0] = captures[0];
1672 0 : _o3[1] = build_one_cst (TREE_TYPE (captures[1]));
1673 0 : _r3 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
1674 0 : _o2[1] = _r3;
1675 : }
1676 0 : _r2 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
1677 0 : _o1[1] = _r2;
1678 : }
1679 0 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1680 0 : res_op0 = _r1;
1681 : }
1682 0 : tree res_op1;
1683 0 : res_op1 = captures[2];
1684 0 : tree _r;
1685 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1686 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 439, __FILE__, __LINE__, true);
1687 0 : return _r;
1688 : }
1689 : next_after_fail545:;
1690 : }
1691 : }
1692 : }
1693 : }
1694 : else
1695 : {
1696 106 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1697 106 : && TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))
1698 : )
1699 : {
1700 106 : if (cmp == EQ_EXPR || cmp == NE_EXPR
1701 : )
1702 : {
1703 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail546;
1704 0 : {
1705 0 : tree res_op0;
1706 0 : res_op0 = captures[1];
1707 0 : tree res_op1;
1708 0 : {
1709 0 : tree _o1[2], _r1;
1710 0 : _o1[0] = captures[0];
1711 0 : _o1[1] = captures[2];
1712 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1713 0 : res_op1 = _r1;
1714 : }
1715 0 : tree _r;
1716 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1717 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 440, __FILE__, __LINE__, true);
1718 0 : return _r;
1719 : }
1720 0 : next_after_fail546:;
1721 : }
1722 : else
1723 : {
1724 106 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail547;
1725 106 : {
1726 106 : tree res_op0;
1727 106 : {
1728 106 : tree _o1[2], _r1;
1729 106 : _o1[0] = captures[1];
1730 106 : {
1731 106 : tree _o2[2], _r2;
1732 106 : _o2[0] = captures[0];
1733 106 : _o2[1] = build_one_cst (TREE_TYPE (captures[1]));
1734 106 : _r2 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
1735 106 : _o1[1] = _r2;
1736 : }
1737 106 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1738 106 : res_op0 = _r1;
1739 : }
1740 106 : tree res_op1;
1741 106 : {
1742 106 : tree _o1[1], _r1;
1743 106 : _o1[0] = captures[2];
1744 106 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
1745 106 : res_op1 = _r1;
1746 : }
1747 106 : tree _r;
1748 106 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
1749 106 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 441, __FILE__, __LINE__, true);
1750 106 : return _r;
1751 : }
1752 0 : next_after_fail547:;
1753 : }
1754 : }
1755 : }
1756 : }
1757 : return NULL_TREE;
1758 : }
1759 :
1760 : tree
1761 6 : generic_simplify_331 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1762 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1763 : const combined_fn ARG_UNUSED (SIN),
1764 : const combined_fn ARG_UNUSED (COS),
1765 : const combined_fn ARG_UNUSED (TAN))
1766 : {
1767 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1768 6 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1769 : )
1770 : {
1771 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail600;
1772 6 : {
1773 6 : tree res_op0;
1774 6 : res_op0 = captures[1];
1775 6 : tree _r;
1776 6 : _r = maybe_build_call_expr_loc (loc, TAN, type, 1, res_op0);
1777 6 : if (!_r)
1778 0 : goto next_after_fail600;
1779 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 492, __FILE__, __LINE__, true);
1780 6 : return _r;
1781 : }
1782 : next_after_fail600:;
1783 : }
1784 : return NULL_TREE;
1785 : }
1786 :
1787 : tree
1788 0 : generic_simplify_339 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1789 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1790 : const enum tree_code ARG_UNUSED (op),
1791 : const combined_fn ARG_UNUSED (bt),
1792 : const combined_fn ARG_UNUSED (bf),
1793 : const combined_fn ARG_UNUSED (floor),
1794 : const combined_fn ARG_UNUSED (ceil))
1795 : {
1796 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1797 0 : if (!HONOR_SIGNED_ZEROS (type) && !HONOR_SIGN_DEPENDENT_ROUNDING (type)
1798 : )
1799 : {
1800 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail608;
1801 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail608;
1802 0 : {
1803 0 : tree res_op0;
1804 0 : {
1805 0 : tree _o1[2], _r1;
1806 0 : _o1[0] = captures[1];
1807 0 : _o1[1] = build_real (type, dconsthalf);
1808 0 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1809 0 : res_op0 = _r1;
1810 : }
1811 0 : tree _r;
1812 0 : _r = maybe_build_call_expr_loc (loc, floor, type, 1, res_op0);
1813 0 : if (!_r)
1814 0 : goto next_after_fail608;
1815 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 500, __FILE__, __LINE__, true);
1816 0 : return _r;
1817 : }
1818 : next_after_fail608:;
1819 : }
1820 : return NULL_TREE;
1821 : }
1822 :
1823 : tree
1824 15 : generic_simplify_348 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1825 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1826 : const enum tree_code ARG_UNUSED (op))
1827 : {
1828 15 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1829 15 : if (INTEGRAL_TYPE_P (type)
1830 15 : && TYPE_PRECISION (type) > 1
1831 15 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1832 30 : && expr_no_side_effects_p (captures[1])
1833 : )
1834 : {
1835 8 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail623;
1836 8 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail623;
1837 8 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail623;
1838 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail623;
1839 8 : {
1840 8 : tree res_op0;
1841 8 : {
1842 8 : tree _o1[2], _r1;
1843 8 : {
1844 8 : tree _o2[1], _r2;
1845 8 : _o2[0] = captures[0];
1846 8 : if (TREE_TYPE (_o2[0]) != type)
1847 : {
1848 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, type, _o2[0]);
1849 : }
1850 : else
1851 : _r2 = _o2[0];
1852 8 : _o1[0] = _r2;
1853 : }
1854 8 : _o1[1] = captures[1];
1855 8 : _r1 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1856 8 : res_op0 = _r1;
1857 : }
1858 8 : tree res_op1;
1859 8 : res_op1 = captures[2];
1860 8 : tree _r;
1861 8 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1862 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 514, __FILE__, __LINE__, true);
1863 8 : return _r;
1864 : }
1865 : next_after_fail623:;
1866 : }
1867 : return NULL_TREE;
1868 : }
1869 :
1870 : tree
1871 0 : generic_simplify_356 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1872 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1873 : const enum tree_code ARG_UNUSED (op))
1874 : {
1875 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1876 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail631;
1877 0 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail631;
1878 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail631;
1879 0 : {
1880 0 : tree _r;
1881 0 : _r = captures[2];
1882 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 522, __FILE__, __LINE__, true);
1883 : return _r;
1884 : }
1885 : next_after_fail631:;
1886 : return NULL_TREE;
1887 : }
1888 :
1889 : tree
1890 6 : generic_simplify_363 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1891 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1892 : const enum tree_code ARG_UNUSED (neeq),
1893 : const combined_fn ARG_UNUSED (sign))
1894 : {
1895 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1896 6 : if (neeq == NE_EXPR
1897 : )
1898 : {
1899 3 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail638;
1900 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail638;
1901 3 : {
1902 3 : tree res_op0;
1903 3 : res_op0 = captures[0];
1904 3 : tree _r;
1905 3 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
1906 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 529, __FILE__, __LINE__, true);
1907 3 : return _r;
1908 : }
1909 : next_after_fail638:;
1910 : }
1911 : else
1912 : {
1913 3 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail639;
1914 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail639;
1915 3 : {
1916 3 : tree res_op0;
1917 3 : {
1918 3 : tree _o1[1], _r1;
1919 3 : _o1[0] = captures[0];
1920 3 : _r1 = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
1921 3 : res_op0 = _r1;
1922 : }
1923 3 : tree _r;
1924 3 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
1925 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 530, __FILE__, __LINE__, true);
1926 3 : return _r;
1927 : }
1928 : next_after_fail639:;
1929 : }
1930 : return NULL_TREE;
1931 : }
1932 :
1933 : tree
1934 83707 : generic_simplify_374 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1935 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1936 : const enum tree_code ARG_UNUSED (op))
1937 : {
1938 83707 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1939 167414 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1940 83707 : && TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1941 167414 : && wi::only_sign_bit_p (wi::to_wide (captures[1]))
1942 : )
1943 : {
1944 5 : {
1945 5 : tree stype = signed_type_for (TREE_TYPE (captures[1]));
1946 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail654;
1947 5 : {
1948 5 : tree res_op0;
1949 5 : {
1950 5 : tree _o1[1], _r1;
1951 5 : _o1[0] = captures[0];
1952 5 : if (TREE_TYPE (_o1[0]) != stype)
1953 : {
1954 5 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
1955 : }
1956 : else
1957 : _r1 = _o1[0];
1958 5 : res_op0 = _r1;
1959 : }
1960 5 : tree res_op1;
1961 5 : {
1962 5 : tree _o1[1], _r1;
1963 5 : _o1[0] = captures[2];
1964 5 : if (TREE_TYPE (_o1[0]) != stype)
1965 : {
1966 5 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
1967 : }
1968 : else
1969 : _r1 = _o1[0];
1970 5 : res_op1 = _r1;
1971 : }
1972 5 : tree _r;
1973 5 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1974 5 : if (TREE_SIDE_EFFECTS (captures[1]))
1975 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1976 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 544, __FILE__, __LINE__, true);
1977 5 : return _r;
1978 : }
1979 0 : next_after_fail654:;
1980 : }
1981 : }
1982 : return NULL_TREE;
1983 : }
1984 :
1985 : tree
1986 1251752 : generic_simplify_385 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1987 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1988 : const enum tree_code ARG_UNUSED (cmp))
1989 : {
1990 1251752 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1991 2503504 : if ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
1992 386 : || POINTER_TYPE_P (TREE_TYPE (captures[2]))
1993 11 : || VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[2])))
1994 2503504 : && tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
1995 : )
1996 : {
1997 1080398 : {
1998 1080398 : tree cst = uniform_integer_cst_p (captures[2]);
1999 1080398 : tree arg1_type = TREE_TYPE (cst);
2000 1080398 : unsigned int prec = TYPE_PRECISION (arg1_type);
2001 1080398 : wide_int max = wi::max_value (arg1_type);
2002 1080398 : wide_int signed_max = wi::max_value (prec, SIGNED);
2003 1080398 : wide_int min = wi::min_value (arg1_type);
2004 1080398 : if (wi::to_wide (cst) == max
2005 : )
2006 : {
2007 671 : if (cmp == GT_EXPR
2008 : )
2009 : {
2010 448 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail668;
2011 448 : {
2012 448 : tree _r;
2013 448 : _r = constant_boolean_node (false, type);
2014 448 : if (TREE_SIDE_EFFECTS (captures[1]))
2015 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2016 448 : if (TREE_SIDE_EFFECTS (captures[2]))
2017 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2018 448 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 558, __FILE__, __LINE__, true);
2019 448 : return _r;
2020 : }
2021 0 : next_after_fail668:;
2022 : }
2023 : else
2024 : {
2025 223 : if (cmp == GE_EXPR
2026 : )
2027 : {
2028 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail669;
2029 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail669;
2030 0 : {
2031 0 : tree res_op0;
2032 0 : res_op0 = captures[0];
2033 0 : tree res_op1;
2034 0 : res_op1 = captures[2];
2035 0 : tree _r;
2036 0 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
2037 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 559, __FILE__, __LINE__, true);
2038 0 : return _r;
2039 : }
2040 1017671 : next_after_fail669:;
2041 : }
2042 : else
2043 : {
2044 223 : if (cmp == LE_EXPR
2045 : )
2046 : {
2047 223 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail670;
2048 223 : {
2049 223 : tree _r;
2050 223 : _r = constant_boolean_node (true, type);
2051 223 : if (TREE_SIDE_EFFECTS (captures[1]))
2052 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2053 223 : if (TREE_SIDE_EFFECTS (captures[2]))
2054 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2055 223 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 560, __FILE__, __LINE__, true);
2056 223 : return _r;
2057 : }
2058 0 : next_after_fail670:;
2059 : }
2060 : else
2061 : {
2062 0 : if (cmp == LT_EXPR
2063 : )
2064 : {
2065 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail671;
2066 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail671;
2067 0 : {
2068 0 : tree res_op0;
2069 0 : res_op0 = captures[0];
2070 0 : tree res_op1;
2071 0 : res_op1 = captures[2];
2072 0 : tree _r;
2073 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
2074 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 561, __FILE__, __LINE__, true);
2075 0 : return _r;
2076 : }
2077 1017671 : next_after_fail671:;
2078 : }
2079 : }
2080 : }
2081 : }
2082 : }
2083 : else
2084 : {
2085 1079727 : if (wi::to_wide (cst) == min
2086 : )
2087 : {
2088 56867 : if (cmp == LT_EXPR
2089 : )
2090 : {
2091 2802 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail672;
2092 2802 : {
2093 2802 : tree _r;
2094 2802 : _r = constant_boolean_node (false, type);
2095 2802 : if (TREE_SIDE_EFFECTS (captures[1]))
2096 6 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2097 2802 : if (TREE_SIDE_EFFECTS (captures[2]))
2098 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2099 2802 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 562, __FILE__, __LINE__, true);
2100 2802 : return _r;
2101 : }
2102 0 : next_after_fail672:;
2103 : }
2104 : else
2105 : {
2106 54065 : if (cmp == LE_EXPR
2107 : )
2108 : {
2109 14851 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail673;
2110 13733 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail673;
2111 13733 : {
2112 13733 : tree res_op0;
2113 13733 : res_op0 = captures[0];
2114 13733 : tree res_op1;
2115 13733 : res_op1 = captures[2];
2116 13733 : tree _r;
2117 13733 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
2118 13733 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 563, __FILE__, __LINE__, true);
2119 13733 : return _r;
2120 : }
2121 1017671 : next_after_fail673:;
2122 : }
2123 : else
2124 : {
2125 39214 : if (cmp == GE_EXPR
2126 : )
2127 : {
2128 8108 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail674;
2129 8108 : {
2130 8108 : tree _r;
2131 8108 : _r = constant_boolean_node (true, type);
2132 8108 : if (TREE_SIDE_EFFECTS (captures[1]))
2133 51 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2134 8108 : if (TREE_SIDE_EFFECTS (captures[2]))
2135 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2136 8108 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 564, __FILE__, __LINE__, true);
2137 8108 : return _r;
2138 : }
2139 0 : next_after_fail674:;
2140 : }
2141 : else
2142 : {
2143 31106 : if (cmp == GT_EXPR
2144 : )
2145 : {
2146 31106 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail675;
2147 25516 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail675;
2148 25516 : {
2149 25516 : tree res_op0;
2150 25516 : res_op0 = captures[0];
2151 25516 : tree res_op1;
2152 25516 : res_op1 = captures[2];
2153 25516 : tree _r;
2154 25516 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
2155 25516 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 565, __FILE__, __LINE__, true);
2156 25516 : return _r;
2157 : }
2158 1017671 : next_after_fail675:;
2159 : }
2160 : }
2161 : }
2162 : }
2163 : }
2164 : else
2165 : {
2166 1022860 : if (wi::to_wide (cst) == max - 1
2167 : )
2168 : {
2169 6363 : if (cmp == GT_EXPR
2170 : )
2171 : {
2172 1404 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail676;
2173 1404 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail676;
2174 1404 : {
2175 1404 : tree res_op0;
2176 1404 : res_op0 = captures[0];
2177 1404 : tree res_op1;
2178 1404 : res_op1 = build_uniform_cst (TREE_TYPE (captures[2]),
2179 1404 : wide_int_to_tree (TREE_TYPE (cst),
2180 1404 : wi::to_wide (cst)
2181 2808 : + 1));
2182 1404 : tree _r;
2183 1404 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
2184 1404 : if (TREE_SIDE_EFFECTS (captures[2]))
2185 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2186 1404 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 566, __FILE__, __LINE__, true);
2187 1404 : return _r;
2188 : }
2189 1017671 : next_after_fail676:;
2190 : }
2191 : else
2192 : {
2193 4959 : if (cmp == LE_EXPR
2194 : )
2195 : {
2196 4959 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail677;
2197 4959 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail677;
2198 4959 : {
2199 4959 : tree res_op0;
2200 4959 : res_op0 = captures[0];
2201 4959 : tree res_op1;
2202 4959 : res_op1 = build_uniform_cst (TREE_TYPE (captures[2]),
2203 4959 : wide_int_to_tree (TREE_TYPE (cst),
2204 4959 : wi::to_wide (cst)
2205 9918 : + 1));
2206 4959 : tree _r;
2207 4959 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
2208 4959 : if (TREE_SIDE_EFFECTS (captures[2]))
2209 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2210 4959 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 567, __FILE__, __LINE__, true);
2211 4959 : return _r;
2212 : }
2213 1017671 : next_after_fail677:;
2214 : }
2215 : }
2216 : }
2217 : else
2218 : {
2219 1016497 : if (wi::to_wide (cst) == min + 1
2220 : )
2221 : {
2222 54170 : if (cmp == GE_EXPR
2223 : )
2224 : {
2225 2308 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail678;
2226 2308 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail678;
2227 2308 : {
2228 2308 : tree res_op0;
2229 2308 : res_op0 = captures[0];
2230 2308 : tree res_op1;
2231 2308 : res_op1 = build_uniform_cst (TREE_TYPE (captures[2]),
2232 2308 : wide_int_to_tree (TREE_TYPE (cst),
2233 2308 : wi::to_wide (cst)
2234 4616 : - 1));
2235 2308 : tree _r;
2236 2308 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
2237 2308 : if (TREE_SIDE_EFFECTS (captures[2]))
2238 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2239 2308 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 568, __FILE__, __LINE__, true);
2240 2308 : return _r;
2241 : }
2242 1017671 : next_after_fail678:;
2243 : }
2244 : else
2245 : {
2246 51862 : if (cmp == LT_EXPR
2247 : )
2248 : {
2249 341 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail679;
2250 341 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail679;
2251 341 : {
2252 341 : tree res_op0;
2253 341 : res_op0 = captures[0];
2254 341 : tree res_op1;
2255 341 : res_op1 = build_uniform_cst (TREE_TYPE (captures[2]),
2256 341 : wide_int_to_tree (TREE_TYPE (cst),
2257 341 : wi::to_wide (cst)
2258 682 : - 1));
2259 341 : tree _r;
2260 341 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
2261 341 : if (TREE_SIDE_EFFECTS (captures[2]))
2262 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2263 341 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 569, __FILE__, __LINE__, true);
2264 341 : return _r;
2265 : }
2266 1017671 : next_after_fail679:;
2267 : }
2268 : }
2269 : }
2270 : else
2271 : {
2272 962327 : if (wi::to_wide (cst) == signed_max
2273 2885 : && TYPE_UNSIGNED (arg1_type)
2274 2885 : && TYPE_MODE (arg1_type) != BLKmode
2275 962327 : && prec == GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (arg1_type))
2276 965212 : && INTEGRAL_TYPE_P (arg1_type)
2277 : )
2278 : {
2279 2885 : if (cmp == LE_EXPR || cmp == GT_EXPR
2280 : )
2281 : {
2282 2885 : {
2283 2885 : tree st = signed_type_for (TREE_TYPE (captures[2]));
2284 2885 : if (cst == captures[2] && cmp == LE_EXPR
2285 : )
2286 : {
2287 2848 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail680;
2288 2848 : {
2289 2848 : tree res_op0;
2290 2848 : {
2291 2848 : tree _o1[1], _r1;
2292 2848 : _o1[0] = captures[1];
2293 2848 : if (TREE_TYPE (_o1[0]) != st)
2294 : {
2295 2844 : _r1 = fold_build1_loc (loc, NOP_EXPR, st, _o1[0]);
2296 : }
2297 : else
2298 : _r1 = _o1[0];
2299 2848 : res_op0 = _r1;
2300 : }
2301 2848 : tree res_op1;
2302 2848 : res_op1 = build_zero_cst (st);
2303 2848 : tree _r;
2304 2848 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
2305 2848 : if (TREE_SIDE_EFFECTS (captures[2]))
2306 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2307 2848 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 570, __FILE__, __LINE__, true);
2308 2848 : return _r;
2309 : }
2310 0 : next_after_fail680:;
2311 0 : }
2312 : else
2313 : {
2314 37 : if (cst == captures[2] && cmp == GT_EXPR
2315 : )
2316 : {
2317 37 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail681;
2318 37 : {
2319 37 : tree res_op0;
2320 37 : {
2321 37 : tree _o1[1], _r1;
2322 37 : _o1[0] = captures[1];
2323 37 : if (TREE_TYPE (_o1[0]) != st)
2324 : {
2325 37 : _r1 = fold_build1_loc (loc, NOP_EXPR, st, _o1[0]);
2326 : }
2327 : else
2328 : _r1 = _o1[0];
2329 37 : res_op0 = _r1;
2330 : }
2331 37 : tree res_op1;
2332 37 : res_op1 = build_zero_cst (st);
2333 37 : tree _r;
2334 37 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
2335 37 : if (TREE_SIDE_EFFECTS (captures[2]))
2336 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2337 37 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 571, __FILE__, __LINE__, true);
2338 37 : return _r;
2339 : }
2340 0 : next_after_fail681:;
2341 0 : }
2342 : else
2343 : {
2344 0 : if (cmp == LE_EXPR
2345 : )
2346 : {
2347 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail682;
2348 0 : {
2349 0 : tree res_op0;
2350 0 : {
2351 0 : tree _o1[1], _r1;
2352 0 : _o1[0] = captures[1];
2353 0 : if (TREE_TYPE (_o1[0]) != st)
2354 : {
2355 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, st, _o1[0]);
2356 : }
2357 : else
2358 : _r1 = _o1[0];
2359 0 : res_op0 = _r1;
2360 : }
2361 0 : tree res_op1;
2362 0 : res_op1 = build_zero_cst (st);
2363 0 : tree _r;
2364 0 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
2365 0 : if (TREE_SIDE_EFFECTS (captures[2]))
2366 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2367 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 572, __FILE__, __LINE__, true);
2368 0 : return _r;
2369 : }
2370 0 : next_after_fail682:;
2371 : }
2372 : else
2373 : {
2374 0 : if (cmp == GT_EXPR
2375 : )
2376 : {
2377 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail683;
2378 0 : {
2379 0 : tree res_op0;
2380 0 : {
2381 0 : tree _o1[1], _r1;
2382 0 : _o1[0] = captures[1];
2383 0 : if (TREE_TYPE (_o1[0]) != st)
2384 : {
2385 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, st, _o1[0]);
2386 : }
2387 : else
2388 : _r1 = _o1[0];
2389 0 : res_op0 = _r1;
2390 : }
2391 0 : tree res_op1;
2392 0 : res_op1 = build_zero_cst (st);
2393 0 : tree _r;
2394 0 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
2395 0 : if (TREE_SIDE_EFFECTS (captures[2]))
2396 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2397 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 573, __FILE__, __LINE__, true);
2398 0 : return _r;
2399 : }
2400 0 : next_after_fail683:;
2401 : }
2402 : }
2403 : }
2404 : }
2405 : }
2406 : }
2407 : }
2408 : }
2409 : }
2410 : }
2411 : }
2412 1080398 : }
2413 : }
2414 : return NULL_TREE;
2415 : }
2416 :
2417 : tree
2418 123859 : generic_simplify_446 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2419 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2420 : {
2421 123859 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2422 123859 : {
2423 123859 : bool wascmp;
2424 123859 : if (bitwise_inverted_equal_p (captures[0], captures[1], wascmp)
2425 123859 : && (!wascmp || element_precision (type) == 1)
2426 : )
2427 : {
2428 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail791;
2429 1 : {
2430 1 : tree res_op0;
2431 1 : res_op0 = captures[0];
2432 1 : tree res_op1;
2433 1 : res_op1 = captures[2];
2434 1 : tree _r;
2435 1 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2436 1 : if (TREE_SIDE_EFFECTS (captures[1]))
2437 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2438 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 646, __FILE__, __LINE__, true);
2439 1 : return _r;
2440 : }
2441 0 : next_after_fail791:;
2442 : }
2443 : }
2444 123858 : return NULL_TREE;
2445 : }
2446 :
2447 : tree
2448 65 : generic_simplify_453 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2449 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2450 : {
2451 65 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2452 65 : if (INTEGRAL_TYPE_P (type)
2453 65 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2454 65 : && TREE_CODE (TREE_TYPE (captures[0])) != BOOLEAN_TYPE
2455 130 : && (!TYPE_UNSIGNED (TREE_TYPE (captures[0]))
2456 19 : || TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (captures[0])))
2457 : )
2458 : {
2459 65 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail798;
2460 65 : {
2461 65 : tree res_op0;
2462 65 : {
2463 65 : tree _o1[1], _r1;
2464 65 : _o1[0] = captures[0];
2465 65 : if (TREE_TYPE (_o1[0]) != type)
2466 : {
2467 20 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2468 : }
2469 : else
2470 : _r1 = _o1[0];
2471 65 : res_op0 = _r1;
2472 : }
2473 65 : tree res_op1;
2474 65 : res_op1 = captures[1];
2475 65 : tree _r;
2476 65 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
2477 65 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 652, __FILE__, __LINE__, true);
2478 65 : return _r;
2479 : }
2480 0 : next_after_fail798:;
2481 : }
2482 : return NULL_TREE;
2483 : }
2484 :
2485 : tree
2486 0 : generic_simplify_460 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2487 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2488 : const enum tree_code ARG_UNUSED (cmp))
2489 : {
2490 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2491 0 : if (fold_before_rtl_expansion_p ()
2492 : )
2493 : {
2494 0 : if (INTEGRAL_TYPE_P (type)
2495 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2496 : )
2497 : {
2498 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail805;
2499 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail805;
2500 0 : {
2501 0 : tree res_op0;
2502 0 : res_op0 = captures[0];
2503 0 : tree res_op1;
2504 0 : res_op1 = captures[3];
2505 0 : tree res_op2;
2506 0 : res_op2 = build_zero_cst (type);
2507 0 : tree _r;
2508 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
2509 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 658, __FILE__, __LINE__, true);
2510 0 : return _r;
2511 : }
2512 : next_after_fail805:;
2513 : }
2514 : }
2515 : return NULL_TREE;
2516 : }
2517 :
2518 : tree
2519 0 : generic_simplify_470 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2520 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2521 : {
2522 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2523 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail837;
2524 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail837;
2525 0 : {
2526 0 : tree _r;
2527 0 : _r = captures[2];
2528 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2529 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2530 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 679, __FILE__, __LINE__, true);
2531 : return _r;
2532 : }
2533 : next_after_fail837:;
2534 : return NULL_TREE;
2535 : }
2536 :
2537 : tree
2538 4 : generic_simplify_475 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2539 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2540 : {
2541 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2542 4 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail854;
2543 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail854;
2544 4 : {
2545 4 : tree _r;
2546 4 : _r = captures[2];
2547 4 : if (TREE_SIDE_EFFECTS (captures[1]))
2548 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2549 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 679, __FILE__, __LINE__, true);
2550 : return _r;
2551 : }
2552 : next_after_fail854:;
2553 : return NULL_TREE;
2554 : }
2555 :
2556 : tree
2557 160713 : generic_simplify_479 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2558 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2559 : const enum tree_code ARG_UNUSED (shift))
2560 : {
2561 160713 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2562 160713 : if (tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
2563 160713 : && TYPE_PRECISION (type) <= HOST_BITS_PER_WIDE_INT
2564 160605 : && tree_fits_uhwi_p (captures[4])
2565 160556 : && tree_to_uhwi (captures[4]) > 0
2566 321268 : && tree_to_uhwi (captures[4]) < TYPE_PRECISION (type)
2567 : )
2568 : {
2569 160555 : {
2570 160555 : unsigned int shiftc = tree_to_uhwi (captures[4]);
2571 160555 : unsigned HOST_WIDE_INT mask = TREE_INT_CST_LOW (captures[5]);
2572 160555 : unsigned HOST_WIDE_INT newmask, zerobits = 0;
2573 160555 : tree shift_type = TREE_TYPE (captures[2]);
2574 160555 : unsigned int prec;
2575 160555 : if (shift == LSHIFT_EXPR)
2576 27779 : zerobits = ((HOST_WIDE_INT_1U << shiftc) - 1);
2577 132776 : else if (shift == RSHIFT_EXPR
2578 132776 : && type_has_mode_precision_p (shift_type))
2579 : {
2580 132776 : prec = TYPE_PRECISION (TREE_TYPE (captures[2]));
2581 132776 : tree arg00 = captures[3];
2582 132776 : if (captures[2] != captures[3]
2583 132776 : && TYPE_UNSIGNED (TREE_TYPE (captures[3])))
2584 : {
2585 0 : tree inner_type = TREE_TYPE (captures[3]);
2586 0 : if (type_has_mode_precision_p (inner_type)
2587 0 : && TYPE_PRECISION (inner_type) < prec)
2588 : {
2589 0 : prec = TYPE_PRECISION (inner_type);
2590 0 : if (shiftc < prec)
2591 0 : shift_type = inner_type;
2592 : }
2593 : }
2594 132776 : zerobits = HOST_WIDE_INT_M1U;
2595 132776 : if (shiftc < prec)
2596 : {
2597 132776 : zerobits >>= HOST_BITS_PER_WIDE_INT - shiftc;
2598 132776 : zerobits <<= prec - shiftc;
2599 : }
2600 132776 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[2]))
2601 132776 : && prec == TYPE_PRECISION (TREE_TYPE (captures[2])))
2602 : {
2603 2892 : if ((mask & zerobits) == 0)
2604 2881 : shift_type = unsigned_type_for (TREE_TYPE (captures[2]));
2605 : else
2606 : zerobits = 0;
2607 : }
2608 : }
2609 160544 : if ((mask & zerobits) == mask
2610 : )
2611 : {
2612 3 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail860;
2613 3 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail860;
2614 3 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail860;
2615 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail860;
2616 3 : {
2617 3 : tree _r;
2618 3 : _r = build_int_cst (type, 0);
2619 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 682, __FILE__, __LINE__, true);
2620 3 : return _r;
2621 : }
2622 : next_after_fail860:;
2623 : }
2624 : else
2625 : {
2626 160552 : {
2627 160552 : newmask = mask | zerobits;
2628 160552 : if (newmask != mask && (newmask & (newmask + 1)) == 0
2629 : )
2630 : {
2631 : {
2632 18370 : for (prec = BITS_PER_UNIT;
2633 33955 : prec < HOST_BITS_PER_WIDE_INT; prec <<= 1)
2634 31848 : if (newmask == (HOST_WIDE_INT_1U << prec) - 1)
2635 : break;
2636 15585 : if (prec < HOST_BITS_PER_WIDE_INT
2637 2107 : || newmask == HOST_WIDE_INT_M1U
2638 : )
2639 : {
2640 13642 : {
2641 13642 : tree newmaskt = build_int_cst_type (TREE_TYPE (captures[5]), newmask);
2642 13642 : if (!tree_int_cst_equal (newmaskt, captures[5])
2643 : )
2644 : {
2645 13642 : if (shift_type != TREE_TYPE (captures[2])
2646 : )
2647 : {
2648 85 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail861;
2649 85 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail861;
2650 85 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail861;
2651 85 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail861;
2652 85 : {
2653 85 : tree res_op0;
2654 85 : {
2655 85 : tree _o1[1], _r1;
2656 85 : {
2657 85 : tree _o2[2], _r2;
2658 85 : {
2659 85 : tree _o3[1], _r3;
2660 85 : _o3[0] = captures[2];
2661 85 : if (TREE_TYPE (_o3[0]) != shift_type)
2662 : {
2663 85 : _r3 = fold_build1_loc (loc, NOP_EXPR, shift_type, _o3[0]);
2664 : }
2665 : else
2666 : _r3 = _o3[0];
2667 85 : _o2[0] = _r3;
2668 : }
2669 85 : _o2[1] = captures[4];
2670 85 : _r2 = fold_build2_loc (loc, shift, shift_type, _o2[0], _o2[1]);
2671 85 : _o1[0] = _r2;
2672 : }
2673 85 : if (TREE_TYPE (_o1[0]) != type)
2674 : {
2675 85 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2676 : }
2677 : else
2678 : _r1 = _o1[0];
2679 85 : res_op0 = _r1;
2680 : }
2681 85 : tree res_op1;
2682 85 : res_op1 = newmaskt;
2683 85 : tree _r;
2684 85 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2685 85 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 683, __FILE__, __LINE__, true);
2686 85 : return _r;
2687 : }
2688 : next_after_fail861:;
2689 : }
2690 : else
2691 : {
2692 13557 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail862;
2693 12509 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail862;
2694 12509 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail862;
2695 12509 : {
2696 12509 : tree res_op0;
2697 12509 : res_op0 = captures[0];
2698 12509 : tree res_op1;
2699 12509 : res_op1 = newmaskt;
2700 12509 : tree _r;
2701 12509 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2702 12509 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 684, __FILE__, __LINE__, true);
2703 12509 : return _r;
2704 : }
2705 : next_after_fail862:;
2706 : }
2707 : }
2708 : }
2709 : }
2710 : }
2711 : }
2712 : }
2713 : }
2714 : }
2715 : }
2716 : return NULL_TREE;
2717 : }
2718 :
2719 : tree
2720 42 : generic_simplify_489 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2721 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2722 : {
2723 42 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2724 42 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail878;
2725 42 : {
2726 42 : tree res_op0;
2727 42 : res_op0 = captures[1];
2728 42 : tree res_op1;
2729 42 : {
2730 42 : tree _o1[1], _r1;
2731 42 : _o1[0] = captures[2];
2732 42 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2733 42 : res_op1 = _r1;
2734 : }
2735 42 : tree _r;
2736 42 : _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
2737 42 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 693, __FILE__, __LINE__, true);
2738 : return _r;
2739 : }
2740 0 : next_after_fail878:;
2741 0 : return NULL_TREE;
2742 : }
2743 :
2744 : tree
2745 31 : generic_simplify_494 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2746 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2747 : {
2748 31 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2749 31 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[2]))
2750 54 : && (element_precision (TREE_TYPE (captures[2]))
2751 23 : <= element_precision (TREE_TYPE (captures[3]))
2752 1 : || !TYPE_UNSIGNED (TREE_TYPE (captures[3])))
2753 : )
2754 : {
2755 22 : {
2756 22 : tree shift_type = TREE_TYPE (captures[2]);
2757 22 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail883;
2758 22 : {
2759 22 : tree res_op0;
2760 22 : {
2761 22 : tree _o1[2], _r1;
2762 22 : {
2763 22 : tree _o2[1], _r2;
2764 22 : _o2[0] = captures[3];
2765 22 : if (TREE_TYPE (_o2[0]) != shift_type)
2766 : {
2767 1 : _r2 = fold_build1_loc (loc, NOP_EXPR, shift_type, _o2[0]);
2768 : }
2769 : else
2770 : _r2 = _o2[0];
2771 22 : _o1[0] = _r2;
2772 : }
2773 22 : _o1[1] = captures[4];
2774 22 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2775 22 : res_op0 = _r1;
2776 : }
2777 22 : tree _r;
2778 22 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2779 22 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 698, __FILE__, __LINE__, true);
2780 22 : return _r;
2781 : }
2782 0 : next_after_fail883:;
2783 : }
2784 : }
2785 : return NULL_TREE;
2786 : }
2787 :
2788 : tree
2789 3515 : generic_simplify_506 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2790 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2791 : {
2792 3515 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2793 3515 : if (!TYPE_SATURATING (type)
2794 : )
2795 : {
2796 3480 : if (!TYPE_OVERFLOW_SANITIZED (type)
2797 6982 : && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[0]))
2798 : )
2799 : {
2800 3502 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail896;
2801 3502 : {
2802 3502 : tree res_op0;
2803 3502 : {
2804 3502 : tree _o1[1], _r1;
2805 3502 : _o1[0] = captures[0];
2806 3502 : if (TREE_TYPE (_o1[0]) != type)
2807 : {
2808 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
2809 : }
2810 : else
2811 : _r1 = _o1[0];
2812 3502 : res_op0 = _r1;
2813 : }
2814 3502 : tree _r;
2815 3502 : _r = non_lvalue_loc (loc, res_op0);
2816 3502 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 709, __FILE__, __LINE__, true);
2817 3502 : return _r;
2818 : }
2819 0 : next_after_fail896:;
2820 : }
2821 : }
2822 : return NULL_TREE;
2823 : }
2824 :
2825 : tree
2826 4 : generic_simplify_513 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2827 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2828 : {
2829 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2830 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail904;
2831 4 : {
2832 4 : tree _r;
2833 4 : _r = captures[1];
2834 4 : if (TREE_SIDE_EFFECTS (captures[0]))
2835 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2836 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 716, __FILE__, __LINE__, true);
2837 : return _r;
2838 : }
2839 0 : next_after_fail904:;
2840 0 : return NULL_TREE;
2841 : }
2842 :
2843 : tree
2844 2 : generic_simplify_522 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2845 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2846 : {
2847 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2848 2 : if (TREE_CODE (type) != COMPLEX_TYPE
2849 2 : && (! ANY_INTEGRAL_TYPE_P (type)
2850 1 : || TYPE_OVERFLOW_UNDEFINED (type))
2851 : )
2852 : {
2853 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail925;
2854 2 : {
2855 2 : tree res_op0;
2856 2 : res_op0 = captures[0];
2857 2 : tree _r;
2858 2 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
2859 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 725, __FILE__, __LINE__, true);
2860 2 : return _r;
2861 : }
2862 0 : next_after_fail925:;
2863 : }
2864 : return NULL_TREE;
2865 : }
2866 :
2867 : tree
2868 0 : generic_simplify_527 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2869 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2870 : const enum tree_code ARG_UNUSED (rotate))
2871 : {
2872 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2873 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail930;
2874 0 : {
2875 0 : tree _r;
2876 0 : _r = captures[0];
2877 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2878 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2879 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 730, __FILE__, __LINE__, true);
2880 : return _r;
2881 : }
2882 0 : next_after_fail930:;
2883 0 : return NULL_TREE;
2884 : }
2885 :
2886 : tree
2887 0 : generic_simplify_533 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2888 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2889 : const enum tree_code ARG_UNUSED (bitop),
2890 : const combined_fn ARG_UNUSED (bswap))
2891 : {
2892 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2893 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail939;
2894 0 : {
2895 0 : tree res_op0;
2896 0 : res_op0 = captures[0];
2897 0 : tree res_op1;
2898 0 : {
2899 0 : tree _o1[1], _r1;
2900 0 : _o1[0] = captures[1];
2901 0 : _r1 = maybe_build_call_expr_loc (loc, bswap, TREE_TYPE (_o1[0]), 1, _o1[0]);
2902 0 : if (!_r1)
2903 0 : goto next_after_fail939;
2904 0 : res_op1 = _r1;
2905 : }
2906 0 : tree _r;
2907 0 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
2908 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 739, __FILE__, __LINE__, true);
2909 : return _r;
2910 : }
2911 : next_after_fail939:;
2912 : return NULL_TREE;
2913 : }
2914 :
2915 : tree
2916 0 : generic_simplify_541 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2917 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
2918 : const combined_fn ARG_UNUSED (cond_op))
2919 : {
2920 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2921 0 : {
2922 0 : tree op_type = TREE_TYPE (captures[4]);
2923 0 : if (element_precision (type) == element_precision (op_type)
2924 : )
2925 : {
2926 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail947;
2927 0 : {
2928 0 : tree res_op0;
2929 0 : {
2930 0 : tree _o1[5], _r1;
2931 0 : _o1[0] = captures[0];
2932 0 : _o1[1] = captures[1];
2933 0 : _o1[2] = captures[2];
2934 0 : _o1[3] = captures[3];
2935 0 : {
2936 0 : tree _o2[1], _r2;
2937 0 : _o2[0] = captures[5];
2938 0 : if (TREE_TYPE (_o2[0]) != op_type)
2939 : {
2940 0 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
2941 : }
2942 : else
2943 : _r2 = _o2[0];
2944 0 : _o1[4] = _r2;
2945 : }
2946 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]);
2947 0 : if (!_r1)
2948 0 : goto next_after_fail947;
2949 0 : res_op0 = _r1;
2950 : }
2951 0 : tree _r;
2952 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
2953 0 : if (TREE_SIDE_EFFECTS (captures[4]))
2954 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
2955 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 742, __FILE__, __LINE__, true);
2956 0 : return _r;
2957 : }
2958 : next_after_fail947:;
2959 : }
2960 : }
2961 : return NULL_TREE;
2962 : }
2963 :
2964 : tree
2965 3392035 : generic_simplify_549 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2966 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2967 : const enum tree_code ARG_UNUSED (cmp))
2968 : {
2969 3392035 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2970 3392035 : if (REAL_VALUE_ISNAN (TREE_REAL_CST (captures[1]))
2971 3392035 : && (cmp != LTGT_EXPR || ! flag_trapping_math)
2972 : )
2973 : {
2974 10 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail955;
2975 10 : {
2976 10 : tree _r;
2977 20 : _r = constant_boolean_node (cmp == ORDERED_EXPR || cmp == LTGT_EXPR
2978 10 : ? false : true, type);
2979 10 : if (TREE_SIDE_EFFECTS (captures[0]))
2980 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2981 10 : if (TREE_SIDE_EFFECTS (captures[1]))
2982 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2983 10 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 750, __FILE__, __LINE__, true);
2984 10 : return _r;
2985 : }
2986 0 : next_after_fail955:;
2987 : }
2988 : return NULL_TREE;
2989 : }
2990 :
2991 : tree
2992 0 : generic_simplify_561 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2993 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2994 : const combined_fn ARG_UNUSED (fns))
2995 : {
2996 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2997 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail967;
2998 0 : {
2999 0 : tree _r;
3000 0 : _r = captures[0];
3001 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 762, __FILE__, __LINE__, true);
3002 : return _r;
3003 : }
3004 0 : next_after_fail967:;
3005 0 : return NULL_TREE;
3006 : }
3007 :
3008 : tree
3009 0 : generic_simplify_565 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3010 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
3011 : {
3012 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3013 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail971;
3014 0 : {
3015 0 : tree _r;
3016 0 : _r = captures[0];
3017 0 : if (TREE_SIDE_EFFECTS (captures[1]))
3018 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3019 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 766, __FILE__, __LINE__, true);
3020 : return _r;
3021 : }
3022 0 : next_after_fail971:;
3023 0 : return NULL_TREE;
3024 : }
3025 :
3026 : tree
3027 0 : generic_simplify_570 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3028 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3029 : const combined_fn ARG_UNUSED (fns))
3030 : {
3031 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3032 0 : if (canonicalize_math_p ()
3033 : )
3034 : {
3035 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail976;
3036 0 : {
3037 0 : tree res_op0;
3038 0 : res_op0 = captures[0];
3039 0 : tree _r;
3040 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3041 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 771, __FILE__, __LINE__, true);
3042 0 : return _r;
3043 : }
3044 0 : next_after_fail976:;
3045 : }
3046 : return NULL_TREE;
3047 : }
3048 :
3049 : tree
3050 0 : generic_simplify_579 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3051 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures))
3052 : {
3053 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3054 0 : if (canonicalize_math_after_vectorization_p ()
3055 : )
3056 : {
3057 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail985;
3058 : {
3059 : tree res_op0;
3060 : res_op0 = captures[0];
3061 : tree res_op1;
3062 : res_op1 = captures[1];
3063 : tree res_op2;
3064 : res_op2 = captures[2];
3065 : tree _r;
3066 : _r = maybe_build_call_expr_loc (loc, CFN_FNMS, type, 3, res_op0, res_op1, res_op2);
3067 : if (!_r)
3068 : goto next_after_fail985;
3069 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 780, __FILE__, __LINE__, true);
3070 : return _r;
3071 : }
3072 0 : next_after_fail985:;
3073 : }
3074 0 : return NULL_TREE;
3075 : }
3076 :
3077 : tree
3078 0 : generic_simplify_589 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3079 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree ARG_UNUSED (_p3), tree ARG_UNUSED (_p4), tree *ARG_UNUSED (captures))
3080 : {
3081 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3082 0 : if (canonicalize_math_after_vectorization_p ()
3083 : )
3084 : {
3085 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail995;
3086 : {
3087 : tree res_op0;
3088 : res_op0 = captures[0];
3089 : tree res_op1;
3090 : res_op1 = captures[1];
3091 : tree res_op2;
3092 : res_op2 = captures[2];
3093 : tree res_op3;
3094 : res_op3 = captures[3];
3095 : tree res_op4;
3096 : res_op4 = captures[4];
3097 : tree _r;
3098 : _r = maybe_build_call_expr_loc (loc, CFN_COND_FMA, type, 5, res_op0, res_op1, res_op2, res_op3, res_op4);
3099 : if (!_r)
3100 : goto next_after_fail995;
3101 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 790, __FILE__, __LINE__, true);
3102 : return _r;
3103 : }
3104 0 : next_after_fail995:;
3105 : }
3106 0 : return NULL_TREE;
3107 : }
3108 :
3109 : tree
3110 0 : generic_simplify_599 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3111 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3112 : const combined_fn ARG_UNUSED (POPCOUNT))
3113 : {
3114 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3115 0 : {
3116 0 : tree type0 = TREE_TYPE (captures[1]);
3117 0 : tree type2 = TREE_TYPE (captures[0]);
3118 0 : if (INTEGRAL_TYPE_P (type0)
3119 0 : && TYPE_PRECISION (type2) <= TYPE_PRECISION (type0)
3120 : )
3121 : {
3122 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1005;
3123 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1005;
3124 0 : {
3125 0 : tree res_op0;
3126 0 : {
3127 0 : tree _o1[2], _r1;
3128 0 : {
3129 0 : tree _o2[1], _r2;
3130 0 : _o2[0] = captures[2];
3131 0 : if (TREE_TYPE (_o2[0]) != type2)
3132 : {
3133 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, type2, _o2[0]);
3134 : }
3135 : else
3136 : _r2 = _o2[0];
3137 0 : _o1[0] = _r2;
3138 : }
3139 0 : _o1[1] = build_zero_cst (type2);
3140 0 : _r1 = fold_build2_loc (loc, NE_EXPR, boolean_type_node, _o1[0], _o1[1]);
3141 0 : res_op0 = _r1;
3142 : }
3143 0 : tree _r;
3144 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3145 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 797, __FILE__, __LINE__, true);
3146 0 : return _r;
3147 : }
3148 : next_after_fail1005:;
3149 : }
3150 : }
3151 : return NULL_TREE;
3152 : }
3153 :
3154 : tree
3155 0 : generic_simplify_609 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3156 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3157 : const combined_fn ARG_UNUSED (reduc))
3158 : {
3159 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3160 0 : {
3161 0 : tree ctor = (TREE_CODE (captures[0]) == SSA_NAME
3162 0 : ? gimple_assign_rhs1 (SSA_NAME_DEF_STMT (captures[0])) : captures[0]);
3163 0 : tree elt = ctor_single_nonzero_element (ctor);
3164 0 : if (elt
3165 0 : && types_match (type, TREE_TYPE (elt))
3166 0 : && !HONOR_SNANS (type)
3167 0 : && !HONOR_SIGNED_ZEROS (type)
3168 : )
3169 : {
3170 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1016;
3171 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1016;
3172 0 : {
3173 0 : tree _r;
3174 0 : _r = elt;
3175 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 804, __FILE__, __LINE__, true);
3176 0 : return _r;
3177 : }
3178 : next_after_fail1016:;
3179 : }
3180 : }
3181 : return NULL_TREE;
3182 : }
3183 :
3184 : tree
3185 504603239 : generic_simplify_VIEW_CONVERT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0)
3186 : {
3187 504603239 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3188 504603239 : {
3189 504603239 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3190 1009206478 : if ((
3191 :
3192 : && useless_type_conversion_p (type, TREE_TYPE (captures[0])))
3193 : || (
3194 : 1
3195 504603239 : && type == TREE_TYPE (captures[0]))
3196 : )
3197 : {
3198 242777871 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1075;
3199 242777871 : {
3200 242777871 : tree _r;
3201 242777871 : _r = captures[0];
3202 242777871 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 818, __FILE__, __LINE__, true);
3203 242777871 : return _r;
3204 : }
3205 0 : next_after_fail1075:;
3206 : }
3207 : }
3208 261825368 : switch (TREE_CODE (_p0))
3209 : {
3210 28829021 : case VIEW_CONVERT_EXPR:
3211 28829021 : {
3212 28829021 : tree _q20 = TREE_OPERAND (_p0, 0);
3213 28829021 : {
3214 28829021 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3215 28829021 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1076;
3216 28829021 : {
3217 28829021 : tree res_op0;
3218 28829021 : res_op0 = captures[0];
3219 28829021 : tree _r;
3220 28829021 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3221 28829021 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 852, __FILE__, __LINE__, true);
3222 504603239 : return _r;
3223 : }
3224 0 : next_after_fail1076:;
3225 : }
3226 0 : break;
3227 : }
3228 0 : case BIT_FIELD_REF:
3229 0 : {
3230 0 : tree _q20 = TREE_OPERAND (_p0, 0);
3231 0 : tree _q21 = TREE_OPERAND (_p0, 1);
3232 0 : tree _q22 = TREE_OPERAND (_p0, 2);
3233 0 : {
3234 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
3235 0 : if (is_gimple_reg_type (type)
3236 0 : && (!INTEGRAL_TYPE_P (type)
3237 0 : || !INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3238 0 : || (type_has_mode_precision_p (type)
3239 0 : && type_has_mode_precision_p (TREE_TYPE (captures[0]))))
3240 : )
3241 : {
3242 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1077;
3243 0 : {
3244 0 : tree res_op0;
3245 0 : res_op0 = captures[1];
3246 0 : tree res_op1;
3247 0 : res_op1 = captures[2];
3248 0 : tree res_op2;
3249 0 : res_op2 = captures[3];
3250 0 : tree _r;
3251 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
3252 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 853, __FILE__, __LINE__, true);
3253 0 : return _r;
3254 : }
3255 0 : next_after_fail1077:;
3256 : }
3257 : }
3258 0 : break;
3259 : }
3260 232996347 : default:;
3261 : }
3262 232996347 : {
3263 232996347 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3264 231198689 : if ((INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
3265 3115266 : && (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0])))
3266 235835462 : && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (captures[0]))
3267 : )
3268 : {
3269 2494424 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1078;
3270 2494424 : {
3271 2494424 : tree res_op0;
3272 2494424 : res_op0 = captures[0];
3273 2494424 : tree _r;
3274 2494424 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3275 2494424 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 854, __FILE__, __LINE__, true);
3276 2494424 : return _r;
3277 : }
3278 0 : next_after_fail1078:;
3279 : }
3280 : }
3281 230501923 : switch (TREE_CODE (_p0))
3282 : {
3283 3354 : CASE_CONVERT:
3284 3354 : {
3285 3354 : tree _q20 = TREE_OPERAND (_p0, 0);
3286 3354 : {
3287 3354 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3288 3354 : {
3289 3354 : bool extended_bitint = false;
3290 3354 : if (BITINT_TYPE_P (TREE_TYPE (captures[0])))
3291 : {
3292 0 : struct bitint_info info;
3293 0 : extended_bitint
3294 0 : = targetm.c.bitint_type_info (TYPE_PRECISION (TREE_TYPE (captures[0])),
3295 : &info);
3296 0 : extended_bitint = extended_bitint && info.extended;
3297 : }
3298 6708 : if ((INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0])))
3299 71 : && (INTEGRAL_TYPE_P (TREE_TYPE (captures[1])) || POINTER_TYPE_P (TREE_TYPE (captures[1])))
3300 71 : && !extended_bitint
3301 71 : && TYPE_SIZE (TREE_TYPE (captures[0])) == TYPE_SIZE (TREE_TYPE (captures[1]))
3302 3354 : && (TYPE_PRECISION (TREE_TYPE (captures[0])) == TYPE_PRECISION (TREE_TYPE (captures[1]))
3303 0 : || (TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (TREE_TYPE (captures[1]))
3304 0 : && TYPE_UNSIGNED (TREE_TYPE (captures[1]))))
3305 : )
3306 : {
3307 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1079;
3308 0 : {
3309 0 : tree res_op0;
3310 0 : res_op0 = captures[1];
3311 0 : tree _r;
3312 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3313 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 855, __FILE__, __LINE__, true);
3314 0 : return _r;
3315 : }
3316 0 : next_after_fail1079:;
3317 : }
3318 : }
3319 : }
3320 3354 : break;
3321 : }
3322 83479 : case CONSTRUCTOR:
3323 83479 : {
3324 83479 : {
3325 83479 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3326 83479 : {
3327 83479 : tree ctor = (TREE_CODE (captures[0]) == SSA_NAME
3328 : ? gimple_assign_rhs1 (SSA_NAME_DEF_STMT (captures[0])) : captures[0]);
3329 83479 : if (CONSTRUCTOR_NELTS (ctor) == 0
3330 : )
3331 : {
3332 6 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1080;
3333 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1080;
3334 6 : {
3335 6 : tree _r;
3336 6 : _r = build_zero_cst (type);
3337 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 856, __FILE__, __LINE__, true);
3338 6 : return _r;
3339 : }
3340 : next_after_fail1080:;
3341 : }
3342 : else
3343 : {
3344 83473 : if (CONSTRUCTOR_NELTS (ctor) == 1
3345 40 : && VECTOR_TYPE_P (TREE_TYPE (ctor))
3346 83508 : && operand_equal_p (TYPE_SIZE (type),
3347 35 : TYPE_SIZE (TREE_TYPE
3348 : (CONSTRUCTOR_ELT (ctor, 0)->value)))
3349 : )
3350 : {
3351 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1081;
3352 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1081;
3353 0 : {
3354 0 : tree res_op0;
3355 0 : res_op0 = CONSTRUCTOR_ELT (ctor, 0)->value;
3356 0 : tree _r;
3357 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3358 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 857, __FILE__, __LINE__, true);
3359 0 : return _r;
3360 : }
3361 : next_after_fail1081:;
3362 : }
3363 : }
3364 : }
3365 : }
3366 : break;
3367 : }
3368 288792 : case VEC_COND_EXPR:
3369 288792 : {
3370 288792 : tree _q20 = TREE_OPERAND (_p0, 0);
3371 288792 : tree _q21 = TREE_OPERAND (_p0, 1);
3372 288792 : tree _q22 = TREE_OPERAND (_p0, 2);
3373 288792 : {
3374 288792 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
3375 288746 : if (VECTOR_TYPE_P (type) && VECTOR_TYPE_P (TREE_TYPE (captures[2]))
3376 289135 : && known_eq (TYPE_VECTOR_SUBPARTS (type),
3377 : TYPE_VECTOR_SUBPARTS (TREE_TYPE (captures[2])))
3378 41851 : && tree_nop_conversion_p (TREE_TYPE (type), TREE_TYPE (TREE_TYPE (captures[2])))
3379 330300 : && (expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
3380 349 : || !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1])))
3381 : )
3382 : {
3383 41508 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1082;
3384 41508 : {
3385 41508 : tree res_op0;
3386 41508 : res_op0 = captures[1];
3387 41508 : tree res_op1;
3388 41508 : {
3389 41508 : tree _o1[1], _r1;
3390 41508 : _o1[0] = captures[2];
3391 41508 : if (TREE_TYPE (_o1[0]) != type)
3392 : {
3393 41508 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
3394 41508 : if (EXPR_P (_r1))
3395 6 : goto next_after_fail1082;
3396 : }
3397 : else
3398 : _r1 = _o1[0];
3399 41502 : res_op1 = _r1;
3400 : }
3401 41502 : tree res_op2;
3402 41502 : {
3403 41502 : tree _o1[1], _r1;
3404 41502 : _o1[0] = captures[3];
3405 41502 : if (TREE_TYPE (_o1[0]) != type)
3406 : {
3407 41502 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
3408 41502 : if (EXPR_P (_r1))
3409 0 : goto next_after_fail1082;
3410 : }
3411 : else
3412 : _r1 = _o1[0];
3413 41502 : res_op2 = _r1;
3414 : }
3415 41502 : tree _r;
3416 41502 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
3417 41502 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 858, __FILE__, __LINE__, true);
3418 41502 : return _r;
3419 : }
3420 247290 : next_after_fail1082:;
3421 : }
3422 : }
3423 247290 : break;
3424 : }
3425 : default:;
3426 : }
3427 : return NULL_TREE;
3428 : }
3429 :
3430 : tree
3431 1851958927 : generic_simplify (location_t loc, enum tree_code code, const tree type ATTRIBUTE_UNUSED, tree _p0)
3432 : {
3433 1851958927 : switch (code)
3434 : {
3435 3691642 : case ABS_EXPR:
3436 3691642 : return generic_simplify_ABS_EXPR (loc, code, type, _p0);
3437 878961035 : CASE_CONVERT:
3438 878961035 : return generic_simplify_CONVERT_EXPR (loc, code, type, _p0);
3439 2860202 : case BIT_NOT_EXPR:
3440 2860202 : return generic_simplify_BIT_NOT_EXPR (loc, code, type, _p0);
3441 942 : case ABSU_EXPR:
3442 942 : return generic_simplify_ABSU_EXPR (loc, code, type, _p0);
3443 4493992 : case NEGATE_EXPR:
3444 4493992 : return generic_simplify_NEGATE_EXPR (loc, code, type, _p0);
3445 504603239 : case VIEW_CONVERT_EXPR:
3446 504603239 : return generic_simplify_VIEW_CONVERT_EXPR (loc, code, type, _p0);
3447 6351650 : case FLOAT_EXPR:
3448 6351650 : return generic_simplify_FLOAT_EXPR (loc, code, type, _p0);
3449 492783 : case FIX_TRUNC_EXPR:
3450 492783 : return generic_simplify_FIX_TRUNC_EXPR (loc, code, type, _p0);
3451 3677 : case PAREN_EXPR:
3452 3677 : return generic_simplify_PAREN_EXPR (loc, code, type, _p0);
3453 1629251 : case REALPART_EXPR:
3454 1629251 : return generic_simplify_REALPART_EXPR (loc, code, type, _p0);
3455 1893179 : case IMAGPART_EXPR:
3456 1893179 : return generic_simplify_IMAGPART_EXPR (loc, code, type, _p0);
3457 1330 : case CONJ_EXPR:
3458 1330 : return generic_simplify_CONJ_EXPR (loc, code, type, _p0);
3459 : default:;
3460 : }
3461 : return NULL_TREE;
3462 : }
3463 :
3464 : tree
3465 33716408 : generic_simplify_MINUS_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
3466 : {
3467 33716408 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3468 33716408 : if (integer_zerop (_p1))
3469 : {
3470 2041124 : {
3471 2041124 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3472 2041124 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1172;
3473 2041124 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1172;
3474 2041124 : {
3475 2041124 : tree res_op0;
3476 2041124 : res_op0 = captures[0];
3477 2041124 : tree _r;
3478 2041124 : _r = non_lvalue_loc (loc, res_op0);
3479 2041124 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 869, __FILE__, __LINE__, true);
3480 2041124 : return _r;
3481 : }
3482 : next_after_fail1172:;
3483 : }
3484 : }
3485 31675284 : if (real_zerop (_p1))
3486 : {
3487 1140 : {
3488 1140 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
3489 1140 : if (fold_real_zero_addition_p (type, captures[0], captures[1], 1)
3490 : )
3491 : {
3492 752 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1173;
3493 752 : {
3494 752 : tree res_op0;
3495 752 : res_op0 = captures[0];
3496 752 : tree _r;
3497 752 : _r = non_lvalue_loc (loc, res_op0);
3498 752 : if (TREE_SIDE_EFFECTS (captures[1]))
3499 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3500 752 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 889, __FILE__, __LINE__, true);
3501 752 : return _r;
3502 : }
3503 0 : next_after_fail1173:;
3504 : }
3505 : }
3506 : }
3507 31674532 : switch (TREE_CODE (_p0))
3508 : {
3509 2275473 : case PLUS_EXPR:
3510 2275473 : {
3511 2275473 : tree _q20 = TREE_OPERAND (_p0, 0);
3512 2275473 : tree _q21 = TREE_OPERAND (_p0, 1);
3513 2275473 : switch (TREE_CODE (_q21))
3514 : {
3515 148387 : case REAL_CST:
3516 148387 : {
3517 148387 : switch (TREE_CODE (_p1))
3518 : {
3519 11 : case REAL_CST:
3520 11 : {
3521 11 : {
3522 11 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
3523 11 : tree res = generic_simplify_4 (loc, type, _p0, _p1, captures, MINUS_EXPR, PLUS_EXPR);
3524 11 : if (res) return res;
3525 : }
3526 8 : break;
3527 : }
3528 : default:;
3529 : }
3530 : break;
3531 : }
3532 : default:;
3533 : }
3534 : break;
3535 : }
3536 1281348 : case MINUS_EXPR:
3537 1281348 : {
3538 1281348 : tree _q20 = TREE_OPERAND (_p0, 0);
3539 1281348 : tree _q21 = TREE_OPERAND (_p0, 1);
3540 1281348 : switch (TREE_CODE (_q21))
3541 : {
3542 93254 : case REAL_CST:
3543 93254 : {
3544 93254 : switch (TREE_CODE (_p1))
3545 : {
3546 40 : case REAL_CST:
3547 40 : {
3548 40 : {
3549 40 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
3550 40 : tree res = generic_simplify_4 (loc, type, _p0, _p1, captures, MINUS_EXPR, MINUS_EXPR);
3551 40 : if (res) return res;
3552 : }
3553 38 : break;
3554 : }
3555 : default:;
3556 : }
3557 : break;
3558 : }
3559 : default:;
3560 : }
3561 : break;
3562 : }
3563 31674527 : default:;
3564 : }
3565 31674527 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
3566 : {
3567 203506 : {
3568 203506 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3569 202755 : if (!FLOAT_TYPE_P (type)
3570 203507 : || (!tree_expr_maybe_nan_p (captures[0])
3571 107 : && !tree_expr_maybe_infinite_p (captures[0])
3572 15 : && (!HONOR_SIGN_DEPENDENT_ROUNDING (type)
3573 1 : || !HONOR_SIGNED_ZEROS (type)))
3574 : )
3575 : {
3576 202768 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1174;
3577 202768 : {
3578 202768 : tree _r;
3579 202768 : _r = build_zero_cst (type);
3580 202768 : if (TREE_SIDE_EFFECTS (captures[0]))
3581 36 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3582 202768 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 890, __FILE__, __LINE__, true);
3583 202768 : return _r;
3584 : }
3585 0 : next_after_fail1174:;
3586 : }
3587 : }
3588 : }
3589 31471759 : switch (TREE_CODE (_p0))
3590 : {
3591 8677203 : CASE_CONVERT:
3592 8677203 : {
3593 8677203 : tree _q20 = TREE_OPERAND (_p0, 0);
3594 8677203 : switch (TREE_CODE (_p1))
3595 : {
3596 4197383 : CASE_CONVERT:
3597 4197383 : {
3598 4197383 : tree _q40 = TREE_OPERAND (_p1, 0);
3599 4197383 : switch (TREE_CODE (_q40))
3600 : {
3601 103127 : case MULT_EXPR:
3602 103127 : {
3603 103127 : tree _q50 = TREE_OPERAND (_q40, 0);
3604 103127 : tree _q51 = TREE_OPERAND (_q40, 1);
3605 103127 : switch (TREE_CODE (_q50))
3606 : {
3607 21 : case TRUNC_DIV_EXPR:
3608 21 : {
3609 21 : tree _q60 = TREE_OPERAND (_q50, 0);
3610 21 : tree _q61 = TREE_OPERAND (_q50, 1);
3611 21 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q20, 0))
3612 : {
3613 21 : if ((_q51 == _q61 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q61, 0))
3614 : {
3615 21 : {
3616 21 : tree captures[4] ATTRIBUTE_UNUSED = { _q60, _q61, _q20, _q61 };
3617 21 : tree res = generic_simplify_40 (loc, type, _p0, _p1, captures);
3618 21 : if (res) return res;
3619 : }
3620 : }
3621 : }
3622 : break;
3623 : }
3624 103106 : default:;
3625 : }
3626 103106 : switch (TREE_CODE (_q51))
3627 : {
3628 0 : case TRUNC_DIV_EXPR:
3629 0 : {
3630 0 : tree _q70 = TREE_OPERAND (_q51, 0);
3631 0 : tree _q71 = TREE_OPERAND (_q51, 1);
3632 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || operand_equal_p (_q70, _q20, 0))
3633 : {
3634 0 : if ((_q71 == _q50 && ! TREE_SIDE_EFFECTS (_q71)) || operand_equal_p (_q71, _q50, 0))
3635 : {
3636 0 : {
3637 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q70, _q71, _q20, _q50 };
3638 0 : tree res = generic_simplify_40 (loc, type, _p0, _p1, captures);
3639 0 : if (res) return res;
3640 : }
3641 : }
3642 : }
3643 : break;
3644 : }
3645 : default:;
3646 : }
3647 : break;
3648 : }
3649 : default:;
3650 : }
3651 : break;
3652 : }
3653 149088 : case MULT_EXPR:
3654 149088 : {
3655 149088 : tree _q40 = TREE_OPERAND (_p1, 0);
3656 149088 : tree _q41 = TREE_OPERAND (_p1, 1);
3657 149088 : switch (TREE_CODE (_q40))
3658 : {
3659 1733 : case TRUNC_DIV_EXPR:
3660 1733 : {
3661 1733 : tree _q50 = TREE_OPERAND (_q40, 0);
3662 1733 : tree _q51 = TREE_OPERAND (_q40, 1);
3663 1733 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
3664 : {
3665 10 : if ((_q41 == _q51 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _q51, 0))
3666 : {
3667 10 : {
3668 10 : tree captures[4] ATTRIBUTE_UNUSED = { _q50, _q51, _q20, _q51 };
3669 10 : tree res = generic_simplify_40 (loc, type, _p0, _p1, captures);
3670 10 : if (res) return res;
3671 : }
3672 : }
3673 : }
3674 : break;
3675 : }
3676 149078 : default:;
3677 : }
3678 149078 : switch (TREE_CODE (_q41))
3679 : {
3680 0 : case TRUNC_DIV_EXPR:
3681 0 : {
3682 0 : tree _q60 = TREE_OPERAND (_q41, 0);
3683 0 : tree _q61 = TREE_OPERAND (_q41, 1);
3684 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q20, 0))
3685 : {
3686 0 : if ((_q61 == _q40 && ! TREE_SIDE_EFFECTS (_q61)) || operand_equal_p (_q61, _q40, 0))
3687 : {
3688 0 : {
3689 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q60, _q61, _q20, _q40 };
3690 0 : tree res = generic_simplify_40 (loc, type, _p0, _p1, captures);
3691 0 : if (res) return res;
3692 : }
3693 : }
3694 : }
3695 : break;
3696 : }
3697 : default:;
3698 : }
3699 : break;
3700 : }
3701 : default:;
3702 : }
3703 : break;
3704 : }
3705 31471728 : default:;
3706 : }
3707 31471728 : switch (TREE_CODE (_p1))
3708 : {
3709 7707346 : CASE_CONVERT:
3710 7707346 : {
3711 7707346 : tree _q30 = TREE_OPERAND (_p1, 0);
3712 7707346 : switch (TREE_CODE (_q30))
3713 : {
3714 138759 : case MULT_EXPR:
3715 138759 : {
3716 138759 : tree _q40 = TREE_OPERAND (_q30, 0);
3717 138759 : tree _q41 = TREE_OPERAND (_q30, 1);
3718 138759 : switch (TREE_CODE (_q40))
3719 : {
3720 12 : case TRUNC_DIV_EXPR:
3721 12 : {
3722 12 : tree _q50 = TREE_OPERAND (_q40, 0);
3723 12 : tree _q51 = TREE_OPERAND (_q40, 1);
3724 12 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _p0, 0))
3725 : {
3726 2 : if ((_q41 == _q51 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _q51, 0))
3727 : {
3728 2 : {
3729 2 : tree captures[4] ATTRIBUTE_UNUSED = { _q50, _q51, _p0, _q51 };
3730 2 : tree res = generic_simplify_40 (loc, type, _p0, _p1, captures);
3731 2 : if (res) return res;
3732 : }
3733 : }
3734 : }
3735 : break;
3736 : }
3737 138757 : default:;
3738 : }
3739 138757 : switch (TREE_CODE (_q41))
3740 : {
3741 0 : case TRUNC_DIV_EXPR:
3742 0 : {
3743 0 : tree _q60 = TREE_OPERAND (_q41, 0);
3744 0 : tree _q61 = TREE_OPERAND (_q41, 1);
3745 0 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _p0, 0))
3746 : {
3747 0 : if ((_q61 == _q40 && ! TREE_SIDE_EFFECTS (_q61)) || operand_equal_p (_q61, _q40, 0))
3748 : {
3749 0 : {
3750 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q60, _q61, _p0, _q40 };
3751 0 : tree res = generic_simplify_40 (loc, type, _p0, _p1, captures);
3752 0 : if (res) return res;
3753 : }
3754 : }
3755 : }
3756 : break;
3757 : }
3758 : default:;
3759 : }
3760 : break;
3761 : }
3762 : default:;
3763 : }
3764 : break;
3765 : }
3766 2014404 : case MULT_EXPR:
3767 2014404 : {
3768 2014404 : tree _q30 = TREE_OPERAND (_p1, 0);
3769 2014404 : tree _q31 = TREE_OPERAND (_p1, 1);
3770 2014404 : switch (TREE_CODE (_q30))
3771 : {
3772 2180 : case TRUNC_DIV_EXPR:
3773 2180 : {
3774 2180 : tree _q40 = TREE_OPERAND (_q30, 0);
3775 2180 : tree _q41 = TREE_OPERAND (_q30, 1);
3776 2180 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _p0, 0))
3777 : {
3778 52 : if ((_q31 == _q41 && ! TREE_SIDE_EFFECTS (_q31)) || operand_equal_p (_q31, _q41, 0))
3779 : {
3780 52 : {
3781 52 : tree captures[4] ATTRIBUTE_UNUSED = { _q40, _q41, _p0, _q41 };
3782 52 : tree res = generic_simplify_40 (loc, type, _p0, _p1, captures);
3783 52 : if (res) return res;
3784 : }
3785 : }
3786 : }
3787 : break;
3788 : }
3789 2014352 : default:;
3790 : }
3791 2014352 : switch (TREE_CODE (_q31))
3792 : {
3793 0 : case TRUNC_DIV_EXPR:
3794 0 : {
3795 0 : tree _q50 = TREE_OPERAND (_q31, 0);
3796 0 : tree _q51 = TREE_OPERAND (_q31, 1);
3797 0 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _p0, 0))
3798 : {
3799 0 : if ((_q51 == _q30 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q30, 0))
3800 : {
3801 0 : {
3802 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q50, _q51, _p0, _q30 };
3803 0 : tree res = generic_simplify_40 (loc, type, _p0, _p1, captures);
3804 0 : if (res) return res;
3805 : }
3806 : }
3807 : }
3808 : break;
3809 : }
3810 : default:;
3811 : }
3812 : break;
3813 : }
3814 31471674 : default:;
3815 : }
3816 31471674 : switch (TREE_CODE (_p0))
3817 : {
3818 1830638 : case MULT_EXPR:
3819 1830638 : {
3820 1830638 : tree _q20 = TREE_OPERAND (_p0, 0);
3821 1830638 : tree _q21 = TREE_OPERAND (_p0, 1);
3822 1830638 : switch (TREE_CODE (_q21))
3823 : {
3824 609 : case PLUS_EXPR:
3825 609 : {
3826 609 : tree _q40 = TREE_OPERAND (_q21, 0);
3827 609 : tree _q41 = TREE_OPERAND (_q21, 1);
3828 609 : switch (TREE_CODE (_q40))
3829 : {
3830 0 : case TRUNC_DIV_EXPR:
3831 0 : {
3832 0 : tree _q50 = TREE_OPERAND (_q40, 0);
3833 0 : tree _q51 = TREE_OPERAND (_q40, 1);
3834 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
3835 : {
3836 0 : if (integer_onep (_q41))
3837 : {
3838 0 : if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
3839 : {
3840 0 : {
3841 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q40, _q50 };
3842 0 : tree res = generic_simplify_41 (loc, type, _p0, _p1, captures);
3843 0 : if (res) return res;
3844 : }
3845 : }
3846 : }
3847 : }
3848 : break;
3849 : }
3850 : default:;
3851 : }
3852 : break;
3853 : }
3854 1830638 : default:;
3855 : }
3856 1830638 : switch (TREE_CODE (_q20))
3857 : {
3858 103664 : case PLUS_EXPR:
3859 103664 : {
3860 103664 : tree _q30 = TREE_OPERAND (_q20, 0);
3861 103664 : tree _q31 = TREE_OPERAND (_q20, 1);
3862 103664 : switch (TREE_CODE (_q30))
3863 : {
3864 1 : case TRUNC_DIV_EXPR:
3865 1 : {
3866 1 : tree _q40 = TREE_OPERAND (_q30, 0);
3867 1 : tree _q41 = TREE_OPERAND (_q30, 1);
3868 1 : if (integer_onep (_q31))
3869 : {
3870 1 : if ((_q21 == _q41 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q41, 0) && types_match (_q21, _q41)))
3871 : {
3872 1 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
3873 : {
3874 1 : {
3875 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q41, _q20, _q30, _q40 };
3876 1 : tree res = generic_simplify_41 (loc, type, _p0, _p1, captures);
3877 1 : if (res) return res;
3878 : }
3879 : }
3880 : }
3881 : }
3882 : break;
3883 : }
3884 : default:;
3885 : }
3886 : break;
3887 : }
3888 : default:;
3889 : }
3890 : break;
3891 : }
3892 1266 : case LSHIFT_EXPR:
3893 1266 : {
3894 1266 : tree _q20 = TREE_OPERAND (_p0, 0);
3895 1266 : tree _q21 = TREE_OPERAND (_p0, 1);
3896 1266 : switch (TREE_CODE (_p1))
3897 : {
3898 0 : case LSHIFT_EXPR:
3899 0 : {
3900 0 : tree _q50 = TREE_OPERAND (_p1, 0);
3901 0 : tree _q51 = TREE_OPERAND (_p1, 1);
3902 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
3903 : {
3904 0 : {
3905 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
3906 0 : tree res = generic_simplify_6 (loc, type, _p0, _p1, captures, MINUS_EXPR);
3907 0 : if (res) return res;
3908 : }
3909 : }
3910 : break;
3911 : }
3912 : default:;
3913 : }
3914 : break;
3915 : }
3916 1181 : case BIT_AND_EXPR:
3917 1181 : {
3918 1181 : tree _q20 = TREE_OPERAND (_p0, 0);
3919 1181 : tree _q21 = TREE_OPERAND (_p0, 1);
3920 1181 : switch (TREE_CODE (_q21))
3921 : {
3922 0 : case BIT_NOT_EXPR:
3923 0 : {
3924 0 : tree _q40 = TREE_OPERAND (_q21, 0);
3925 0 : switch (TREE_CODE (_p1))
3926 : {
3927 0 : case BIT_AND_EXPR:
3928 0 : {
3929 0 : tree _q60 = TREE_OPERAND (_p1, 0);
3930 0 : tree _q61 = TREE_OPERAND (_p1, 1);
3931 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
3932 : {
3933 0 : if ((_q61 == _q40 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q40, 0) && types_match (_q61, _q40)))
3934 : {
3935 0 : {
3936 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _p1 };
3937 0 : tree res = generic_simplify_42 (loc, type, _p0, _p1, captures);
3938 0 : if (res) return res;
3939 : }
3940 : }
3941 : }
3942 0 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
3943 : {
3944 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
3945 : {
3946 0 : {
3947 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _p1 };
3948 0 : tree res = generic_simplify_42 (loc, type, _p0, _p1, captures);
3949 0 : if (res) return res;
3950 : }
3951 : }
3952 : }
3953 : break;
3954 : }
3955 : default:;
3956 : }
3957 : break;
3958 : }
3959 1181 : default:;
3960 : }
3961 1181 : switch (TREE_CODE (_q20))
3962 : {
3963 27 : case BIT_NOT_EXPR:
3964 27 : {
3965 27 : tree _q30 = TREE_OPERAND (_q20, 0);
3966 27 : switch (TREE_CODE (_p1))
3967 : {
3968 21 : case BIT_AND_EXPR:
3969 21 : {
3970 21 : tree _q60 = TREE_OPERAND (_p1, 0);
3971 21 : tree _q61 = TREE_OPERAND (_p1, 1);
3972 21 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
3973 : {
3974 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
3975 : {
3976 0 : {
3977 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q30, _p1 };
3978 0 : tree res = generic_simplify_42 (loc, type, _p0, _p1, captures);
3979 0 : if (res) return res;
3980 : }
3981 : }
3982 : }
3983 21 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
3984 : {
3985 21 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
3986 : {
3987 21 : {
3988 21 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q30, _p1 };
3989 21 : tree res = generic_simplify_42 (loc, type, _p0, _p1, captures);
3990 21 : if (res) return res;
3991 : }
3992 : }
3993 : }
3994 : break;
3995 : }
3996 : default:;
3997 : }
3998 : break;
3999 : }
4000 1160 : default:;
4001 : }
4002 1160 : switch (TREE_CODE (_q21))
4003 : {
4004 1120 : case INTEGER_CST:
4005 1120 : {
4006 1120 : switch (TREE_CODE (_p1))
4007 : {
4008 22 : case BIT_AND_EXPR:
4009 22 : {
4010 22 : tree _q50 = TREE_OPERAND (_p1, 0);
4011 22 : tree _q51 = TREE_OPERAND (_p1, 1);
4012 22 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4013 : {
4014 0 : switch (TREE_CODE (_q51))
4015 : {
4016 0 : case INTEGER_CST:
4017 0 : {
4018 0 : {
4019 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
4020 0 : if (~wi::to_wide (captures[2]) == wi::to_wide (captures[4])
4021 : )
4022 : {
4023 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1175;
4024 0 : {
4025 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1175;
4026 0 : tree res_op0;
4027 0 : {
4028 0 : tree _o1[2], _r1;
4029 0 : _o1[0] = captures[1];
4030 0 : _o1[1] = unshare_expr (captures[4]);
4031 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4032 0 : res_op0 = _r1;
4033 : }
4034 0 : tree res_op1;
4035 0 : res_op1 = captures[4];
4036 0 : tree _r;
4037 0 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
4038 0 : if (TREE_SIDE_EFFECTS (captures[2]))
4039 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4040 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
4041 0 : return _r;
4042 : }
4043 0 : next_after_fail1175:;
4044 : }
4045 : }
4046 0 : break;
4047 : }
4048 : default:;
4049 : }
4050 : }
4051 : break;
4052 : }
4053 : default:;
4054 : }
4055 : break;
4056 : }
4057 1160 : default:;
4058 : }
4059 1160 : switch (TREE_CODE (_p1))
4060 : {
4061 25 : case BIT_AND_EXPR:
4062 25 : {
4063 25 : tree _q50 = TREE_OPERAND (_p1, 0);
4064 25 : tree _q51 = TREE_OPERAND (_p1, 1);
4065 25 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4066 : {
4067 0 : switch (TREE_CODE (_q51))
4068 : {
4069 0 : case BIT_NOT_EXPR:
4070 0 : {
4071 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4072 0 : if ((_q70 == _q21 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q21, 0) && types_match (_q70, _q21)))
4073 : {
4074 0 : {
4075 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
4076 0 : tree res = generic_simplify_43 (loc, type, _p0, _p1, captures);
4077 0 : if (res) return res;
4078 : }
4079 : }
4080 : break;
4081 : }
4082 : default:;
4083 : }
4084 : }
4085 25 : switch (TREE_CODE (_q50))
4086 : {
4087 0 : case BIT_NOT_EXPR:
4088 0 : {
4089 0 : tree _q60 = TREE_OPERAND (_q50, 0);
4090 0 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
4091 : {
4092 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4093 : {
4094 0 : {
4095 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
4096 0 : tree res = generic_simplify_43 (loc, type, _p0, _p1, captures);
4097 0 : if (res) return res;
4098 : }
4099 : }
4100 : }
4101 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4102 : {
4103 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4104 : {
4105 0 : {
4106 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1 };
4107 0 : tree res = generic_simplify_43 (loc, type, _p0, _p1, captures);
4108 0 : if (res) return res;
4109 : }
4110 : }
4111 : }
4112 : break;
4113 : }
4114 25 : default:;
4115 : }
4116 25 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4117 : {
4118 0 : switch (TREE_CODE (_q51))
4119 : {
4120 0 : case BIT_NOT_EXPR:
4121 0 : {
4122 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4123 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4124 : {
4125 0 : {
4126 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1 };
4127 0 : tree res = generic_simplify_43 (loc, type, _p0, _p1, captures);
4128 0 : if (res) return res;
4129 : }
4130 : }
4131 : break;
4132 : }
4133 : default:;
4134 : }
4135 : }
4136 : break;
4137 : }
4138 2 : case PLUS_EXPR:
4139 2 : {
4140 2 : tree _q50 = TREE_OPERAND (_p1, 0);
4141 2 : tree _q51 = TREE_OPERAND (_p1, 1);
4142 2 : switch (TREE_CODE (_q50))
4143 : {
4144 2 : case BIT_IOR_EXPR:
4145 2 : {
4146 2 : tree _q60 = TREE_OPERAND (_q50, 0);
4147 2 : tree _q61 = TREE_OPERAND (_q50, 1);
4148 2 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4149 : {
4150 2 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
4151 : {
4152 2 : if (integer_onep (_q51))
4153 : {
4154 2 : {
4155 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4156 2 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
4157 2 : if (res) return res;
4158 : }
4159 : }
4160 : }
4161 : }
4162 0 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
4163 : {
4164 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
4165 : {
4166 0 : if (integer_onep (_q51))
4167 : {
4168 0 : {
4169 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4170 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
4171 0 : if (res) return res;
4172 : }
4173 : }
4174 : }
4175 : }
4176 : break;
4177 : }
4178 0 : default:;
4179 : }
4180 0 : {
4181 0 : tree _q50_pops[1];
4182 0 : if (tree_nop_convert (_q50, _q50_pops))
4183 : {
4184 0 : tree _q60 = _q50_pops[0];
4185 0 : switch (TREE_CODE (_q60))
4186 : {
4187 0 : case BIT_IOR_EXPR:
4188 0 : {
4189 0 : tree _q70 = TREE_OPERAND (_q60, 0);
4190 0 : tree _q71 = TREE_OPERAND (_q60, 1);
4191 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4192 : {
4193 0 : if ((_q71 == _q21 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q21, 0) && types_match (_q71, _q21)))
4194 : {
4195 0 : if (integer_onep (_q51))
4196 : {
4197 0 : {
4198 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4199 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
4200 0 : if (res) return res;
4201 : }
4202 : }
4203 : }
4204 : }
4205 0 : if ((_q70 == _q21 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q21, 0) && types_match (_q70, _q21)))
4206 : {
4207 0 : if ((_q71 == _q20 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q20, 0) && types_match (_q71, _q20)))
4208 : {
4209 0 : if (integer_onep (_q51))
4210 : {
4211 0 : {
4212 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4213 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
4214 0 : if (res) return res;
4215 : }
4216 : }
4217 : }
4218 : }
4219 : break;
4220 : }
4221 : default:;
4222 : }
4223 : }
4224 : }
4225 0 : break;
4226 : }
4227 1158 : default:;
4228 : }
4229 1158 : {
4230 1158 : tree _p1_pops[1];
4231 1158 : if (tree_nop_convert (_p1, _p1_pops))
4232 : {
4233 7 : tree _q50 = _p1_pops[0];
4234 7 : switch (TREE_CODE (_q50))
4235 : {
4236 0 : case PLUS_EXPR:
4237 0 : {
4238 0 : tree _q60 = TREE_OPERAND (_q50, 0);
4239 0 : tree _q61 = TREE_OPERAND (_q50, 1);
4240 0 : switch (TREE_CODE (_q60))
4241 : {
4242 0 : case BIT_IOR_EXPR:
4243 0 : {
4244 0 : tree _q70 = TREE_OPERAND (_q60, 0);
4245 0 : tree _q71 = TREE_OPERAND (_q60, 1);
4246 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4247 : {
4248 0 : if ((_q71 == _q21 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q21, 0) && types_match (_q71, _q21)))
4249 : {
4250 0 : if (integer_onep (_q61))
4251 : {
4252 0 : {
4253 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4254 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
4255 0 : if (res) return res;
4256 : }
4257 : }
4258 : }
4259 : }
4260 0 : if ((_q70 == _q21 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q21, 0) && types_match (_q70, _q21)))
4261 : {
4262 0 : if ((_q71 == _q20 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q20, 0) && types_match (_q71, _q20)))
4263 : {
4264 0 : if (integer_onep (_q61))
4265 : {
4266 0 : {
4267 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4268 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
4269 0 : if (res) return res;
4270 : }
4271 : }
4272 : }
4273 : }
4274 : break;
4275 : }
4276 0 : default:;
4277 : }
4278 0 : {
4279 0 : tree _q60_pops[1];
4280 0 : if (tree_nop_convert (_q60, _q60_pops))
4281 : {
4282 0 : tree _q70 = _q60_pops[0];
4283 0 : switch (TREE_CODE (_q70))
4284 : {
4285 0 : case BIT_IOR_EXPR:
4286 0 : {
4287 0 : tree _q80 = TREE_OPERAND (_q70, 0);
4288 0 : tree _q81 = TREE_OPERAND (_q70, 1);
4289 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
4290 : {
4291 0 : if ((_q81 == _q21 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q21, 0) && types_match (_q81, _q21)))
4292 : {
4293 0 : if (integer_onep (_q61))
4294 : {
4295 0 : {
4296 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4297 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
4298 0 : if (res) return res;
4299 : }
4300 : }
4301 : }
4302 : }
4303 0 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
4304 : {
4305 0 : if ((_q81 == _q20 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q20, 0) && types_match (_q81, _q20)))
4306 : {
4307 0 : if (integer_onep (_q61))
4308 : {
4309 0 : {
4310 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4311 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
4312 0 : if (res) return res;
4313 : }
4314 : }
4315 : }
4316 : }
4317 : break;
4318 : }
4319 : default:;
4320 : }
4321 : }
4322 : }
4323 0 : break;
4324 : }
4325 : default:;
4326 : }
4327 : }
4328 : }
4329 1158 : break;
4330 : }
4331 2849 : case BIT_NOT_EXPR:
4332 2849 : {
4333 2849 : tree _q20 = TREE_OPERAND (_p0, 0);
4334 2849 : switch (TREE_CODE (_p1))
4335 : {
4336 22 : case BIT_NOT_EXPR:
4337 22 : {
4338 22 : tree _q40 = TREE_OPERAND (_p1, 0);
4339 22 : {
4340 22 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
4341 22 : if (!TYPE_OVERFLOW_SANITIZED (type)
4342 : )
4343 : {
4344 9 : {
4345 9 : tree utype = unsigned_type_for (type);
4346 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1176;
4347 9 : {
4348 9 : tree res_op0;
4349 9 : {
4350 9 : tree _o1[2], _r1;
4351 9 : {
4352 9 : tree _o2[1], _r2;
4353 9 : _o2[0] = captures[1];
4354 9 : if (TREE_TYPE (_o2[0]) != utype)
4355 : {
4356 9 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
4357 : }
4358 : else
4359 : _r2 = _o2[0];
4360 9 : _o1[0] = _r2;
4361 : }
4362 9 : {
4363 9 : tree _o2[1], _r2;
4364 9 : _o2[0] = captures[0];
4365 9 : if (TREE_TYPE (_o2[0]) != utype)
4366 : {
4367 9 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
4368 : }
4369 : else
4370 : _r2 = _o2[0];
4371 9 : _o1[1] = _r2;
4372 : }
4373 9 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4374 9 : res_op0 = _r1;
4375 : }
4376 9 : tree _r;
4377 9 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4378 9 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
4379 9 : return _r;
4380 : }
4381 0 : next_after_fail1176:;
4382 : }
4383 : }
4384 : }
4385 13 : break;
4386 : }
4387 : default:;
4388 : }
4389 : break;
4390 : }
4391 2273668 : case PLUS_EXPR:
4392 2273668 : {
4393 2273668 : tree _q20 = TREE_OPERAND (_p0, 0);
4394 2273668 : tree _q21 = TREE_OPERAND (_p0, 1);
4395 2273668 : switch (TREE_CODE (_p1))
4396 : {
4397 14 : case BIT_IOR_EXPR:
4398 14 : {
4399 14 : tree _q50 = TREE_OPERAND (_p1, 0);
4400 14 : tree _q51 = TREE_OPERAND (_p1, 1);
4401 14 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4402 : {
4403 13 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4404 : {
4405 13 : {
4406 13 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4407 13 : if (!TYPE_OVERFLOW_SANITIZED (type) && !TYPE_OVERFLOW_TRAPS (type)
4408 13 : && !TYPE_SATURATING (type)
4409 : )
4410 : {
4411 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1177;
4412 0 : {
4413 0 : tree res_op0;
4414 0 : res_op0 = captures[0];
4415 0 : tree res_op1;
4416 0 : res_op1 = captures[1];
4417 0 : tree _r;
4418 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
4419 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
4420 0 : return _r;
4421 : }
4422 0 : next_after_fail1177:;
4423 : }
4424 : }
4425 : }
4426 : }
4427 : break;
4428 : }
4429 86 : case BIT_AND_EXPR:
4430 86 : {
4431 86 : tree _q50 = TREE_OPERAND (_p1, 0);
4432 86 : tree _q51 = TREE_OPERAND (_p1, 1);
4433 86 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4434 : {
4435 25 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4436 : {
4437 13 : {
4438 13 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4439 13 : if (!TYPE_OVERFLOW_SANITIZED (type) && !TYPE_OVERFLOW_TRAPS (type)
4440 13 : && !TYPE_SATURATING (type)
4441 : )
4442 : {
4443 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1178;
4444 0 : {
4445 0 : tree res_op0;
4446 0 : res_op0 = captures[0];
4447 0 : tree res_op1;
4448 0 : res_op1 = captures[1];
4449 0 : tree _r;
4450 0 : _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
4451 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
4452 0 : return _r;
4453 : }
4454 0 : next_after_fail1178:;
4455 : }
4456 : }
4457 : }
4458 : }
4459 : break;
4460 : }
4461 2273668 : default:;
4462 : }
4463 2273668 : switch (TREE_CODE (_q20))
4464 : {
4465 593 : case BIT_AND_EXPR:
4466 593 : {
4467 593 : tree _q30 = TREE_OPERAND (_q20, 0);
4468 593 : tree _q31 = TREE_OPERAND (_q20, 1);
4469 593 : if (integer_all_onesp (_q21))
4470 : {
4471 1 : switch (TREE_CODE (_p1))
4472 : {
4473 1 : case BIT_IOR_EXPR:
4474 1 : {
4475 1 : tree _q70 = TREE_OPERAND (_p1, 0);
4476 1 : tree _q71 = TREE_OPERAND (_p1, 1);
4477 1 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
4478 : {
4479 1 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
4480 : {
4481 1 : {
4482 1 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q31 };
4483 1 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures);
4484 1 : if (res) return res;
4485 : }
4486 : }
4487 : }
4488 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
4489 : {
4490 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
4491 : {
4492 0 : {
4493 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q31, _q30 };
4494 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures);
4495 0 : if (res) return res;
4496 : }
4497 : }
4498 : }
4499 : break;
4500 : }
4501 0 : default:;
4502 : }
4503 0 : {
4504 0 : tree _p1_pops[1];
4505 0 : if (tree_nop_convert (_p1, _p1_pops))
4506 : {
4507 0 : tree _q70 = _p1_pops[0];
4508 0 : switch (TREE_CODE (_q70))
4509 : {
4510 0 : case BIT_IOR_EXPR:
4511 0 : {
4512 0 : tree _q80 = TREE_OPERAND (_q70, 0);
4513 0 : tree _q81 = TREE_OPERAND (_q70, 1);
4514 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
4515 : {
4516 0 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
4517 : {
4518 0 : {
4519 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q31 };
4520 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures);
4521 0 : if (res) return res;
4522 : }
4523 : }
4524 : }
4525 0 : if ((_q80 == _q31 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q31, 0) && types_match (_q80, _q31)))
4526 : {
4527 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
4528 : {
4529 0 : {
4530 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q31, _q30 };
4531 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures);
4532 0 : if (res) return res;
4533 : }
4534 : }
4535 : }
4536 : break;
4537 : }
4538 : default:;
4539 : }
4540 : }
4541 : }
4542 : }
4543 : break;
4544 : }
4545 2273667 : default:;
4546 : }
4547 2273667 : {
4548 2273667 : tree _q20_pops[1];
4549 2273667 : if (tree_nop_convert (_q20, _q20_pops))
4550 : {
4551 552059 : tree _q30 = _q20_pops[0];
4552 552059 : switch (TREE_CODE (_q30))
4553 : {
4554 0 : case BIT_AND_EXPR:
4555 0 : {
4556 0 : tree _q40 = TREE_OPERAND (_q30, 0);
4557 0 : tree _q41 = TREE_OPERAND (_q30, 1);
4558 0 : if (integer_all_onesp (_q21))
4559 : {
4560 0 : switch (TREE_CODE (_p1))
4561 : {
4562 0 : case BIT_IOR_EXPR:
4563 0 : {
4564 0 : tree _q80 = TREE_OPERAND (_p1, 0);
4565 0 : tree _q81 = TREE_OPERAND (_p1, 1);
4566 0 : if ((_q80 == _q40 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q40, 0) && types_match (_q80, _q40)))
4567 : {
4568 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
4569 : {
4570 0 : {
4571 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q41 };
4572 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures);
4573 0 : if (res) return res;
4574 : }
4575 : }
4576 : }
4577 0 : if ((_q80 == _q41 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q41, 0) && types_match (_q80, _q41)))
4578 : {
4579 0 : if ((_q81 == _q40 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q40, 0) && types_match (_q81, _q40)))
4580 : {
4581 0 : {
4582 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q40 };
4583 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures);
4584 0 : if (res) return res;
4585 : }
4586 : }
4587 : }
4588 : break;
4589 : }
4590 0 : default:;
4591 : }
4592 0 : {
4593 0 : tree _p1_pops[1];
4594 0 : if (tree_nop_convert (_p1, _p1_pops))
4595 : {
4596 0 : tree _q80 = _p1_pops[0];
4597 0 : switch (TREE_CODE (_q80))
4598 : {
4599 0 : case BIT_IOR_EXPR:
4600 0 : {
4601 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4602 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4603 0 : if ((_q90 == _q40 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q40, 0) && types_match (_q90, _q40)))
4604 : {
4605 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
4606 : {
4607 0 : {
4608 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q41 };
4609 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures);
4610 0 : if (res) return res;
4611 : }
4612 : }
4613 : }
4614 0 : if ((_q90 == _q41 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q41, 0) && types_match (_q90, _q41)))
4615 : {
4616 0 : if ((_q91 == _q40 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q40, 0) && types_match (_q91, _q40)))
4617 : {
4618 0 : {
4619 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q40 };
4620 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures);
4621 0 : if (res) return res;
4622 : }
4623 : }
4624 : }
4625 : break;
4626 : }
4627 : default:;
4628 : }
4629 : }
4630 : }
4631 : }
4632 : break;
4633 : }
4634 : default:;
4635 : }
4636 : }
4637 : }
4638 2273667 : break;
4639 : }
4640 77 : case BIT_IOR_EXPR:
4641 77 : {
4642 77 : tree _q20 = TREE_OPERAND (_p0, 0);
4643 77 : tree _q21 = TREE_OPERAND (_p0, 1);
4644 77 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
4645 : {
4646 5 : {
4647 5 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
4648 5 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures);
4649 5 : if (res) return res;
4650 : }
4651 : }
4652 72 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4653 : {
4654 0 : {
4655 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
4656 0 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures);
4657 0 : if (res) return res;
4658 : }
4659 : }
4660 72 : switch (TREE_CODE (_p1))
4661 : {
4662 0 : case BIT_XOR_EXPR:
4663 0 : {
4664 0 : tree _q50 = TREE_OPERAND (_p1, 0);
4665 0 : tree _q51 = TREE_OPERAND (_p1, 1);
4666 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4667 : {
4668 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4669 : {
4670 0 : {
4671 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4672 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1179;
4673 0 : {
4674 0 : tree res_op0;
4675 0 : res_op0 = captures[0];
4676 0 : tree res_op1;
4677 0 : res_op1 = captures[1];
4678 0 : tree _r;
4679 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
4680 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 895, __FILE__, __LINE__, true);
4681 0 : return _r;
4682 : }
4683 0 : next_after_fail1179:;
4684 : }
4685 : }
4686 : }
4687 : break;
4688 : }
4689 0 : case BIT_AND_EXPR:
4690 0 : {
4691 0 : tree _q50 = TREE_OPERAND (_p1, 0);
4692 0 : tree _q51 = TREE_OPERAND (_p1, 1);
4693 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4694 : {
4695 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4696 : {
4697 0 : {
4698 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4699 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1180;
4700 0 : {
4701 0 : tree res_op0;
4702 0 : res_op0 = captures[0];
4703 0 : tree res_op1;
4704 0 : res_op1 = captures[1];
4705 0 : tree _r;
4706 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
4707 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
4708 0 : return _r;
4709 : }
4710 0 : next_after_fail1180:;
4711 : }
4712 : }
4713 : }
4714 : break;
4715 : }
4716 : default:;
4717 : }
4718 : break;
4719 : }
4720 31471635 : default:;
4721 : }
4722 31471635 : {
4723 31471635 : tree _p0_pops[1];
4724 31471635 : if (tree_nop_convert (_p0, _p0_pops))
4725 : {
4726 7564095 : tree _q20 = _p0_pops[0];
4727 7564095 : switch (TREE_CODE (_q20))
4728 : {
4729 1010221 : case PLUS_EXPR:
4730 1010221 : {
4731 1010221 : tree _q30 = TREE_OPERAND (_q20, 0);
4732 1010221 : tree _q31 = TREE_OPERAND (_q20, 1);
4733 1010221 : switch (TREE_CODE (_q30))
4734 : {
4735 8 : case BIT_AND_EXPR:
4736 8 : {
4737 8 : tree _q40 = TREE_OPERAND (_q30, 0);
4738 8 : tree _q41 = TREE_OPERAND (_q30, 1);
4739 8 : if (integer_all_onesp (_q31))
4740 : {
4741 0 : switch (TREE_CODE (_p1))
4742 : {
4743 0 : case BIT_IOR_EXPR:
4744 0 : {
4745 0 : tree _q80 = TREE_OPERAND (_p1, 0);
4746 0 : tree _q81 = TREE_OPERAND (_p1, 1);
4747 0 : if ((_q80 == _q40 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q40, 0) && types_match (_q80, _q40)))
4748 : {
4749 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
4750 : {
4751 0 : {
4752 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q40, _q41 };
4753 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures);
4754 0 : if (res) return res;
4755 : }
4756 : }
4757 : }
4758 0 : if ((_q80 == _q41 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q41, 0) && types_match (_q80, _q41)))
4759 : {
4760 0 : if ((_q81 == _q40 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q40, 0) && types_match (_q81, _q40)))
4761 : {
4762 0 : {
4763 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q41, _q40 };
4764 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures);
4765 0 : if (res) return res;
4766 : }
4767 : }
4768 : }
4769 : break;
4770 : }
4771 0 : default:;
4772 : }
4773 0 : {
4774 0 : tree _p1_pops[1];
4775 0 : if (tree_nop_convert (_p1, _p1_pops))
4776 : {
4777 0 : tree _q80 = _p1_pops[0];
4778 0 : switch (TREE_CODE (_q80))
4779 : {
4780 0 : case BIT_IOR_EXPR:
4781 0 : {
4782 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4783 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4784 0 : if ((_q90 == _q40 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q40, 0) && types_match (_q90, _q40)))
4785 : {
4786 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
4787 : {
4788 0 : {
4789 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q40, _q41 };
4790 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures);
4791 0 : if (res) return res;
4792 : }
4793 : }
4794 : }
4795 0 : if ((_q90 == _q41 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q41, 0) && types_match (_q90, _q41)))
4796 : {
4797 0 : if ((_q91 == _q40 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q40, 0) && types_match (_q91, _q40)))
4798 : {
4799 0 : {
4800 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q41, _q40 };
4801 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures);
4802 0 : if (res) return res;
4803 : }
4804 : }
4805 : }
4806 : break;
4807 : }
4808 : default:;
4809 : }
4810 : }
4811 : }
4812 : }
4813 : break;
4814 : }
4815 1010221 : default:;
4816 : }
4817 1010221 : {
4818 1010221 : tree _q30_pops[1];
4819 1010221 : if (tree_nop_convert (_q30, _q30_pops))
4820 : {
4821 45179 : tree _q40 = _q30_pops[0];
4822 45179 : switch (TREE_CODE (_q40))
4823 : {
4824 0 : case BIT_AND_EXPR:
4825 0 : {
4826 0 : tree _q50 = TREE_OPERAND (_q40, 0);
4827 0 : tree _q51 = TREE_OPERAND (_q40, 1);
4828 0 : if (integer_all_onesp (_q31))
4829 : {
4830 0 : switch (TREE_CODE (_p1))
4831 : {
4832 0 : case BIT_IOR_EXPR:
4833 0 : {
4834 0 : tree _q90 = TREE_OPERAND (_p1, 0);
4835 0 : tree _q91 = TREE_OPERAND (_p1, 1);
4836 0 : if ((_q90 == _q50 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q50, 0) && types_match (_q90, _q50)))
4837 : {
4838 0 : if ((_q91 == _q51 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q51, 0) && types_match (_q91, _q51)))
4839 : {
4840 0 : {
4841 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q50, _q51 };
4842 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures);
4843 0 : if (res) return res;
4844 : }
4845 : }
4846 : }
4847 0 : if ((_q90 == _q51 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q51, 0) && types_match (_q90, _q51)))
4848 : {
4849 0 : if ((_q91 == _q50 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q50, 0) && types_match (_q91, _q50)))
4850 : {
4851 0 : {
4852 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q51, _q50 };
4853 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures);
4854 0 : if (res) return res;
4855 : }
4856 : }
4857 : }
4858 : break;
4859 : }
4860 0 : default:;
4861 : }
4862 0 : {
4863 0 : tree _p1_pops[1];
4864 0 : if (tree_nop_convert (_p1, _p1_pops))
4865 : {
4866 0 : tree _q90 = _p1_pops[0];
4867 0 : switch (TREE_CODE (_q90))
4868 : {
4869 0 : case BIT_IOR_EXPR:
4870 0 : {
4871 0 : tree _q100 = TREE_OPERAND (_q90, 0);
4872 0 : tree _q101 = TREE_OPERAND (_q90, 1);
4873 0 : if ((_q100 == _q50 && ! TREE_SIDE_EFFECTS (_q100)) || (operand_equal_p (_q100, _q50, 0) && types_match (_q100, _q50)))
4874 : {
4875 0 : if ((_q101 == _q51 && ! TREE_SIDE_EFFECTS (_q101)) || (operand_equal_p (_q101, _q51, 0) && types_match (_q101, _q51)))
4876 : {
4877 0 : {
4878 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q50, _q51 };
4879 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures);
4880 0 : if (res) return res;
4881 : }
4882 : }
4883 : }
4884 0 : if ((_q100 == _q51 && ! TREE_SIDE_EFFECTS (_q100)) || (operand_equal_p (_q100, _q51, 0) && types_match (_q100, _q51)))
4885 : {
4886 0 : if ((_q101 == _q50 && ! TREE_SIDE_EFFECTS (_q101)) || (operand_equal_p (_q101, _q50, 0) && types_match (_q101, _q50)))
4887 : {
4888 0 : {
4889 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q51, _q50 };
4890 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures);
4891 0 : if (res) return res;
4892 : }
4893 : }
4894 : }
4895 : break;
4896 : }
4897 : default:;
4898 : }
4899 : }
4900 : }
4901 : }
4902 : break;
4903 : }
4904 : default:;
4905 : }
4906 : }
4907 : }
4908 1010221 : break;
4909 : }
4910 14 : case BIT_AND_EXPR:
4911 14 : {
4912 14 : tree _q30 = TREE_OPERAND (_q20, 0);
4913 14 : tree _q31 = TREE_OPERAND (_q20, 1);
4914 14 : switch (TREE_CODE (_p1))
4915 : {
4916 0 : case PLUS_EXPR:
4917 0 : {
4918 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4919 0 : tree _q61 = TREE_OPERAND (_p1, 1);
4920 0 : switch (TREE_CODE (_q60))
4921 : {
4922 0 : case BIT_IOR_EXPR:
4923 0 : {
4924 0 : tree _q70 = TREE_OPERAND (_q60, 0);
4925 0 : tree _q71 = TREE_OPERAND (_q60, 1);
4926 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
4927 : {
4928 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
4929 : {
4930 0 : if (integer_onep (_q61))
4931 : {
4932 0 : {
4933 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
4934 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
4935 0 : if (res) return res;
4936 : }
4937 : }
4938 : }
4939 : }
4940 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
4941 : {
4942 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
4943 : {
4944 0 : if (integer_onep (_q61))
4945 : {
4946 0 : {
4947 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
4948 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
4949 0 : if (res) return res;
4950 : }
4951 : }
4952 : }
4953 : }
4954 : break;
4955 : }
4956 0 : default:;
4957 : }
4958 0 : {
4959 0 : tree _q60_pops[1];
4960 0 : if (tree_nop_convert (_q60, _q60_pops))
4961 : {
4962 0 : tree _q70 = _q60_pops[0];
4963 0 : switch (TREE_CODE (_q70))
4964 : {
4965 0 : case BIT_IOR_EXPR:
4966 0 : {
4967 0 : tree _q80 = TREE_OPERAND (_q70, 0);
4968 0 : tree _q81 = TREE_OPERAND (_q70, 1);
4969 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
4970 : {
4971 0 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
4972 : {
4973 0 : if (integer_onep (_q61))
4974 : {
4975 0 : {
4976 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
4977 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
4978 0 : if (res) return res;
4979 : }
4980 : }
4981 : }
4982 : }
4983 0 : if ((_q80 == _q31 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q31, 0) && types_match (_q80, _q31)))
4984 : {
4985 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
4986 : {
4987 0 : if (integer_onep (_q61))
4988 : {
4989 0 : {
4990 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
4991 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
4992 0 : if (res) return res;
4993 : }
4994 : }
4995 : }
4996 : }
4997 : break;
4998 : }
4999 : default:;
5000 : }
5001 : }
5002 : }
5003 0 : break;
5004 : }
5005 14 : default:;
5006 : }
5007 14 : {
5008 14 : tree _p1_pops[1];
5009 14 : if (tree_nop_convert (_p1, _p1_pops))
5010 : {
5011 14 : tree _q60 = _p1_pops[0];
5012 14 : switch (TREE_CODE (_q60))
5013 : {
5014 0 : case PLUS_EXPR:
5015 0 : {
5016 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5017 0 : tree _q71 = TREE_OPERAND (_q60, 1);
5018 0 : switch (TREE_CODE (_q70))
5019 : {
5020 0 : case BIT_IOR_EXPR:
5021 0 : {
5022 0 : tree _q80 = TREE_OPERAND (_q70, 0);
5023 0 : tree _q81 = TREE_OPERAND (_q70, 1);
5024 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
5025 : {
5026 0 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
5027 : {
5028 0 : if (integer_onep (_q71))
5029 : {
5030 0 : {
5031 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q60 };
5032 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
5033 0 : if (res) return res;
5034 : }
5035 : }
5036 : }
5037 : }
5038 0 : if ((_q80 == _q31 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q31, 0) && types_match (_q80, _q31)))
5039 : {
5040 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
5041 : {
5042 0 : if (integer_onep (_q71))
5043 : {
5044 0 : {
5045 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q60 };
5046 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
5047 0 : if (res) return res;
5048 : }
5049 : }
5050 : }
5051 : }
5052 : break;
5053 : }
5054 0 : default:;
5055 : }
5056 0 : {
5057 0 : tree _q70_pops[1];
5058 0 : if (tree_nop_convert (_q70, _q70_pops))
5059 : {
5060 0 : tree _q80 = _q70_pops[0];
5061 0 : switch (TREE_CODE (_q80))
5062 : {
5063 0 : case BIT_IOR_EXPR:
5064 0 : {
5065 0 : tree _q90 = TREE_OPERAND (_q80, 0);
5066 0 : tree _q91 = TREE_OPERAND (_q80, 1);
5067 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
5068 : {
5069 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
5070 : {
5071 0 : if (integer_onep (_q71))
5072 : {
5073 0 : {
5074 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q60 };
5075 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
5076 0 : if (res) return res;
5077 : }
5078 : }
5079 : }
5080 : }
5081 0 : if ((_q90 == _q31 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q31, 0) && types_match (_q90, _q31)))
5082 : {
5083 0 : if ((_q91 == _q30 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q30, 0) && types_match (_q91, _q30)))
5084 : {
5085 0 : if (integer_onep (_q71))
5086 : {
5087 0 : {
5088 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q60 };
5089 0 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures);
5090 0 : if (res) return res;
5091 : }
5092 : }
5093 : }
5094 : }
5095 : break;
5096 : }
5097 : default:;
5098 : }
5099 : }
5100 : }
5101 0 : break;
5102 : }
5103 : default:;
5104 : }
5105 : }
5106 : }
5107 14 : break;
5108 : }
5109 : default:;
5110 : }
5111 : }
5112 : }
5113 31471635 : if (tree_negate_expr_p (_p1))
5114 : {
5115 7605552 : {
5116 7605552 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
5117 7605552 : if (!FIXED_POINT_TYPE_P (type)
5118 : )
5119 : {
5120 7605552 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1181;
5121 7605552 : {
5122 7605552 : tree res_op0;
5123 7605552 : res_op0 = captures[0];
5124 7605552 : tree res_op1;
5125 7605552 : {
5126 7605552 : tree _o1[1], _r1;
5127 7605552 : _o1[0] = captures[1];
5128 7605552 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
5129 7605552 : res_op1 = _r1;
5130 : }
5131 7605552 : tree _r;
5132 7605552 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
5133 7605552 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
5134 7605552 : return _r;
5135 : }
5136 0 : next_after_fail1181:;
5137 : }
5138 : }
5139 : }
5140 23866083 : switch (TREE_CODE (_p0))
5141 : {
5142 5213154 : CASE_CONVERT:
5143 5213154 : {
5144 5213154 : tree _q20 = TREE_OPERAND (_p0, 0);
5145 5213154 : switch (TREE_CODE (_p1))
5146 : {
5147 4197362 : CASE_CONVERT:
5148 4197362 : {
5149 4197362 : tree _q40 = TREE_OPERAND (_p1, 0);
5150 4197362 : switch (TREE_CODE (_q40))
5151 : {
5152 15 : case BIT_AND_EXPR:
5153 15 : {
5154 15 : tree _q50 = TREE_OPERAND (_q40, 0);
5155 15 : tree _q51 = TREE_OPERAND (_q40, 1);
5156 15 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
5157 : {
5158 0 : {
5159 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q50, _p1, _q40, _q51, _q20 };
5160 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
5161 0 : if (res) return res;
5162 : }
5163 : }
5164 15 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
5165 : {
5166 1 : {
5167 1 : tree captures[5] ATTRIBUTE_UNUSED = { _q51, _p1, _q40, _q50, _q20 };
5168 1 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
5169 1 : if (res) return res;
5170 : }
5171 : }
5172 : break;
5173 : }
5174 : default:;
5175 : }
5176 : break;
5177 : }
5178 4918 : case BIT_AND_EXPR:
5179 4918 : {
5180 4918 : tree _q40 = TREE_OPERAND (_p1, 0);
5181 4918 : tree _q41 = TREE_OPERAND (_p1, 1);
5182 4918 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _q20, 0))
5183 : {
5184 0 : {
5185 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q40, _p1, _p1, _q41, _q20 };
5186 0 : tree res = generic_simplify_48 (loc, type, _p0, _p1, captures);
5187 0 : if (res) return res;
5188 : }
5189 : }
5190 4918 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _q20, 0))
5191 : {
5192 21 : {
5193 21 : tree captures[5] ATTRIBUTE_UNUSED = { _q41, _p1, _p1, _q40, _q20 };
5194 21 : tree res = generic_simplify_48 (loc, type, _p0, _p1, captures);
5195 21 : if (res) return res;
5196 : }
5197 : }
5198 : break;
5199 : }
5200 5213132 : default:;
5201 : }
5202 5213132 : switch (TREE_CODE (_q20))
5203 : {
5204 108806 : case ADDR_EXPR:
5205 108806 : {
5206 108806 : switch (TREE_CODE (_p1))
5207 : {
5208 100729 : CASE_CONVERT:
5209 100729 : {
5210 100729 : tree _q40 = TREE_OPERAND (_p1, 0);
5211 100729 : switch (TREE_CODE (_q40))
5212 : {
5213 27246 : case POINTER_PLUS_EXPR:
5214 27246 : {
5215 27246 : tree _q50 = TREE_OPERAND (_q40, 0);
5216 27246 : tree _q51 = TREE_OPERAND (_q40, 1);
5217 27246 : {
5218 27246 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q50, _q51 };
5219 27246 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
5220 : )
5221 : {
5222 27246 : {
5223 27246 : poly_int64 diff;
5224 27246 : if (ptr_difference_const (captures[0], captures[1], &diff)
5225 : )
5226 : {
5227 12012 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1182;
5228 12012 : {
5229 12012 : tree res_op0;
5230 12012 : res_op0 = build_int_cst_type (type, diff);
5231 12012 : tree res_op1;
5232 12012 : {
5233 12012 : tree _o1[1], _r1;
5234 12012 : _o1[0] = captures[2];
5235 12012 : if (TREE_TYPE (_o1[0]) != type)
5236 : {
5237 12012 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
5238 : }
5239 : else
5240 : _r1 = _o1[0];
5241 12012 : res_op1 = _r1;
5242 : }
5243 12012 : tree _r;
5244 12012 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
5245 12012 : if (TREE_SIDE_EFFECTS (captures[0]))
5246 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
5247 12012 : if (TREE_SIDE_EFFECTS (captures[1]))
5248 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5249 12012 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 898, __FILE__, __LINE__, true);
5250 12012 : return _r;
5251 : }
5252 0 : next_after_fail1182:;
5253 : }
5254 : }
5255 : }
5256 : }
5257 15234 : break;
5258 : }
5259 88717 : default:;
5260 : }
5261 88717 : {
5262 88717 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
5263 88717 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
5264 : )
5265 : {
5266 88717 : {
5267 88717 : poly_int64 diff;
5268 88717 : if (ptr_difference_const (captures[0], captures[1], &diff)
5269 : )
5270 : {
5271 54060 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1183;
5272 54060 : {
5273 54060 : tree _r;
5274 54060 : _r = build_int_cst_type (type, diff);
5275 54060 : if (TREE_SIDE_EFFECTS (captures[0]))
5276 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
5277 54060 : if (TREE_SIDE_EFFECTS (captures[1]))
5278 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5279 54060 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 899, __FILE__, __LINE__, true);
5280 54060 : return _r;
5281 : }
5282 0 : next_after_fail1183:;
5283 : }
5284 : }
5285 : }
5286 : }
5287 34657 : break;
5288 : }
5289 : default:;
5290 : }
5291 : break;
5292 : }
5293 101265 : case POINTER_PLUS_EXPR:
5294 101265 : {
5295 101265 : tree _q30 = TREE_OPERAND (_q20, 0);
5296 101265 : tree _q31 = TREE_OPERAND (_q20, 1);
5297 101265 : switch (TREE_CODE (_p1))
5298 : {
5299 100175 : CASE_CONVERT:
5300 100175 : {
5301 100175 : tree _q60 = TREE_OPERAND (_p1, 0);
5302 100175 : switch (TREE_CODE (_q60))
5303 : {
5304 5301 : case ADDR_EXPR:
5305 5301 : {
5306 5301 : {
5307 5301 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q60 };
5308 5301 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
5309 : )
5310 : {
5311 5301 : {
5312 5301 : poly_int64 diff;
5313 5301 : if (ptr_difference_const (captures[0], captures[2], &diff)
5314 : )
5315 : {
5316 1154 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1184;
5317 1154 : {
5318 1154 : tree res_op0;
5319 1154 : {
5320 1154 : tree _o1[1], _r1;
5321 1154 : _o1[0] = captures[1];
5322 1154 : if (TREE_TYPE (_o1[0]) != type)
5323 : {
5324 881 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
5325 : }
5326 : else
5327 : _r1 = _o1[0];
5328 1154 : res_op0 = _r1;
5329 : }
5330 1154 : tree res_op1;
5331 1154 : res_op1 = build_int_cst_type (type, diff);
5332 1154 : tree _r;
5333 1154 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
5334 1154 : if (TREE_SIDE_EFFECTS (captures[0]))
5335 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
5336 1154 : if (TREE_SIDE_EFFECTS (captures[2]))
5337 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
5338 1154 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 900, __FILE__, __LINE__, true);
5339 1154 : return _r;
5340 : }
5341 0 : next_after_fail1184:;
5342 : }
5343 : }
5344 : }
5345 : }
5346 4147 : break;
5347 : }
5348 : default:;
5349 : }
5350 : break;
5351 : }
5352 : default:;
5353 : }
5354 : break;
5355 : }
5356 5145906 : default:;
5357 : }
5358 5145906 : switch (TREE_CODE (_p1))
5359 : {
5360 4130135 : CASE_CONVERT:
5361 4130135 : {
5362 4130135 : tree _q40 = TREE_OPERAND (_p1, 0);
5363 4130135 : switch (TREE_CODE (_q40))
5364 : {
5365 60413 : case ADDR_EXPR:
5366 60413 : {
5367 60413 : {
5368 60413 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
5369 60413 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
5370 : )
5371 : {
5372 60392 : {
5373 60392 : poly_int64 diff;
5374 60392 : if (ptr_difference_const (captures[0], captures[1], &diff)
5375 : )
5376 : {
5377 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1185;
5378 0 : {
5379 0 : tree _r;
5380 0 : _r = build_int_cst_type (type, diff);
5381 0 : if (TREE_SIDE_EFFECTS (captures[0]))
5382 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
5383 0 : if (TREE_SIDE_EFFECTS (captures[1]))
5384 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5385 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 901, __FILE__, __LINE__, true);
5386 0 : return _r;
5387 : }
5388 0 : next_after_fail1185:;
5389 : }
5390 : }
5391 : }
5392 : }
5393 60413 : break;
5394 : }
5395 : default:;
5396 : }
5397 : break;
5398 : }
5399 : default:;
5400 : }
5401 : break;
5402 : }
5403 23798835 : default:;
5404 : }
5405 23798835 : if (integer_onep (_p0))
5406 : {
5407 108753 : switch (TREE_CODE (_p1))
5408 : {
5409 27542 : case SSA_NAME:
5410 27542 : {
5411 27542 : {
5412 27542 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
5413 27542 : if (INTEGRAL_TYPE_P (type)
5414 27542 : && ssa_name_has_boolean_range (captures[1])
5415 : )
5416 : {
5417 212 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1186;
5418 212 : {
5419 212 : tree res_op0;
5420 212 : res_op0 = captures[1];
5421 212 : tree res_op1;
5422 212 : res_op1 = captures[0];
5423 212 : tree _r;
5424 212 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
5425 212 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 902, __FILE__, __LINE__, true);
5426 212 : return _r;
5427 : }
5428 0 : next_after_fail1186:;
5429 : }
5430 : }
5431 27330 : break;
5432 : }
5433 : default:;
5434 : }
5435 : }
5436 23798623 : switch (TREE_CODE (_p1))
5437 : {
5438 7640117 : CASE_CONVERT:
5439 7640117 : {
5440 7640117 : tree _q30 = TREE_OPERAND (_p1, 0);
5441 7640117 : switch (TREE_CODE (_q30))
5442 : {
5443 14 : case BIT_AND_EXPR:
5444 14 : {
5445 14 : tree _q40 = TREE_OPERAND (_q30, 0);
5446 14 : tree _q41 = TREE_OPERAND (_q30, 1);
5447 14 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _p0, 0))
5448 : {
5449 0 : {
5450 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q40, _p1, _q30, _q41, _p0 };
5451 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
5452 0 : if (res) return res;
5453 : }
5454 : }
5455 14 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _p0, 0))
5456 : {
5457 0 : {
5458 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q41, _p1, _q30, _q40, _p0 };
5459 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
5460 0 : if (res) return res;
5461 : }
5462 : }
5463 : break;
5464 : }
5465 : default:;
5466 : }
5467 : break;
5468 : }
5469 7000 : case BIT_AND_EXPR:
5470 7000 : {
5471 7000 : tree _q30 = TREE_OPERAND (_p1, 0);
5472 7000 : tree _q31 = TREE_OPERAND (_p1, 1);
5473 7000 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || operand_equal_p (_q30, _p0, 0))
5474 : {
5475 213 : {
5476 213 : tree captures[5] ATTRIBUTE_UNUSED = { _q30, _p1, _p1, _q31, _p0 };
5477 213 : tree res = generic_simplify_48 (loc, type, _p0, _p1, captures);
5478 213 : if (res) return res;
5479 : }
5480 : }
5481 6787 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || operand_equal_p (_q31, _p0, 0))
5482 : {
5483 38 : {
5484 38 : tree captures[5] ATTRIBUTE_UNUSED = { _q31, _p1, _p1, _q30, _p0 };
5485 38 : tree res = generic_simplify_48 (loc, type, _p0, _p1, captures);
5486 38 : if (res) return res;
5487 : }
5488 : }
5489 : break;
5490 : }
5491 23798372 : default:;
5492 : }
5493 23798372 : switch (TREE_CODE (_p0))
5494 : {
5495 1750592 : case PLUS_EXPR:
5496 1750592 : {
5497 1750592 : tree _q20 = TREE_OPERAND (_p0, 0);
5498 1750592 : tree _q21 = TREE_OPERAND (_p0, 1);
5499 1750592 : switch (TREE_CODE (_p1))
5500 : {
5501 472091 : case PLUS_EXPR:
5502 472091 : {
5503 472091 : tree _q50 = TREE_OPERAND (_p1, 0);
5504 472091 : tree _q51 = TREE_OPERAND (_p1, 1);
5505 472091 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5506 : {
5507 170952 : {
5508 170952 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5509 341904 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
5510 341904 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5511 40229 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
5512 : )
5513 : {
5514 170946 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1187;
5515 170946 : {
5516 170946 : tree res_op0;
5517 170946 : res_op0 = captures[0];
5518 170946 : tree res_op1;
5519 170946 : res_op1 = captures[2];
5520 170946 : tree _r;
5521 170946 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
5522 170946 : if (TREE_SIDE_EFFECTS (captures[1]))
5523 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5524 170946 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 903, __FILE__, __LINE__, true);
5525 170946 : return _r;
5526 : }
5527 0 : next_after_fail1187:;
5528 : }
5529 : }
5530 : }
5531 301145 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5532 : {
5533 407 : {
5534 407 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5535 814 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
5536 814 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5537 297 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
5538 : )
5539 : {
5540 407 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1188;
5541 407 : {
5542 407 : tree res_op0;
5543 407 : res_op0 = captures[0];
5544 407 : tree res_op1;
5545 407 : res_op1 = captures[2];
5546 407 : tree _r;
5547 407 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
5548 407 : if (TREE_SIDE_EFFECTS (captures[1]))
5549 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5550 407 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 903, __FILE__, __LINE__, true);
5551 407 : return _r;
5552 : }
5553 0 : next_after_fail1188:;
5554 : }
5555 : }
5556 : }
5557 300738 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5558 : {
5559 219 : {
5560 219 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
5561 438 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
5562 438 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5563 130 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
5564 : )
5565 : {
5566 219 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1189;
5567 219 : {
5568 219 : tree res_op0;
5569 219 : res_op0 = captures[0];
5570 219 : tree res_op1;
5571 219 : res_op1 = captures[2];
5572 219 : tree _r;
5573 219 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
5574 219 : if (TREE_SIDE_EFFECTS (captures[1]))
5575 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5576 219 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 903, __FILE__, __LINE__, true);
5577 219 : return _r;
5578 : }
5579 0 : next_after_fail1189:;
5580 : }
5581 : }
5582 : }
5583 300519 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5584 : {
5585 172048 : {
5586 172048 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
5587 344096 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
5588 344096 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5589 138657 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
5590 : )
5591 : {
5592 172048 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1190;
5593 172048 : {
5594 172048 : tree res_op0;
5595 172048 : res_op0 = captures[0];
5596 172048 : tree res_op1;
5597 172048 : res_op1 = captures[2];
5598 172048 : tree _r;
5599 172048 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
5600 172048 : if (TREE_SIDE_EFFECTS (captures[1]))
5601 2 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5602 172048 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 903, __FILE__, __LINE__, true);
5603 172048 : return _r;
5604 : }
5605 0 : next_after_fail1190:;
5606 : }
5607 : }
5608 : }
5609 : break;
5610 : }
5611 : default:;
5612 : }
5613 : break;
5614 : }
5615 954018 : case MINUS_EXPR:
5616 954018 : {
5617 954018 : tree _q20 = TREE_OPERAND (_p0, 0);
5618 954018 : tree _q21 = TREE_OPERAND (_p0, 1);
5619 954018 : switch (TREE_CODE (_p1))
5620 : {
5621 3919 : case MINUS_EXPR:
5622 3919 : {
5623 3919 : tree _q50 = TREE_OPERAND (_p1, 0);
5624 3919 : tree _q51 = TREE_OPERAND (_p1, 1);
5625 3919 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5626 : {
5627 3877 : {
5628 3877 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5629 7754 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
5630 7754 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5631 0 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
5632 : )
5633 : {
5634 3877 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1191;
5635 3877 : {
5636 3877 : tree res_op0;
5637 3877 : res_op0 = captures[0];
5638 3877 : tree res_op1;
5639 3877 : res_op1 = captures[2];
5640 3877 : tree _r;
5641 3877 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
5642 3877 : if (TREE_SIDE_EFFECTS (captures[1]))
5643 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5644 3877 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 904, __FILE__, __LINE__, true);
5645 3877 : return _r;
5646 : }
5647 0 : next_after_fail1191:;
5648 : }
5649 : }
5650 : }
5651 42 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5652 : {
5653 0 : {
5654 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5655 0 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
5656 0 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
5657 0 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1])))
5658 : )
5659 : {
5660 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1192;
5661 0 : {
5662 0 : tree res_op0;
5663 0 : res_op0 = captures[2];
5664 0 : tree res_op1;
5665 0 : res_op1 = captures[1];
5666 0 : tree _r;
5667 0 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
5668 0 : if (TREE_SIDE_EFFECTS (captures[0]))
5669 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
5670 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 905, __FILE__, __LINE__, true);
5671 0 : return _r;
5672 : }
5673 0 : next_after_fail1192:;
5674 : }
5675 : }
5676 : }
5677 : break;
5678 : }
5679 : default:;
5680 : }
5681 : break;
5682 : }
5683 59 : case POINTER_DIFF_EXPR:
5684 59 : {
5685 59 : tree _q20 = TREE_OPERAND (_p0, 0);
5686 59 : tree _q21 = TREE_OPERAND (_p0, 1);
5687 59 : switch (TREE_CODE (_p1))
5688 : {
5689 0 : case POINTER_DIFF_EXPR:
5690 0 : {
5691 0 : tree _q50 = TREE_OPERAND (_p1, 0);
5692 0 : tree _q51 = TREE_OPERAND (_p1, 1);
5693 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5694 : {
5695 0 : {
5696 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
5697 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5698 0 : && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[2]))
5699 : )
5700 : {
5701 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1193;
5702 0 : {
5703 0 : tree res_op0;
5704 0 : res_op0 = captures[1];
5705 0 : tree res_op1;
5706 0 : res_op1 = captures[3];
5707 0 : tree _r;
5708 0 : _r = fold_build2_loc (loc, POINTER_DIFF_EXPR, type, res_op0, res_op1);
5709 0 : if (TREE_SIDE_EFFECTS (captures[2]))
5710 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
5711 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
5712 0 : return _r;
5713 : }
5714 0 : next_after_fail1193:;
5715 : }
5716 : }
5717 : }
5718 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5719 : {
5720 0 : {
5721 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
5722 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5723 0 : && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[1]))
5724 : )
5725 : {
5726 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1194;
5727 0 : {
5728 0 : tree res_op0;
5729 0 : res_op0 = captures[3];
5730 0 : tree res_op1;
5731 0 : res_op1 = captures[2];
5732 0 : tree _r;
5733 0 : _r = fold_build2_loc (loc, POINTER_DIFF_EXPR, type, res_op0, res_op1);
5734 0 : if (TREE_SIDE_EFFECTS (captures[1]))
5735 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5736 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 907, __FILE__, __LINE__, true);
5737 0 : return _r;
5738 : }
5739 0 : next_after_fail1194:;
5740 : }
5741 : }
5742 : }
5743 : break;
5744 : }
5745 : default:;
5746 : }
5747 : break;
5748 : }
5749 23450875 : default:;
5750 : }
5751 23450875 : switch (TREE_CODE (_p1))
5752 : {
5753 7640117 : CASE_CONVERT:
5754 7640117 : {
5755 7640117 : tree _q30 = TREE_OPERAND (_p1, 0);
5756 7640117 : switch (TREE_CODE (_q30))
5757 : {
5758 1467 : case NEGATE_EXPR:
5759 1467 : {
5760 1467 : tree _q40 = TREE_OPERAND (_q30, 0);
5761 1467 : {
5762 1467 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
5763 1467 : tree res = generic_simplify_49 (loc, type, _p0, _p1, captures);
5764 1467 : if (res) return res;
5765 : }
5766 1467 : break;
5767 : }
5768 : default:;
5769 : }
5770 : break;
5771 : }
5772 45 : case NEGATE_EXPR:
5773 45 : {
5774 45 : tree _q30 = TREE_OPERAND (_p1, 0);
5775 45 : {
5776 45 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
5777 45 : tree res = generic_simplify_49 (loc, type, _p0, _p1, captures);
5778 45 : if (res) return res;
5779 : }
5780 40 : break;
5781 : }
5782 23450870 : default:;
5783 : }
5784 23450870 : switch (TREE_CODE (_p0))
5785 : {
5786 1406972 : case PLUS_EXPR:
5787 1406972 : {
5788 1406972 : tree _q20 = TREE_OPERAND (_p0, 0);
5789 1406972 : tree _q21 = TREE_OPERAND (_p0, 1);
5790 1406972 : {
5791 1406972 : tree _q20_pops[1];
5792 1406972 : if (tree_nop_convert (_q20, _q20_pops))
5793 : {
5794 335507 : tree _q30 = _q20_pops[0];
5795 335507 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
5796 : {
5797 338 : {
5798 338 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q21 };
5799 338 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures);
5800 338 : if (res) return res;
5801 : }
5802 : }
5803 : }
5804 : }
5805 1406634 : {
5806 1406634 : tree _q21_pops[1];
5807 1406634 : if (tree_nop_convert (_q21, _q21_pops))
5808 : {
5809 491220 : tree _q40 = _q21_pops[0];
5810 491220 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
5811 : {
5812 89 : {
5813 89 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
5814 89 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures);
5815 89 : if (res) return res;
5816 : }
5817 : }
5818 : }
5819 : }
5820 1406545 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5821 : {
5822 53627 : {
5823 53627 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5824 53627 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures);
5825 53627 : if (res) return res;
5826 : }
5827 : }
5828 1352918 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5829 : {
5830 1701 : {
5831 1701 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
5832 1701 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures);
5833 1701 : if (res) return res;
5834 : }
5835 : }
5836 : break;
5837 : }
5838 950141 : case MINUS_EXPR:
5839 950141 : {
5840 950141 : tree _q20 = TREE_OPERAND (_p0, 0);
5841 950141 : tree _q21 = TREE_OPERAND (_p0, 1);
5842 950141 : {
5843 950141 : tree _q20_pops[1];
5844 950141 : if (tree_nop_convert (_q20, _q20_pops))
5845 : {
5846 91826 : tree _q30 = _q20_pops[0];
5847 91826 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
5848 : {
5849 0 : {
5850 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q21 };
5851 0 : tree res = generic_simplify_51 (loc, type, _p0, _p1, captures);
5852 0 : if (res) return res;
5853 : }
5854 : }
5855 : }
5856 : }
5857 950141 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5858 : {
5859 178 : {
5860 178 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5861 178 : tree res = generic_simplify_51 (loc, type, _p0, _p1, captures);
5862 178 : if (res) return res;
5863 : }
5864 : }
5865 : break;
5866 : }
5867 23394948 : default:;
5868 : }
5869 23394948 : {
5870 23394948 : tree _p0_pops[1];
5871 23394948 : if (tree_nop_convert (_p0, _p0_pops))
5872 : {
5873 4580842 : tree _q20 = _p0_pops[0];
5874 4580842 : switch (TREE_CODE (_q20))
5875 : {
5876 350636 : case PLUS_EXPR:
5877 350636 : {
5878 350636 : tree _q30 = TREE_OPERAND (_q20, 0);
5879 350636 : tree _q31 = TREE_OPERAND (_q20, 1);
5880 350636 : {
5881 350636 : tree _q30_pops[1];
5882 350636 : if (tree_nop_convert (_q30, _q30_pops))
5883 : {
5884 31608 : tree _q40 = _q30_pops[0];
5885 31608 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
5886 : {
5887 625 : {
5888 625 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q31 };
5889 625 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures);
5890 625 : if (res) return res;
5891 : }
5892 : }
5893 : }
5894 : }
5895 350011 : {
5896 350011 : tree _q31_pops[1];
5897 350011 : if (tree_nop_convert (_q31, _q31_pops))
5898 : {
5899 2141 : tree _q50 = _q31_pops[0];
5900 2141 : if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
5901 : {
5902 52 : {
5903 52 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
5904 52 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures);
5905 52 : if (res) return res;
5906 : }
5907 : }
5908 : }
5909 : }
5910 349959 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
5911 : {
5912 10 : {
5913 10 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
5914 10 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures);
5915 10 : if (res) return res;
5916 : }
5917 : }
5918 349949 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
5919 : {
5920 0 : {
5921 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q30 };
5922 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures);
5923 0 : if (res) return res;
5924 : }
5925 : }
5926 : break;
5927 : }
5928 883 : case MINUS_EXPR:
5929 883 : {
5930 883 : tree _q30 = TREE_OPERAND (_q20, 0);
5931 883 : tree _q31 = TREE_OPERAND (_q20, 1);
5932 883 : {
5933 883 : tree _q30_pops[1];
5934 883 : if (tree_nop_convert (_q30, _q30_pops))
5935 : {
5936 408 : tree _q40 = _q30_pops[0];
5937 408 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
5938 : {
5939 0 : {
5940 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q31 };
5941 0 : tree res = generic_simplify_51 (loc, type, _p0, _p1, captures);
5942 0 : if (res) return res;
5943 : }
5944 : }
5945 : }
5946 : }
5947 883 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
5948 : {
5949 0 : {
5950 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
5951 0 : tree res = generic_simplify_51 (loc, type, _p0, _p1, captures);
5952 0 : if (res) return res;
5953 : }
5954 : }
5955 : break;
5956 : }
5957 : default:;
5958 : }
5959 : }
5960 : }
5961 23394261 : switch (TREE_CODE (_p1))
5962 : {
5963 1296596 : case PLUS_EXPR:
5964 1296596 : {
5965 1296596 : tree _q30 = TREE_OPERAND (_p1, 0);
5966 1296596 : tree _q31 = TREE_OPERAND (_p1, 1);
5967 1296596 : {
5968 1296596 : tree _q30_pops[1];
5969 1296596 : if (tree_nop_convert (_q30, _q30_pops))
5970 : {
5971 327102 : tree _q40 = _q30_pops[0];
5972 327102 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
5973 : {
5974 71 : {
5975 71 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
5976 71 : tree res = generic_simplify_52 (loc, type, _p0, _p1, captures);
5977 71 : if (res) return res;
5978 : }
5979 : }
5980 : }
5981 : }
5982 1296525 : {
5983 1296525 : tree _q31_pops[1];
5984 1296525 : if (tree_nop_convert (_q31, _q31_pops))
5985 : {
5986 62186 : tree _q50 = _q31_pops[0];
5987 62186 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
5988 : {
5989 0 : {
5990 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
5991 0 : tree res = generic_simplify_52 (loc, type, _p0, _p1, captures);
5992 0 : if (res) return res;
5993 : }
5994 : }
5995 : }
5996 : }
5997 1296525 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5998 : {
5999 38481 : {
6000 38481 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
6001 38481 : tree res = generic_simplify_52 (loc, type, _p0, _p1, captures);
6002 38481 : if (res) return res;
6003 : }
6004 : }
6005 1258044 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6006 : {
6007 2593 : {
6008 2593 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
6009 2593 : tree res = generic_simplify_52 (loc, type, _p0, _p1, captures);
6010 2593 : if (res) return res;
6011 : }
6012 : }
6013 : break;
6014 : }
6015 79957 : case MINUS_EXPR:
6016 79957 : {
6017 79957 : tree _q30 = TREE_OPERAND (_p1, 0);
6018 79957 : tree _q31 = TREE_OPERAND (_p1, 1);
6019 79957 : {
6020 79957 : tree _q30_pops[1];
6021 79957 : if (tree_nop_convert (_q30, _q30_pops))
6022 : {
6023 61 : tree _q40 = _q30_pops[0];
6024 61 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
6025 : {
6026 0 : {
6027 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
6028 0 : tree res = generic_simplify_53 (loc, type, _p0, _p1, captures);
6029 0 : if (res) return res;
6030 : }
6031 : }
6032 : }
6033 : }
6034 79957 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
6035 : {
6036 134 : {
6037 134 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
6038 134 : tree res = generic_simplify_53 (loc, type, _p0, _p1, captures);
6039 134 : if (res) return res;
6040 : }
6041 : }
6042 : break;
6043 : }
6044 23352982 : default:;
6045 : }
6046 23352982 : {
6047 23352982 : tree _p1_pops[1];
6048 23352982 : if (tree_nop_convert (_p1, _p1_pops))
6049 : {
6050 6728734 : tree _q30 = _p1_pops[0];
6051 6728734 : switch (TREE_CODE (_q30))
6052 : {
6053 664140 : case PLUS_EXPR:
6054 664140 : {
6055 664140 : tree _q40 = TREE_OPERAND (_q30, 0);
6056 664140 : tree _q41 = TREE_OPERAND (_q30, 1);
6057 664140 : {
6058 664140 : tree _q40_pops[1];
6059 664140 : if (tree_nop_convert (_q40, _q40_pops))
6060 : {
6061 68113 : tree _q50 = _q40_pops[0];
6062 68113 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
6063 : {
6064 152 : {
6065 152 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
6066 152 : tree res = generic_simplify_52 (loc, type, _p0, _p1, captures);
6067 152 : if (res) return res;
6068 : }
6069 : }
6070 : }
6071 : }
6072 663988 : {
6073 663988 : tree _q41_pops[1];
6074 663988 : if (tree_nop_convert (_q41, _q41_pops))
6075 : {
6076 17670 : tree _q60 = _q41_pops[0];
6077 17670 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
6078 : {
6079 0 : {
6080 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
6081 0 : tree res = generic_simplify_52 (loc, type, _p0, _p1, captures);
6082 0 : if (res) return res;
6083 : }
6084 : }
6085 : }
6086 : }
6087 663988 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
6088 : {
6089 7 : {
6090 7 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
6091 7 : tree res = generic_simplify_52 (loc, type, _p0, _p1, captures);
6092 7 : if (res) return res;
6093 : }
6094 : }
6095 663981 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
6096 : {
6097 0 : {
6098 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
6099 0 : tree res = generic_simplify_52 (loc, type, _p0, _p1, captures);
6100 0 : if (res) return res;
6101 : }
6102 : }
6103 : break;
6104 : }
6105 7421 : case MINUS_EXPR:
6106 7421 : {
6107 7421 : tree _q40 = TREE_OPERAND (_q30, 0);
6108 7421 : tree _q41 = TREE_OPERAND (_q30, 1);
6109 7421 : {
6110 7421 : tree _q40_pops[1];
6111 7421 : if (tree_nop_convert (_q40, _q40_pops))
6112 : {
6113 6712 : tree _q50 = _q40_pops[0];
6114 6712 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
6115 : {
6116 0 : {
6117 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
6118 0 : tree res = generic_simplify_53 (loc, type, _p0, _p1, captures);
6119 0 : if (res) return res;
6120 : }
6121 : }
6122 : }
6123 : }
6124 7421 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
6125 : {
6126 2 : {
6127 2 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
6128 2 : tree res = generic_simplify_53 (loc, type, _p0, _p1, captures);
6129 2 : if (res) return res;
6130 : }
6131 : }
6132 : break;
6133 : }
6134 : default:;
6135 : }
6136 : }
6137 : }
6138 23352821 : switch (TREE_CODE (_p0))
6139 : {
6140 1351228 : case PLUS_EXPR:
6141 1351228 : {
6142 1351228 : tree _q20 = TREE_OPERAND (_p0, 0);
6143 1351228 : tree _q21 = TREE_OPERAND (_p0, 1);
6144 1351228 : switch (TREE_CODE (_p1))
6145 : {
6146 0 : case MINUS_EXPR:
6147 0 : {
6148 0 : tree _q50 = TREE_OPERAND (_p1, 0);
6149 0 : tree _q51 = TREE_OPERAND (_p1, 1);
6150 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6151 : {
6152 0 : {
6153 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
6154 0 : tree res = generic_simplify_54 (loc, type, _p0, _p1, captures);
6155 0 : if (res) return res;
6156 : }
6157 : }
6158 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6159 : {
6160 0 : {
6161 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
6162 0 : tree res = generic_simplify_54 (loc, type, _p0, _p1, captures);
6163 0 : if (res) return res;
6164 : }
6165 : }
6166 : break;
6167 : }
6168 1351228 : default:;
6169 : }
6170 1351228 : if (CONSTANT_CLASS_P (_q21))
6171 : {
6172 563261 : if (CONSTANT_CLASS_P (_p1))
6173 : {
6174 13 : {
6175 13 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6176 13 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures, PLUS_EXPR, MINUS_EXPR, MINUS_EXPR);
6177 13 : if (res) return res;
6178 : }
6179 : }
6180 : }
6181 : break;
6182 : }
6183 949960 : case MINUS_EXPR:
6184 949960 : {
6185 949960 : tree _q20 = TREE_OPERAND (_p0, 0);
6186 949960 : tree _q21 = TREE_OPERAND (_p0, 1);
6187 949960 : if (CONSTANT_CLASS_P (_q21))
6188 : {
6189 93226 : if (CONSTANT_CLASS_P (_p1))
6190 : {
6191 12 : {
6192 12 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6193 12 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures, MINUS_EXPR, PLUS_EXPR, MINUS_EXPR);
6194 12 : if (res) return res;
6195 : }
6196 : }
6197 : }
6198 949960 : if (CONSTANT_CLASS_P (_q20))
6199 : {
6200 2880 : if (CONSTANT_CLASS_P (_p1))
6201 : {
6202 1 : {
6203 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6204 1 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures, MINUS_EXPR);
6205 1 : if (res) return res;
6206 : }
6207 : }
6208 : }
6209 : break;
6210 : }
6211 5130961 : CASE_CONVERT:
6212 5130961 : {
6213 5130961 : tree _q20 = TREE_OPERAND (_p0, 0);
6214 5130961 : switch (TREE_CODE (_p1))
6215 : {
6216 4130125 : CASE_CONVERT:
6217 4130125 : {
6218 4130125 : tree _q40 = TREE_OPERAND (_p1, 0);
6219 4130125 : {
6220 4130125 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6221 4130125 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures, MINUS_EXPR);
6222 4130125 : if (res) return res;
6223 : }
6224 4115788 : break;
6225 : }
6226 5116624 : default:;
6227 : }
6228 5116624 : switch (TREE_CODE (_q20))
6229 : {
6230 222 : case NEGATE_EXPR:
6231 222 : {
6232 222 : tree _q30 = TREE_OPERAND (_q20, 0);
6233 222 : if (integer_each_onep (_p1))
6234 : {
6235 0 : {
6236 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
6237 0 : tree res = generic_simplify_56 (loc, type, _p0, _p1, captures);
6238 0 : if (res) return res;
6239 : }
6240 : }
6241 : break;
6242 : }
6243 399996 : case PLUS_EXPR:
6244 399996 : {
6245 399996 : tree _q30 = TREE_OPERAND (_q20, 0);
6246 399996 : tree _q31 = TREE_OPERAND (_q20, 1);
6247 399996 : switch (TREE_CODE (_p1))
6248 : {
6249 383432 : CASE_CONVERT:
6250 383432 : {
6251 383432 : tree _q60 = TREE_OPERAND (_p1, 0);
6252 383432 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q30, 0))
6253 : {
6254 6258 : {
6255 6258 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q30 };
6256 6258 : tree res = generic_simplify_57 (loc, type, _p0, _p1, captures);
6257 6258 : if (res) return res;
6258 : }
6259 : }
6260 377288 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q31, 0))
6261 : {
6262 32 : {
6263 32 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q31 };
6264 32 : tree res = generic_simplify_57 (loc, type, _p0, _p1, captures);
6265 32 : if (res) return res;
6266 : }
6267 : }
6268 : break;
6269 : }
6270 393820 : default:;
6271 : }
6272 393820 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q30, 0))
6273 : {
6274 3863 : {
6275 3863 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q30 };
6276 3863 : tree res = generic_simplify_57 (loc, type, _p0, _p1, captures);
6277 3863 : if (res) return res;
6278 : }
6279 : }
6280 389957 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q31, 0))
6281 : {
6282 960 : {
6283 960 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q31 };
6284 960 : tree res = generic_simplify_57 (loc, type, _p0, _p1, captures);
6285 960 : if (res) return res;
6286 : }
6287 : }
6288 : break;
6289 : }
6290 100111 : case POINTER_PLUS_EXPR:
6291 100111 : {
6292 100111 : tree _q30 = TREE_OPERAND (_q20, 0);
6293 100111 : tree _q31 = TREE_OPERAND (_q20, 1);
6294 100111 : switch (TREE_CODE (_p1))
6295 : {
6296 99021 : CASE_CONVERT:
6297 99021 : {
6298 99021 : tree _q60 = TREE_OPERAND (_p1, 0);
6299 99021 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q30, 0))
6300 : {
6301 11325 : {
6302 11325 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q30 };
6303 11325 : if (!TYPE_SATURATING (type)
6304 : )
6305 : {
6306 11325 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
6307 22650 : && !FIXED_POINT_TYPE_P (type)
6308 : )
6309 : {
6310 11325 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
6311 11325 : || (POINTER_TYPE_P (TREE_TYPE (captures[0]))
6312 0 : && TREE_CODE (captures[1]) == INTEGER_CST
6313 0 : && tree_int_cst_sign_bit (captures[1]) == 0)
6314 : )
6315 : {
6316 11325 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1195;
6317 11325 : {
6318 11325 : tree res_op0;
6319 11325 : res_op0 = captures[1];
6320 11325 : tree _r;
6321 11325 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
6322 11325 : if (TREE_SIDE_EFFECTS (captures[2]))
6323 11 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
6324 11325 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 908, __FILE__, __LINE__, true);
6325 11325 : return _r;
6326 : }
6327 0 : next_after_fail1195:;
6328 : }
6329 : }
6330 : }
6331 : }
6332 : }
6333 : break;
6334 : }
6335 : default:;
6336 : }
6337 : break;
6338 : }
6339 5094300 : default:;
6340 : }
6341 5094300 : switch (TREE_CODE (_p1))
6342 : {
6343 4093592 : CASE_CONVERT:
6344 4093592 : {
6345 4093592 : tree _q40 = TREE_OPERAND (_p1, 0);
6346 4093592 : switch (TREE_CODE (_q40))
6347 : {
6348 487568 : case PLUS_EXPR:
6349 487568 : {
6350 487568 : tree _q50 = TREE_OPERAND (_q40, 0);
6351 487568 : tree _q51 = TREE_OPERAND (_q40, 1);
6352 487568 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
6353 : {
6354 2145 : {
6355 2145 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
6356 2145 : tree res = generic_simplify_58 (loc, type, _p0, _p1, captures);
6357 2145 : if (res) return res;
6358 : }
6359 : }
6360 485495 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
6361 : {
6362 18 : {
6363 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q50, _q20 };
6364 18 : tree res = generic_simplify_58 (loc, type, _p0, _p1, captures);
6365 18 : if (res) return res;
6366 : }
6367 : }
6368 : break;
6369 : }
6370 : default:;
6371 : }
6372 : break;
6373 : }
6374 : default:;
6375 : }
6376 : break;
6377 : }
6378 140931 : case NEGATE_EXPR:
6379 140931 : {
6380 140931 : tree _q20 = TREE_OPERAND (_p0, 0);
6381 140931 : if (integer_each_onep (_p1))
6382 : {
6383 41 : {
6384 41 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
6385 41 : tree res = generic_simplify_56 (loc, type, _p0, _p1, captures);
6386 41 : if (res) return res;
6387 : }
6388 : }
6389 : break;
6390 : }
6391 23314028 : default:;
6392 : }
6393 23314028 : {
6394 23314028 : tree _p0_pops[1];
6395 23314028 : if (tree_nop_convert (_p0, _p0_pops))
6396 : {
6397 4533178 : tree _q20 = _p0_pops[0];
6398 4533178 : switch (TREE_CODE (_q20))
6399 : {
6400 331561 : case PLUS_EXPR:
6401 331561 : {
6402 331561 : tree _q30 = TREE_OPERAND (_q20, 0);
6403 331561 : tree _q31 = TREE_OPERAND (_q20, 1);
6404 331561 : if (CONSTANT_CLASS_P (_q31))
6405 : {
6406 325036 : if (CONSTANT_CLASS_P (_p1))
6407 : {
6408 0 : {
6409 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
6410 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures, PLUS_EXPR, MINUS_EXPR, MINUS_EXPR);
6411 0 : if (res) return res;
6412 : }
6413 : }
6414 : }
6415 : break;
6416 : }
6417 883 : case MINUS_EXPR:
6418 883 : {
6419 883 : tree _q30 = TREE_OPERAND (_q20, 0);
6420 883 : tree _q31 = TREE_OPERAND (_q20, 1);
6421 883 : if (CONSTANT_CLASS_P (_q31))
6422 : {
6423 0 : if (CONSTANT_CLASS_P (_p1))
6424 : {
6425 0 : {
6426 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
6427 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures, MINUS_EXPR, PLUS_EXPR, MINUS_EXPR);
6428 0 : if (res) return res;
6429 : }
6430 : }
6431 : }
6432 883 : if (CONSTANT_CLASS_P (_q30))
6433 : {
6434 18 : if (CONSTANT_CLASS_P (_p1))
6435 : {
6436 0 : {
6437 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
6438 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures, MINUS_EXPR);
6439 0 : if (res) return res;
6440 : }
6441 : }
6442 : }
6443 : break;
6444 : }
6445 : default:;
6446 : }
6447 : }
6448 : }
6449 23314028 : if (CONSTANT_CLASS_P (_p0))
6450 : {
6451 5634980 : switch (TREE_CODE (_p1))
6452 : {
6453 823 : case MINUS_EXPR:
6454 823 : {
6455 823 : tree _q30 = TREE_OPERAND (_p1, 0);
6456 823 : tree _q31 = TREE_OPERAND (_p1, 1);
6457 823 : if (CONSTANT_CLASS_P (_q30))
6458 : {
6459 639 : {
6460 639 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q31 };
6461 639 : tree res = generic_simplify_55 (loc, type, _p0, _p1, captures);
6462 639 : if (res) return res;
6463 : }
6464 : }
6465 : break;
6466 : }
6467 5634350 : default:;
6468 : }
6469 5634350 : {
6470 5634350 : tree _p1_pops[1];
6471 5634350 : if (tree_nop_convert (_p1, _p1_pops))
6472 : {
6473 1835445 : tree _q30 = _p1_pops[0];
6474 1835445 : switch (TREE_CODE (_q30))
6475 : {
6476 7207 : case MINUS_EXPR:
6477 7207 : {
6478 7207 : tree _q40 = TREE_OPERAND (_q30, 0);
6479 7207 : tree _q41 = TREE_OPERAND (_q30, 1);
6480 7207 : if (CONSTANT_CLASS_P (_q40))
6481 : {
6482 29 : {
6483 29 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q41 };
6484 29 : tree res = generic_simplify_55 (loc, type, _p0, _p1, captures);
6485 29 : if (res) return res;
6486 : }
6487 : }
6488 : break;
6489 : }
6490 : default:;
6491 : }
6492 : }
6493 : }
6494 : }
6495 23313369 : if (integer_all_onesp (_p0))
6496 : {
6497 1331759 : {
6498 1331759 : tree captures[1] ATTRIBUTE_UNUSED = { _p1 };
6499 1331759 : if (!TYPE_SATURATING (type)
6500 : )
6501 : {
6502 1331759 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
6503 2663518 : && !FIXED_POINT_TYPE_P (type)
6504 : )
6505 : {
6506 1331759 : if (TREE_CODE (type) != COMPLEX_TYPE
6507 : )
6508 : {
6509 1331757 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1196;
6510 1331757 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1196;
6511 1331757 : {
6512 1331757 : tree res_op0;
6513 1331757 : res_op0 = captures[0];
6514 1331757 : tree _r;
6515 1331757 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
6516 1331757 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
6517 1331757 : return _r;
6518 : }
6519 : next_after_fail1196:;
6520 : }
6521 : }
6522 : }
6523 : }
6524 : }
6525 21981612 : switch (TREE_CODE (_p1))
6526 : {
6527 7259455 : CASE_CONVERT:
6528 7259455 : {
6529 7259455 : tree _q30 = TREE_OPERAND (_p1, 0);
6530 7259455 : switch (TREE_CODE (_q30))
6531 : {
6532 672037 : case PLUS_EXPR:
6533 672037 : {
6534 672037 : tree _q40 = TREE_OPERAND (_q30, 0);
6535 672037 : tree _q41 = TREE_OPERAND (_q30, 1);
6536 672037 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _p0, 0))
6537 : {
6538 0 : {
6539 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _p0 };
6540 0 : tree res = generic_simplify_58 (loc, type, _p0, _p1, captures);
6541 0 : if (res) return res;
6542 : }
6543 : }
6544 672037 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _p0, 0))
6545 : {
6546 8062 : {
6547 8062 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _p0 };
6548 8062 : tree res = generic_simplify_58 (loc, type, _p0, _p1, captures);
6549 8062 : if (res) return res;
6550 : }
6551 : }
6552 : break;
6553 : }
6554 : default:;
6555 : }
6556 : break;
6557 : }
6558 21973747 : default:;
6559 : }
6560 21973747 : switch (TREE_CODE (_p0))
6561 : {
6562 5092209 : CASE_CONVERT:
6563 5092209 : {
6564 5092209 : tree _q20 = TREE_OPERAND (_p0, 0);
6565 5092209 : switch (TREE_CODE (_p1))
6566 : {
6567 4091501 : CASE_CONVERT:
6568 4091501 : {
6569 4091501 : tree _q40 = TREE_OPERAND (_p1, 0);
6570 4091501 : switch (TREE_CODE (_q40))
6571 : {
6572 393269 : case POINTER_PLUS_EXPR:
6573 393269 : {
6574 393269 : tree _q50 = TREE_OPERAND (_q40, 0);
6575 393269 : tree _q51 = TREE_OPERAND (_q40, 1);
6576 393269 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
6577 : {
6578 2162 : {
6579 2162 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
6580 2162 : if (!TYPE_SATURATING (type)
6581 : )
6582 : {
6583 2162 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
6584 4324 : && !FIXED_POINT_TYPE_P (type)
6585 : )
6586 : {
6587 2162 : if (INTEGRAL_TYPE_P (type)
6588 2162 : && TYPE_OVERFLOW_UNDEFINED (type)
6589 0 : && TREE_CODE (captures[1]) != INTEGER_CST
6590 2162 : && element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
6591 : )
6592 : {
6593 0 : {
6594 0 : tree utype = unsigned_type_for (type);
6595 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1197;
6596 0 : {
6597 0 : tree res_op0;
6598 0 : {
6599 0 : tree _o1[1], _r1;
6600 0 : {
6601 0 : tree _o2[1], _r2;
6602 0 : _o2[0] = captures[1];
6603 0 : if (TREE_TYPE (_o2[0]) != utype)
6604 : {
6605 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
6606 : }
6607 : else
6608 : _r2 = _o2[0];
6609 0 : _o1[0] = _r2;
6610 : }
6611 0 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
6612 0 : res_op0 = _r1;
6613 : }
6614 0 : tree _r;
6615 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
6616 0 : if (TREE_SIDE_EFFECTS (captures[2]))
6617 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
6618 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 910, __FILE__, __LINE__, true);
6619 0 : return _r;
6620 : }
6621 0 : next_after_fail1197:;
6622 : }
6623 : }
6624 : else
6625 : {
6626 2162 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
6627 2162 : || (POINTER_TYPE_P (TREE_TYPE (captures[0]))
6628 0 : && TREE_CODE (captures[1]) == INTEGER_CST
6629 0 : && tree_int_cst_sign_bit (captures[1]) == 0)
6630 : )
6631 : {
6632 2162 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1198;
6633 2162 : {
6634 2162 : tree res_op0;
6635 2162 : {
6636 2162 : tree _o1[1], _r1;
6637 2162 : _o1[0] = captures[1];
6638 2162 : if (TREE_TYPE (_o1[0]) != type)
6639 : {
6640 2158 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
6641 : }
6642 : else
6643 : _r1 = _o1[0];
6644 2162 : res_op0 = _r1;
6645 : }
6646 2162 : tree _r;
6647 2162 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
6648 2162 : if (TREE_SIDE_EFFECTS (captures[2]))
6649 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
6650 2162 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 911, __FILE__, __LINE__, true);
6651 2162 : return _r;
6652 : }
6653 0 : next_after_fail1198:;
6654 : }
6655 : }
6656 : }
6657 : }
6658 : }
6659 : }
6660 : break;
6661 : }
6662 : default:;
6663 : }
6664 : break;
6665 : }
6666 5090047 : default:;
6667 : }
6668 5090047 : switch (TREE_CODE (_q20))
6669 : {
6670 388997 : case PLUS_EXPR:
6671 388997 : {
6672 388997 : tree _q30 = TREE_OPERAND (_q20, 0);
6673 388997 : tree _q31 = TREE_OPERAND (_q20, 1);
6674 388997 : switch (TREE_CODE (_p1))
6675 : {
6676 372561 : CASE_CONVERT:
6677 372561 : {
6678 372561 : tree _q60 = TREE_OPERAND (_p1, 0);
6679 372561 : switch (TREE_CODE (_q60))
6680 : {
6681 201783 : case PLUS_EXPR:
6682 201783 : {
6683 201783 : tree _q70 = TREE_OPERAND (_q60, 0);
6684 201783 : tree _q71 = TREE_OPERAND (_q60, 1);
6685 201783 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || operand_equal_p (_q70, _q30, 0))
6686 : {
6687 5415 : {
6688 5415 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q71, _q30 };
6689 5415 : tree res = generic_simplify_59 (loc, type, _p0, _p1, captures);
6690 5415 : if (res) return res;
6691 : }
6692 : }
6693 196368 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || operand_equal_p (_q71, _q30, 0))
6694 : {
6695 70 : {
6696 70 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q70, _q30 };
6697 70 : tree res = generic_simplify_59 (loc, type, _p0, _p1, captures);
6698 70 : if (res) return res;
6699 : }
6700 : }
6701 196298 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || operand_equal_p (_q70, _q31, 0))
6702 : {
6703 90 : {
6704 90 : tree captures[4] ATTRIBUTE_UNUSED = { _q31, _q30, _q71, _q31 };
6705 90 : tree res = generic_simplify_59 (loc, type, _p0, _p1, captures);
6706 90 : if (res) return res;
6707 : }
6708 : }
6709 196208 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || operand_equal_p (_q71, _q31, 0))
6710 : {
6711 146302 : {
6712 146302 : tree captures[4] ATTRIBUTE_UNUSED = { _q31, _q30, _q70, _q31 };
6713 146302 : tree res = generic_simplify_59 (loc, type, _p0, _p1, captures);
6714 146302 : if (res) return res;
6715 : }
6716 : }
6717 : break;
6718 : }
6719 : default:;
6720 : }
6721 : break;
6722 : }
6723 : default:;
6724 : }
6725 : break;
6726 : }
6727 88786 : case POINTER_PLUS_EXPR:
6728 88786 : {
6729 88786 : tree _q30 = TREE_OPERAND (_q20, 0);
6730 88786 : tree _q31 = TREE_OPERAND (_q20, 1);
6731 88786 : switch (TREE_CODE (_p1))
6732 : {
6733 87696 : CASE_CONVERT:
6734 87696 : {
6735 87696 : tree _q60 = TREE_OPERAND (_p1, 0);
6736 87696 : switch (TREE_CODE (_q60))
6737 : {
6738 51265 : case POINTER_PLUS_EXPR:
6739 51265 : {
6740 51265 : tree _q70 = TREE_OPERAND (_q60, 0);
6741 51265 : tree _q71 = TREE_OPERAND (_q60, 1);
6742 51265 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || operand_equal_p (_q70, _q30, 0))
6743 : {
6744 10267 : {
6745 10267 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q71, _q30 };
6746 10267 : if (!TYPE_SATURATING (type)
6747 : )
6748 : {
6749 10267 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
6750 20534 : && !FIXED_POINT_TYPE_P (type)
6751 : )
6752 : {
6753 10267 : if (INTEGRAL_TYPE_P (type)
6754 10267 : && TYPE_OVERFLOW_UNDEFINED (type)
6755 10267 : && element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
6756 : )
6757 : {
6758 0 : {
6759 0 : tree utype = unsigned_type_for (type);
6760 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1199;
6761 0 : {
6762 0 : tree res_op0;
6763 0 : {
6764 0 : tree _o1[2], _r1;
6765 0 : {
6766 0 : tree _o2[1], _r2;
6767 0 : _o2[0] = captures[1];
6768 0 : if (TREE_TYPE (_o2[0]) != utype)
6769 : {
6770 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
6771 : }
6772 : else
6773 : _r2 = _o2[0];
6774 0 : _o1[0] = _r2;
6775 : }
6776 0 : {
6777 0 : tree _o2[1], _r2;
6778 0 : _o2[0] = captures[2];
6779 0 : if (TREE_TYPE (_o2[0]) != utype)
6780 : {
6781 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
6782 : }
6783 : else
6784 : _r2 = _o2[0];
6785 0 : _o1[1] = _r2;
6786 : }
6787 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
6788 0 : res_op0 = _r1;
6789 : }
6790 0 : tree _r;
6791 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
6792 0 : if (TREE_SIDE_EFFECTS (captures[3]))
6793 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
6794 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 912, __FILE__, __LINE__, true);
6795 0 : return _r;
6796 : }
6797 0 : next_after_fail1199:;
6798 : }
6799 : }
6800 : else
6801 : {
6802 10267 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
6803 10267 : || (POINTER_TYPE_P (TREE_TYPE (captures[0]))
6804 0 : && TREE_CODE (captures[1]) == INTEGER_CST
6805 0 : && tree_int_cst_sign_bit (captures[1]) == 0
6806 0 : && TREE_CODE (captures[2]) == INTEGER_CST
6807 0 : && tree_int_cst_sign_bit (captures[2]) == 0)
6808 : )
6809 : {
6810 10267 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1200;
6811 10267 : {
6812 10267 : tree res_op0;
6813 10267 : {
6814 10267 : tree _o1[1], _r1;
6815 10267 : _o1[0] = captures[1];
6816 10267 : if (TREE_TYPE (_o1[0]) != type)
6817 : {
6818 10093 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
6819 : }
6820 : else
6821 : _r1 = _o1[0];
6822 10267 : res_op0 = _r1;
6823 : }
6824 10267 : tree res_op1;
6825 10267 : {
6826 10267 : tree _o1[1], _r1;
6827 10267 : _o1[0] = captures[2];
6828 10267 : if (TREE_TYPE (_o1[0]) != type)
6829 : {
6830 10110 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
6831 : }
6832 : else
6833 : _r1 = _o1[0];
6834 10267 : res_op1 = _r1;
6835 : }
6836 10267 : tree _r;
6837 10267 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
6838 10267 : if (TREE_SIDE_EFFECTS (captures[3]))
6839 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
6840 10267 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 913, __FILE__, __LINE__, true);
6841 10267 : return _r;
6842 : }
6843 0 : next_after_fail1200:;
6844 : }
6845 : }
6846 : }
6847 : }
6848 : }
6849 : }
6850 : break;
6851 : }
6852 : default:;
6853 : }
6854 : break;
6855 : }
6856 : default:;
6857 : }
6858 : break;
6859 : }
6860 : default:;
6861 : }
6862 : break;
6863 : }
6864 1460986 : case MULT_EXPR:
6865 1460986 : {
6866 1460986 : tree _q20 = TREE_OPERAND (_p0, 0);
6867 1460986 : tree _q21 = TREE_OPERAND (_p0, 1);
6868 1460986 : switch (TREE_CODE (_p1))
6869 : {
6870 691749 : case MULT_EXPR:
6871 691749 : {
6872 691749 : tree _q50 = TREE_OPERAND (_p1, 0);
6873 691749 : tree _q51 = TREE_OPERAND (_p1, 1);
6874 691749 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6875 : {
6876 3952 : {
6877 3952 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
6878 3952 : tree res = generic_simplify_25 (loc, type, _p0, _p1, captures, MINUS_EXPR);
6879 3952 : if (res) return res;
6880 : }
6881 : }
6882 690542 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6883 : {
6884 14001 : {
6885 14001 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
6886 14001 : tree res = generic_simplify_25 (loc, type, _p0, _p1, captures, MINUS_EXPR);
6887 14001 : if (res) return res;
6888 : }
6889 : }
6890 676541 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6891 : {
6892 34282 : {
6893 34282 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q51 };
6894 34282 : tree res = generic_simplify_25 (loc, type, _p0, _p1, captures, MINUS_EXPR);
6895 34282 : if (res) return res;
6896 : }
6897 : }
6898 642357 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6899 : {
6900 208499 : {
6901 208499 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q50 };
6902 208499 : tree res = generic_simplify_25 (loc, type, _p0, _p1, captures, MINUS_EXPR);
6903 208499 : if (res) return res;
6904 : }
6905 : }
6906 : break;
6907 : }
6908 : default:;
6909 : }
6910 : break;
6911 : }
6912 21573590 : default:;
6913 : }
6914 21573590 : switch (TREE_CODE (_p1))
6915 : {
6916 1739892 : case MULT_EXPR:
6917 1739892 : {
6918 1739892 : tree _q30 = TREE_OPERAND (_p1, 0);
6919 1739892 : tree _q31 = TREE_OPERAND (_p1, 1);
6920 1739892 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
6921 : {
6922 3911 : {
6923 3911 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
6924 3911 : tree res = generic_simplify_26 (loc, type, _p0, _p1, captures, MINUS_EXPR);
6925 3911 : if (res) return res;
6926 : }
6927 : }
6928 1736055 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6929 : {
6930 1313 : {
6931 1313 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q30 };
6932 1313 : tree res = generic_simplify_26 (loc, type, _p0, _p1, captures, MINUS_EXPR);
6933 1313 : if (res) return res;
6934 : }
6935 : }
6936 : break;
6937 : }
6938 21568539 : default:;
6939 : }
6940 21568539 : switch (TREE_CODE (_p0))
6941 : {
6942 1208470 : case MULT_EXPR:
6943 1208470 : {
6944 1208470 : tree _q20 = TREE_OPERAND (_p0, 0);
6945 1208470 : tree _q21 = TREE_OPERAND (_p0, 1);
6946 1208470 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
6947 : {
6948 60110 : {
6949 60110 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
6950 60110 : tree res = generic_simplify_27 (loc, type, _p0, _p1, captures, MINUS_EXPR);
6951 60110 : if (res) return res;
6952 : }
6953 : }
6954 1148446 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
6955 : {
6956 644 : {
6957 644 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
6958 644 : tree res = generic_simplify_27 (loc, type, _p0, _p1, captures, MINUS_EXPR);
6959 644 : if (res) return res;
6960 : }
6961 : }
6962 : break;
6963 : }
6964 21508416 : default:;
6965 : }
6966 21508416 : switch (TREE_CODE (_p1))
6967 : {
6968 1734841 : case MULT_EXPR:
6969 1734841 : {
6970 1734841 : tree _q30 = TREE_OPERAND (_p1, 0);
6971 1734841 : tree _q31 = TREE_OPERAND (_p1, 1);
6972 1734841 : switch (TREE_CODE (_q30))
6973 : {
6974 75467 : case MINUS_EXPR:
6975 75467 : {
6976 75467 : tree _q40 = TREE_OPERAND (_q30, 0);
6977 75467 : tree _q41 = TREE_OPERAND (_q30, 1);
6978 75467 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
6979 : {
6980 19 : if (tree_zero_one_valued_p (_q31))
6981 : {
6982 0 : {
6983 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q31 };
6984 0 : tree res = generic_simplify_60 (loc, type, _p0, _p1, captures);
6985 0 : if (res) return res;
6986 : }
6987 : }
6988 : }
6989 : break;
6990 : }
6991 1734841 : default:;
6992 : }
6993 1734841 : if (tree_zero_one_valued_p (_q30))
6994 : {
6995 1156 : switch (TREE_CODE (_q31))
6996 : {
6997 9 : case MINUS_EXPR:
6998 9 : {
6999 9 : tree _q50 = TREE_OPERAND (_q31, 0);
7000 9 : tree _q51 = TREE_OPERAND (_q31, 1);
7001 9 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
7002 : {
7003 9 : {
7004 9 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q51, _q30 };
7005 9 : tree res = generic_simplify_60 (loc, type, _p0, _p1, captures);
7006 9 : if (res) return res;
7007 : }
7008 : }
7009 : break;
7010 : }
7011 : default:;
7012 : }
7013 : }
7014 : break;
7015 : }
7016 21508414 : default:;
7017 : }
7018 21508414 : switch (TREE_CODE (_p0))
7019 : {
7020 0 : case VEC_COND_EXPR:
7021 0 : {
7022 0 : tree _q20 = TREE_OPERAND (_p0, 0);
7023 0 : tree _q21 = TREE_OPERAND (_p0, 1);
7024 0 : tree _q22 = TREE_OPERAND (_p0, 2);
7025 0 : switch (TREE_CODE (_p1))
7026 : {
7027 0 : case VEC_COND_EXPR:
7028 0 : {
7029 0 : tree _q60 = TREE_OPERAND (_p1, 0);
7030 0 : tree _q61 = TREE_OPERAND (_p1, 1);
7031 0 : tree _q62 = TREE_OPERAND (_p1, 2);
7032 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7033 : {
7034 0 : {
7035 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
7036 0 : if (VECTOR_TYPE_P (type)
7037 0 : && (TREE_CODE_CLASS (MINUS_EXPR) != tcc_comparison
7038 : || types_match (type, TREE_TYPE (captures[2]))
7039 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
7040 : || (optimize_vectors_before_lowering_p ()
7041 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
7042 : )
7043 : {
7044 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1201;
7045 0 : {
7046 0 : tree res_op0;
7047 0 : res_op0 = captures[1];
7048 0 : tree res_op1;
7049 0 : {
7050 0 : tree _o1[2], _r1;
7051 0 : _o1[0] = captures[2];
7052 0 : _o1[1] = captures[5];
7053 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, type, _o1[0], _o1[1]);
7054 0 : if (EXPR_P (_r1))
7055 0 : goto next_after_fail1201;
7056 0 : res_op1 = _r1;
7057 : }
7058 0 : tree res_op2;
7059 0 : {
7060 0 : tree _o1[2], _r1;
7061 0 : _o1[0] = captures[3];
7062 0 : _o1[1] = captures[6];
7063 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, type, _o1[0], _o1[1]);
7064 0 : if (EXPR_P (_r1))
7065 0 : goto next_after_fail1201;
7066 0 : res_op2 = _r1;
7067 : }
7068 0 : tree _r;
7069 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7070 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
7071 0 : return _r;
7072 : }
7073 0 : next_after_fail1201:;
7074 : }
7075 : }
7076 : }
7077 : break;
7078 : }
7079 0 : default:;
7080 : }
7081 0 : {
7082 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
7083 0 : if (VECTOR_TYPE_P (type)
7084 0 : && (TREE_CODE_CLASS (MINUS_EXPR) != tcc_comparison
7085 : || types_match (type, TREE_TYPE (captures[2]))
7086 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
7087 : || (optimize_vectors_before_lowering_p ()
7088 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
7089 : )
7090 : {
7091 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1202;
7092 0 : {
7093 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1202;
7094 0 : tree res_op0;
7095 0 : res_op0 = captures[1];
7096 0 : tree res_op1;
7097 0 : {
7098 0 : tree _o1[2], _r1;
7099 0 : _o1[0] = captures[2];
7100 0 : _o1[1] = unshare_expr (captures[4]);
7101 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, type, _o1[0], _o1[1]);
7102 0 : if (EXPR_P (_r1))
7103 0 : goto next_after_fail1202;
7104 0 : res_op1 = _r1;
7105 : }
7106 0 : tree res_op2;
7107 0 : {
7108 0 : tree _o1[2], _r1;
7109 0 : _o1[0] = captures[3];
7110 0 : _o1[1] = captures[4];
7111 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, type, _o1[0], _o1[1]);
7112 0 : if (EXPR_P (_r1))
7113 0 : goto next_after_fail1202;
7114 0 : res_op2 = _r1;
7115 : }
7116 0 : tree _r;
7117 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7118 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
7119 0 : return _r;
7120 : }
7121 0 : next_after_fail1202:;
7122 : }
7123 : }
7124 0 : break;
7125 : }
7126 21508414 : default:;
7127 : }
7128 21508414 : if (integer_zerop (_p0))
7129 : {
7130 294881 : {
7131 294881 : tree captures[1] ATTRIBUTE_UNUSED = { _p1 };
7132 294881 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1203;
7133 294881 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1203;
7134 294881 : {
7135 294881 : tree res_op0;
7136 294881 : res_op0 = captures[0];
7137 294881 : tree _r;
7138 294881 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
7139 294881 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 914, __FILE__, __LINE__, true);
7140 294881 : return _r;
7141 : }
7142 : next_after_fail1203:;
7143 : }
7144 : }
7145 21213533 : if (real_zerop (_p0))
7146 : {
7147 136 : {
7148 136 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
7149 136 : if (fold_real_zero_addition_p (type, captures[1], captures[0], 0)
7150 : )
7151 : {
7152 55 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1204;
7153 55 : {
7154 55 : tree res_op0;
7155 55 : res_op0 = captures[1];
7156 55 : tree _r;
7157 55 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
7158 55 : if (TREE_SIDE_EFFECTS (captures[0]))
7159 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
7160 55 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 915, __FILE__, __LINE__, true);
7161 55 : return _r;
7162 : }
7163 0 : next_after_fail1204:;
7164 : }
7165 : }
7166 : }
7167 21213478 : switch (TREE_CODE (_p1))
7168 : {
7169 4 : case VEC_COND_EXPR:
7170 4 : {
7171 4 : tree _q30 = TREE_OPERAND (_p1, 0);
7172 4 : tree _q31 = TREE_OPERAND (_p1, 1);
7173 4 : tree _q32 = TREE_OPERAND (_p1, 2);
7174 4 : {
7175 4 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
7176 4 : if (VECTOR_TYPE_P (type)
7177 4 : && (TREE_CODE_CLASS (MINUS_EXPR) != tcc_comparison
7178 : || types_match (type, TREE_TYPE (captures[3]))
7179 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
7180 : || (optimize_vectors_before_lowering_p ()
7181 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
7182 : )
7183 : {
7184 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1205;
7185 4 : {
7186 4 : if (! tree_invariant_p (captures[0])) goto next_after_fail1205;
7187 0 : tree res_op0;
7188 0 : res_op0 = captures[2];
7189 0 : tree res_op1;
7190 0 : {
7191 0 : tree _o1[2], _r1;
7192 0 : _o1[0] = unshare_expr (captures[0]);
7193 0 : _o1[1] = captures[3];
7194 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, type, _o1[0], _o1[1]);
7195 0 : if (EXPR_P (_r1))
7196 0 : goto next_after_fail1205;
7197 0 : res_op1 = _r1;
7198 : }
7199 0 : tree res_op2;
7200 0 : {
7201 0 : tree _o1[2], _r1;
7202 0 : _o1[0] = captures[0];
7203 0 : _o1[1] = captures[4];
7204 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, type, _o1[0], _o1[1]);
7205 0 : if (EXPR_P (_r1))
7206 0 : goto next_after_fail1205;
7207 0 : res_op2 = _r1;
7208 : }
7209 0 : tree _r;
7210 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7211 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
7212 0 : return _r;
7213 : }
7214 4 : next_after_fail1205:;
7215 : }
7216 : }
7217 4 : if (integer_each_onep (_q31))
7218 : {
7219 0 : if (integer_zerop (_q32))
7220 : {
7221 0 : {
7222 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
7223 0 : tree res = generic_simplify_61 (loc, type, _p0, _p1, captures);
7224 0 : if (res) return res;
7225 : }
7226 : }
7227 : }
7228 : break;
7229 : }
7230 111666 : case VIEW_CONVERT_EXPR:
7231 111666 : {
7232 111666 : tree _q30 = TREE_OPERAND (_p1, 0);
7233 111666 : switch (TREE_CODE (_q30))
7234 : {
7235 0 : case VEC_COND_EXPR:
7236 0 : {
7237 0 : tree _q40 = TREE_OPERAND (_q30, 0);
7238 0 : tree _q41 = TREE_OPERAND (_q30, 1);
7239 0 : tree _q42 = TREE_OPERAND (_q30, 2);
7240 0 : if (integer_each_onep (_q41))
7241 : {
7242 0 : if (integer_zerop (_q42))
7243 : {
7244 0 : {
7245 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q30, _q40, _q41, _q42 };
7246 0 : tree res = generic_simplify_61 (loc, type, _p0, _p1, captures);
7247 0 : if (res) return res;
7248 : }
7249 : }
7250 : }
7251 : break;
7252 : }
7253 : default:;
7254 : }
7255 : break;
7256 : }
7257 21213478 : default:;
7258 : }
7259 21213478 : switch (TREE_CODE (_p0))
7260 : {
7261 111973 : case RDIV_EXPR:
7262 111973 : {
7263 111973 : tree _q20 = TREE_OPERAND (_p0, 0);
7264 111973 : tree _q21 = TREE_OPERAND (_p0, 1);
7265 111973 : switch (TREE_CODE (_p1))
7266 : {
7267 18739 : case RDIV_EXPR:
7268 18739 : {
7269 18739 : tree _q50 = TREE_OPERAND (_p1, 0);
7270 18739 : tree _q51 = TREE_OPERAND (_p1, 1);
7271 18739 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7272 : {
7273 18719 : {
7274 18719 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
7275 18719 : tree res = generic_simplify_33 (loc, type, _p0, _p1, captures, MINUS_EXPR);
7276 18719 : if (res) return res;
7277 : }
7278 : }
7279 : break;
7280 : }
7281 : default:;
7282 : }
7283 : break;
7284 : }
7285 1351228 : case PLUS_EXPR:
7286 1351228 : {
7287 1351228 : tree _q20 = TREE_OPERAND (_p0, 0);
7288 1351228 : tree _q21 = TREE_OPERAND (_p0, 1);
7289 1351228 : switch (TREE_CODE (_q20))
7290 : {
7291 57069 : case CALL_EXPR:
7292 57069 : switch (get_call_combined_fn (_q20))
7293 : {
7294 4 : case CFN_BUILT_IN_POPCOUNT:
7295 4 : if (call_expr_nargs (_q20) == 1)
7296 : {
7297 4 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
7298 4 : switch (TREE_CODE (_q21))
7299 : {
7300 4 : case CALL_EXPR:
7301 4 : switch (get_call_combined_fn (_q21))
7302 : {
7303 4 : case CFN_BUILT_IN_POPCOUNT:
7304 4 : if (call_expr_nargs (_q21) == 1)
7305 : {
7306 4 : tree _q50 = CALL_EXPR_ARG (_q21, 0);
7307 4 : switch (TREE_CODE (_p1))
7308 : {
7309 4 : case CALL_EXPR:
7310 4 : switch (get_call_combined_fn (_p1))
7311 : {
7312 4 : case CFN_BUILT_IN_POPCOUNT:
7313 4 : if (call_expr_nargs (_p1) == 1)
7314 : {
7315 4 : tree _q70 = CALL_EXPR_ARG (_p1, 0);
7316 4 : switch (TREE_CODE (_q70))
7317 : {
7318 2 : case BIT_AND_EXPR:
7319 2 : {
7320 2 : tree _q80 = TREE_OPERAND (_q70, 0);
7321 2 : tree _q81 = TREE_OPERAND (_q70, 1);
7322 2 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7323 : {
7324 1 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7325 : {
7326 1 : {
7327 1 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7328 1 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNT);
7329 1 : if (res) return res;
7330 : }
7331 : }
7332 : }
7333 1 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
7334 : {
7335 1 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
7336 : {
7337 1 : {
7338 1 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7339 1 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNT);
7340 1 : if (res) return res;
7341 : }
7342 : }
7343 : }
7344 : break;
7345 : }
7346 2 : case BIT_IOR_EXPR:
7347 2 : {
7348 2 : tree _q80 = TREE_OPERAND (_q70, 0);
7349 2 : tree _q81 = TREE_OPERAND (_q70, 1);
7350 2 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7351 : {
7352 1 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7353 : {
7354 1 : {
7355 1 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7356 1 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNT);
7357 1 : if (res) return res;
7358 : }
7359 : }
7360 : }
7361 1 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
7362 : {
7363 1 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
7364 : {
7365 1 : {
7366 1 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7367 1 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNT);
7368 1 : if (res) return res;
7369 : }
7370 : }
7371 : }
7372 : break;
7373 : }
7374 : default:;
7375 : }
7376 : }
7377 : break;
7378 : default:;
7379 : }
7380 : break;
7381 : default:;
7382 : }
7383 : }
7384 : break;
7385 : default:;
7386 : }
7387 : break;
7388 : default:;
7389 : }
7390 : }
7391 : break;
7392 0 : case CFN_BUILT_IN_POPCOUNTLL:
7393 0 : if (call_expr_nargs (_q20) == 1)
7394 : {
7395 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
7396 0 : switch (TREE_CODE (_q21))
7397 : {
7398 0 : case CALL_EXPR:
7399 0 : switch (get_call_combined_fn (_q21))
7400 : {
7401 0 : case CFN_BUILT_IN_POPCOUNTLL:
7402 0 : if (call_expr_nargs (_q21) == 1)
7403 : {
7404 0 : tree _q50 = CALL_EXPR_ARG (_q21, 0);
7405 0 : switch (TREE_CODE (_p1))
7406 : {
7407 0 : case CALL_EXPR:
7408 0 : switch (get_call_combined_fn (_p1))
7409 : {
7410 0 : case CFN_BUILT_IN_POPCOUNTLL:
7411 0 : if (call_expr_nargs (_p1) == 1)
7412 : {
7413 0 : tree _q70 = CALL_EXPR_ARG (_p1, 0);
7414 0 : switch (TREE_CODE (_q70))
7415 : {
7416 0 : case BIT_AND_EXPR:
7417 0 : {
7418 0 : tree _q80 = TREE_OPERAND (_q70, 0);
7419 0 : tree _q81 = TREE_OPERAND (_q70, 1);
7420 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7421 : {
7422 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7423 : {
7424 0 : {
7425 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7426 0 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTLL);
7427 0 : if (res) return res;
7428 : }
7429 : }
7430 : }
7431 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
7432 : {
7433 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
7434 : {
7435 0 : {
7436 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7437 0 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTLL);
7438 0 : if (res) return res;
7439 : }
7440 : }
7441 : }
7442 : break;
7443 : }
7444 0 : case BIT_IOR_EXPR:
7445 0 : {
7446 0 : tree _q80 = TREE_OPERAND (_q70, 0);
7447 0 : tree _q81 = TREE_OPERAND (_q70, 1);
7448 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7449 : {
7450 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7451 : {
7452 0 : {
7453 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7454 0 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTLL);
7455 0 : if (res) return res;
7456 : }
7457 : }
7458 : }
7459 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
7460 : {
7461 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
7462 : {
7463 0 : {
7464 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7465 0 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTLL);
7466 0 : if (res) return res;
7467 : }
7468 : }
7469 : }
7470 : break;
7471 : }
7472 : default:;
7473 : }
7474 : }
7475 : break;
7476 : default:;
7477 : }
7478 : break;
7479 : default:;
7480 : }
7481 : }
7482 : break;
7483 : default:;
7484 : }
7485 : break;
7486 : default:;
7487 : }
7488 : }
7489 : break;
7490 0 : case CFN_POPCOUNT:
7491 0 : if (call_expr_nargs (_q20) == 1)
7492 : {
7493 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
7494 0 : switch (TREE_CODE (_q21))
7495 : {
7496 0 : case CALL_EXPR:
7497 0 : switch (get_call_combined_fn (_q21))
7498 : {
7499 0 : case CFN_POPCOUNT:
7500 0 : if (call_expr_nargs (_q21) == 1)
7501 : {
7502 0 : tree _q50 = CALL_EXPR_ARG (_q21, 0);
7503 0 : switch (TREE_CODE (_p1))
7504 : {
7505 0 : case CALL_EXPR:
7506 0 : switch (get_call_combined_fn (_p1))
7507 : {
7508 0 : case CFN_POPCOUNT:
7509 0 : if (call_expr_nargs (_p1) == 1)
7510 : {
7511 0 : tree _q70 = CALL_EXPR_ARG (_p1, 0);
7512 0 : switch (TREE_CODE (_q70))
7513 : {
7514 0 : case BIT_AND_EXPR:
7515 0 : {
7516 0 : tree _q80 = TREE_OPERAND (_q70, 0);
7517 0 : tree _q81 = TREE_OPERAND (_q70, 1);
7518 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7519 : {
7520 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7521 : {
7522 0 : {
7523 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7524 0 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_POPCOUNT);
7525 0 : if (res) return res;
7526 : }
7527 : }
7528 : }
7529 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
7530 : {
7531 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
7532 : {
7533 0 : {
7534 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7535 0 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_POPCOUNT);
7536 0 : if (res) return res;
7537 : }
7538 : }
7539 : }
7540 : break;
7541 : }
7542 0 : case BIT_IOR_EXPR:
7543 0 : {
7544 0 : tree _q80 = TREE_OPERAND (_q70, 0);
7545 0 : tree _q81 = TREE_OPERAND (_q70, 1);
7546 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7547 : {
7548 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7549 : {
7550 0 : {
7551 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7552 0 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_POPCOUNT);
7553 0 : if (res) return res;
7554 : }
7555 : }
7556 : }
7557 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
7558 : {
7559 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
7560 : {
7561 0 : {
7562 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7563 0 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_POPCOUNT);
7564 0 : if (res) return res;
7565 : }
7566 : }
7567 : }
7568 : break;
7569 : }
7570 : default:;
7571 : }
7572 : }
7573 : break;
7574 : default:;
7575 : }
7576 : break;
7577 : default:;
7578 : }
7579 : }
7580 : break;
7581 : default:;
7582 : }
7583 : break;
7584 : default:;
7585 : }
7586 : }
7587 : break;
7588 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
7589 0 : if (call_expr_nargs (_q20) == 1)
7590 : {
7591 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
7592 0 : switch (TREE_CODE (_q21))
7593 : {
7594 0 : case CALL_EXPR:
7595 0 : switch (get_call_combined_fn (_q21))
7596 : {
7597 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
7598 0 : if (call_expr_nargs (_q21) == 1)
7599 : {
7600 0 : tree _q50 = CALL_EXPR_ARG (_q21, 0);
7601 0 : switch (TREE_CODE (_p1))
7602 : {
7603 0 : case CALL_EXPR:
7604 0 : switch (get_call_combined_fn (_p1))
7605 : {
7606 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
7607 0 : if (call_expr_nargs (_p1) == 1)
7608 : {
7609 0 : tree _q70 = CALL_EXPR_ARG (_p1, 0);
7610 0 : switch (TREE_CODE (_q70))
7611 : {
7612 0 : case BIT_AND_EXPR:
7613 0 : {
7614 0 : tree _q80 = TREE_OPERAND (_q70, 0);
7615 0 : tree _q81 = TREE_OPERAND (_q70, 1);
7616 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7617 : {
7618 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7619 : {
7620 0 : {
7621 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7622 0 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
7623 0 : if (res) return res;
7624 : }
7625 : }
7626 : }
7627 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
7628 : {
7629 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
7630 : {
7631 0 : {
7632 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7633 0 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
7634 0 : if (res) return res;
7635 : }
7636 : }
7637 : }
7638 : break;
7639 : }
7640 0 : case BIT_IOR_EXPR:
7641 0 : {
7642 0 : tree _q80 = TREE_OPERAND (_q70, 0);
7643 0 : tree _q81 = TREE_OPERAND (_q70, 1);
7644 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7645 : {
7646 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7647 : {
7648 0 : {
7649 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7650 0 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
7651 0 : if (res) return res;
7652 : }
7653 : }
7654 : }
7655 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
7656 : {
7657 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
7658 : {
7659 0 : {
7660 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7661 0 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
7662 0 : if (res) return res;
7663 : }
7664 : }
7665 : }
7666 : break;
7667 : }
7668 : default:;
7669 : }
7670 : }
7671 : break;
7672 : default:;
7673 : }
7674 : break;
7675 : default:;
7676 : }
7677 : }
7678 : break;
7679 : default:;
7680 : }
7681 : break;
7682 : default:;
7683 : }
7684 : }
7685 : break;
7686 0 : case CFN_BUILT_IN_POPCOUNTL:
7687 0 : if (call_expr_nargs (_q20) == 1)
7688 : {
7689 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
7690 0 : switch (TREE_CODE (_q21))
7691 : {
7692 0 : case CALL_EXPR:
7693 0 : switch (get_call_combined_fn (_q21))
7694 : {
7695 0 : case CFN_BUILT_IN_POPCOUNTL:
7696 0 : if (call_expr_nargs (_q21) == 1)
7697 : {
7698 0 : tree _q50 = CALL_EXPR_ARG (_q21, 0);
7699 0 : switch (TREE_CODE (_p1))
7700 : {
7701 0 : case CALL_EXPR:
7702 0 : switch (get_call_combined_fn (_p1))
7703 : {
7704 0 : case CFN_BUILT_IN_POPCOUNTL:
7705 0 : if (call_expr_nargs (_p1) == 1)
7706 : {
7707 0 : tree _q70 = CALL_EXPR_ARG (_p1, 0);
7708 0 : switch (TREE_CODE (_q70))
7709 : {
7710 0 : case BIT_AND_EXPR:
7711 0 : {
7712 0 : tree _q80 = TREE_OPERAND (_q70, 0);
7713 0 : tree _q81 = TREE_OPERAND (_q70, 1);
7714 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7715 : {
7716 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7717 : {
7718 0 : {
7719 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7720 0 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTL);
7721 0 : if (res) return res;
7722 : }
7723 : }
7724 : }
7725 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
7726 : {
7727 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
7728 : {
7729 0 : {
7730 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7731 0 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTL);
7732 0 : if (res) return res;
7733 : }
7734 : }
7735 : }
7736 : break;
7737 : }
7738 0 : case BIT_IOR_EXPR:
7739 0 : {
7740 0 : tree _q80 = TREE_OPERAND (_q70, 0);
7741 0 : tree _q81 = TREE_OPERAND (_q70, 1);
7742 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7743 : {
7744 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7745 : {
7746 0 : {
7747 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7748 0 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTL);
7749 0 : if (res) return res;
7750 : }
7751 : }
7752 : }
7753 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
7754 : {
7755 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
7756 : {
7757 0 : {
7758 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7759 0 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTL);
7760 0 : if (res) return res;
7761 : }
7762 : }
7763 : }
7764 : break;
7765 : }
7766 : default:;
7767 : }
7768 : }
7769 : break;
7770 : default:;
7771 : }
7772 : break;
7773 : default:;
7774 : }
7775 : }
7776 : break;
7777 : default:;
7778 : }
7779 : break;
7780 : default:;
7781 : }
7782 : }
7783 : break;
7784 : default:;
7785 : }
7786 : break;
7787 : default:;
7788 : }
7789 : break;
7790 : }
7791 0 : case VEC_PERM_EXPR:
7792 0 : {
7793 0 : tree _q20 = TREE_OPERAND (_p0, 0);
7794 0 : tree _q21 = TREE_OPERAND (_p0, 1);
7795 0 : tree _q22 = TREE_OPERAND (_p0, 2);
7796 0 : switch (TREE_CODE (_q20))
7797 : {
7798 0 : case MULT_EXPR:
7799 0 : {
7800 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7801 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7802 0 : if (tree_vec_same_elem_p (_q31))
7803 : {
7804 0 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
7805 : {
7806 0 : {
7807 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q22, _p1 };
7808 0 : tree res = generic_simplify_64 (loc, type, _p0, _p1, captures);
7809 0 : if (res) return res;
7810 : }
7811 : }
7812 : }
7813 0 : if (tree_vec_same_elem_p (_q30))
7814 : {
7815 0 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
7816 : {
7817 0 : {
7818 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q30, _q22, _p1 };
7819 0 : tree res = generic_simplify_64 (loc, type, _p0, _p1, captures);
7820 0 : if (res) return res;
7821 : }
7822 : }
7823 : }
7824 : break;
7825 : }
7826 : default:;
7827 : }
7828 : break;
7829 : }
7830 817484 : case CALL_EXPR:
7831 817484 : switch (get_call_combined_fn (_p0))
7832 : {
7833 18 : case CFN_BUILT_IN_LOG:
7834 18 : if (call_expr_nargs (_p0) == 1)
7835 : {
7836 18 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7837 18 : switch (TREE_CODE (_p1))
7838 : {
7839 0 : case CALL_EXPR:
7840 0 : switch (get_call_combined_fn (_p1))
7841 : {
7842 0 : case CFN_BUILT_IN_LOG:
7843 0 : if (call_expr_nargs (_p1) == 1)
7844 : {
7845 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7846 0 : {
7847 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
7848 0 : tree res = generic_simplify_62 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG);
7849 0 : if (res) return res;
7850 : }
7851 : }
7852 : break;
7853 : default:;
7854 : }
7855 : break;
7856 : default:;
7857 : }
7858 : }
7859 : break;
7860 2 : case CFN_BUILT_IN_LOG2:
7861 2 : if (call_expr_nargs (_p0) == 1)
7862 : {
7863 2 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7864 2 : switch (TREE_CODE (_p1))
7865 : {
7866 0 : case CALL_EXPR:
7867 0 : switch (get_call_combined_fn (_p1))
7868 : {
7869 0 : case CFN_BUILT_IN_LOG2:
7870 0 : if (call_expr_nargs (_p1) == 1)
7871 : {
7872 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7873 0 : {
7874 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
7875 0 : tree res = generic_simplify_62 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2);
7876 0 : if (res) return res;
7877 : }
7878 : }
7879 : break;
7880 : default:;
7881 : }
7882 : break;
7883 : default:;
7884 : }
7885 : }
7886 : break;
7887 0 : case CFN_BUILT_IN_LOGF:
7888 0 : if (call_expr_nargs (_p0) == 1)
7889 : {
7890 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7891 0 : switch (TREE_CODE (_p1))
7892 : {
7893 0 : case CALL_EXPR:
7894 0 : switch (get_call_combined_fn (_p1))
7895 : {
7896 0 : case CFN_BUILT_IN_LOGF:
7897 0 : if (call_expr_nargs (_p1) == 1)
7898 : {
7899 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7900 0 : {
7901 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
7902 0 : tree res = generic_simplify_62 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF);
7903 0 : if (res) return res;
7904 : }
7905 : }
7906 : break;
7907 : default:;
7908 : }
7909 : break;
7910 : default:;
7911 : }
7912 : }
7913 : break;
7914 0 : case CFN_BUILT_IN_LOGL:
7915 0 : if (call_expr_nargs (_p0) == 1)
7916 : {
7917 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7918 0 : switch (TREE_CODE (_p1))
7919 : {
7920 0 : case CALL_EXPR:
7921 0 : switch (get_call_combined_fn (_p1))
7922 : {
7923 0 : case CFN_BUILT_IN_LOGL:
7924 0 : if (call_expr_nargs (_p1) == 1)
7925 : {
7926 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7927 0 : {
7928 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
7929 0 : tree res = generic_simplify_62 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL);
7930 0 : if (res) return res;
7931 : }
7932 : }
7933 : break;
7934 : default:;
7935 : }
7936 : break;
7937 : default:;
7938 : }
7939 : }
7940 : break;
7941 0 : case CFN_BUILT_IN_LOG10F:
7942 0 : if (call_expr_nargs (_p0) == 1)
7943 : {
7944 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7945 0 : switch (TREE_CODE (_p1))
7946 : {
7947 0 : case CALL_EXPR:
7948 0 : switch (get_call_combined_fn (_p1))
7949 : {
7950 0 : case CFN_BUILT_IN_LOG10F:
7951 0 : if (call_expr_nargs (_p1) == 1)
7952 : {
7953 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7954 0 : {
7955 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
7956 0 : tree res = generic_simplify_62 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F);
7957 0 : if (res) return res;
7958 : }
7959 : }
7960 : break;
7961 : default:;
7962 : }
7963 : break;
7964 : default:;
7965 : }
7966 : }
7967 : break;
7968 0 : case CFN_BUILT_IN_LOG10L:
7969 0 : if (call_expr_nargs (_p0) == 1)
7970 : {
7971 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7972 0 : switch (TREE_CODE (_p1))
7973 : {
7974 0 : case CALL_EXPR:
7975 0 : switch (get_call_combined_fn (_p1))
7976 : {
7977 0 : case CFN_BUILT_IN_LOG10L:
7978 0 : if (call_expr_nargs (_p1) == 1)
7979 : {
7980 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7981 0 : {
7982 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
7983 0 : tree res = generic_simplify_62 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L);
7984 0 : if (res) return res;
7985 : }
7986 : }
7987 : break;
7988 : default:;
7989 : }
7990 : break;
7991 : default:;
7992 : }
7993 : }
7994 : break;
7995 0 : case CFN_LOG:
7996 0 : if (call_expr_nargs (_p0) == 1)
7997 : {
7998 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7999 0 : switch (TREE_CODE (_p1))
8000 : {
8001 0 : case CALL_EXPR:
8002 0 : switch (get_call_combined_fn (_p1))
8003 : {
8004 0 : case CFN_LOG:
8005 0 : if (call_expr_nargs (_p1) == 1)
8006 : {
8007 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8008 0 : {
8009 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8010 0 : tree res = generic_simplify_62 (loc, type, _p0, _p1, captures, CFN_LOG);
8011 0 : if (res) return res;
8012 : }
8013 : }
8014 : break;
8015 : default:;
8016 : }
8017 : break;
8018 : default:;
8019 : }
8020 : }
8021 : break;
8022 0 : case CFN_LOG2:
8023 0 : if (call_expr_nargs (_p0) == 1)
8024 : {
8025 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8026 0 : switch (TREE_CODE (_p1))
8027 : {
8028 0 : case CALL_EXPR:
8029 0 : switch (get_call_combined_fn (_p1))
8030 : {
8031 0 : case CFN_LOG2:
8032 0 : if (call_expr_nargs (_p1) == 1)
8033 : {
8034 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8035 0 : {
8036 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8037 0 : tree res = generic_simplify_62 (loc, type, _p0, _p1, captures, CFN_LOG2);
8038 0 : if (res) return res;
8039 : }
8040 : }
8041 : break;
8042 : default:;
8043 : }
8044 : break;
8045 : default:;
8046 : }
8047 : }
8048 : break;
8049 0 : case CFN_LOG10:
8050 0 : if (call_expr_nargs (_p0) == 1)
8051 : {
8052 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8053 0 : switch (TREE_CODE (_p1))
8054 : {
8055 0 : case CALL_EXPR:
8056 0 : switch (get_call_combined_fn (_p1))
8057 : {
8058 0 : case CFN_LOG10:
8059 0 : if (call_expr_nargs (_p1) == 1)
8060 : {
8061 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8062 0 : {
8063 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8064 0 : tree res = generic_simplify_62 (loc, type, _p0, _p1, captures, CFN_LOG10);
8065 0 : if (res) return res;
8066 : }
8067 : }
8068 : break;
8069 : default:;
8070 : }
8071 : break;
8072 : default:;
8073 : }
8074 : }
8075 : break;
8076 6 : case CFN_BUILT_IN_LOG10:
8077 6 : if (call_expr_nargs (_p0) == 1)
8078 : {
8079 6 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8080 6 : switch (TREE_CODE (_p1))
8081 : {
8082 2 : case CALL_EXPR:
8083 2 : switch (get_call_combined_fn (_p1))
8084 : {
8085 2 : case CFN_BUILT_IN_LOG10:
8086 2 : if (call_expr_nargs (_p1) == 1)
8087 : {
8088 2 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8089 2 : {
8090 2 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8091 2 : tree res = generic_simplify_62 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10);
8092 2 : if (res) return res;
8093 : }
8094 : }
8095 : break;
8096 : default:;
8097 : }
8098 : break;
8099 : default:;
8100 : }
8101 : }
8102 : break;
8103 0 : case CFN_BUILT_IN_LOG2F:
8104 0 : if (call_expr_nargs (_p0) == 1)
8105 : {
8106 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8107 0 : switch (TREE_CODE (_p1))
8108 : {
8109 0 : case CALL_EXPR:
8110 0 : switch (get_call_combined_fn (_p1))
8111 : {
8112 0 : case CFN_BUILT_IN_LOG2F:
8113 0 : if (call_expr_nargs (_p1) == 1)
8114 : {
8115 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8116 0 : {
8117 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8118 0 : tree res = generic_simplify_62 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F);
8119 0 : if (res) return res;
8120 : }
8121 : }
8122 : break;
8123 : default:;
8124 : }
8125 : break;
8126 : default:;
8127 : }
8128 : }
8129 : break;
8130 0 : case CFN_BUILT_IN_LOG2L:
8131 0 : if (call_expr_nargs (_p0) == 1)
8132 : {
8133 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8134 0 : switch (TREE_CODE (_p1))
8135 : {
8136 0 : case CALL_EXPR:
8137 0 : switch (get_call_combined_fn (_p1))
8138 : {
8139 0 : case CFN_BUILT_IN_LOG2L:
8140 0 : if (call_expr_nargs (_p1) == 1)
8141 : {
8142 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8143 0 : {
8144 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8145 0 : tree res = generic_simplify_62 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L);
8146 0 : if (res) return res;
8147 : }
8148 : }
8149 : break;
8150 : default:;
8151 : }
8152 : break;
8153 : default:;
8154 : }
8155 : }
8156 : break;
8157 : default:;
8158 : }
8159 : break;
8160 21213461 : default:;
8161 : }
8162 21213461 : switch (TREE_CODE (_p1))
8163 : {
8164 6731 : case BIT_AND_EXPR:
8165 6731 : {
8166 6731 : tree _q30 = TREE_OPERAND (_p1, 0);
8167 6731 : tree _q31 = TREE_OPERAND (_p1, 1);
8168 6731 : switch (TREE_CODE (_q30))
8169 : {
8170 80 : case MAX_EXPR:
8171 80 : {
8172 80 : tree _q40 = TREE_OPERAND (_q30, 0);
8173 80 : tree _q41 = TREE_OPERAND (_q30, 1);
8174 80 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
8175 : {
8176 80 : switch (TREE_CODE (_q41))
8177 : {
8178 80 : case INTEGER_CST:
8179 80 : {
8180 80 : switch (TREE_CODE (_q31))
8181 : {
8182 72 : case INTEGER_CST:
8183 72 : {
8184 72 : {
8185 72 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q31 };
8186 72 : {
8187 72 : auto i = wi::neg (wi::to_wide (captures[2]));
8188 72 : if (wi::popcount (i) == 1
8189 200 : && (wi::to_wide (captures[1])) == (i - 1)
8190 : )
8191 : {
8192 40 : if (TYPE_UNSIGNED (TREE_TYPE (captures[0]))
8193 : )
8194 : {
8195 8 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1206;
8196 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1206;
8197 8 : {
8198 8 : tree res_op0;
8199 8 : res_op0 = captures[0];
8200 8 : tree res_op1;
8201 8 : res_op1 = captures[1];
8202 8 : tree _r;
8203 8 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
8204 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 916, __FILE__, __LINE__, true);
8205 8 : return _r;
8206 : }
8207 64 : next_after_fail1206:;
8208 : }
8209 : else
8210 : {
8211 32 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1207;
8212 32 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1207;
8213 32 : {
8214 32 : if (! tree_invariant_p (captures[0])) goto next_after_fail1207;
8215 0 : if (! tree_invariant_p (captures[1])) goto next_after_fail1207;
8216 0 : tree res_op0;
8217 0 : {
8218 0 : tree _o1[2], _r1;
8219 0 : _o1[0] = unshare_expr (captures[0]);
8220 0 : _o1[1] = unshare_expr (captures[1]);
8221 0 : _r1 = fold_build2_loc (loc, LE_EXPR, boolean_type_node, _o1[0], _o1[1]);
8222 0 : res_op0 = _r1;
8223 : }
8224 0 : tree res_op1;
8225 0 : res_op1 = unshare_expr (captures[0]);
8226 0 : tree res_op2;
8227 0 : {
8228 0 : tree _o1[2], _r1;
8229 0 : _o1[0] = captures[0];
8230 0 : _o1[1] = captures[1];
8231 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8232 0 : res_op2 = _r1;
8233 : }
8234 0 : tree _r;
8235 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
8236 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 917, __FILE__, __LINE__, true);
8237 0 : return _r;
8238 : }
8239 64 : next_after_fail1207:;
8240 : }
8241 : }
8242 8 : }
8243 : }
8244 64 : break;
8245 : }
8246 : default:;
8247 : }
8248 : break;
8249 : }
8250 : default:;
8251 : }
8252 : }
8253 : break;
8254 : }
8255 : default:;
8256 : }
8257 : break;
8258 : }
8259 21213453 : default:;
8260 : }
8261 21213453 : switch (TREE_CODE (_p0))
8262 : {
8263 0 : case VEC_PERM_EXPR:
8264 0 : {
8265 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8266 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8267 0 : tree _q22 = TREE_OPERAND (_p0, 2);
8268 0 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
8269 : {
8270 0 : switch (TREE_CODE (_p1))
8271 : {
8272 0 : case VEC_PERM_EXPR:
8273 0 : {
8274 0 : tree _q60 = TREE_OPERAND (_p1, 0);
8275 0 : tree _q61 = TREE_OPERAND (_p1, 1);
8276 0 : tree _q62 = TREE_OPERAND (_p1, 2);
8277 0 : if ((_q61 == _q60 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q60, 0) && types_match (_q61, _q60)))
8278 : {
8279 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
8280 : {
8281 0 : {
8282 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q22, _q60 };
8283 0 : if (VECTOR_INTEGER_TYPE_P (type)
8284 : )
8285 : {
8286 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1208;
8287 0 : {
8288 0 : tree res_op0;
8289 0 : {
8290 0 : tree _o1[2], _r1;
8291 0 : _o1[0] = captures[0];
8292 0 : _o1[1] = captures[2];
8293 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8294 0 : captures[3] = _r1;
8295 : }
8296 0 : res_op0 = unshare_expr (captures[3]);
8297 0 : tree res_op1;
8298 0 : res_op1 = captures[3];
8299 0 : tree res_op2;
8300 0 : res_op2 = captures[1];
8301 0 : tree _r;
8302 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
8303 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 879, __FILE__, __LINE__, true);
8304 0 : return _r;
8305 : }
8306 0 : next_after_fail1208:;
8307 : }
8308 : }
8309 : }
8310 : }
8311 : break;
8312 : }
8313 0 : default:;
8314 : }
8315 0 : switch (TREE_CODE (_q22))
8316 : {
8317 0 : case VECTOR_CST:
8318 0 : {
8319 0 : switch (TREE_CODE (_p1))
8320 : {
8321 0 : case VEC_PERM_EXPR:
8322 0 : {
8323 0 : tree _q60 = TREE_OPERAND (_p1, 0);
8324 0 : tree _q61 = TREE_OPERAND (_p1, 1);
8325 0 : tree _q62 = TREE_OPERAND (_p1, 2);
8326 0 : if ((_q61 == _q60 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q60, 0) && types_match (_q61, _q60)))
8327 : {
8328 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
8329 : {
8330 0 : switch (TREE_CODE (_q62))
8331 : {
8332 0 : case VECTOR_CST:
8333 0 : {
8334 0 : {
8335 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q22, _q60 };
8336 0 : tree res = generic_simplify_39 (loc, type, _p0, _p1, captures, MINUS_EXPR);
8337 0 : if (res) return res;
8338 : }
8339 0 : break;
8340 : }
8341 : default:;
8342 : }
8343 : }
8344 : }
8345 : break;
8346 : }
8347 : default:;
8348 : }
8349 : break;
8350 : }
8351 : default:;
8352 : }
8353 : }
8354 : break;
8355 : }
8356 : default:;
8357 : }
8358 : return NULL_TREE;
8359 : }
8360 :
8361 : tree
8362 1386532 : generic_simplify_LSHIFT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
8363 : {
8364 1386532 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8365 1386532 : switch (TREE_CODE (_p1))
8366 : {
8367 249 : case TRUNC_MOD_EXPR:
8368 249 : {
8369 249 : tree _q30 = TREE_OPERAND (_p1, 0);
8370 249 : tree _q31 = TREE_OPERAND (_p1, 1);
8371 249 : {
8372 249 : tree _q31_pops[1];
8373 249 : if (tree_power_of_two_cand (_q31, _q31_pops))
8374 : {
8375 243 : tree _q50 = _q31_pops[0];
8376 243 : {
8377 243 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q50 };
8378 243 : tree res = generic_simplify_408 (loc, type, _p0, _p1, captures, LSHIFT_EXPR, TRUNC_MOD_EXPR);
8379 243 : if (res) return res;
8380 : }
8381 : }
8382 : }
8383 75 : break;
8384 : }
8385 0 : case FLOOR_MOD_EXPR:
8386 0 : {
8387 0 : tree _q30 = TREE_OPERAND (_p1, 0);
8388 0 : tree _q31 = TREE_OPERAND (_p1, 1);
8389 0 : {
8390 0 : tree _q31_pops[1];
8391 0 : if (tree_power_of_two_cand (_q31, _q31_pops))
8392 : {
8393 0 : tree _q50 = _q31_pops[0];
8394 0 : {
8395 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q50 };
8396 0 : tree res = generic_simplify_408 (loc, type, _p0, _p1, captures, LSHIFT_EXPR, FLOOR_MOD_EXPR);
8397 0 : if (res) return res;
8398 : }
8399 : }
8400 : }
8401 0 : break;
8402 : }
8403 1386358 : default:;
8404 : }
8405 1386358 : if (uniform_integer_cst_p (_p1))
8406 : {
8407 997202 : {
8408 997202 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8409 997202 : tree res = generic_simplify_409 (loc, type, _p0, _p1, captures, LSHIFT_EXPR);
8410 997202 : if (res) return res;
8411 : }
8412 : }
8413 1385893 : switch (TREE_CODE (_p0))
8414 : {
8415 848591 : CASE_CONVERT:
8416 848591 : {
8417 848591 : tree _q20 = TREE_OPERAND (_p0, 0);
8418 848591 : switch (TREE_CODE (_q20))
8419 : {
8420 4 : case LT_EXPR:
8421 4 : {
8422 4 : tree _q30 = TREE_OPERAND (_q20, 0);
8423 4 : tree _q31 = TREE_OPERAND (_q20, 1);
8424 4 : if (integer_zerop (_q31))
8425 : {
8426 4 : switch (TREE_CODE (_p1))
8427 : {
8428 4 : case INTEGER_CST:
8429 4 : {
8430 4 : {
8431 4 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
8432 4 : if (TYPE_SIGN (TREE_TYPE (captures[0])) == SIGNED
8433 4 : && wi::eq_p (wi::to_wide (captures[2]), TYPE_PRECISION (TREE_TYPE (captures[0])) - 1)
8434 : )
8435 : {
8436 0 : {
8437 0 : wide_int wone = wi::one (TYPE_PRECISION (type));
8438 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1636;
8439 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1636;
8440 0 : {
8441 0 : tree res_op0;
8442 0 : {
8443 0 : tree _o1[1], _r1;
8444 0 : _o1[0] = captures[0];
8445 0 : if (TREE_TYPE (_o1[0]) != type)
8446 : {
8447 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
8448 : }
8449 : else
8450 : _r1 = _o1[0];
8451 0 : res_op0 = _r1;
8452 : }
8453 0 : tree res_op1;
8454 0 : res_op1 = wide_int_to_tree (type,
8455 0 : wi::lshift (wone, wi::to_wide (captures[2])));
8456 0 : tree _r;
8457 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
8458 0 : if (TREE_SIDE_EFFECTS (captures[1]))
8459 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
8460 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 987, __FILE__, __LINE__, true);
8461 0 : return _r;
8462 : }
8463 0 : next_after_fail1636:;
8464 0 : }
8465 : }
8466 : }
8467 4 : break;
8468 : }
8469 : default:;
8470 : }
8471 : }
8472 : break;
8473 : }
8474 123 : CASE_CONVERT:
8475 123 : {
8476 123 : tree _q30 = TREE_OPERAND (_q20, 0);
8477 123 : switch (TREE_CODE (_q30))
8478 : {
8479 0 : case RSHIFT_EXPR:
8480 0 : {
8481 0 : tree _q40 = TREE_OPERAND (_q30, 0);
8482 0 : tree _q41 = TREE_OPERAND (_q30, 1);
8483 0 : switch (TREE_CODE (_q41))
8484 : {
8485 0 : case INTEGER_CST:
8486 0 : {
8487 0 : if ((_p1 == _q41 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q41, 0) && types_match (_p1, _q41)))
8488 : {
8489 0 : {
8490 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q40, _q41 };
8491 0 : if (wi::ltu_p (wi::to_wide (captures[2]), element_precision (type))
8492 0 : && INTEGRAL_TYPE_P (type)
8493 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8494 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
8495 0 : && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (captures[1]))
8496 0 : && (TYPE_PRECISION (TREE_TYPE (captures[0])) >= TYPE_PRECISION (type)
8497 0 : || wi::geu_p (wi::to_wide (captures[2]),
8498 0 : TYPE_PRECISION (type)
8499 0 : - TYPE_PRECISION (TREE_TYPE (captures[0]))))
8500 : )
8501 : {
8502 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1637;
8503 0 : {
8504 0 : tree res_op0;
8505 0 : {
8506 0 : tree _o1[1], _r1;
8507 0 : _o1[0] = captures[1];
8508 0 : if (TREE_TYPE (_o1[0]) != type)
8509 : {
8510 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
8511 : }
8512 : else
8513 : _r1 = _o1[0];
8514 0 : res_op0 = _r1;
8515 : }
8516 0 : tree res_op1;
8517 0 : {
8518 0 : tree _o1[2], _r1;
8519 0 : _o1[0] = build_minus_one_cst (type);
8520 0 : _o1[1] = captures[2];
8521 0 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8522 0 : res_op1 = _r1;
8523 : }
8524 0 : tree _r;
8525 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
8526 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 988, __FILE__, __LINE__, true);
8527 0 : return _r;
8528 : }
8529 0 : next_after_fail1637:;
8530 : }
8531 : }
8532 : }
8533 : break;
8534 : }
8535 : default:;
8536 : }
8537 : break;
8538 : }
8539 : default:;
8540 : }
8541 : break;
8542 : }
8543 : default:;
8544 : }
8545 : break;
8546 : }
8547 19066 : case RSHIFT_EXPR:
8548 19066 : {
8549 19066 : tree _q20 = TREE_OPERAND (_p0, 0);
8550 19066 : tree _q21 = TREE_OPERAND (_p0, 1);
8551 19066 : switch (TREE_CODE (_q21))
8552 : {
8553 48 : case INTEGER_CST:
8554 48 : {
8555 48 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8556 : {
8557 3 : {
8558 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8559 3 : tree res = generic_simplify_410 (loc, type, _p0, _p1, captures);
8560 3 : if (res) return res;
8561 : }
8562 : }
8563 : break;
8564 : }
8565 : default:;
8566 : }
8567 : break;
8568 : }
8569 1385890 : default:;
8570 : }
8571 1385890 : {
8572 1385890 : tree _p0_pops[1];
8573 1385890 : if (tree_nop_convert (_p0, _p0_pops))
8574 : {
8575 817818 : tree _q20 = _p0_pops[0];
8576 817818 : switch (TREE_CODE (_q20))
8577 : {
8578 73 : case RSHIFT_EXPR:
8579 73 : {
8580 73 : tree _q30 = TREE_OPERAND (_q20, 0);
8581 73 : tree _q31 = TREE_OPERAND (_q20, 1);
8582 73 : switch (TREE_CODE (_q31))
8583 : {
8584 67 : case INTEGER_CST:
8585 67 : {
8586 67 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
8587 : {
8588 8 : {
8589 8 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
8590 8 : tree res = generic_simplify_410 (loc, type, _p0, _p1, captures);
8591 8 : if (res) return res;
8592 : }
8593 : }
8594 : break;
8595 : }
8596 : default:;
8597 : }
8598 : break;
8599 : }
8600 : default:;
8601 : }
8602 : }
8603 : }
8604 1385882 : if (integer_onep (_p0))
8605 : {
8606 316206 : switch (TREE_CODE (_p1))
8607 : {
8608 46001 : case MINUS_EXPR:
8609 46001 : {
8610 46001 : tree _q30 = TREE_OPERAND (_p1, 0);
8611 46001 : tree _q31 = TREE_OPERAND (_p1, 1);
8612 46001 : switch (TREE_CODE (_q30))
8613 : {
8614 45998 : case INTEGER_CST:
8615 45998 : {
8616 45998 : {
8617 45998 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31 };
8618 45998 : if (INTEGRAL_TYPE_P (type)
8619 45998 : && wi::eq_p (wi::to_wide (captures[2]), TYPE_PRECISION (type) - 1)
8620 45998 : && single_use (captures[1])
8621 : )
8622 : {
8623 28236 : if (TYPE_UNSIGNED (type)
8624 : )
8625 : {
8626 28230 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1638;
8627 28230 : {
8628 28230 : tree res_op0;
8629 28230 : {
8630 28230 : tree _o1[2], _r1;
8631 28230 : _o1[0] = captures[0];
8632 28230 : _o1[1] = captures[2];
8633 28230 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8634 28230 : res_op0 = _r1;
8635 : }
8636 28230 : tree res_op1;
8637 28230 : res_op1 = captures[3];
8638 28230 : tree _r;
8639 28230 : _r = fold_build2_loc (loc, RSHIFT_EXPR, type, res_op0, res_op1);
8640 28230 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 989, __FILE__, __LINE__, true);
8641 28230 : return _r;
8642 : }
8643 0 : next_after_fail1638:;
8644 : }
8645 : else
8646 : {
8647 6 : {
8648 6 : tree utype = unsigned_type_for (type);
8649 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1639;
8650 6 : {
8651 6 : tree res_op0;
8652 6 : {
8653 6 : tree _o1[2], _r1;
8654 6 : {
8655 6 : tree _o2[2], _r2;
8656 6 : {
8657 6 : tree _o3[1], _r3;
8658 6 : _o3[0] = captures[0];
8659 6 : if (TREE_TYPE (_o3[0]) != utype)
8660 : {
8661 6 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
8662 : }
8663 : else
8664 : _r3 = _o3[0];
8665 6 : _o2[0] = _r3;
8666 : }
8667 6 : _o2[1] = captures[2];
8668 6 : _r2 = fold_build2_loc (loc, LSHIFT_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8669 6 : _o1[0] = _r2;
8670 : }
8671 6 : _o1[1] = captures[3];
8672 6 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8673 6 : res_op0 = _r1;
8674 : }
8675 6 : tree _r;
8676 6 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
8677 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 990, __FILE__, __LINE__, true);
8678 6 : return _r;
8679 : }
8680 0 : next_after_fail1639:;
8681 : }
8682 : }
8683 : }
8684 : }
8685 17762 : break;
8686 : }
8687 : default:;
8688 : }
8689 : break;
8690 : }
8691 : default:;
8692 : }
8693 : }
8694 1357646 : if (integer_zerop (_p1))
8695 : {
8696 1046 : {
8697 1046 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8698 1046 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, LSHIFT_EXPR);
8699 1046 : if (res) return res;
8700 : }
8701 : }
8702 1356600 : if (integer_zerop (_p0))
8703 : {
8704 178 : {
8705 178 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8706 178 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, LSHIFT_EXPR);
8707 178 : if (res) return res;
8708 : }
8709 : }
8710 1356422 : switch (TREE_CODE (_p1))
8711 : {
8712 0 : case VECTOR_CST:
8713 0 : {
8714 0 : {
8715 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8716 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, LSHIFT_EXPR);
8717 0 : if (res) return res;
8718 : }
8719 0 : break;
8720 : }
8721 0 : case CONSTRUCTOR:
8722 0 : {
8723 0 : {
8724 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8725 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, LSHIFT_EXPR);
8726 0 : if (res) return res;
8727 : }
8728 0 : break;
8729 : }
8730 1356422 : default:;
8731 : }
8732 1356422 : switch (TREE_CODE (_p0))
8733 : {
8734 280 : case LSHIFT_EXPR:
8735 280 : {
8736 280 : tree _q20 = TREE_OPERAND (_p0, 0);
8737 280 : tree _q21 = TREE_OPERAND (_p0, 1);
8738 280 : switch (TREE_CODE (_q21))
8739 : {
8740 39 : case INTEGER_CST:
8741 39 : {
8742 39 : switch (TREE_CODE (_p1))
8743 : {
8744 39 : case INTEGER_CST:
8745 39 : {
8746 39 : {
8747 39 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8748 39 : tree res = generic_simplify_415 (loc, type, _p0, _p1, captures, LSHIFT_EXPR);
8749 39 : if (res) return res;
8750 : }
8751 0 : break;
8752 : }
8753 : default:;
8754 : }
8755 : break;
8756 : }
8757 : default:;
8758 : }
8759 : break;
8760 : }
8761 848436 : CASE_CONVERT:
8762 848436 : {
8763 848436 : tree _q20 = TREE_OPERAND (_p0, 0);
8764 848436 : switch (TREE_CODE (_q20))
8765 : {
8766 0 : case BIT_AND_EXPR:
8767 0 : {
8768 0 : tree _q30 = TREE_OPERAND (_q20, 0);
8769 0 : tree _q31 = TREE_OPERAND (_q20, 1);
8770 0 : switch (TREE_CODE (_q31))
8771 : {
8772 0 : case INTEGER_CST:
8773 0 : {
8774 0 : switch (TREE_CODE (_p1))
8775 : {
8776 0 : case INTEGER_CST:
8777 0 : {
8778 0 : {
8779 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
8780 0 : tree res = generic_simplify_416 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, LSHIFT_EXPR);
8781 0 : if (res) return res;
8782 : }
8783 0 : break;
8784 : }
8785 : default:;
8786 : }
8787 : break;
8788 : }
8789 : default:;
8790 : }
8791 : break;
8792 : }
8793 11 : case BIT_XOR_EXPR:
8794 11 : {
8795 11 : tree _q30 = TREE_OPERAND (_q20, 0);
8796 11 : tree _q31 = TREE_OPERAND (_q20, 1);
8797 11 : switch (TREE_CODE (_q31))
8798 : {
8799 0 : case INTEGER_CST:
8800 0 : {
8801 0 : switch (TREE_CODE (_p1))
8802 : {
8803 0 : case INTEGER_CST:
8804 0 : {
8805 0 : {
8806 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
8807 0 : tree res = generic_simplify_416 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LSHIFT_EXPR);
8808 0 : if (res) return res;
8809 : }
8810 0 : break;
8811 : }
8812 : default:;
8813 : }
8814 : break;
8815 : }
8816 : default:;
8817 : }
8818 : break;
8819 : }
8820 18 : case BIT_IOR_EXPR:
8821 18 : {
8822 18 : tree _q30 = TREE_OPERAND (_q20, 0);
8823 18 : tree _q31 = TREE_OPERAND (_q20, 1);
8824 18 : switch (TREE_CODE (_q31))
8825 : {
8826 11 : case INTEGER_CST:
8827 11 : {
8828 11 : switch (TREE_CODE (_p1))
8829 : {
8830 11 : case INTEGER_CST:
8831 11 : {
8832 11 : {
8833 11 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
8834 11 : tree res = generic_simplify_416 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, LSHIFT_EXPR);
8835 11 : if (res) return res;
8836 : }
8837 2 : break;
8838 : }
8839 : default:;
8840 : }
8841 : break;
8842 : }
8843 : default:;
8844 : }
8845 : break;
8846 : }
8847 : default:;
8848 : }
8849 : break;
8850 : }
8851 13632 : case BIT_AND_EXPR:
8852 13632 : {
8853 13632 : tree _q20 = TREE_OPERAND (_p0, 0);
8854 13632 : tree _q21 = TREE_OPERAND (_p0, 1);
8855 13632 : switch (TREE_CODE (_q21))
8856 : {
8857 13537 : case INTEGER_CST:
8858 13537 : {
8859 13537 : switch (TREE_CODE (_p1))
8860 : {
8861 13398 : case INTEGER_CST:
8862 13398 : {
8863 13398 : {
8864 13398 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
8865 13398 : tree res = generic_simplify_417 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, LSHIFT_EXPR);
8866 13398 : if (res) return res;
8867 : }
8868 7 : break;
8869 : }
8870 : default:;
8871 : }
8872 : break;
8873 : }
8874 : default:;
8875 : }
8876 : break;
8877 : }
8878 76 : case BIT_XOR_EXPR:
8879 76 : {
8880 76 : tree _q20 = TREE_OPERAND (_p0, 0);
8881 76 : tree _q21 = TREE_OPERAND (_p0, 1);
8882 76 : switch (TREE_CODE (_q21))
8883 : {
8884 7 : case INTEGER_CST:
8885 7 : {
8886 7 : switch (TREE_CODE (_p1))
8887 : {
8888 7 : case INTEGER_CST:
8889 7 : {
8890 7 : {
8891 7 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
8892 7 : tree res = generic_simplify_417 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LSHIFT_EXPR);
8893 7 : if (res) return res;
8894 : }
8895 0 : break;
8896 : }
8897 : default:;
8898 : }
8899 : break;
8900 : }
8901 : default:;
8902 : }
8903 : break;
8904 : }
8905 78 : case BIT_IOR_EXPR:
8906 78 : {
8907 78 : tree _q20 = TREE_OPERAND (_p0, 0);
8908 78 : tree _q21 = TREE_OPERAND (_p0, 1);
8909 78 : switch (TREE_CODE (_q21))
8910 : {
8911 2 : case INTEGER_CST:
8912 2 : {
8913 2 : switch (TREE_CODE (_p1))
8914 : {
8915 2 : case INTEGER_CST:
8916 2 : {
8917 2 : {
8918 2 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
8919 2 : tree res = generic_simplify_417 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, LSHIFT_EXPR);
8920 2 : if (res) return res;
8921 : }
8922 0 : break;
8923 : }
8924 : default:;
8925 : }
8926 : break;
8927 : }
8928 : default:;
8929 : }
8930 : break;
8931 : }
8932 1 : case VEC_COND_EXPR:
8933 1 : {
8934 1 : tree _q20 = TREE_OPERAND (_p0, 0);
8935 1 : tree _q21 = TREE_OPERAND (_p0, 1);
8936 1 : tree _q22 = TREE_OPERAND (_p0, 2);
8937 1 : switch (TREE_CODE (_p1))
8938 : {
8939 0 : case VEC_COND_EXPR:
8940 0 : {
8941 0 : tree _q60 = TREE_OPERAND (_p1, 0);
8942 0 : tree _q61 = TREE_OPERAND (_p1, 1);
8943 0 : tree _q62 = TREE_OPERAND (_p1, 2);
8944 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
8945 : {
8946 0 : {
8947 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
8948 0 : if (VECTOR_TYPE_P (type)
8949 0 : && (TREE_CODE_CLASS (LSHIFT_EXPR) != tcc_comparison
8950 : || types_match (type, TREE_TYPE (captures[2]))
8951 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8952 : || (optimize_vectors_before_lowering_p ()
8953 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8954 : )
8955 : {
8956 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1640;
8957 0 : {
8958 0 : tree res_op0;
8959 0 : res_op0 = captures[1];
8960 0 : tree res_op1;
8961 0 : {
8962 0 : tree _o1[2], _r1;
8963 0 : _o1[0] = captures[2];
8964 0 : _o1[1] = captures[5];
8965 0 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, type, _o1[0], _o1[1]);
8966 0 : if (EXPR_P (_r1))
8967 0 : goto next_after_fail1640;
8968 0 : res_op1 = _r1;
8969 : }
8970 0 : tree res_op2;
8971 0 : {
8972 0 : tree _o1[2], _r1;
8973 0 : _o1[0] = captures[3];
8974 0 : _o1[1] = captures[6];
8975 0 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, type, _o1[0], _o1[1]);
8976 0 : if (EXPR_P (_r1))
8977 0 : goto next_after_fail1640;
8978 0 : res_op2 = _r1;
8979 : }
8980 0 : tree _r;
8981 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8982 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
8983 0 : return _r;
8984 : }
8985 0 : next_after_fail1640:;
8986 : }
8987 : }
8988 : }
8989 : break;
8990 : }
8991 1 : default:;
8992 : }
8993 1 : {
8994 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
8995 1 : if (VECTOR_TYPE_P (type)
8996 1 : && (TREE_CODE_CLASS (LSHIFT_EXPR) != tcc_comparison
8997 : || types_match (type, TREE_TYPE (captures[2]))
8998 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8999 : || (optimize_vectors_before_lowering_p ()
9000 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9001 : )
9002 : {
9003 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1641;
9004 1 : {
9005 1 : if (! tree_invariant_p (captures[4])) goto next_after_fail1641;
9006 0 : tree res_op0;
9007 0 : res_op0 = captures[1];
9008 0 : tree res_op1;
9009 0 : {
9010 0 : tree _o1[2], _r1;
9011 0 : _o1[0] = captures[2];
9012 0 : _o1[1] = unshare_expr (captures[4]);
9013 0 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, type, _o1[0], _o1[1]);
9014 0 : if (EXPR_P (_r1))
9015 0 : goto next_after_fail1641;
9016 0 : res_op1 = _r1;
9017 : }
9018 0 : tree res_op2;
9019 0 : {
9020 0 : tree _o1[2], _r1;
9021 0 : _o1[0] = captures[3];
9022 0 : _o1[1] = captures[4];
9023 0 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, type, _o1[0], _o1[1]);
9024 0 : if (EXPR_P (_r1))
9025 0 : goto next_after_fail1641;
9026 0 : res_op2 = _r1;
9027 : }
9028 0 : tree _r;
9029 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9030 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
9031 0 : return _r;
9032 : }
9033 1 : next_after_fail1641:;
9034 : }
9035 : }
9036 1 : break;
9037 : }
9038 1342974 : default:;
9039 : }
9040 1342974 : switch (TREE_CODE (_p1))
9041 : {
9042 3 : case VEC_COND_EXPR:
9043 3 : {
9044 3 : tree _q30 = TREE_OPERAND (_p1, 0);
9045 3 : tree _q31 = TREE_OPERAND (_p1, 1);
9046 3 : tree _q32 = TREE_OPERAND (_p1, 2);
9047 3 : {
9048 3 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
9049 3 : if (VECTOR_TYPE_P (type)
9050 3 : && (TREE_CODE_CLASS (LSHIFT_EXPR) != tcc_comparison
9051 : || types_match (type, TREE_TYPE (captures[3]))
9052 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
9053 : || (optimize_vectors_before_lowering_p ()
9054 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
9055 : )
9056 : {
9057 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1642;
9058 3 : {
9059 3 : if (! tree_invariant_p (captures[0])) goto next_after_fail1642;
9060 1 : tree res_op0;
9061 1 : res_op0 = captures[2];
9062 1 : tree res_op1;
9063 1 : {
9064 1 : tree _o1[2], _r1;
9065 1 : _o1[0] = unshare_expr (captures[0]);
9066 1 : _o1[1] = captures[3];
9067 1 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, type, _o1[0], _o1[1]);
9068 1 : if (EXPR_P (_r1))
9069 0 : goto next_after_fail1642;
9070 1 : res_op1 = _r1;
9071 : }
9072 1 : tree res_op2;
9073 1 : {
9074 1 : tree _o1[2], _r1;
9075 1 : _o1[0] = captures[0];
9076 1 : _o1[1] = captures[4];
9077 1 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, type, _o1[0], _o1[1]);
9078 1 : if (EXPR_P (_r1))
9079 0 : goto next_after_fail1642;
9080 1 : res_op2 = _r1;
9081 : }
9082 1 : tree _r;
9083 1 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9084 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
9085 1 : return _r;
9086 : }
9087 2 : next_after_fail1642:;
9088 : }
9089 : }
9090 2 : break;
9091 : }
9092 1342973 : default:;
9093 : }
9094 1342973 : switch (TREE_CODE (_p0))
9095 : {
9096 0 : case VEC_PERM_EXPR:
9097 0 : {
9098 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9099 0 : tree _q21 = TREE_OPERAND (_p0, 1);
9100 0 : tree _q22 = TREE_OPERAND (_p0, 2);
9101 0 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
9102 : {
9103 0 : switch (TREE_CODE (_p1))
9104 : {
9105 0 : case VEC_PERM_EXPR:
9106 0 : {
9107 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9108 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9109 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9110 0 : if ((_q61 == _q60 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q60, 0) && types_match (_q61, _q60)))
9111 : {
9112 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
9113 : {
9114 0 : {
9115 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q22, _q60 };
9116 0 : if (VECTOR_INTEGER_TYPE_P (type)
9117 : )
9118 : {
9119 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1643;
9120 0 : {
9121 0 : tree res_op0;
9122 0 : {
9123 0 : tree _o1[2], _r1;
9124 0 : _o1[0] = captures[0];
9125 0 : _o1[1] = captures[2];
9126 0 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9127 0 : captures[3] = _r1;
9128 : }
9129 0 : res_op0 = unshare_expr (captures[3]);
9130 0 : tree res_op1;
9131 0 : res_op1 = captures[3];
9132 0 : tree res_op2;
9133 0 : res_op2 = captures[1];
9134 0 : tree _r;
9135 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
9136 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 879, __FILE__, __LINE__, true);
9137 0 : return _r;
9138 : }
9139 0 : next_after_fail1643:;
9140 : }
9141 : }
9142 : }
9143 : }
9144 : break;
9145 : }
9146 : default:;
9147 : }
9148 : }
9149 : break;
9150 : }
9151 : default:;
9152 : }
9153 : return NULL_TREE;
9154 : }
9155 :
9156 : tree
9157 82721 : generic_simplify_MIN_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
9158 : {
9159 82721 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
9160 82721 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
9161 : {
9162 0 : {
9163 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
9164 0 : tree res = generic_simplify_510 (loc, type, _p0, _p1, captures, MIN_EXPR);
9165 0 : if (res) return res;
9166 : }
9167 : }
9168 82721 : switch (TREE_CODE (_p0))
9169 : {
9170 46 : case MIN_EXPR:
9171 46 : {
9172 46 : tree _q20 = TREE_OPERAND (_p0, 0);
9173 46 : tree _q21 = TREE_OPERAND (_p0, 1);
9174 46 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9175 : {
9176 0 : {
9177 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
9178 0 : tree res = generic_simplify_511 (loc, type, _p0, _p1, captures, MIN_EXPR);
9179 0 : if (res) return res;
9180 : }
9181 : }
9182 46 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
9183 : {
9184 0 : {
9185 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
9186 0 : tree res = generic_simplify_511 (loc, type, _p0, _p1, captures, MIN_EXPR);
9187 0 : if (res) return res;
9188 : }
9189 : }
9190 : break;
9191 : }
9192 82721 : default:;
9193 : }
9194 82721 : switch (TREE_CODE (_p1))
9195 : {
9196 0 : case MIN_EXPR:
9197 0 : {
9198 0 : tree _q30 = TREE_OPERAND (_p1, 0);
9199 0 : tree _q31 = TREE_OPERAND (_p1, 1);
9200 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9201 : {
9202 0 : {
9203 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q31 };
9204 0 : tree res = generic_simplify_512 (loc, type, _p0, _p1, captures, MIN_EXPR);
9205 0 : if (res) return res;
9206 : }
9207 : }
9208 0 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
9209 : {
9210 0 : {
9211 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q30 };
9212 0 : tree res = generic_simplify_512 (loc, type, _p0, _p1, captures, MIN_EXPR);
9213 0 : if (res) return res;
9214 : }
9215 : }
9216 : break;
9217 : }
9218 82721 : default:;
9219 : }
9220 82721 : switch (TREE_CODE (_p0))
9221 : {
9222 4 : case MAX_EXPR:
9223 4 : {
9224 4 : tree _q20 = TREE_OPERAND (_p0, 0);
9225 4 : tree _q21 = TREE_OPERAND (_p0, 1);
9226 4 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
9227 : {
9228 3 : {
9229 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9230 3 : tree res = generic_simplify_513 (loc, type, _p0, _p1, captures);
9231 3 : if (res) return res;
9232 : }
9233 : }
9234 1 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9235 : {
9236 1 : {
9237 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9238 1 : tree res = generic_simplify_513 (loc, type, _p0, _p1, captures);
9239 1 : if (res) return res;
9240 : }
9241 : }
9242 : break;
9243 : }
9244 82717 : default:;
9245 : }
9246 82717 : switch (TREE_CODE (_p1))
9247 : {
9248 0 : case MAX_EXPR:
9249 0 : {
9250 0 : tree _q30 = TREE_OPERAND (_p1, 0);
9251 0 : tree _q31 = TREE_OPERAND (_p1, 1);
9252 0 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
9253 : {
9254 0 : {
9255 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
9256 0 : tree res = generic_simplify_513 (loc, type, _p0, _p1, captures);
9257 0 : if (res) return res;
9258 : }
9259 : }
9260 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9261 : {
9262 0 : {
9263 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _p0 };
9264 0 : tree res = generic_simplify_513 (loc, type, _p0, _p1, captures);
9265 0 : if (res) return res;
9266 : }
9267 : }
9268 : break;
9269 : }
9270 0 : case NEGATE_EXPR:
9271 0 : {
9272 0 : tree _q30 = TREE_OPERAND (_p1, 0);
9273 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9274 : {
9275 0 : {
9276 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
9277 0 : tree res = generic_simplify_514 (loc, type, _p0, _p1, captures);
9278 0 : if (res) return res;
9279 : }
9280 : }
9281 : break;
9282 : }
9283 82717 : default:;
9284 : }
9285 82717 : switch (TREE_CODE (_p0))
9286 : {
9287 2 : case NEGATE_EXPR:
9288 2 : {
9289 2 : tree _q20 = TREE_OPERAND (_p0, 0);
9290 2 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9291 : {
9292 2 : {
9293 2 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9294 2 : tree res = generic_simplify_514 (loc, type, _p0, _p1, captures);
9295 2 : if (res) return res;
9296 : }
9297 : }
9298 : break;
9299 : }
9300 82715 : default:;
9301 : }
9302 82715 : {
9303 82715 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9304 82715 : if (INTEGRAL_TYPE_P (type)
9305 80919 : && TYPE_MIN_VALUE (type)
9306 163634 : && operand_equal_p (captures[1], TYPE_MIN_VALUE (type), OEP_ONLY_CONST)
9307 : )
9308 : {
9309 544 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1707;
9310 544 : {
9311 544 : tree _r;
9312 544 : _r = captures[1];
9313 544 : if (TREE_SIDE_EFFECTS (captures[0]))
9314 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
9315 544 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1005, __FILE__, __LINE__, true);
9316 544 : return _r;
9317 : }
9318 0 : next_after_fail1707:;
9319 : }
9320 : else
9321 : {
9322 82171 : if (INTEGRAL_TYPE_P (type)
9323 80375 : && TYPE_MAX_VALUE (type)
9324 162546 : && operand_equal_p (captures[1], TYPE_MAX_VALUE (type), OEP_ONLY_CONST)
9325 : )
9326 : {
9327 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1708;
9328 1 : {
9329 1 : tree _r;
9330 1 : _r = captures[0];
9331 1 : if (TREE_SIDE_EFFECTS (captures[1]))
9332 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
9333 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1006, __FILE__, __LINE__, true);
9334 1 : return _r;
9335 : }
9336 0 : next_after_fail1708:;
9337 : }
9338 : }
9339 : }
9340 82170 : switch (TREE_CODE (_p1))
9341 : {
9342 22 : case PLUS_EXPR:
9343 22 : {
9344 22 : tree _q30 = TREE_OPERAND (_p1, 0);
9345 22 : tree _q31 = TREE_OPERAND (_p1, 1);
9346 22 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9347 : {
9348 0 : switch (TREE_CODE (_q31))
9349 : {
9350 0 : case INTEGER_CST:
9351 0 : {
9352 0 : {
9353 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
9354 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
9355 : )
9356 : {
9357 0 : if (tree_int_cst_sgn (captures[2]) > 0
9358 : )
9359 : {
9360 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1709;
9361 0 : {
9362 0 : tree _r;
9363 0 : _r = captures[0];
9364 0 : if (TREE_SIDE_EFFECTS (captures[2]))
9365 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
9366 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1007, __FILE__, __LINE__, true);
9367 0 : return _r;
9368 : }
9369 0 : next_after_fail1709:;
9370 : }
9371 : else
9372 : {
9373 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1710;
9374 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1710;
9375 0 : {
9376 0 : tree _r;
9377 0 : _r = captures[1];
9378 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1008, __FILE__, __LINE__, true);
9379 0 : return _r;
9380 : }
9381 0 : next_after_fail1710:;
9382 : }
9383 : }
9384 : }
9385 0 : break;
9386 : }
9387 : default:;
9388 : }
9389 : }
9390 : break;
9391 : }
9392 82170 : default:;
9393 : }
9394 82170 : switch (TREE_CODE (_p0))
9395 : {
9396 5603 : case PLUS_EXPR:
9397 5603 : {
9398 5603 : tree _q20 = TREE_OPERAND (_p0, 0);
9399 5603 : tree _q21 = TREE_OPERAND (_p0, 1);
9400 5603 : switch (TREE_CODE (_q21))
9401 : {
9402 5474 : case INTEGER_CST:
9403 5474 : {
9404 5474 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9405 : {
9406 0 : {
9407 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
9408 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
9409 : )
9410 : {
9411 0 : if (tree_int_cst_sgn (captures[2]) > 0
9412 : )
9413 : {
9414 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1711;
9415 0 : {
9416 0 : tree _r;
9417 0 : _r = captures[0];
9418 0 : if (TREE_SIDE_EFFECTS (captures[2]))
9419 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
9420 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1007, __FILE__, __LINE__, true);
9421 0 : return _r;
9422 : }
9423 0 : next_after_fail1711:;
9424 : }
9425 : else
9426 : {
9427 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1712;
9428 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1712;
9429 0 : {
9430 0 : tree _r;
9431 0 : _r = captures[1];
9432 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1008, __FILE__, __LINE__, true);
9433 0 : return _r;
9434 : }
9435 0 : next_after_fail1712:;
9436 : }
9437 : }
9438 : }
9439 : }
9440 : break;
9441 : }
9442 : default:;
9443 : }
9444 : break;
9445 : }
9446 46 : case MIN_EXPR:
9447 46 : {
9448 46 : tree _q20 = TREE_OPERAND (_p0, 0);
9449 46 : tree _q21 = TREE_OPERAND (_p0, 1);
9450 46 : switch (TREE_CODE (_p1))
9451 : {
9452 0 : case MAX_EXPR:
9453 0 : {
9454 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9455 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9456 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9457 : {
9458 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9459 : {
9460 0 : {
9461 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9462 0 : if (!HONOR_NANS (captures[0])
9463 : )
9464 : {
9465 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1713;
9466 0 : {
9467 0 : tree res_op0;
9468 0 : res_op0 = captures[0];
9469 0 : tree res_op1;
9470 0 : res_op1 = captures[1];
9471 0 : tree _r;
9472 0 : _r = fold_build2_loc (loc, MIN_EXPR, type, res_op0, res_op1);
9473 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
9474 0 : return _r;
9475 : }
9476 0 : next_after_fail1713:;
9477 : }
9478 : }
9479 : }
9480 : }
9481 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9482 : {
9483 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9484 : {
9485 0 : {
9486 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9487 0 : if (!HONOR_NANS (captures[0])
9488 : )
9489 : {
9490 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1714;
9491 0 : {
9492 0 : tree res_op0;
9493 0 : res_op0 = captures[0];
9494 0 : tree res_op1;
9495 0 : res_op1 = captures[1];
9496 0 : tree _r;
9497 0 : _r = fold_build2_loc (loc, MIN_EXPR, type, res_op0, res_op1);
9498 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
9499 0 : return _r;
9500 : }
9501 0 : next_after_fail1714:;
9502 : }
9503 : }
9504 : }
9505 : }
9506 : break;
9507 : }
9508 : default:;
9509 : }
9510 : break;
9511 : }
9512 0 : case MAX_EXPR:
9513 0 : {
9514 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9515 0 : tree _q21 = TREE_OPERAND (_p0, 1);
9516 0 : switch (TREE_CODE (_p1))
9517 : {
9518 0 : case MIN_EXPR:
9519 0 : {
9520 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9521 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9522 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9523 : {
9524 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9525 : {
9526 0 : {
9527 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9528 0 : if (!HONOR_NANS (captures[0])
9529 : )
9530 : {
9531 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1715;
9532 0 : {
9533 0 : tree res_op0;
9534 0 : res_op0 = captures[0];
9535 0 : tree res_op1;
9536 0 : res_op1 = captures[1];
9537 0 : tree _r;
9538 0 : _r = fold_build2_loc (loc, MIN_EXPR, type, res_op0, res_op1);
9539 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
9540 0 : return _r;
9541 : }
9542 0 : next_after_fail1715:;
9543 : }
9544 : }
9545 : }
9546 : }
9547 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9548 : {
9549 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9550 : {
9551 0 : {
9552 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9553 0 : if (!HONOR_NANS (captures[0])
9554 : )
9555 : {
9556 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1716;
9557 0 : {
9558 0 : tree res_op0;
9559 0 : res_op0 = captures[0];
9560 0 : tree res_op1;
9561 0 : res_op1 = captures[1];
9562 0 : tree _r;
9563 0 : _r = fold_build2_loc (loc, MIN_EXPR, type, res_op0, res_op1);
9564 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
9565 0 : return _r;
9566 : }
9567 0 : next_after_fail1716:;
9568 : }
9569 : }
9570 : }
9571 : }
9572 : break;
9573 : }
9574 : default:;
9575 : }
9576 : break;
9577 : }
9578 563 : CASE_CONVERT:
9579 563 : {
9580 563 : tree _q20 = TREE_OPERAND (_p0, 0);
9581 563 : switch (TREE_CODE (_q20))
9582 : {
9583 47 : case ADDR_EXPR:
9584 47 : {
9585 47 : switch (TREE_CODE (_p1))
9586 : {
9587 47 : CASE_CONVERT:
9588 47 : {
9589 47 : tree _q40 = TREE_OPERAND (_p1, 0);
9590 47 : switch (TREE_CODE (_q40))
9591 : {
9592 47 : case ADDR_EXPR:
9593 47 : {
9594 47 : {
9595 47 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
9596 47 : tree res = generic_simplify_515 (loc, type, _p0, _p1, captures, MIN_EXPR, LT_EXPR);
9597 47 : if (res) return res;
9598 : }
9599 47 : break;
9600 : }
9601 : default:;
9602 : }
9603 : break;
9604 : }
9605 0 : case ADDR_EXPR:
9606 0 : {
9607 0 : {
9608 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
9609 0 : tree res = generic_simplify_516 (loc, type, _p0, _p1, captures, MIN_EXPR, LT_EXPR);
9610 0 : if (res) return res;
9611 : }
9612 0 : break;
9613 : }
9614 : default:;
9615 : }
9616 : break;
9617 : }
9618 : default:;
9619 : }
9620 : break;
9621 : }
9622 10 : case ADDR_EXPR:
9623 10 : {
9624 10 : switch (TREE_CODE (_p1))
9625 : {
9626 0 : CASE_CONVERT:
9627 0 : {
9628 0 : tree _q30 = TREE_OPERAND (_p1, 0);
9629 0 : switch (TREE_CODE (_q30))
9630 : {
9631 0 : case ADDR_EXPR:
9632 0 : {
9633 0 : {
9634 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _p1, _q30 };
9635 0 : tree res = generic_simplify_517 (loc, type, _p0, _p1, captures, MIN_EXPR, LT_EXPR);
9636 0 : if (res) return res;
9637 : }
9638 0 : break;
9639 : }
9640 : default:;
9641 : }
9642 : break;
9643 : }
9644 10 : case ADDR_EXPR:
9645 10 : {
9646 10 : {
9647 10 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _p1, _p1 };
9648 10 : tree res = generic_simplify_518 (loc, type, _p0, _p1, captures, MIN_EXPR, LT_EXPR);
9649 10 : if (res) return res;
9650 : }
9651 10 : break;
9652 : }
9653 : default:;
9654 : }
9655 : break;
9656 : }
9657 0 : case NEGATE_EXPR:
9658 0 : {
9659 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9660 0 : switch (TREE_CODE (_p1))
9661 : {
9662 0 : case NEGATE_EXPR:
9663 0 : {
9664 0 : tree _q40 = TREE_OPERAND (_p1, 0);
9665 0 : {
9666 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
9667 0 : if (FLOAT_TYPE_P (TREE_TYPE (captures[1]))
9668 0 : || (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
9669 0 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1])))
9670 : )
9671 : {
9672 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1717;
9673 0 : {
9674 0 : tree res_op0;
9675 0 : {
9676 0 : tree _o1[2], _r1;
9677 0 : _o1[0] = captures[1];
9678 0 : _o1[1] = captures[3];
9679 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9680 0 : res_op0 = _r1;
9681 : }
9682 0 : tree _r;
9683 0 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
9684 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1009, __FILE__, __LINE__, true);
9685 0 : return _r;
9686 : }
9687 0 : next_after_fail1717:;
9688 : }
9689 : }
9690 0 : break;
9691 : }
9692 : default:;
9693 : }
9694 : break;
9695 : }
9696 0 : case BIT_NOT_EXPR:
9697 0 : {
9698 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9699 0 : switch (TREE_CODE (_p1))
9700 : {
9701 0 : case BIT_NOT_EXPR:
9702 0 : {
9703 0 : tree _q40 = TREE_OPERAND (_p1, 0);
9704 0 : {
9705 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
9706 0 : tree res = generic_simplify_519 (loc, type, _p0, _p1, captures, MIN_EXPR, MAX_EXPR);
9707 0 : if (res) return res;
9708 : }
9709 0 : break;
9710 : }
9711 : default:;
9712 : }
9713 : break;
9714 : }
9715 0 : case VEC_COND_EXPR:
9716 0 : {
9717 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9718 0 : tree _q21 = TREE_OPERAND (_p0, 1);
9719 0 : tree _q22 = TREE_OPERAND (_p0, 2);
9720 0 : switch (TREE_CODE (_p1))
9721 : {
9722 0 : case VEC_COND_EXPR:
9723 0 : {
9724 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9725 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9726 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9727 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9728 : {
9729 0 : {
9730 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
9731 0 : if (VECTOR_TYPE_P (type)
9732 0 : && (TREE_CODE_CLASS (MIN_EXPR) != tcc_comparison
9733 : || types_match (type, TREE_TYPE (captures[2]))
9734 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9735 : || (optimize_vectors_before_lowering_p ()
9736 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9737 : )
9738 : {
9739 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1718;
9740 0 : {
9741 0 : tree res_op0;
9742 0 : res_op0 = captures[1];
9743 0 : tree res_op1;
9744 0 : {
9745 0 : tree _o1[2], _r1;
9746 0 : _o1[0] = captures[2];
9747 0 : _o1[1] = captures[5];
9748 0 : _r1 = fold_build2_loc (loc, MIN_EXPR, type, _o1[0], _o1[1]);
9749 0 : if (EXPR_P (_r1))
9750 0 : goto next_after_fail1718;
9751 0 : res_op1 = _r1;
9752 : }
9753 0 : tree res_op2;
9754 0 : {
9755 0 : tree _o1[2], _r1;
9756 0 : _o1[0] = captures[3];
9757 0 : _o1[1] = captures[6];
9758 0 : _r1 = fold_build2_loc (loc, MIN_EXPR, type, _o1[0], _o1[1]);
9759 0 : if (EXPR_P (_r1))
9760 0 : goto next_after_fail1718;
9761 0 : res_op2 = _r1;
9762 : }
9763 0 : tree _r;
9764 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9765 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
9766 0 : return _r;
9767 : }
9768 0 : next_after_fail1718:;
9769 : }
9770 : }
9771 : }
9772 : break;
9773 : }
9774 0 : default:;
9775 : }
9776 0 : {
9777 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
9778 0 : if (VECTOR_TYPE_P (type)
9779 0 : && (TREE_CODE_CLASS (MIN_EXPR) != tcc_comparison
9780 : || types_match (type, TREE_TYPE (captures[2]))
9781 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9782 : || (optimize_vectors_before_lowering_p ()
9783 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9784 : )
9785 : {
9786 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1719;
9787 0 : {
9788 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1719;
9789 0 : tree res_op0;
9790 0 : res_op0 = captures[1];
9791 0 : tree res_op1;
9792 0 : {
9793 0 : tree _o1[2], _r1;
9794 0 : _o1[0] = captures[2];
9795 0 : _o1[1] = unshare_expr (captures[4]);
9796 0 : _r1 = fold_build2_loc (loc, MIN_EXPR, type, _o1[0], _o1[1]);
9797 0 : if (EXPR_P (_r1))
9798 0 : goto next_after_fail1719;
9799 0 : res_op1 = _r1;
9800 : }
9801 0 : tree res_op2;
9802 0 : {
9803 0 : tree _o1[2], _r1;
9804 0 : _o1[0] = captures[3];
9805 0 : _o1[1] = captures[4];
9806 0 : _r1 = fold_build2_loc (loc, MIN_EXPR, type, _o1[0], _o1[1]);
9807 0 : if (EXPR_P (_r1))
9808 0 : goto next_after_fail1719;
9809 0 : res_op2 = _r1;
9810 : }
9811 0 : tree _r;
9812 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9813 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
9814 0 : return _r;
9815 : }
9816 0 : next_after_fail1719:;
9817 : }
9818 : }
9819 0 : break;
9820 : }
9821 82170 : default:;
9822 : }
9823 82170 : switch (TREE_CODE (_p1))
9824 : {
9825 0 : case VEC_COND_EXPR:
9826 0 : {
9827 0 : tree _q30 = TREE_OPERAND (_p1, 0);
9828 0 : tree _q31 = TREE_OPERAND (_p1, 1);
9829 0 : tree _q32 = TREE_OPERAND (_p1, 2);
9830 0 : {
9831 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
9832 0 : if (VECTOR_TYPE_P (type)
9833 0 : && (TREE_CODE_CLASS (MIN_EXPR) != tcc_comparison
9834 : || types_match (type, TREE_TYPE (captures[3]))
9835 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
9836 : || (optimize_vectors_before_lowering_p ()
9837 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
9838 : )
9839 : {
9840 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1720;
9841 0 : {
9842 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1720;
9843 0 : tree res_op0;
9844 0 : res_op0 = captures[2];
9845 0 : tree res_op1;
9846 0 : {
9847 0 : tree _o1[2], _r1;
9848 0 : _o1[0] = unshare_expr (captures[0]);
9849 0 : _o1[1] = captures[3];
9850 0 : _r1 = fold_build2_loc (loc, MIN_EXPR, type, _o1[0], _o1[1]);
9851 0 : if (EXPR_P (_r1))
9852 0 : goto next_after_fail1720;
9853 0 : res_op1 = _r1;
9854 : }
9855 0 : tree res_op2;
9856 0 : {
9857 0 : tree _o1[2], _r1;
9858 0 : _o1[0] = captures[0];
9859 0 : _o1[1] = captures[4];
9860 0 : _r1 = fold_build2_loc (loc, MIN_EXPR, type, _o1[0], _o1[1]);
9861 0 : if (EXPR_P (_r1))
9862 0 : goto next_after_fail1720;
9863 0 : res_op2 = _r1;
9864 : }
9865 0 : tree _r;
9866 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9867 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
9868 0 : return _r;
9869 : }
9870 0 : next_after_fail1720:;
9871 : }
9872 : }
9873 0 : break;
9874 : }
9875 82170 : default:;
9876 : }
9877 82170 : if (tree_zero_one_valued_p (_p0))
9878 : {
9879 3 : if (tree_zero_one_valued_p (_p1))
9880 : {
9881 2 : {
9882 2 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9883 2 : tree res = generic_simplify_520 (loc, type, _p0, _p1, captures, MIN_EXPR, BIT_AND_EXPR);
9884 2 : if (res) return res;
9885 : }
9886 : }
9887 : }
9888 : return NULL_TREE;
9889 : }
9890 :
9891 : tree
9892 555114 : generic_simplify_COMPLEX_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
9893 : {
9894 555114 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
9895 555114 : switch (TREE_CODE (_p0))
9896 : {
9897 40 : case REALPART_EXPR:
9898 40 : {
9899 40 : tree _q20 = TREE_OPERAND (_p0, 0);
9900 40 : switch (TREE_CODE (_p1))
9901 : {
9902 30 : case IMAGPART_EXPR:
9903 30 : {
9904 30 : tree _q40 = TREE_OPERAND (_p1, 0);
9905 30 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
9906 : {
9907 30 : {
9908 30 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9909 30 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1736;
9910 30 : {
9911 30 : tree _r;
9912 30 : _r = captures[0];
9913 30 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1015, __FILE__, __LINE__, true);
9914 30 : return _r;
9915 : }
9916 0 : next_after_fail1736:;
9917 : }
9918 : }
9919 : break;
9920 : }
9921 : default:;
9922 : }
9923 : break;
9924 : }
9925 : default:;
9926 : }
9927 : return NULL_TREE;
9928 : }
9929 :
9930 : tree
9931 190995 : generic_simplify_ORDERED_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
9932 : {
9933 190995 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
9934 190995 : switch (TREE_CODE (_p0))
9935 : {
9936 0 : case VEC_COND_EXPR:
9937 0 : {
9938 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9939 0 : tree _q21 = TREE_OPERAND (_p0, 1);
9940 0 : tree _q22 = TREE_OPERAND (_p0, 2);
9941 0 : switch (TREE_CODE (_p1))
9942 : {
9943 0 : case VEC_COND_EXPR:
9944 0 : {
9945 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9946 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9947 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9948 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9949 : {
9950 0 : {
9951 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
9952 0 : if (VECTOR_TYPE_P (type)
9953 0 : && (TREE_CODE_CLASS (ORDERED_EXPR) != tcc_comparison
9954 0 : || types_match (type, TREE_TYPE (captures[2]))
9955 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9956 : || (optimize_vectors_before_lowering_p ()
9957 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9958 : )
9959 : {
9960 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1742;
9961 0 : {
9962 0 : tree res_op0;
9963 0 : res_op0 = captures[1];
9964 0 : tree res_op1;
9965 0 : {
9966 0 : tree _o1[2], _r1;
9967 0 : _o1[0] = captures[2];
9968 0 : _o1[1] = captures[5];
9969 0 : _r1 = fold_build2_loc (loc, ORDERED_EXPR, type, _o1[0], _o1[1]);
9970 0 : if (EXPR_P (_r1))
9971 0 : goto next_after_fail1742;
9972 0 : res_op1 = _r1;
9973 : }
9974 0 : tree res_op2;
9975 0 : {
9976 0 : tree _o1[2], _r1;
9977 0 : _o1[0] = captures[3];
9978 0 : _o1[1] = captures[6];
9979 0 : _r1 = fold_build2_loc (loc, ORDERED_EXPR, type, _o1[0], _o1[1]);
9980 0 : if (EXPR_P (_r1))
9981 0 : goto next_after_fail1742;
9982 0 : res_op2 = _r1;
9983 : }
9984 0 : tree _r;
9985 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9986 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
9987 0 : return _r;
9988 : }
9989 0 : next_after_fail1742:;
9990 : }
9991 : }
9992 : }
9993 : break;
9994 : }
9995 0 : default:;
9996 : }
9997 0 : {
9998 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
9999 0 : if (VECTOR_TYPE_P (type)
10000 0 : && (TREE_CODE_CLASS (ORDERED_EXPR) != tcc_comparison
10001 0 : || types_match (type, TREE_TYPE (captures[2]))
10002 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10003 : || (optimize_vectors_before_lowering_p ()
10004 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10005 : )
10006 : {
10007 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1743;
10008 0 : {
10009 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1743;
10010 0 : tree res_op0;
10011 0 : res_op0 = captures[1];
10012 0 : tree res_op1;
10013 0 : {
10014 0 : tree _o1[2], _r1;
10015 0 : _o1[0] = captures[2];
10016 0 : _o1[1] = unshare_expr (captures[4]);
10017 0 : _r1 = fold_build2_loc (loc, ORDERED_EXPR, type, _o1[0], _o1[1]);
10018 0 : if (EXPR_P (_r1))
10019 0 : goto next_after_fail1743;
10020 0 : res_op1 = _r1;
10021 : }
10022 0 : tree res_op2;
10023 0 : {
10024 0 : tree _o1[2], _r1;
10025 0 : _o1[0] = captures[3];
10026 0 : _o1[1] = captures[4];
10027 0 : _r1 = fold_build2_loc (loc, ORDERED_EXPR, type, _o1[0], _o1[1]);
10028 0 : if (EXPR_P (_r1))
10029 0 : goto next_after_fail1743;
10030 0 : res_op2 = _r1;
10031 : }
10032 0 : tree _r;
10033 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10034 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
10035 0 : return _r;
10036 : }
10037 0 : next_after_fail1743:;
10038 : }
10039 : }
10040 0 : break;
10041 : }
10042 190995 : default:;
10043 : }
10044 190995 : switch (TREE_CODE (_p1))
10045 : {
10046 0 : case VEC_COND_EXPR:
10047 0 : {
10048 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10049 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10050 0 : tree _q32 = TREE_OPERAND (_p1, 2);
10051 0 : {
10052 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
10053 0 : if (VECTOR_TYPE_P (type)
10054 0 : && (TREE_CODE_CLASS (ORDERED_EXPR) != tcc_comparison
10055 0 : || types_match (type, TREE_TYPE (captures[3]))
10056 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
10057 : || (optimize_vectors_before_lowering_p ()
10058 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
10059 : )
10060 : {
10061 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1744;
10062 0 : {
10063 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1744;
10064 0 : tree res_op0;
10065 0 : res_op0 = captures[2];
10066 0 : tree res_op1;
10067 0 : {
10068 0 : tree _o1[2], _r1;
10069 0 : _o1[0] = unshare_expr (captures[0]);
10070 0 : _o1[1] = captures[3];
10071 0 : _r1 = fold_build2_loc (loc, ORDERED_EXPR, type, _o1[0], _o1[1]);
10072 0 : if (EXPR_P (_r1))
10073 0 : goto next_after_fail1744;
10074 0 : res_op1 = _r1;
10075 : }
10076 0 : tree res_op2;
10077 0 : {
10078 0 : tree _o1[2], _r1;
10079 0 : _o1[0] = captures[0];
10080 0 : _o1[1] = captures[4];
10081 0 : _r1 = fold_build2_loc (loc, ORDERED_EXPR, type, _o1[0], _o1[1]);
10082 0 : if (EXPR_P (_r1))
10083 0 : goto next_after_fail1744;
10084 0 : res_op2 = _r1;
10085 : }
10086 0 : tree _r;
10087 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10088 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
10089 0 : return _r;
10090 : }
10091 0 : next_after_fail1744:;
10092 : }
10093 : }
10094 0 : break;
10095 : }
10096 190995 : default:;
10097 : }
10098 190995 : switch (TREE_CODE (_p0))
10099 : {
10100 0 : case FLOAT_EXPR:
10101 0 : {
10102 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10103 0 : switch (TREE_CODE (_p1))
10104 : {
10105 0 : case FLOAT_EXPR:
10106 0 : {
10107 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10108 0 : {
10109 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
10110 0 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, ORDERED_EXPR, ORDERED_EXPR);
10111 0 : if (res) return res;
10112 : }
10113 0 : break;
10114 : }
10115 : default:;
10116 : }
10117 : break;
10118 : }
10119 0 : case NEGATE_EXPR:
10120 0 : {
10121 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10122 0 : switch (TREE_CODE (_p1))
10123 : {
10124 0 : case NEGATE_EXPR:
10125 0 : {
10126 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10127 0 : {
10128 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
10129 0 : tree res = generic_simplify_262 (loc, type, _p0, _p1, captures, ORDERED_EXPR, ORDERED_EXPR);
10130 0 : if (res) return res;
10131 : }
10132 0 : break;
10133 : }
10134 0 : default:;
10135 : }
10136 0 : if (CONSTANT_CLASS_P (_p1))
10137 : {
10138 0 : {
10139 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
10140 0 : tree res = generic_simplify_263 (loc, type, _p0, _p1, captures, ORDERED_EXPR, ORDERED_EXPR);
10141 0 : if (res) return res;
10142 : }
10143 : }
10144 : break;
10145 : }
10146 190995 : default:;
10147 : }
10148 190995 : switch (TREE_CODE (_p1))
10149 : {
10150 102 : case REAL_CST:
10151 102 : {
10152 102 : {
10153 102 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
10154 102 : tree res = generic_simplify_549 (loc, type, _p0, _p1, captures, ORDERED_EXPR);
10155 102 : if (res) return res;
10156 : }
10157 102 : break;
10158 : }
10159 190995 : default:;
10160 : }
10161 190995 : {
10162 190995 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
10163 190995 : if (tree_expr_nan_p (captures[0]) || tree_expr_nan_p (captures[1])
10164 : )
10165 : {
10166 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1745;
10167 0 : {
10168 0 : tree _r;
10169 0 : _r = constant_boolean_node (false, type);
10170 0 : if (TREE_SIDE_EFFECTS (captures[0]))
10171 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
10172 0 : if (TREE_SIDE_EFFECTS (captures[1]))
10173 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
10174 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1018, __FILE__, __LINE__, true);
10175 0 : return _r;
10176 : }
10177 0 : next_after_fail1745:;
10178 : }
10179 : else
10180 : {
10181 190995 : if (!tree_expr_maybe_nan_p (captures[0]) && !tree_expr_maybe_nan_p (captures[1])
10182 : )
10183 : {
10184 10 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1746;
10185 10 : {
10186 10 : tree _r;
10187 10 : _r = constant_boolean_node (true, type);
10188 10 : if (TREE_SIDE_EFFECTS (captures[0]))
10189 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
10190 10 : if (TREE_SIDE_EFFECTS (captures[1]))
10191 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
10192 10 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1019, __FILE__, __LINE__, true);
10193 10 : return _r;
10194 : }
10195 0 : next_after_fail1746:;
10196 : }
10197 : }
10198 : }
10199 190985 : return NULL_TREE;
10200 : }
10201 :
10202 : tree
10203 839503 : generic_simplify_UNLE_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
10204 : {
10205 839503 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10206 839503 : switch (TREE_CODE (_p0))
10207 : {
10208 0 : case VEC_COND_EXPR:
10209 0 : {
10210 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10211 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10212 0 : tree _q22 = TREE_OPERAND (_p0, 2);
10213 0 : switch (TREE_CODE (_p1))
10214 : {
10215 0 : case VEC_COND_EXPR:
10216 0 : {
10217 0 : tree _q60 = TREE_OPERAND (_p1, 0);
10218 0 : tree _q61 = TREE_OPERAND (_p1, 1);
10219 0 : tree _q62 = TREE_OPERAND (_p1, 2);
10220 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
10221 : {
10222 0 : {
10223 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
10224 0 : if (VECTOR_TYPE_P (type)
10225 0 : && (TREE_CODE_CLASS (UNLE_EXPR) != tcc_comparison
10226 0 : || types_match (type, TREE_TYPE (captures[2]))
10227 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10228 : || (optimize_vectors_before_lowering_p ()
10229 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10230 : )
10231 : {
10232 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1750;
10233 0 : {
10234 0 : tree res_op0;
10235 0 : res_op0 = captures[1];
10236 0 : tree res_op1;
10237 0 : {
10238 0 : tree _o1[2], _r1;
10239 0 : _o1[0] = captures[2];
10240 0 : _o1[1] = captures[5];
10241 0 : _r1 = fold_build2_loc (loc, UNLE_EXPR, type, _o1[0], _o1[1]);
10242 0 : if (EXPR_P (_r1))
10243 0 : goto next_after_fail1750;
10244 0 : res_op1 = _r1;
10245 : }
10246 0 : tree res_op2;
10247 0 : {
10248 0 : tree _o1[2], _r1;
10249 0 : _o1[0] = captures[3];
10250 0 : _o1[1] = captures[6];
10251 0 : _r1 = fold_build2_loc (loc, UNLE_EXPR, type, _o1[0], _o1[1]);
10252 0 : if (EXPR_P (_r1))
10253 0 : goto next_after_fail1750;
10254 0 : res_op2 = _r1;
10255 : }
10256 0 : tree _r;
10257 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10258 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
10259 0 : return _r;
10260 : }
10261 0 : next_after_fail1750:;
10262 : }
10263 : }
10264 : }
10265 : break;
10266 : }
10267 0 : default:;
10268 : }
10269 0 : {
10270 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
10271 0 : if (VECTOR_TYPE_P (type)
10272 0 : && (TREE_CODE_CLASS (UNLE_EXPR) != tcc_comparison
10273 0 : || types_match (type, TREE_TYPE (captures[2]))
10274 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10275 : || (optimize_vectors_before_lowering_p ()
10276 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10277 : )
10278 : {
10279 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1751;
10280 0 : {
10281 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1751;
10282 0 : tree res_op0;
10283 0 : res_op0 = captures[1];
10284 0 : tree res_op1;
10285 0 : {
10286 0 : tree _o1[2], _r1;
10287 0 : _o1[0] = captures[2];
10288 0 : _o1[1] = unshare_expr (captures[4]);
10289 0 : _r1 = fold_build2_loc (loc, UNLE_EXPR, type, _o1[0], _o1[1]);
10290 0 : if (EXPR_P (_r1))
10291 0 : goto next_after_fail1751;
10292 0 : res_op1 = _r1;
10293 : }
10294 0 : tree res_op2;
10295 0 : {
10296 0 : tree _o1[2], _r1;
10297 0 : _o1[0] = captures[3];
10298 0 : _o1[1] = captures[4];
10299 0 : _r1 = fold_build2_loc (loc, UNLE_EXPR, type, _o1[0], _o1[1]);
10300 0 : if (EXPR_P (_r1))
10301 0 : goto next_after_fail1751;
10302 0 : res_op2 = _r1;
10303 : }
10304 0 : tree _r;
10305 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10306 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
10307 0 : return _r;
10308 : }
10309 0 : next_after_fail1751:;
10310 : }
10311 : }
10312 0 : break;
10313 : }
10314 839503 : default:;
10315 : }
10316 839503 : switch (TREE_CODE (_p1))
10317 : {
10318 0 : case VEC_COND_EXPR:
10319 0 : {
10320 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10321 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10322 0 : tree _q32 = TREE_OPERAND (_p1, 2);
10323 0 : {
10324 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
10325 0 : if (VECTOR_TYPE_P (type)
10326 0 : && (TREE_CODE_CLASS (UNLE_EXPR) != tcc_comparison
10327 0 : || types_match (type, TREE_TYPE (captures[3]))
10328 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
10329 : || (optimize_vectors_before_lowering_p ()
10330 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
10331 : )
10332 : {
10333 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1752;
10334 0 : {
10335 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1752;
10336 0 : tree res_op0;
10337 0 : res_op0 = captures[2];
10338 0 : tree res_op1;
10339 0 : {
10340 0 : tree _o1[2], _r1;
10341 0 : _o1[0] = unshare_expr (captures[0]);
10342 0 : _o1[1] = captures[3];
10343 0 : _r1 = fold_build2_loc (loc, UNLE_EXPR, type, _o1[0], _o1[1]);
10344 0 : if (EXPR_P (_r1))
10345 0 : goto next_after_fail1752;
10346 0 : res_op1 = _r1;
10347 : }
10348 0 : tree res_op2;
10349 0 : {
10350 0 : tree _o1[2], _r1;
10351 0 : _o1[0] = captures[0];
10352 0 : _o1[1] = captures[4];
10353 0 : _r1 = fold_build2_loc (loc, UNLE_EXPR, type, _o1[0], _o1[1]);
10354 0 : if (EXPR_P (_r1))
10355 0 : goto next_after_fail1752;
10356 0 : res_op2 = _r1;
10357 : }
10358 0 : tree _r;
10359 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10360 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
10361 0 : return _r;
10362 : }
10363 0 : next_after_fail1752:;
10364 : }
10365 : }
10366 0 : break;
10367 : }
10368 839503 : default:;
10369 : }
10370 839503 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
10371 : {
10372 30 : {
10373 30 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10374 30 : tree res = generic_simplify_551 (loc, type, _p0, _p1, captures, UNLE_EXPR);
10375 30 : if (res) return res;
10376 : }
10377 : }
10378 839473 : switch (TREE_CODE (_p0))
10379 : {
10380 96 : case FLOAT_EXPR:
10381 96 : {
10382 96 : tree _q20 = TREE_OPERAND (_p0, 0);
10383 96 : switch (TREE_CODE (_p1))
10384 : {
10385 0 : case FLOAT_EXPR:
10386 0 : {
10387 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10388 0 : {
10389 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
10390 0 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, UNLE_EXPR, LE_EXPR);
10391 0 : if (res) return res;
10392 : }
10393 0 : break;
10394 : }
10395 : default:;
10396 : }
10397 : break;
10398 : }
10399 112 : case NEGATE_EXPR:
10400 112 : {
10401 112 : tree _q20 = TREE_OPERAND (_p0, 0);
10402 112 : switch (TREE_CODE (_p1))
10403 : {
10404 0 : case NEGATE_EXPR:
10405 0 : {
10406 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10407 0 : {
10408 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
10409 0 : tree res = generic_simplify_262 (loc, type, _p0, _p1, captures, UNLE_EXPR, UNGE_EXPR);
10410 0 : if (res) return res;
10411 : }
10412 0 : break;
10413 : }
10414 112 : default:;
10415 : }
10416 112 : if (CONSTANT_CLASS_P (_p1))
10417 : {
10418 112 : {
10419 112 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
10420 112 : tree res = generic_simplify_263 (loc, type, _p0, _p1, captures, UNLE_EXPR, UNGE_EXPR);
10421 112 : if (res) return res;
10422 : }
10423 : }
10424 : break;
10425 : }
10426 839361 : default:;
10427 : }
10428 839361 : switch (TREE_CODE (_p1))
10429 : {
10430 489521 : case REAL_CST:
10431 489521 : {
10432 489521 : {
10433 489521 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
10434 489521 : tree res = generic_simplify_549 (loc, type, _p0, _p1, captures, UNLE_EXPR);
10435 489521 : if (res) return res;
10436 : }
10437 489519 : break;
10438 : }
10439 : default:;
10440 : }
10441 : return NULL_TREE;
10442 : }
10443 :
10444 : tree
10445 3951935 : generic_simplify_TRUTH_ORIF_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
10446 : {
10447 3951935 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10448 3951935 : switch (TREE_CODE (_p0))
10449 : {
10450 377276 : case LE_EXPR:
10451 377276 : {
10452 377276 : tree _q20 = TREE_OPERAND (_p0, 0);
10453 377276 : tree _q21 = TREE_OPERAND (_p0, 1);
10454 377276 : switch (TREE_CODE (_q20))
10455 : {
10456 90 : case POINTER_PLUS_EXPR:
10457 90 : {
10458 90 : tree _q30 = TREE_OPERAND (_q20, 0);
10459 90 : tree _q31 = TREE_OPERAND (_q20, 1);
10460 90 : switch (TREE_CODE (_q31))
10461 : {
10462 2 : case INTEGER_CST:
10463 2 : {
10464 2 : switch (TREE_CODE (_p1))
10465 : {
10466 2 : case LE_EXPR:
10467 2 : {
10468 2 : tree _q70 = TREE_OPERAND (_p1, 0);
10469 2 : tree _q71 = TREE_OPERAND (_p1, 1);
10470 2 : switch (TREE_CODE (_q70))
10471 : {
10472 2 : case POINTER_PLUS_EXPR:
10473 2 : {
10474 2 : tree _q80 = TREE_OPERAND (_q70, 0);
10475 2 : tree _q81 = TREE_OPERAND (_q70, 1);
10476 2 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
10477 : {
10478 2 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
10479 : {
10480 2 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
10481 : {
10482 2 : {
10483 2 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70 };
10484 2 : const enum tree_code cmp = LE_EXPR;
10485 2 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
10486 1 : && TYPE_OVERFLOW_WRAPS (sizetype)
10487 3 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
10488 : )
10489 : {
10490 1 : {
10491 1 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
10492 1 : offset_int rhs = off * 2;
10493 1 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
10494 : )
10495 : {
10496 1 : {
10497 1 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
10498 1 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
10499 1 : if (cmp == LT_EXPR
10500 : )
10501 : {
10502 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1766;
10503 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1766;
10504 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1766;
10505 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1766;
10506 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1766;
10507 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1766;
10508 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1766;
10509 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1766;
10510 : {
10511 : tree res_op0;
10512 : {
10513 : tree _o1[1], _r1;
10514 : {
10515 : tree _o2[2], _r2;
10516 : _o2[0] = swap_p ? captures[6] : captures[1];
10517 : _o2[1] = swap_p ? captures[2] : captures[4];
10518 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10519 : _o1[0] = _r2;
10520 : }
10521 : if (TREE_TYPE (_o1[0]) != sizetype)
10522 : {
10523 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10524 : }
10525 : else
10526 : _r1 = _o1[0];
10527 : res_op0 = _r1;
10528 : }
10529 : tree res_op1;
10530 : res_op1 = rhs_tree;
10531 : tree _r;
10532 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10533 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 922, __FILE__, __LINE__, true);
10534 1 : return _r;
10535 : }
10536 : next_after_fail1766:;
10537 : }
10538 : else
10539 : {
10540 1 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1767;
10541 1 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1767;
10542 1 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1767;
10543 1 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1767;
10544 1 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1767;
10545 1 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1767;
10546 1 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1767;
10547 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1767;
10548 1 : {
10549 1 : tree res_op0;
10550 1 : {
10551 1 : tree _o1[1], _r1;
10552 1 : {
10553 1 : tree _o2[2], _r2;
10554 1 : {
10555 1 : tree _o3[2], _r3;
10556 1 : _o3[0] = swap_p ? captures[4] : captures[2];
10557 1 : _o3[1] = wide_int_to_tree (sizetype, off);
10558 1 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
10559 1 : _o2[0] = _r3;
10560 : }
10561 1 : _o2[1] = swap_p ? captures[2] : captures[4];
10562 1 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10563 1 : _o1[0] = _r2;
10564 : }
10565 1 : if (TREE_TYPE (_o1[0]) != sizetype)
10566 : {
10567 1 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10568 : }
10569 : else
10570 : _r1 = _o1[0];
10571 1 : res_op0 = _r1;
10572 : }
10573 1 : tree res_op1;
10574 1 : res_op1 = rhs_tree;
10575 1 : tree _r;
10576 1 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10577 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 923, __FILE__, __LINE__, true);
10578 1 : return _r;
10579 : }
10580 0 : next_after_fail1767:;
10581 : }
10582 : }
10583 : }
10584 : }
10585 : }
10586 : }
10587 : }
10588 : }
10589 : }
10590 : break;
10591 : }
10592 : default:;
10593 : }
10594 : break;
10595 : }
10596 0 : case GE_EXPR:
10597 0 : {
10598 0 : tree _q70 = TREE_OPERAND (_p1, 0);
10599 0 : tree _q71 = TREE_OPERAND (_p1, 1);
10600 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
10601 : {
10602 0 : switch (TREE_CODE (_q71))
10603 : {
10604 0 : case POINTER_PLUS_EXPR:
10605 0 : {
10606 0 : tree _q90 = TREE_OPERAND (_q71, 0);
10607 0 : tree _q91 = TREE_OPERAND (_q71, 1);
10608 0 : if ((_q90 == _q21 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q21, 0) && types_match (_q90, _q21)))
10609 : {
10610 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
10611 : {
10612 0 : {
10613 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q71 };
10614 0 : const enum tree_code cmp = LE_EXPR;
10615 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
10616 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
10617 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
10618 : )
10619 : {
10620 0 : {
10621 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
10622 0 : offset_int rhs = off * 2;
10623 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
10624 : )
10625 : {
10626 0 : {
10627 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
10628 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
10629 0 : if (cmp == LT_EXPR
10630 : )
10631 : {
10632 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1768;
10633 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1768;
10634 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1768;
10635 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1768;
10636 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1768;
10637 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1768;
10638 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1768;
10639 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1768;
10640 : {
10641 : tree res_op0;
10642 : {
10643 : tree _o1[1], _r1;
10644 : {
10645 : tree _o2[2], _r2;
10646 : _o2[0] = swap_p ? captures[6] : captures[1];
10647 : _o2[1] = swap_p ? captures[2] : captures[4];
10648 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10649 : _o1[0] = _r2;
10650 : }
10651 : if (TREE_TYPE (_o1[0]) != sizetype)
10652 : {
10653 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10654 : }
10655 : else
10656 : _r1 = _o1[0];
10657 : res_op0 = _r1;
10658 : }
10659 : tree res_op1;
10660 : res_op1 = rhs_tree;
10661 : tree _r;
10662 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10663 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 922, __FILE__, __LINE__, true);
10664 0 : return _r;
10665 : }
10666 : next_after_fail1768:;
10667 : }
10668 : else
10669 : {
10670 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1769;
10671 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1769;
10672 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1769;
10673 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1769;
10674 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1769;
10675 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1769;
10676 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1769;
10677 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1769;
10678 0 : {
10679 0 : tree res_op0;
10680 0 : {
10681 0 : tree _o1[1], _r1;
10682 0 : {
10683 0 : tree _o2[2], _r2;
10684 0 : {
10685 0 : tree _o3[2], _r3;
10686 0 : _o3[0] = swap_p ? captures[4] : captures[2];
10687 0 : _o3[1] = wide_int_to_tree (sizetype, off);
10688 0 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
10689 0 : _o2[0] = _r3;
10690 : }
10691 0 : _o2[1] = swap_p ? captures[2] : captures[4];
10692 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10693 0 : _o1[0] = _r2;
10694 : }
10695 0 : if (TREE_TYPE (_o1[0]) != sizetype)
10696 : {
10697 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10698 : }
10699 : else
10700 : _r1 = _o1[0];
10701 0 : res_op0 = _r1;
10702 : }
10703 0 : tree res_op1;
10704 0 : res_op1 = rhs_tree;
10705 0 : tree _r;
10706 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10707 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 923, __FILE__, __LINE__, true);
10708 0 : return _r;
10709 : }
10710 0 : next_after_fail1769:;
10711 : }
10712 : }
10713 : }
10714 : }
10715 : }
10716 : }
10717 : }
10718 : }
10719 : break;
10720 : }
10721 : default:;
10722 : }
10723 : }
10724 : break;
10725 : }
10726 : default:;
10727 : }
10728 : break;
10729 : }
10730 : default:;
10731 : }
10732 : break;
10733 : }
10734 : default:;
10735 : }
10736 : break;
10737 : }
10738 759396 : case LT_EXPR:
10739 759396 : {
10740 759396 : tree _q20 = TREE_OPERAND (_p0, 0);
10741 759396 : tree _q21 = TREE_OPERAND (_p0, 1);
10742 759396 : switch (TREE_CODE (_q20))
10743 : {
10744 13 : case POINTER_PLUS_EXPR:
10745 13 : {
10746 13 : tree _q30 = TREE_OPERAND (_q20, 0);
10747 13 : tree _q31 = TREE_OPERAND (_q20, 1);
10748 13 : switch (TREE_CODE (_q31))
10749 : {
10750 7 : case INTEGER_CST:
10751 7 : {
10752 7 : switch (TREE_CODE (_p1))
10753 : {
10754 2 : case LT_EXPR:
10755 2 : {
10756 2 : tree _q70 = TREE_OPERAND (_p1, 0);
10757 2 : tree _q71 = TREE_OPERAND (_p1, 1);
10758 2 : switch (TREE_CODE (_q70))
10759 : {
10760 2 : case POINTER_PLUS_EXPR:
10761 2 : {
10762 2 : tree _q80 = TREE_OPERAND (_q70, 0);
10763 2 : tree _q81 = TREE_OPERAND (_q70, 1);
10764 2 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
10765 : {
10766 2 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
10767 : {
10768 2 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
10769 : {
10770 2 : {
10771 2 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70 };
10772 2 : const enum tree_code cmp = LT_EXPR;
10773 2 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
10774 1 : && TYPE_OVERFLOW_WRAPS (sizetype)
10775 3 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
10776 : )
10777 : {
10778 1 : {
10779 1 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
10780 1 : offset_int rhs = off * 2;
10781 1 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
10782 : )
10783 : {
10784 1 : {
10785 1 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
10786 1 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
10787 1 : if (cmp == LT_EXPR
10788 : )
10789 : {
10790 1 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1770;
10791 1 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1770;
10792 1 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1770;
10793 1 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1770;
10794 1 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1770;
10795 1 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1770;
10796 1 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1770;
10797 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1770;
10798 1 : {
10799 1 : tree res_op0;
10800 1 : {
10801 1 : tree _o1[1], _r1;
10802 1 : {
10803 1 : tree _o2[2], _r2;
10804 1 : _o2[0] = swap_p ? captures[6] : captures[1];
10805 1 : _o2[1] = swap_p ? captures[2] : captures[4];
10806 1 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10807 1 : _o1[0] = _r2;
10808 : }
10809 1 : if (TREE_TYPE (_o1[0]) != sizetype)
10810 : {
10811 1 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10812 : }
10813 : else
10814 : _r1 = _o1[0];
10815 1 : res_op0 = _r1;
10816 : }
10817 1 : tree res_op1;
10818 1 : res_op1 = rhs_tree;
10819 1 : tree _r;
10820 1 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10821 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 922, __FILE__, __LINE__, true);
10822 1 : return _r;
10823 : }
10824 0 : next_after_fail1770:;
10825 : }
10826 : else
10827 : {
10828 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1771;
10829 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1771;
10830 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1771;
10831 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1771;
10832 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1771;
10833 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1771;
10834 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1771;
10835 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1771;
10836 : {
10837 : tree res_op0;
10838 : {
10839 : tree _o1[1], _r1;
10840 : {
10841 : tree _o2[2], _r2;
10842 : {
10843 : tree _o3[2], _r3;
10844 : _o3[0] = swap_p ? captures[4] : captures[2];
10845 : _o3[1] = wide_int_to_tree (sizetype, off);
10846 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
10847 : _o2[0] = _r3;
10848 : }
10849 : _o2[1] = swap_p ? captures[2] : captures[4];
10850 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10851 : _o1[0] = _r2;
10852 : }
10853 : if (TREE_TYPE (_o1[0]) != sizetype)
10854 : {
10855 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10856 : }
10857 : else
10858 : _r1 = _o1[0];
10859 : res_op0 = _r1;
10860 : }
10861 : tree res_op1;
10862 : res_op1 = rhs_tree;
10863 : tree _r;
10864 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10865 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 923, __FILE__, __LINE__, true);
10866 : return _r;
10867 : }
10868 : next_after_fail1771:;
10869 : }
10870 : }
10871 : }
10872 : }
10873 : }
10874 : }
10875 : }
10876 : }
10877 : }
10878 : break;
10879 : }
10880 : default:;
10881 : }
10882 : break;
10883 : }
10884 0 : case GT_EXPR:
10885 0 : {
10886 0 : tree _q70 = TREE_OPERAND (_p1, 0);
10887 0 : tree _q71 = TREE_OPERAND (_p1, 1);
10888 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
10889 : {
10890 0 : switch (TREE_CODE (_q71))
10891 : {
10892 0 : case POINTER_PLUS_EXPR:
10893 0 : {
10894 0 : tree _q90 = TREE_OPERAND (_q71, 0);
10895 0 : tree _q91 = TREE_OPERAND (_q71, 1);
10896 0 : if ((_q90 == _q21 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q21, 0) && types_match (_q90, _q21)))
10897 : {
10898 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
10899 : {
10900 0 : {
10901 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q71 };
10902 0 : const enum tree_code cmp = LT_EXPR;
10903 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
10904 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
10905 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
10906 : )
10907 : {
10908 0 : {
10909 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
10910 0 : offset_int rhs = off * 2;
10911 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
10912 : )
10913 : {
10914 0 : {
10915 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
10916 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
10917 0 : if (cmp == LT_EXPR
10918 : )
10919 : {
10920 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1772;
10921 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1772;
10922 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1772;
10923 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1772;
10924 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1772;
10925 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1772;
10926 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1772;
10927 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1772;
10928 0 : {
10929 0 : tree res_op0;
10930 0 : {
10931 0 : tree _o1[1], _r1;
10932 0 : {
10933 0 : tree _o2[2], _r2;
10934 0 : _o2[0] = swap_p ? captures[6] : captures[1];
10935 0 : _o2[1] = swap_p ? captures[2] : captures[4];
10936 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10937 0 : _o1[0] = _r2;
10938 : }
10939 0 : if (TREE_TYPE (_o1[0]) != sizetype)
10940 : {
10941 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10942 : }
10943 : else
10944 : _r1 = _o1[0];
10945 0 : res_op0 = _r1;
10946 : }
10947 0 : tree res_op1;
10948 0 : res_op1 = rhs_tree;
10949 0 : tree _r;
10950 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10951 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 922, __FILE__, __LINE__, true);
10952 0 : return _r;
10953 : }
10954 0 : next_after_fail1772:;
10955 : }
10956 : else
10957 : {
10958 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1773;
10959 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1773;
10960 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1773;
10961 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1773;
10962 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1773;
10963 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1773;
10964 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1773;
10965 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1773;
10966 : {
10967 : tree res_op0;
10968 : {
10969 : tree _o1[1], _r1;
10970 : {
10971 : tree _o2[2], _r2;
10972 : {
10973 : tree _o3[2], _r3;
10974 : _o3[0] = swap_p ? captures[4] : captures[2];
10975 : _o3[1] = wide_int_to_tree (sizetype, off);
10976 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
10977 : _o2[0] = _r3;
10978 : }
10979 : _o2[1] = swap_p ? captures[2] : captures[4];
10980 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10981 : _o1[0] = _r2;
10982 : }
10983 : if (TREE_TYPE (_o1[0]) != sizetype)
10984 : {
10985 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10986 : }
10987 : else
10988 : _r1 = _o1[0];
10989 : res_op0 = _r1;
10990 : }
10991 : tree res_op1;
10992 : res_op1 = rhs_tree;
10993 : tree _r;
10994 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10995 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 923, __FILE__, __LINE__, true);
10996 : return _r;
10997 : }
10998 : next_after_fail1773:;
10999 : }
11000 : }
11001 : }
11002 : }
11003 : }
11004 : }
11005 : }
11006 : }
11007 : break;
11008 : }
11009 : default:;
11010 : }
11011 : }
11012 : break;
11013 : }
11014 : default:;
11015 : }
11016 : break;
11017 : }
11018 : default:;
11019 : }
11020 : break;
11021 : }
11022 : default:;
11023 : }
11024 : break;
11025 : }
11026 67544 : case GE_EXPR:
11027 67544 : {
11028 67544 : tree _q20 = TREE_OPERAND (_p0, 0);
11029 67544 : tree _q21 = TREE_OPERAND (_p0, 1);
11030 67544 : switch (TREE_CODE (_q21))
11031 : {
11032 0 : case POINTER_PLUS_EXPR:
11033 0 : {
11034 0 : tree _q40 = TREE_OPERAND (_q21, 0);
11035 0 : tree _q41 = TREE_OPERAND (_q21, 1);
11036 0 : switch (TREE_CODE (_q41))
11037 : {
11038 0 : case INTEGER_CST:
11039 0 : {
11040 0 : switch (TREE_CODE (_p1))
11041 : {
11042 0 : case LE_EXPR:
11043 0 : {
11044 0 : tree _q70 = TREE_OPERAND (_p1, 0);
11045 0 : tree _q71 = TREE_OPERAND (_p1, 1);
11046 0 : switch (TREE_CODE (_q70))
11047 : {
11048 0 : case POINTER_PLUS_EXPR:
11049 0 : {
11050 0 : tree _q80 = TREE_OPERAND (_q70, 0);
11051 0 : tree _q81 = TREE_OPERAND (_q70, 1);
11052 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
11053 : {
11054 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
11055 : {
11056 0 : if ((_q71 == _q40 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q40, 0) && types_match (_q71, _q40)))
11057 : {
11058 0 : {
11059 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q70 };
11060 0 : const enum tree_code cmp = LE_EXPR;
11061 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11062 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
11063 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11064 : )
11065 : {
11066 0 : {
11067 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11068 0 : offset_int rhs = off * 2;
11069 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11070 : )
11071 : {
11072 0 : {
11073 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11074 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11075 0 : if (cmp == LT_EXPR
11076 : )
11077 : {
11078 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1774;
11079 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1774;
11080 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1774;
11081 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1774;
11082 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1774;
11083 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1774;
11084 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1774;
11085 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1774;
11086 : {
11087 : tree res_op0;
11088 : {
11089 : tree _o1[1], _r1;
11090 : {
11091 : tree _o2[2], _r2;
11092 : _o2[0] = swap_p ? captures[6] : captures[1];
11093 : _o2[1] = swap_p ? captures[2] : captures[4];
11094 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11095 : _o1[0] = _r2;
11096 : }
11097 : if (TREE_TYPE (_o1[0]) != sizetype)
11098 : {
11099 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11100 : }
11101 : else
11102 : _r1 = _o1[0];
11103 : res_op0 = _r1;
11104 : }
11105 : tree res_op1;
11106 : res_op1 = rhs_tree;
11107 : tree _r;
11108 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11109 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 922, __FILE__, __LINE__, true);
11110 0 : return _r;
11111 : }
11112 : next_after_fail1774:;
11113 : }
11114 : else
11115 : {
11116 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1775;
11117 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1775;
11118 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1775;
11119 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1775;
11120 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1775;
11121 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1775;
11122 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1775;
11123 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1775;
11124 0 : {
11125 0 : tree res_op0;
11126 0 : {
11127 0 : tree _o1[1], _r1;
11128 0 : {
11129 0 : tree _o2[2], _r2;
11130 0 : {
11131 0 : tree _o3[2], _r3;
11132 0 : _o3[0] = swap_p ? captures[4] : captures[2];
11133 0 : _o3[1] = wide_int_to_tree (sizetype, off);
11134 0 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11135 0 : _o2[0] = _r3;
11136 : }
11137 0 : _o2[1] = swap_p ? captures[2] : captures[4];
11138 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11139 0 : _o1[0] = _r2;
11140 : }
11141 0 : if (TREE_TYPE (_o1[0]) != sizetype)
11142 : {
11143 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11144 : }
11145 : else
11146 : _r1 = _o1[0];
11147 0 : res_op0 = _r1;
11148 : }
11149 0 : tree res_op1;
11150 0 : res_op1 = rhs_tree;
11151 0 : tree _r;
11152 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11153 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 923, __FILE__, __LINE__, true);
11154 0 : return _r;
11155 : }
11156 0 : next_after_fail1775:;
11157 : }
11158 : }
11159 : }
11160 : }
11161 : }
11162 : }
11163 : }
11164 : }
11165 : }
11166 : break;
11167 : }
11168 : default:;
11169 : }
11170 : break;
11171 : }
11172 0 : case GE_EXPR:
11173 0 : {
11174 0 : tree _q70 = TREE_OPERAND (_p1, 0);
11175 0 : tree _q71 = TREE_OPERAND (_p1, 1);
11176 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
11177 : {
11178 0 : switch (TREE_CODE (_q71))
11179 : {
11180 0 : case POINTER_PLUS_EXPR:
11181 0 : {
11182 0 : tree _q90 = TREE_OPERAND (_q71, 0);
11183 0 : tree _q91 = TREE_OPERAND (_q71, 1);
11184 0 : if ((_q90 == _q20 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q20, 0) && types_match (_q90, _q20)))
11185 : {
11186 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
11187 : {
11188 0 : {
11189 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q71 };
11190 0 : const enum tree_code cmp = LE_EXPR;
11191 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11192 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
11193 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11194 : )
11195 : {
11196 0 : {
11197 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11198 0 : offset_int rhs = off * 2;
11199 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11200 : )
11201 : {
11202 0 : {
11203 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11204 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11205 0 : if (cmp == LT_EXPR
11206 : )
11207 : {
11208 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1776;
11209 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1776;
11210 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1776;
11211 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1776;
11212 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1776;
11213 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1776;
11214 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1776;
11215 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1776;
11216 : {
11217 : tree res_op0;
11218 : {
11219 : tree _o1[1], _r1;
11220 : {
11221 : tree _o2[2], _r2;
11222 : _o2[0] = swap_p ? captures[6] : captures[1];
11223 : _o2[1] = swap_p ? captures[2] : captures[4];
11224 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11225 : _o1[0] = _r2;
11226 : }
11227 : if (TREE_TYPE (_o1[0]) != sizetype)
11228 : {
11229 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11230 : }
11231 : else
11232 : _r1 = _o1[0];
11233 : res_op0 = _r1;
11234 : }
11235 : tree res_op1;
11236 : res_op1 = rhs_tree;
11237 : tree _r;
11238 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11239 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 922, __FILE__, __LINE__, true);
11240 0 : return _r;
11241 : }
11242 : next_after_fail1776:;
11243 : }
11244 : else
11245 : {
11246 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1777;
11247 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1777;
11248 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1777;
11249 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1777;
11250 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1777;
11251 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1777;
11252 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1777;
11253 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1777;
11254 0 : {
11255 0 : tree res_op0;
11256 0 : {
11257 0 : tree _o1[1], _r1;
11258 0 : {
11259 0 : tree _o2[2], _r2;
11260 0 : {
11261 0 : tree _o3[2], _r3;
11262 0 : _o3[0] = swap_p ? captures[4] : captures[2];
11263 0 : _o3[1] = wide_int_to_tree (sizetype, off);
11264 0 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11265 0 : _o2[0] = _r3;
11266 : }
11267 0 : _o2[1] = swap_p ? captures[2] : captures[4];
11268 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11269 0 : _o1[0] = _r2;
11270 : }
11271 0 : if (TREE_TYPE (_o1[0]) != sizetype)
11272 : {
11273 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11274 : }
11275 : else
11276 : _r1 = _o1[0];
11277 0 : res_op0 = _r1;
11278 : }
11279 0 : tree res_op1;
11280 0 : res_op1 = rhs_tree;
11281 0 : tree _r;
11282 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11283 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 923, __FILE__, __LINE__, true);
11284 0 : return _r;
11285 : }
11286 0 : next_after_fail1777:;
11287 : }
11288 : }
11289 : }
11290 : }
11291 : }
11292 : }
11293 : }
11294 : }
11295 : break;
11296 : }
11297 : default:;
11298 : }
11299 : }
11300 : break;
11301 : }
11302 : default:;
11303 : }
11304 : break;
11305 : }
11306 : default:;
11307 : }
11308 : break;
11309 : }
11310 : default:;
11311 : }
11312 : break;
11313 : }
11314 68138 : case GT_EXPR:
11315 68138 : {
11316 68138 : tree _q20 = TREE_OPERAND (_p0, 0);
11317 68138 : tree _q21 = TREE_OPERAND (_p0, 1);
11318 68138 : switch (TREE_CODE (_q21))
11319 : {
11320 0 : case POINTER_PLUS_EXPR:
11321 0 : {
11322 0 : tree _q40 = TREE_OPERAND (_q21, 0);
11323 0 : tree _q41 = TREE_OPERAND (_q21, 1);
11324 0 : switch (TREE_CODE (_q41))
11325 : {
11326 0 : case INTEGER_CST:
11327 0 : {
11328 0 : switch (TREE_CODE (_p1))
11329 : {
11330 0 : case LT_EXPR:
11331 0 : {
11332 0 : tree _q70 = TREE_OPERAND (_p1, 0);
11333 0 : tree _q71 = TREE_OPERAND (_p1, 1);
11334 0 : switch (TREE_CODE (_q70))
11335 : {
11336 0 : case POINTER_PLUS_EXPR:
11337 0 : {
11338 0 : tree _q80 = TREE_OPERAND (_q70, 0);
11339 0 : tree _q81 = TREE_OPERAND (_q70, 1);
11340 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
11341 : {
11342 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
11343 : {
11344 0 : if ((_q71 == _q40 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q40, 0) && types_match (_q71, _q40)))
11345 : {
11346 0 : {
11347 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q70 };
11348 0 : const enum tree_code cmp = LT_EXPR;
11349 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11350 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
11351 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11352 : )
11353 : {
11354 0 : {
11355 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11356 0 : offset_int rhs = off * 2;
11357 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11358 : )
11359 : {
11360 0 : {
11361 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11362 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11363 0 : if (cmp == LT_EXPR
11364 : )
11365 : {
11366 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1778;
11367 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1778;
11368 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1778;
11369 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1778;
11370 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1778;
11371 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1778;
11372 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1778;
11373 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1778;
11374 0 : {
11375 0 : tree res_op0;
11376 0 : {
11377 0 : tree _o1[1], _r1;
11378 0 : {
11379 0 : tree _o2[2], _r2;
11380 0 : _o2[0] = swap_p ? captures[6] : captures[1];
11381 0 : _o2[1] = swap_p ? captures[2] : captures[4];
11382 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11383 0 : _o1[0] = _r2;
11384 : }
11385 0 : if (TREE_TYPE (_o1[0]) != sizetype)
11386 : {
11387 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11388 : }
11389 : else
11390 : _r1 = _o1[0];
11391 0 : res_op0 = _r1;
11392 : }
11393 0 : tree res_op1;
11394 0 : res_op1 = rhs_tree;
11395 0 : tree _r;
11396 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11397 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 922, __FILE__, __LINE__, true);
11398 0 : return _r;
11399 : }
11400 0 : next_after_fail1778:;
11401 : }
11402 : else
11403 : {
11404 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1779;
11405 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1779;
11406 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1779;
11407 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1779;
11408 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1779;
11409 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1779;
11410 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1779;
11411 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1779;
11412 : {
11413 : tree res_op0;
11414 : {
11415 : tree _o1[1], _r1;
11416 : {
11417 : tree _o2[2], _r2;
11418 : {
11419 : tree _o3[2], _r3;
11420 : _o3[0] = swap_p ? captures[4] : captures[2];
11421 : _o3[1] = wide_int_to_tree (sizetype, off);
11422 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11423 : _o2[0] = _r3;
11424 : }
11425 : _o2[1] = swap_p ? captures[2] : captures[4];
11426 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11427 : _o1[0] = _r2;
11428 : }
11429 : if (TREE_TYPE (_o1[0]) != sizetype)
11430 : {
11431 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11432 : }
11433 : else
11434 : _r1 = _o1[0];
11435 : res_op0 = _r1;
11436 : }
11437 : tree res_op1;
11438 : res_op1 = rhs_tree;
11439 : tree _r;
11440 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11441 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 923, __FILE__, __LINE__, true);
11442 : return _r;
11443 : }
11444 : next_after_fail1779:;
11445 : }
11446 : }
11447 : }
11448 : }
11449 : }
11450 : }
11451 : }
11452 : }
11453 : }
11454 : break;
11455 : }
11456 : default:;
11457 : }
11458 : break;
11459 : }
11460 0 : case GT_EXPR:
11461 0 : {
11462 0 : tree _q70 = TREE_OPERAND (_p1, 0);
11463 0 : tree _q71 = TREE_OPERAND (_p1, 1);
11464 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
11465 : {
11466 0 : switch (TREE_CODE (_q71))
11467 : {
11468 0 : case POINTER_PLUS_EXPR:
11469 0 : {
11470 0 : tree _q90 = TREE_OPERAND (_q71, 0);
11471 0 : tree _q91 = TREE_OPERAND (_q71, 1);
11472 0 : if ((_q90 == _q20 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q20, 0) && types_match (_q90, _q20)))
11473 : {
11474 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
11475 : {
11476 0 : {
11477 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q71 };
11478 0 : const enum tree_code cmp = LT_EXPR;
11479 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11480 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
11481 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11482 : )
11483 : {
11484 0 : {
11485 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11486 0 : offset_int rhs = off * 2;
11487 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11488 : )
11489 : {
11490 0 : {
11491 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11492 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11493 0 : if (cmp == LT_EXPR
11494 : )
11495 : {
11496 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1780;
11497 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1780;
11498 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1780;
11499 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1780;
11500 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1780;
11501 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1780;
11502 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1780;
11503 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1780;
11504 0 : {
11505 0 : tree res_op0;
11506 0 : {
11507 0 : tree _o1[1], _r1;
11508 0 : {
11509 0 : tree _o2[2], _r2;
11510 0 : _o2[0] = swap_p ? captures[6] : captures[1];
11511 0 : _o2[1] = swap_p ? captures[2] : captures[4];
11512 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11513 0 : _o1[0] = _r2;
11514 : }
11515 0 : if (TREE_TYPE (_o1[0]) != sizetype)
11516 : {
11517 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11518 : }
11519 : else
11520 : _r1 = _o1[0];
11521 0 : res_op0 = _r1;
11522 : }
11523 0 : tree res_op1;
11524 0 : res_op1 = rhs_tree;
11525 0 : tree _r;
11526 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11527 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 922, __FILE__, __LINE__, true);
11528 0 : return _r;
11529 : }
11530 0 : next_after_fail1780:;
11531 : }
11532 : else
11533 : {
11534 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1781;
11535 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1781;
11536 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1781;
11537 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1781;
11538 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1781;
11539 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1781;
11540 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1781;
11541 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1781;
11542 : {
11543 : tree res_op0;
11544 : {
11545 : tree _o1[1], _r1;
11546 : {
11547 : tree _o2[2], _r2;
11548 : {
11549 : tree _o3[2], _r3;
11550 : _o3[0] = swap_p ? captures[4] : captures[2];
11551 : _o3[1] = wide_int_to_tree (sizetype, off);
11552 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11553 : _o2[0] = _r3;
11554 : }
11555 : _o2[1] = swap_p ? captures[2] : captures[4];
11556 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11557 : _o1[0] = _r2;
11558 : }
11559 : if (TREE_TYPE (_o1[0]) != sizetype)
11560 : {
11561 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11562 : }
11563 : else
11564 : _r1 = _o1[0];
11565 : res_op0 = _r1;
11566 : }
11567 : tree res_op1;
11568 : res_op1 = rhs_tree;
11569 : tree _r;
11570 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11571 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 923, __FILE__, __LINE__, true);
11572 : return _r;
11573 : }
11574 : next_after_fail1781:;
11575 : }
11576 : }
11577 : }
11578 : }
11579 : }
11580 : }
11581 : }
11582 : }
11583 : break;
11584 : }
11585 : default:;
11586 : }
11587 : }
11588 : break;
11589 : }
11590 : default:;
11591 : }
11592 : break;
11593 : }
11594 : default:;
11595 : }
11596 : break;
11597 : }
11598 : default:;
11599 : }
11600 : break;
11601 : }
11602 : default:;
11603 : }
11604 : return NULL_TREE;
11605 : }
11606 : #pragma GCC diagnostic pop
|
