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 117519889 : tree_bit_not_with_nop (tree t, tree *res_ops)
11 : {
12 117519889 : const tree type = TREE_TYPE (t);
13 117519889 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 117519889 : if (TREE_SIDE_EFFECTS (t)) return false;
15 117519889 : switch (TREE_CODE (t))
16 : {
17 158467 : case BIT_NOT_EXPR:
18 158467 : {
19 158467 : tree _p0 = TREE_OPERAND (t, 0);
20 158467 : {
21 158467 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
22 158467 : {
23 158467 : res_ops[0] = captures[0];
24 158467 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 2, __FILE__, __LINE__, false);
25 : return true;
26 : }
27 : }
28 25474582 : break;
29 : }
30 25474582 : CASE_CONVERT:
31 25474582 : {
32 25474582 : tree _p0 = TREE_OPERAND (t, 0);
33 25474582 : switch (TREE_CODE (_p0))
34 : {
35 1126 : case BIT_NOT_EXPR:
36 1126 : {
37 1126 : tree _q20 = TREE_OPERAND (_p0, 0);
38 1126 : {
39 1126 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
40 1126 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
41 : )
42 : {
43 617 : {
44 617 : res_ops[0] = captures[0];
45 617 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 3, __FILE__, __LINE__, false);
46 617 : return true;
47 : }
48 : }
49 : }
50 : break;
51 : }
52 : default:;
53 : }
54 : break;
55 : }
56 : default:;
57 : }
58 : return false;
59 : }
60 :
61 : bool
62 86222481 : tree_with_known_nonzero_bits_1 (tree t)
63 : {
64 86222481 : const tree type = TREE_TYPE (t);
65 86222481 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
66 86222481 : if (TREE_SIDE_EFFECTS (t)) return false;
67 86222481 : switch (TREE_CODE (t))
68 : {
69 20658122 : case INTEGER_CST:
70 20658122 : {
71 20658122 : {
72 20658122 : tree captures[1] ATTRIBUTE_UNUSED = { t };
73 20658122 : {
74 20658122 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 37, __FILE__, __LINE__, false);
75 20658122 : return true;
76 : }
77 : }
78 27761126 : break;
79 : }
80 27761126 : case SSA_NAME:
81 27761126 : {
82 27761126 : {
83 27761126 : tree captures[1] ATTRIBUTE_UNUSED = { t };
84 27761126 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
85 : )
86 : {
87 19640934 : {
88 19640934 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 38, __FILE__, __LINE__, false);
89 19640934 : return true;
90 : }
91 : }
92 : }
93 : break;
94 : }
95 : default:;
96 : }
97 : return false;
98 : }
99 :
100 : bool
101 0 : tree_compositional_complex (tree t)
102 : {
103 0 : const tree type = TREE_TYPE (t);
104 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
105 0 : if (TREE_SIDE_EFFECTS (t)) return false;
106 0 : switch (TREE_CODE (t))
107 : {
108 0 : CASE_CONVERT:
109 0 : {
110 0 : tree _p0 = TREE_OPERAND (t, 0);
111 0 : switch (TREE_CODE (_p0))
112 : {
113 0 : case COMPLEX_EXPR:
114 0 : {
115 0 : tree _q20 = TREE_OPERAND (_p0, 0);
116 0 : tree _q21 = TREE_OPERAND (_p0, 1);
117 0 : {
118 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
119 0 : {
120 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 43, __FILE__, __LINE__, false);
121 0 : return true;
122 : }
123 : }
124 : break;
125 : }
126 : default:;
127 : }
128 : break;
129 : }
130 0 : case COMPLEX_EXPR:
131 0 : {
132 0 : tree _p0 = TREE_OPERAND (t, 0);
133 0 : tree _p1 = TREE_OPERAND (t, 1);
134 0 : {
135 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
136 0 : {
137 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 43, __FILE__, __LINE__, false);
138 0 : return true;
139 : }
140 : }
141 : break;
142 : }
143 : default:;
144 : }
145 : return false;
146 : }
147 :
148 : tree
149 0 : generic_simplify_10 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
150 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
151 : const enum tree_code ARG_UNUSED (bit_op))
152 : {
153 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
154 0 : if (bit_op == BIT_AND_EXPR
155 : )
156 : {
157 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail83;
158 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail83;
159 0 : {
160 0 : tree _r;
161 0 : _r = build_zero_cst (type);
162 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 58, __FILE__, __LINE__, true);
163 0 : return _r;
164 : }
165 : next_after_fail83:;
166 : }
167 : else
168 : {
169 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail84;
170 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail84;
171 0 : {
172 0 : tree _r;
173 0 : _r = build_minus_one_cst (type);
174 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 59, __FILE__, __LINE__, true);
175 0 : return _r;
176 : }
177 : next_after_fail84:;
178 : }
179 : return NULL_TREE;
180 : }
181 :
182 : tree
183 0 : generic_simplify_19 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
184 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
185 : const enum tree_code ARG_UNUSED (lop),
186 : const enum tree_code ARG_UNUSED (res))
187 : {
188 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
189 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail93;
190 0 : {
191 0 : tree res_op0;
192 0 : res_op0 = captures[0];
193 0 : tree res_op1;
194 0 : res_op1 = captures[1];
195 0 : tree _r;
196 0 : _r = fold_build2_loc (loc, res, type, res_op0, res_op1);
197 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 68, __FILE__, __LINE__, true);
198 : return _r;
199 : }
200 0 : next_after_fail93:;
201 0 : return NULL_TREE;
202 : }
203 :
204 : tree
205 113 : generic_simplify_27 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
206 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
207 : const enum tree_code ARG_UNUSED (opo),
208 : const enum tree_code ARG_UNUSED (opi))
209 : {
210 113 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
211 113 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail101;
212 113 : {
213 113 : tree res_op0;
214 113 : {
215 113 : tree _o1[1], _r1;
216 113 : _o1[0] = captures[1];
217 113 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
218 113 : res_op0 = _r1;
219 : }
220 113 : tree res_op1;
221 113 : res_op1 = captures[2];
222 113 : tree _r;
223 113 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
224 113 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 76, __FILE__, __LINE__, true);
225 : return _r;
226 : }
227 0 : next_after_fail101:;
228 0 : return NULL_TREE;
229 : }
230 :
231 : tree
232 599 : generic_simplify_33 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
233 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
234 : const enum tree_code ARG_UNUSED (bitop))
235 : {
236 599 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
237 599 : if (!CONSTANT_CLASS_P (captures[0])
238 : )
239 : {
240 599 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail107;
241 599 : {
242 599 : tree res_op0;
243 599 : res_op0 = captures[0];
244 599 : tree res_op1;
245 599 : {
246 599 : tree _o1[2], _r1;
247 599 : _o1[0] = captures[1];
248 599 : _o1[1] = captures[2];
249 599 : _r1 = fold_build2_loc (loc, bitop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
250 599 : if (EXPR_P (_r1))
251 0 : goto next_after_fail107;
252 599 : res_op1 = _r1;
253 : }
254 599 : tree _r;
255 599 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
256 599 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 81, __FILE__, __LINE__, true);
257 599 : return _r;
258 : }
259 : next_after_fail107:;
260 : }
261 : else
262 : {
263 0 : {
264 0 : tree cst1 = const_binop (bitop, type, captures[0], captures[2]);
265 0 : if (cst1
266 : )
267 : {
268 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail108;
269 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail108;
270 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail108;
271 0 : {
272 0 : tree res_op0;
273 0 : res_op0 = captures[1];
274 0 : tree res_op1;
275 0 : res_op1 = cst1;
276 0 : tree _r;
277 0 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
278 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 82, __FILE__, __LINE__, true);
279 0 : return _r;
280 : }
281 : next_after_fail108:;
282 : }
283 : else
284 : {
285 0 : {
286 0 : tree cst2 = const_binop (bitop, type, captures[1], captures[2]);
287 0 : if (cst2
288 : )
289 : {
290 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail109;
291 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail109;
292 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail109;
293 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail109;
294 0 : {
295 0 : tree res_op0;
296 0 : res_op0 = captures[0];
297 0 : tree res_op1;
298 0 : res_op1 = cst2;
299 0 : tree _r;
300 0 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
301 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 83, __FILE__, __LINE__, true);
302 0 : return _r;
303 : }
304 : next_after_fail109:;
305 : }
306 : }
307 : }
308 : }
309 : }
310 : return NULL_TREE;
311 : }
312 :
313 : tree
314 64 : generic_simplify_47 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
315 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
316 : const enum tree_code ARG_UNUSED (cmp),
317 : const enum tree_code ARG_UNUSED (icmp),
318 : const enum tree_code ARG_UNUSED (ncmp))
319 : {
320 64 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
321 64 : {
322 64 : enum tree_code ic = invert_tree_comparison
323 64 : (cmp, HONOR_NANS (captures[0]));
324 64 : if (ic == icmp
325 : )
326 : {
327 64 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail124;
328 64 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail124;
329 64 : {
330 64 : tree res_op0;
331 64 : res_op0 = captures[0];
332 64 : tree res_op1;
333 64 : res_op1 = captures[1];
334 64 : tree _r;
335 64 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
336 64 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 94, __FILE__, __LINE__, true);
337 64 : return _r;
338 : }
339 : next_after_fail124:;
340 : }
341 : else
342 : {
343 0 : if (ic == ncmp
344 : )
345 : {
346 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail125;
347 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail125;
348 0 : {
349 0 : tree res_op0;
350 0 : res_op0 = captures[0];
351 0 : tree res_op1;
352 0 : res_op1 = captures[1];
353 0 : tree _r;
354 0 : _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
355 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 95, __FILE__, __LINE__, true);
356 0 : return _r;
357 : }
358 : next_after_fail125:;
359 : }
360 : }
361 : }
362 : return NULL_TREE;
363 : }
364 :
365 : tree
366 3009696 : generic_simplify_62 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
367 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
368 : const enum tree_code ARG_UNUSED (inner_op),
369 : const enum tree_code ARG_UNUSED (neg_inner_op),
370 : const enum tree_code ARG_UNUSED (outer_op))
371 : {
372 3009696 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
373 3009696 : if (!TYPE_SATURATING (type)
374 : )
375 : {
376 3009696 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
377 6019147 : && !FIXED_POINT_TYPE_P (type)
378 : )
379 : {
380 3009451 : if (!ANY_INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_WRAPS (type)
381 : )
382 : {
383 2033972 : if (!CONSTANT_CLASS_P (captures[0])
384 : )
385 : {
386 2033965 : if (outer_op == PLUS_EXPR
387 : )
388 : {
389 2033965 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail142;
390 2033965 : {
391 2033965 : tree res_op0;
392 2033965 : {
393 2033965 : tree _o1[1], _r1;
394 2033965 : _o1[0] = captures[0];
395 2033965 : if (TREE_TYPE (_o1[0]) != type)
396 : {
397 865227 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
398 : }
399 : else
400 : _r1 = _o1[0];
401 2033965 : res_op0 = _r1;
402 : }
403 2033965 : tree res_op1;
404 2033965 : {
405 2033965 : tree _o1[2], _r1;
406 2033965 : _o1[0] = captures[2];
407 2033965 : {
408 2033965 : tree _o2[1], _r2;
409 2033965 : _o2[0] = captures[1];
410 2033965 : if (TREE_TYPE (_o2[0]) != type)
411 : {
412 856506 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o2[0]);
413 : }
414 : else
415 : _r2 = _o2[0];
416 2033965 : _o1[1] = _r2;
417 : }
418 2033965 : _r1 = fold_build2_loc (loc, inner_op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
419 2033965 : if (EXPR_P (_r1))
420 0 : goto next_after_fail142;
421 2033965 : res_op1 = _r1;
422 : }
423 2033965 : tree _r;
424 2033965 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
425 2033965 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 111, __FILE__, __LINE__, true);
426 2033965 : return _r;
427 : }
428 : next_after_fail142:;
429 : }
430 : else
431 : {
432 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail143;
433 0 : {
434 0 : tree res_op0;
435 0 : {
436 0 : tree _o1[1], _r1;
437 0 : _o1[0] = captures[0];
438 0 : if (TREE_TYPE (_o1[0]) != type)
439 : {
440 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
441 : }
442 : else
443 : _r1 = _o1[0];
444 0 : res_op0 = _r1;
445 : }
446 0 : tree res_op1;
447 0 : {
448 0 : tree _o1[2], _r1;
449 0 : _o1[0] = captures[2];
450 0 : {
451 0 : tree _o2[1], _r2;
452 0 : _o2[0] = captures[1];
453 0 : if (TREE_TYPE (_o2[0]) != type)
454 : {
455 0 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o2[0]);
456 : }
457 : else
458 : _r2 = _o2[0];
459 0 : _o1[1] = _r2;
460 : }
461 0 : _r1 = fold_build2_loc (loc, neg_inner_op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
462 0 : if (EXPR_P (_r1))
463 0 : goto next_after_fail143;
464 0 : res_op1 = _r1;
465 : }
466 0 : tree _r;
467 0 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
468 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 112, __FILE__, __LINE__, true);
469 0 : return _r;
470 : }
471 : next_after_fail143:;
472 : }
473 : }
474 : }
475 : else
476 : {
477 1950958 : if (!ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
478 1950958 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0]))
479 : )
480 : {
481 177287 : if (outer_op == PLUS_EXPR
482 : )
483 : {
484 177260 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail144;
485 177260 : {
486 177260 : tree res_op0;
487 177260 : {
488 177260 : tree _o1[2], _r1;
489 177260 : _o1[0] = captures[0];
490 177260 : {
491 177260 : tree _o2[2], _r2;
492 177260 : {
493 177260 : tree _o3[1], _r3;
494 177260 : _o3[0] = captures[2];
495 177260 : if (TREE_TYPE (_o3[0]) != TREE_TYPE (_o1[0]))
496 : {
497 177260 : _r3 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (_o1[0]), _o3[0]);
498 : }
499 : else
500 : _r3 = _o3[0];
501 177260 : _o2[0] = _r3;
502 : }
503 177260 : _o2[1] = captures[1];
504 177260 : _r2 = fold_build2_loc (loc, inner_op, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
505 177260 : if (EXPR_P (_r2))
506 0 : goto next_after_fail144;
507 177260 : _o1[1] = _r2;
508 : }
509 177260 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
510 177260 : res_op0 = _r1;
511 : }
512 177260 : tree _r;
513 177260 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
514 177260 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 113, __FILE__, __LINE__, true);
515 177260 : return _r;
516 : }
517 : next_after_fail144:;
518 : }
519 : else
520 : {
521 27 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail145;
522 27 : {
523 27 : tree res_op0;
524 27 : {
525 27 : tree _o1[2], _r1;
526 27 : _o1[0] = captures[0];
527 27 : {
528 27 : tree _o2[2], _r2;
529 27 : {
530 27 : tree _o3[1], _r3;
531 27 : _o3[0] = captures[2];
532 27 : if (TREE_TYPE (_o3[0]) != TREE_TYPE (_o1[0]))
533 : {
534 27 : _r3 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (_o1[0]), _o3[0]);
535 : }
536 : else
537 : _r3 = _o3[0];
538 27 : _o2[0] = _r3;
539 : }
540 27 : _o2[1] = captures[1];
541 27 : _r2 = fold_build2_loc (loc, neg_inner_op, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
542 27 : if (EXPR_P (_r2))
543 0 : goto next_after_fail145;
544 27 : _o1[1] = _r2;
545 : }
546 27 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
547 27 : res_op0 = _r1;
548 : }
549 27 : tree _r;
550 27 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
551 27 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 114, __FILE__, __LINE__, true);
552 27 : return _r;
553 : }
554 : next_after_fail145:;
555 : }
556 : }
557 : else
558 : {
559 798192 : if (types_match (type, captures[0]) && !TYPE_OVERFLOW_SANITIZED (type)
560 : )
561 : {
562 796949 : {
563 796949 : tree cst = const_binop (outer_op == inner_op
564 : ? PLUS_EXPR : MINUS_EXPR,
565 : type, captures[1], captures[2]);
566 796949 : if (cst
567 : )
568 : {
569 796949 : if (INTEGRAL_TYPE_P (type) && !TREE_OVERFLOW (cst)
570 : )
571 : {
572 796935 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail146;
573 796935 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail146;
574 796935 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail146;
575 796935 : {
576 796935 : tree res_op0;
577 796935 : res_op0 = captures[0];
578 796935 : tree res_op1;
579 796935 : res_op1 = cst;
580 796935 : tree _r;
581 796935 : _r = fold_build2_loc (loc, inner_op, type, res_op0, res_op1);
582 796935 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 115, __FILE__, __LINE__, true);
583 796935 : return _r;
584 : }
585 : next_after_fail146:;
586 : }
587 : else
588 : {
589 28 : if (INTEGRAL_TYPE_P (type)
590 28 : && wi::to_wide (cst) == wi::min_value (type)
591 : )
592 : {
593 7 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail147;
594 7 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail147;
595 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail147;
596 7 : {
597 7 : tree res_op0;
598 7 : res_op0 = captures[0];
599 7 : tree res_op1;
600 7 : res_op1 = wide_int_to_tree (type, wi::to_wide (cst));
601 7 : tree _r;
602 7 : _r = fold_build2_loc (loc, neg_inner_op, type, res_op0, res_op1);
603 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 116, __FILE__, __LINE__, true);
604 7 : return _r;
605 : }
606 : next_after_fail147:;
607 : }
608 : else
609 : {
610 7 : {
611 7 : tree utype = unsigned_type_for (type);
612 7 : if (utype
613 : )
614 : {
615 7 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail148;
616 7 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail148;
617 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail148;
618 7 : {
619 7 : tree res_op0;
620 7 : {
621 7 : tree _o1[2], _r1;
622 7 : {
623 7 : tree _o2[1], _r2;
624 7 : _o2[0] = captures[0];
625 7 : if (TREE_TYPE (_o2[0]) != utype)
626 : {
627 7 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, utype, _o2[0]);
628 : }
629 : else
630 : _r2 = _o2[0];
631 7 : _o1[0] = _r2;
632 : }
633 7 : {
634 7 : tree _o2[1], _r2;
635 7 : _o2[0] = TREE_OVERFLOW (cst)
636 7 : ? drop_tree_overflow (cst) : cst;
637 7 : if (TREE_TYPE (_o2[0]) != utype)
638 : {
639 7 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, utype, _o2[0]);
640 : }
641 : else
642 : _r2 = _o2[0];
643 7 : _o1[1] = _r2;
644 : }
645 7 : _r1 = fold_build2_loc (loc, inner_op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
646 7 : res_op0 = _r1;
647 : }
648 7 : tree _r;
649 7 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
650 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 117, __FILE__, __LINE__, true);
651 7 : return _r;
652 : }
653 : next_after_fail148:;
654 : }
655 : }
656 : }
657 : }
658 : }
659 : }
660 : }
661 : }
662 : }
663 : }
664 : }
665 : return NULL_TREE;
666 : }
667 :
668 : tree
669 20275 : generic_simplify_119 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
670 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
671 : {
672 20275 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
673 20275 : {
674 20275 : bool wascmp;
675 20275 : if (bitwise_inverted_equal_p (captures[0], captures[2], wascmp)
676 20275 : && (!wascmp || element_precision (type) == 1)
677 : )
678 : {
679 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail217;
680 1 : {
681 1 : tree res_op0;
682 1 : res_op0 = captures[0];
683 1 : tree res_op1;
684 1 : {
685 1 : tree _o1[1], _r1;
686 1 : _o1[0] = captures[3];
687 1 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
688 1 : res_op1 = _r1;
689 : }
690 1 : tree _r;
691 1 : _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
692 1 : if (TREE_SIDE_EFFECTS (captures[2]))
693 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
694 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 183, __FILE__, __LINE__, true);
695 1 : return _r;
696 : }
697 0 : next_after_fail217:;
698 : }
699 : }
700 20274 : return NULL_TREE;
701 : }
702 :
703 : tree
704 8 : generic_simplify_127 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
705 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
706 : {
707 8 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
708 16 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
709 16 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
710 : )
711 : {
712 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail225;
713 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail225;
714 0 : {
715 0 : tree _r;
716 0 : _r = captures[2];
717 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 189, __FILE__, __LINE__, true);
718 0 : return _r;
719 : }
720 : next_after_fail225:;
721 : }
722 : return NULL_TREE;
723 : }
724 :
725 : tree
726 0 : generic_simplify_137 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
727 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
728 : {
729 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
730 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail235;
731 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail235;
732 0 : {
733 0 : tree _r;
734 0 : _r = captures[0];
735 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 193, __FILE__, __LINE__, true);
736 : return _r;
737 : }
738 : next_after_fail235:;
739 : return NULL_TREE;
740 : }
741 :
742 : tree
743 2 : generic_simplify_146 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
744 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
745 : const enum tree_code ARG_UNUSED (bitop),
746 : const enum tree_code ARG_UNUSED (rbitop))
747 : {
748 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
749 2 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail248;
750 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail248;
751 2 : {
752 2 : tree res_op0;
753 2 : res_op0 = captures[0];
754 2 : tree res_op1;
755 2 : res_op1 = captures[2];
756 2 : tree _r;
757 2 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
758 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 201, __FILE__, __LINE__, true);
759 : return _r;
760 : }
761 : next_after_fail248:;
762 : return NULL_TREE;
763 : }
764 :
765 : tree
766 0 : generic_simplify_152 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
767 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
768 : const enum tree_code ARG_UNUSED (op))
769 : {
770 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
771 0 : if (bitwise_equal_p (captures[4], captures[7])
772 : )
773 : {
774 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail255;
775 0 : {
776 0 : tree res_op0;
777 0 : {
778 0 : tree _o1[2], _r1;
779 0 : {
780 0 : tree _o2[2], _r2;
781 0 : _o2[0] = captures[5];
782 0 : {
783 0 : tree _o3[1], _r3;
784 0 : _o3[0] = captures[6];
785 0 : if (TREE_TYPE (_o3[0]) != TREE_TYPE (_o2[0]))
786 : {
787 0 : _r3 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o2[0]), _o3[0]);
788 : }
789 : else
790 : _r3 = _o3[0];
791 0 : _o2[1] = _r3;
792 : }
793 0 : _r2 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
794 0 : _o1[0] = _r2;
795 : }
796 0 : {
797 0 : tree _o2[1], _r2;
798 0 : _o2[0] = captures[4];
799 0 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
800 : {
801 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
802 : }
803 : else
804 : _r2 = _o2[0];
805 0 : _o1[1] = _r2;
806 : }
807 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
808 0 : res_op0 = _r1;
809 : }
810 0 : tree _r;
811 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
812 0 : if (TREE_SIDE_EFFECTS (captures[7]))
813 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[7]), _r);
814 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 204, __FILE__, __LINE__, true);
815 0 : return _r;
816 : }
817 0 : next_after_fail255:;
818 : }
819 : return NULL_TREE;
820 : }
821 :
822 : tree
823 0 : generic_simplify_164 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
824 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
825 : const enum tree_code ARG_UNUSED (cmp),
826 : const enum tree_code ARG_UNUSED (bitop),
827 : const enum tree_code ARG_UNUSED (neeq))
828 : {
829 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
830 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail289;
831 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail289;
832 0 : {
833 0 : tree res_op0;
834 0 : {
835 0 : tree _o1[2], _r1;
836 0 : _o1[0] = build_zero_cst (TREE_TYPE (captures[0]));
837 0 : _o1[1] = captures[3];
838 0 : _r1 = fold_build2_loc (loc, cmp, type, _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, bitop, type, res_op0, res_op1);
845 0 : if (TREE_SIDE_EFFECTS (captures[2]))
846 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
847 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 230, __FILE__, __LINE__, true);
848 : return _r;
849 : }
850 : next_after_fail289:;
851 : return NULL_TREE;
852 : }
853 :
854 : tree
855 0 : generic_simplify_172 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
856 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
857 : const enum tree_code ARG_UNUSED (cmp),
858 : const enum tree_code ARG_UNUSED (bitop),
859 : const enum tree_code ARG_UNUSED (neeq))
860 : {
861 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
862 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail310;
863 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail310;
864 0 : {
865 0 : tree res_op0;
866 0 : {
867 0 : tree _o1[2], _r1;
868 0 : _o1[0] = build_zero_cst (TREE_TYPE (captures[0]));
869 0 : _o1[1] = captures[3];
870 0 : _r1 = fold_build2_loc (loc, cmp, type, _o1[0], _o1[1]);
871 0 : res_op0 = _r1;
872 : }
873 0 : tree res_op1;
874 0 : res_op1 = captures[4];
875 0 : tree _r;
876 0 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
877 0 : if (TREE_SIDE_EFFECTS (captures[2]))
878 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
879 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 230, __FILE__, __LINE__, true);
880 : return _r;
881 : }
882 : next_after_fail310:;
883 : return NULL_TREE;
884 : }
885 :
886 : tree
887 0 : generic_simplify_178 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
888 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
889 : {
890 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
891 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail317;
892 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail317;
893 0 : {
894 0 : tree _r;
895 0 : _r = captures[1];
896 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 236, __FILE__, __LINE__, true);
897 : return _r;
898 : }
899 : next_after_fail317:;
900 : return NULL_TREE;
901 : }
902 :
903 : tree
904 0 : generic_simplify_181 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
905 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
906 : {
907 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
908 0 : if (type_has_mode_precision_p (type)
909 0 : && tree_fits_uhwi_p (captures[1])
910 0 : && tree_fits_uhwi_p (captures[3])
911 0 : && tree_fits_uhwi_p (captures[4])
912 0 : && ((~((HOST_WIDE_INT_1U << tree_to_uhwi (captures[1])) - 1)) & tree_to_uhwi (captures[4])) == 0
913 0 : && (tree_to_uhwi (captures[1]) + tree_to_uhwi (captures[3])) == TYPE_PRECISION (type)
914 0 : && TYPE_UNSIGNED (type)
915 0 : && captures[0] == captures[2]
916 : )
917 : {
918 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail320;
919 0 : {
920 0 : tree res_op0;
921 0 : {
922 0 : tree _o1[2], _r1;
923 0 : _o1[0] = captures[0];
924 0 : _o1[1] = captures[3];
925 0 : _r1 = fold_build2_loc (loc, RROTATE_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
926 0 : res_op0 = _r1;
927 : }
928 0 : tree res_op1;
929 0 : res_op1 = captures[4];
930 0 : tree _r;
931 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
932 0 : if (TREE_SIDE_EFFECTS (captures[1]))
933 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
934 0 : if (TREE_SIDE_EFFECTS (captures[2]))
935 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
936 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 238, __FILE__, __LINE__, true);
937 0 : return _r;
938 : }
939 0 : next_after_fail320:;
940 : }
941 : return NULL_TREE;
942 : }
943 :
944 : tree
945 0 : generic_simplify_188 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
946 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
947 : const combined_fn ARG_UNUSED (copysigns))
948 : {
949 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
950 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail327;
951 0 : {
952 0 : if (! tree_invariant_p (captures[1])) goto next_after_fail327;
953 0 : tree res_op0;
954 0 : res_op0 = unshare_expr (captures[1]);
955 0 : tree res_op1;
956 0 : res_op1 = captures[1];
957 0 : tree _r;
958 0 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
959 0 : if (TREE_SIDE_EFFECTS (captures[2]))
960 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
961 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 243, __FILE__, __LINE__, true);
962 : return _r;
963 : }
964 : next_after_fail327:;
965 : return NULL_TREE;
966 : }
967 :
968 : tree
969 1206 : generic_simplify_194 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
970 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
971 : const enum tree_code ARG_UNUSED (cmp))
972 : {
973 1206 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
974 1206 : if (fold_before_rtl_expansion_p ()
975 : )
976 : {
977 0 : if (INTEGRAL_TYPE_P (type)
978 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
979 : )
980 : {
981 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail335;
982 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail335;
983 0 : {
984 0 : tree res_op0;
985 0 : res_op0 = captures[0];
986 0 : tree res_op1;
987 0 : res_op1 = captures[3];
988 0 : tree res_op2;
989 0 : res_op2 = build_zero_cst (type);
990 0 : tree _r;
991 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
992 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 249, __FILE__, __LINE__, true);
993 0 : return _r;
994 : }
995 : next_after_fail335:;
996 : }
997 : }
998 : return NULL_TREE;
999 : }
1000 :
1001 : tree
1002 5590 : generic_simplify_200 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1003 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1004 : const enum tree_code ARG_UNUSED (op))
1005 : {
1006 5590 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1007 5590 : {
1008 5590 : poly_widest_int factor;
1009 5590 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[2]))
1010 5559 : && tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[2]))
1011 11149 : && multiple_p (wi::to_poly_widest (captures[3]), wi::to_widest (captures[1]), &factor)
1012 : )
1013 : {
1014 5489 : {
1015 5489 : wi::overflow_type overflow;
1016 5489 : wide_int mul;
1017 5489 : if (types_match (type, TREE_TYPE (captures[2]))
1018 5443 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[2]))
1019 0 : && TREE_CODE (captures[2]) == INTEGER_CST
1020 0 : && TREE_CODE (captures[3]) == INTEGER_CST
1021 5489 : && (mul = wi::mul (wi::to_wide (captures[2]), wi::to_wide (captures[3]),
1022 0 : TYPE_SIGN (type), &overflow),
1023 0 : !overflow)
1024 5489 : && (TYPE_UNSIGNED (type)
1025 5489 : || known_eq (factor, 1)
1026 0 : || (get_range_pos_neg (captures[0])
1027 0 : | (((op == PLUS_EXPR) ^ (tree_int_cst_sgn (captures[2]) < 0))
1028 0 : ? 1 : 2)) != 3)
1029 : )
1030 : {
1031 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail341;
1032 0 : {
1033 0 : tree res_op0;
1034 0 : {
1035 0 : tree _o1[2], _r1;
1036 0 : _o1[0] = captures[0];
1037 0 : _o1[1] = wide_int_to_tree (type, factor);
1038 0 : _r1 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1039 0 : res_op0 = _r1;
1040 : }
1041 0 : tree res_op1;
1042 0 : res_op1 = wide_int_to_tree (type, mul);
1043 0 : tree _r;
1044 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1045 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1046 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1047 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1048 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1049 0 : if (TREE_SIDE_EFFECTS (captures[3]))
1050 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
1051 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 254, __FILE__, __LINE__, true);
1052 0 : return _r;
1053 : }
1054 0 : next_after_fail341:;
1055 : }
1056 : else
1057 : {
1058 5489 : {
1059 5489 : tree utype = unsigned_type_for (type);
1060 5489 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail342;
1061 5489 : {
1062 5489 : tree res_op0;
1063 5489 : {
1064 5489 : tree _o1[2], _r1;
1065 5489 : {
1066 5489 : tree _o2[2], _r2;
1067 5489 : {
1068 5489 : tree _o3[1], _r3;
1069 5489 : _o3[0] = captures[0];
1070 5489 : if (TREE_TYPE (_o3[0]) != utype)
1071 : {
1072 5489 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
1073 : }
1074 : else
1075 : _r3 = _o3[0];
1076 5489 : _o2[0] = _r3;
1077 : }
1078 5489 : _o2[1] = wide_int_to_tree (utype, factor);
1079 5489 : _r2 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
1080 5489 : _o1[0] = _r2;
1081 : }
1082 5489 : {
1083 5489 : tree _o2[2], _r2;
1084 5489 : {
1085 5489 : tree _o3[1], _r3;
1086 5489 : _o3[0] = captures[3];
1087 5489 : if (TREE_TYPE (_o3[0]) != utype)
1088 : {
1089 14 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
1090 : }
1091 : else
1092 : _r3 = _o3[0];
1093 5489 : _o2[0] = _r3;
1094 : }
1095 5489 : {
1096 5489 : tree _o3[1], _r3;
1097 5489 : _o3[0] = captures[2];
1098 5489 : if (TREE_TYPE (_o3[0]) != utype)
1099 : {
1100 46 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
1101 : }
1102 : else
1103 : _r3 = _o3[0];
1104 5489 : _o2[1] = _r3;
1105 : }
1106 5489 : _r2 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
1107 5489 : _o1[1] = _r2;
1108 : }
1109 5489 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1110 5489 : res_op0 = _r1;
1111 : }
1112 5489 : tree _r;
1113 5489 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1114 5489 : if (TREE_SIDE_EFFECTS (captures[1]))
1115 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1116 5489 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 255, __FILE__, __LINE__, true);
1117 5489 : return _r;
1118 : }
1119 0 : next_after_fail342:;
1120 : }
1121 : }
1122 0 : }
1123 : }
1124 5590 : }
1125 101 : return NULL_TREE;
1126 : }
1127 :
1128 : tree
1129 6 : generic_simplify_230 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1130 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1131 : const enum tree_code ARG_UNUSED (neeq))
1132 : {
1133 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1134 6 : {
1135 6 : poly_int64 diff; tree inner_type = TREE_TYPE (captures[1]);
1136 6 : if (ptr_difference_const (captures[0], captures[2], &diff)
1137 : )
1138 : {
1139 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail389;
1140 0 : {
1141 0 : tree res_op0;
1142 0 : {
1143 0 : tree _o1[2], _r1;
1144 0 : _o1[0] = build_int_cst_type (inner_type, diff);
1145 0 : _o1[1] = captures[1];
1146 0 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1147 0 : res_op0 = _r1;
1148 : }
1149 0 : tree res_op1;
1150 0 : res_op1 = captures[3];
1151 0 : tree _r;
1152 0 : _r = fold_build2_loc (loc, neeq, type, res_op0, res_op1);
1153 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1154 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1155 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1156 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1157 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 300, __FILE__, __LINE__, true);
1158 0 : return _r;
1159 : }
1160 0 : next_after_fail389:;
1161 : }
1162 : }
1163 6 : return NULL_TREE;
1164 : }
1165 :
1166 : tree
1167 13 : generic_simplify_240 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1168 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1169 : const enum tree_code ARG_UNUSED (cmp))
1170 : {
1171 13 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1172 13 : if (tree_fits_shwi_p (captures[3])
1173 13 : && tree_to_shwi (captures[3]) > 0
1174 26 : && tree_to_shwi (captures[3]) < TYPE_PRECISION (TREE_TYPE (captures[2]))
1175 : )
1176 : {
1177 13 : if (tree_to_shwi (captures[3]) > wi::ctz (wi::to_wide (captures[5]))
1178 : )
1179 : {
1180 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail402;
1181 0 : {
1182 0 : tree _r;
1183 0 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1184 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1185 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1186 0 : if (TREE_SIDE_EFFECTS (captures[3]))
1187 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
1188 0 : if (TREE_SIDE_EFFECTS (captures[4]))
1189 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
1190 0 : if (TREE_SIDE_EFFECTS (captures[5]))
1191 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
1192 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 313, __FILE__, __LINE__, true);
1193 0 : return _r;
1194 : }
1195 0 : next_after_fail402:;
1196 : }
1197 : else
1198 : {
1199 13 : {
1200 13 : wide_int c1 = wi::to_wide (captures[3]);
1201 13 : wide_int c2 = wi::lrshift (wi::to_wide (captures[4]), c1);
1202 13 : wide_int c3 = wi::lrshift (wi::to_wide (captures[5]), c1);
1203 13 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail403;
1204 13 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail403;
1205 13 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail403;
1206 13 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail403;
1207 13 : {
1208 13 : tree res_op0;
1209 13 : {
1210 13 : tree _o1[2], _r1;
1211 13 : _o1[0] = captures[2];
1212 13 : _o1[1] = wide_int_to_tree (TREE_TYPE (captures[2]), c2);
1213 13 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1214 13 : res_op0 = _r1;
1215 : }
1216 13 : tree res_op1;
1217 13 : res_op1 = wide_int_to_tree (TREE_TYPE (captures[2]), c3);
1218 13 : tree _r;
1219 13 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1220 13 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 314, __FILE__, __LINE__, true);
1221 13 : return _r;
1222 : }
1223 0 : next_after_fail403:;
1224 13 : }
1225 : }
1226 : }
1227 : return NULL_TREE;
1228 : }
1229 :
1230 : tree
1231 30015 : generic_simplify_255 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1232 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1233 : const enum tree_code ARG_UNUSED (cmp),
1234 : const enum tree_code ARG_UNUSED (scmp))
1235 : {
1236 30015 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1237 30015 : if (integer_zerop (captures[2])
1238 : )
1239 : {
1240 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail427;
1241 7 : {
1242 7 : tree res_op0;
1243 7 : res_op0 = captures[2];
1244 7 : tree res_op1;
1245 7 : res_op1 = captures[3];
1246 7 : tree _r;
1247 7 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1248 7 : if (TREE_SIDE_EFFECTS (captures[1]))
1249 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1250 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 337, __FILE__, __LINE__, true);
1251 7 : return _r;
1252 : }
1253 0 : next_after_fail427:;
1254 : }
1255 : else
1256 : {
1257 60016 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1258 60016 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
1259 60016 : && single_use (captures[0])
1260 : )
1261 : {
1262 5957 : if (tree_int_cst_sgn (captures[2]) < 0
1263 : )
1264 : {
1265 15 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail428;
1266 15 : {
1267 15 : tree res_op0;
1268 15 : res_op0 = captures[1];
1269 15 : tree res_op1;
1270 15 : res_op1 = captures[3];
1271 15 : tree _r;
1272 15 : _r = fold_build2_loc (loc, scmp, type, res_op0, res_op1);
1273 15 : if (TREE_SIDE_EFFECTS (captures[2]))
1274 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1275 15 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 338, __FILE__, __LINE__, true);
1276 15 : return _r;
1277 : }
1278 0 : next_after_fail428:;
1279 : }
1280 : else
1281 : {
1282 5942 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail429;
1283 5942 : {
1284 5942 : tree res_op0;
1285 5942 : res_op0 = captures[1];
1286 5942 : tree res_op1;
1287 5942 : res_op1 = captures[3];
1288 5942 : tree _r;
1289 5942 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1290 5942 : if (TREE_SIDE_EFFECTS (captures[2]))
1291 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1292 5942 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 339, __FILE__, __LINE__, true);
1293 5942 : return _r;
1294 : }
1295 0 : next_after_fail429:;
1296 : }
1297 : }
1298 : }
1299 : return NULL_TREE;
1300 : }
1301 :
1302 : tree
1303 81580 : generic_simplify_268 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1304 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1305 : const enum tree_code ARG_UNUSED (cmp),
1306 : const enum tree_code ARG_UNUSED (icmp))
1307 : {
1308 81580 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1309 81580 : if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (captures[2]))
1310 81580 : && ! DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[2]))
1311 : )
1312 : {
1313 81089 : {
1314 81089 : tree itype = TREE_TYPE (captures[1]);
1315 81089 : signop isign = TYPE_SIGN (itype);
1316 81089 : format_helper fmt (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (captures[2]))));
1317 81089 : bool itype_ok = fmt.can_represent_integral_type_p (itype);
1318 81089 : bool value_ok = itype_ok;
1319 81089 : const REAL_VALUE_TYPE *cst = TREE_REAL_CST_PTR (captures[2]);
1320 81089 : bool exception_p = real_isnan (cst)
1321 150 : && flag_trapping_math
1322 81239 : && ((cmp != EQ_EXPR && cmp != NE_EXPR)
1323 30 : || (cst->signalling
1324 30 : && HONOR_SNANS (TREE_TYPE (captures[2]))));
1325 81089 : if (flag_trapping_math && !value_ok)
1326 : exception_p = true;
1327 39775 : if (! exception_p
1328 : )
1329 : {
1330 39625 : {
1331 39625 : signop isign = TYPE_SIGN (itype);
1332 39625 : wide_int imin_val = wi::min_value (itype);
1333 39625 : wide_int imax_val = wi::max_value (itype);
1334 39625 : REAL_VALUE_TYPE imin, imax;
1335 39625 : real_from_integer (&imin, fmt, imin_val, isign);
1336 39625 : real_from_integer (&imax, fmt, imax_val, isign);
1337 39625 : REAL_VALUE_TYPE icst;
1338 39625 : if (cmp == GT_EXPR || cmp == GE_EXPR)
1339 38883 : real_ceil (&icst, fmt, cst);
1340 742 : else if (cmp == LT_EXPR || cmp == LE_EXPR)
1341 232 : real_floor (&icst, fmt, cst);
1342 : else
1343 510 : real_trunc (&icst, fmt, cst);
1344 39625 : bool cst_int_p = real_isfinite (cst) && real_identical (&icst, cst);
1345 39625 : bool overflow_p = false;
1346 39625 : wide_int icst_val
1347 39625 : = real_to_integer (&icst, &overflow_p, TYPE_PRECISION (itype));
1348 39625 : if (real_compare (LT_EXPR, cst, &imin)
1349 : )
1350 : {
1351 19477 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail480;
1352 19477 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail480;
1353 19477 : {
1354 19477 : tree _r;
1355 19477 : _r = constant_boolean_node (cmp == GT_EXPR || cmp == GE_EXPR || cmp == NE_EXPR,
1356 : type);
1357 19477 : if (TREE_SIDE_EFFECTS (captures[1]))
1358 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1359 19477 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 389, __FILE__, __LINE__, true);
1360 19477 : return _r;
1361 : }
1362 208 : next_after_fail480:;
1363 : }
1364 : else
1365 : {
1366 20148 : if (real_compare (GT_EXPR, cst, &imax)
1367 : )
1368 : {
1369 120 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail481;
1370 120 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail481;
1371 120 : {
1372 120 : tree _r;
1373 120 : _r = constant_boolean_node (cmp == LT_EXPR || cmp == LE_EXPR || cmp == NE_EXPR,
1374 : type);
1375 120 : if (TREE_SIDE_EFFECTS (captures[1]))
1376 1 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1377 120 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 390, __FILE__, __LINE__, true);
1378 120 : return _r;
1379 : }
1380 208 : next_after_fail481:;
1381 : }
1382 : else
1383 : {
1384 20028 : if (!cst_int_p
1385 136 : && (cmp == EQ_EXPR || cmp == NE_EXPR)
1386 : )
1387 : {
1388 28 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail482;
1389 28 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail482;
1390 28 : {
1391 28 : tree _r;
1392 28 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1393 28 : if (TREE_SIDE_EFFECTS (captures[1]))
1394 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1395 28 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 391, __FILE__, __LINE__, true);
1396 28 : return _r;
1397 : }
1398 208 : next_after_fail482:;
1399 : }
1400 : else
1401 : {
1402 20000 : if (cst_int_p
1403 79676 : && fold_cmp_float_cst_p (imin_val, imax_val, cmp, &icst, fmt,
1404 : icst_val, isign)
1405 : )
1406 : {
1407 19684 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail483;
1408 19684 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail483;
1409 19684 : {
1410 19684 : tree res_op0;
1411 19684 : res_op0 = captures[1];
1412 19684 : tree res_op1;
1413 19684 : res_op1 = wide_int_to_tree (itype, icst_val);
1414 19684 : tree _r;
1415 19684 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1416 19684 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 392, __FILE__, __LINE__, true);
1417 19684 : return _r;
1418 : }
1419 208 : next_after_fail483:;
1420 : }
1421 : else
1422 : {
1423 632 : if (!cst_int_p
1424 748 : && fold_cmp_float_cst_p (imin_val, imax_val, icmp, &icst, fmt,
1425 : icst_val, isign)
1426 : )
1427 : {
1428 108 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail484;
1429 108 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail484;
1430 108 : {
1431 108 : tree res_op0;
1432 108 : res_op0 = captures[1];
1433 108 : tree res_op1;
1434 108 : res_op1 = wide_int_to_tree (itype, icst_val);
1435 108 : tree _r;
1436 108 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
1437 108 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 393, __FILE__, __LINE__, true);
1438 108 : return _r;
1439 : }
1440 208 : next_after_fail484:;
1441 : }
1442 : }
1443 : }
1444 : }
1445 : }
1446 39625 : }
1447 : }
1448 : }
1449 : }
1450 : return NULL_TREE;
1451 : }
1452 :
1453 : tree
1454 111884 : generic_simplify_284 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1455 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1456 : const enum tree_code ARG_UNUSED (cmp),
1457 : const enum tree_code ARG_UNUSED (icmp))
1458 : {
1459 111884 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1460 111884 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail519;
1461 111860 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail519;
1462 111860 : {
1463 111860 : tree res_op0;
1464 111860 : res_op0 = captures[0];
1465 111860 : tree res_op1;
1466 111860 : res_op1 = build_zero_cst (TREE_TYPE (captures[1]));
1467 111860 : tree _r;
1468 111860 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
1469 111860 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 420, __FILE__, __LINE__, true);
1470 : return _r;
1471 : }
1472 : next_after_fail519:;
1473 : return NULL_TREE;
1474 : }
1475 :
1476 : tree
1477 18 : generic_simplify_289 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1478 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1479 : const enum tree_code ARG_UNUSED (cmp),
1480 : const enum tree_code ARG_UNUSED (ncmp))
1481 : {
1482 18 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1483 36 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1484 18 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1485 36 : && types_match (captures[0], captures[2])
1486 : )
1487 : {
1488 2 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail524;
1489 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail524;
1490 2 : {
1491 2 : tree res_op0;
1492 2 : {
1493 2 : tree _o1[2], _r1;
1494 2 : _o1[0] = captures[0];
1495 2 : _o1[1] = captures[2];
1496 2 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1497 2 : res_op0 = _r1;
1498 : }
1499 2 : tree res_op1;
1500 2 : res_op1 = captures[1];
1501 2 : tree _r;
1502 2 : _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
1503 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 423, __FILE__, __LINE__, true);
1504 2 : return _r;
1505 : }
1506 : next_after_fail524:;
1507 : }
1508 : return NULL_TREE;
1509 : }
1510 :
1511 : tree
1512 0 : generic_simplify_295 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1513 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1514 : const enum tree_code ARG_UNUSED (inner),
1515 : const enum tree_code ARG_UNUSED (outer))
1516 : {
1517 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1518 0 : {
1519 0 : bool cst1 = integer_onep (captures[1]);
1520 0 : bool cst0 = integer_zerop (captures[1]);
1521 0 : bool innereq = inner == EQ_EXPR;
1522 0 : bool outereq = outer == EQ_EXPR;
1523 0 : if (innereq ? cst0 : cst1
1524 : )
1525 : {
1526 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail544;
1527 0 : {
1528 0 : tree _r;
1529 0 : _r = constant_boolean_node (!outereq, type);
1530 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1531 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
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", 435, __FILE__, __LINE__, true);
1535 0 : return _r;
1536 : }
1537 0 : next_after_fail544:;
1538 : }
1539 : else
1540 : {
1541 0 : if (innereq ? cst1 : cst0
1542 : )
1543 : {
1544 0 : {
1545 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[0]));
1546 0 : tree ucst1 = build_one_cst (utype);
1547 0 : if (!outereq
1548 : )
1549 : {
1550 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail545;
1551 0 : {
1552 0 : tree res_op0;
1553 0 : {
1554 0 : tree _o1[1], _r1;
1555 0 : _o1[0] = captures[0];
1556 0 : if (TREE_TYPE (_o1[0]) != utype)
1557 : {
1558 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, utype, _o1[0]);
1559 : }
1560 : else
1561 : _r1 = _o1[0];
1562 0 : res_op0 = _r1;
1563 : }
1564 0 : tree res_op1;
1565 0 : res_op1 = ucst1;
1566 0 : tree _r;
1567 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
1568 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1569 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1570 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 436, __FILE__, __LINE__, true);
1571 0 : return _r;
1572 : }
1573 0 : next_after_fail545:;
1574 : }
1575 : else
1576 : {
1577 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail546;
1578 0 : {
1579 0 : tree res_op0;
1580 0 : {
1581 0 : tree _o1[1], _r1;
1582 0 : _o1[0] = captures[0];
1583 0 : if (TREE_TYPE (_o1[0]) != utype)
1584 : {
1585 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, utype, _o1[0]);
1586 : }
1587 : else
1588 : _r1 = _o1[0];
1589 0 : res_op0 = _r1;
1590 : }
1591 0 : tree res_op1;
1592 0 : res_op1 = ucst1;
1593 0 : tree _r;
1594 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1595 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1596 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1597 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 437, __FILE__, __LINE__, true);
1598 0 : return _r;
1599 : }
1600 0 : next_after_fail546:;
1601 : }
1602 : }
1603 : }
1604 : else
1605 : {
1606 0 : {
1607 0 : tree value = build_int_cst (TREE_TYPE (captures[0]), !innereq);
1608 0 : if (outereq
1609 : )
1610 : {
1611 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail547;
1612 0 : {
1613 0 : tree res_op0;
1614 0 : res_op0 = captures[0];
1615 0 : tree res_op1;
1616 0 : res_op1 = value;
1617 0 : tree _r;
1618 0 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
1619 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1620 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1621 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 438, __FILE__, __LINE__, true);
1622 0 : return _r;
1623 : }
1624 0 : next_after_fail547:;
1625 : }
1626 : else
1627 : {
1628 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail548;
1629 0 : {
1630 0 : tree res_op0;
1631 0 : res_op0 = captures[0];
1632 0 : tree res_op1;
1633 0 : res_op1 = value;
1634 0 : tree _r;
1635 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
1636 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1637 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1638 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 439, __FILE__, __LINE__, true);
1639 0 : return _r;
1640 : }
1641 0 : next_after_fail548:;
1642 : }
1643 : }
1644 : }
1645 : }
1646 : }
1647 : return NULL_TREE;
1648 : }
1649 :
1650 : tree
1651 374 : generic_simplify_301 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1652 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1653 : const enum tree_code ARG_UNUSED (op),
1654 : const combined_fn ARG_UNUSED (ctz))
1655 : {
1656 374 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1657 374 : {
1658 374 : tree type0 = TREE_TYPE (captures[1]);
1659 374 : int prec = TYPE_PRECISION (type0);
1660 374 : bool ok = true;
1661 374 : if (sanitize_flags_p (SANITIZE_BUILTIN)
1662 374 : && (!cfun
1663 64 : || (cfun->curr_properties & PROP_ssa) == 0))
1664 : ok = false;
1665 620 : if (ok && prec <= MAX_FIXED_MODE_SIZE
1666 : )
1667 : {
1668 310 : if (tree_int_cst_sgn (captures[2]) < 0 || wi::to_widest (captures[2]) >= prec
1669 : )
1670 : {
1671 36 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail565;
1672 36 : {
1673 36 : tree _r;
1674 36 : _r = constant_boolean_node (op != EQ_EXPR, type);
1675 36 : if (TREE_SIDE_EFFECTS (captures[1]))
1676 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1677 36 : if (TREE_SIDE_EFFECTS (captures[2]))
1678 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1679 36 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 456, __FILE__, __LINE__, true);
1680 310 : return _r;
1681 : }
1682 0 : next_after_fail565:;
1683 : }
1684 : else
1685 : {
1686 274 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail566;
1687 274 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail566;
1688 274 : {
1689 274 : tree res_op0;
1690 274 : {
1691 274 : tree _o1[2], _r1;
1692 274 : _o1[0] = captures[1];
1693 274 : _o1[1] = wide_int_to_tree (type0,
1694 274 : wi::mask (tree_to_uhwi (captures[2]) + 1,
1695 : false, prec));
1696 274 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1697 274 : res_op0 = _r1;
1698 : }
1699 274 : tree res_op1;
1700 274 : res_op1 = wide_int_to_tree (type0,
1701 274 : wi::shifted_mask (tree_to_uhwi (captures[2]), 1,
1702 : false, prec));
1703 274 : tree _r;
1704 274 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1705 274 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 457, __FILE__, __LINE__, true);
1706 274 : return _r;
1707 : }
1708 64 : next_after_fail566:;
1709 : }
1710 : }
1711 : }
1712 64 : return NULL_TREE;
1713 : }
1714 :
1715 : tree
1716 0 : generic_simplify_313 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1717 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1718 : const combined_fn ARG_UNUSED (COPYSIGN_ALL))
1719 : {
1720 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1721 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail582;
1722 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail582;
1723 0 : {
1724 0 : tree _r;
1725 0 : _r = captures[1];
1726 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 473, __FILE__, __LINE__, true);
1727 : return _r;
1728 : }
1729 : next_after_fail582:;
1730 : return NULL_TREE;
1731 : }
1732 :
1733 : tree
1734 768 : generic_simplify_320 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1735 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1736 : const enum tree_code ARG_UNUSED (div))
1737 : {
1738 768 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1739 1536 : if (!ALL_FRACT_MODE_P (TYPE_MODE (type))
1740 768 : && !integer_zerop (captures[0])
1741 1035 : && (!flag_non_call_exceptions || tree_expr_nonzero_p (captures[0]))
1742 : )
1743 : {
1744 111 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail591;
1745 111 : {
1746 111 : tree _r;
1747 111 : _r = build_one_cst (type);
1748 111 : if (TREE_SIDE_EFFECTS (captures[0]))
1749 2 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1750 111 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 480, __FILE__, __LINE__, true);
1751 111 : return _r;
1752 : }
1753 0 : next_after_fail591:;
1754 : }
1755 : return NULL_TREE;
1756 : }
1757 :
1758 : tree
1759 192 : generic_simplify_326 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1760 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1761 : const enum tree_code ARG_UNUSED (div))
1762 : {
1763 192 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1764 192 : if (ANY_INTEGRAL_TYPE_P (type)
1765 : )
1766 : {
1767 192 : if (TYPE_OVERFLOW_UNDEFINED (type) && !TYPE_OVERFLOW_SANITIZED (type)
1768 : )
1769 : {
1770 164 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail598;
1771 164 : {
1772 164 : tree _r;
1773 164 : _r = captures[1];
1774 164 : if (TREE_SIDE_EFFECTS (captures[2]))
1775 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1776 164 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 487, __FILE__, __LINE__, true);
1777 164 : return _r;
1778 : }
1779 0 : next_after_fail598:;
1780 : }
1781 : }
1782 : return NULL_TREE;
1783 : }
1784 :
1785 : tree
1786 216658 : generic_simplify_330 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1787 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1788 : const enum tree_code ARG_UNUSED (mod))
1789 : {
1790 216658 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1791 216658 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail602;
1792 216658 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail602;
1793 216658 : {
1794 216658 : tree _r;
1795 216658 : _r = build_zero_cst (type);
1796 216658 : if (TREE_SIDE_EFFECTS (captures[0]))
1797 47 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1798 216658 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 491, __FILE__, __LINE__, true);
1799 : return _r;
1800 : }
1801 : next_after_fail602:;
1802 : return NULL_TREE;
1803 : }
1804 :
1805 : tree
1806 6 : generic_simplify_340 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1807 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1808 : const combined_fn ARG_UNUSED (SIN),
1809 : const combined_fn ARG_UNUSED (TAN),
1810 : const combined_fn ARG_UNUSED (COS))
1811 : {
1812 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1813 6 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1814 : )
1815 : {
1816 6 : if (! HONOR_NANS (captures[1])
1817 6 : && ! HONOR_INFINITIES (captures[1])
1818 : )
1819 : {
1820 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail614;
1821 6 : {
1822 6 : tree res_op0;
1823 6 : res_op0 = captures[1];
1824 6 : tree _r;
1825 6 : _r = maybe_build_call_expr_loc (loc, COS, type, 1, res_op0);
1826 6 : if (!_r)
1827 0 : goto next_after_fail614;
1828 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 503, __FILE__, __LINE__, true);
1829 6 : return _r;
1830 : }
1831 : next_after_fail614:;
1832 : }
1833 : }
1834 : return NULL_TREE;
1835 : }
1836 :
1837 : tree
1838 167061 : generic_simplify_348 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1839 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1840 : const enum tree_code ARG_UNUSED (cmp))
1841 : {
1842 167061 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1843 167061 : {
1844 167061 : tree from_type = TREE_TYPE (captures[0]);
1845 167061 : tree c1_type = TREE_TYPE (captures[1]), c2_type = TREE_TYPE (captures[2]);
1846 167061 : enum tree_code code = ERROR_MARK;
1847 167061 : if (integer_zerop (captures[1])
1848 69476 : && INTEGRAL_TYPE_P (from_type)
1849 66661 : && (cmp == GE_EXPR || cmp == LT_EXPR)
1850 17757 : && TYPE_UNSIGNED (from_type)
1851 1809 : && !TYPE_UNSIGNED (c1_type)
1852 1809 : && TYPE_PRECISION (from_type) == TYPE_PRECISION (c1_type)
1853 603 : && int_fits_type_p (captures[2], from_type)
1854 167664 : && (types_match (c2_type, from_type)
1855 16 : || (TYPE_PRECISION (c2_type) > TYPE_PRECISION (from_type)
1856 16 : && (TYPE_UNSIGNED (from_type)
1857 0 : || TYPE_SIGN (c2_type) == TYPE_SIGN (from_type)))))
1858 : {
1859 603 : tree_code ncmp = cmp == GE_EXPR ? LE_EXPR : GT_EXPR;
1860 603 : widest_int c1 = wi::mask<widest_int>(TYPE_PRECISION (c1_type) - 1, 0);
1861 603 : code = minmax_from_comparison (ncmp, captures[0], c1, wi::to_widest (captures[2]));
1862 603 : }
1863 603 : if (code == ERROR_MARK
1864 167056 : && INTEGRAL_TYPE_P (from_type)
1865 164241 : && int_fits_type_p (captures[2], from_type)
1866 164240 : && (types_match (c1_type, from_type)
1867 7215 : || (TYPE_PRECISION (c1_type) > TYPE_PRECISION (from_type)
1868 0 : && (TYPE_UNSIGNED (from_type)
1869 0 : || TYPE_SIGN (c1_type) == TYPE_SIGN (from_type))))
1870 157628 : && (types_match (c2_type, from_type)
1871 62546 : || (TYPE_PRECISION (c2_type) > TYPE_PRECISION (from_type)
1872 19379 : && (TYPE_UNSIGNED (from_type)
1873 670 : || TYPE_SIGN (c2_type) == TYPE_SIGN (from_type)))))
1874 : {
1875 113269 : if (cmp != EQ_EXPR)
1876 113257 : code = minmax_from_comparison (cmp, captures[0], captures[1], captures[0], captures[2]);
1877 12 : else if (int_fits_type_p (captures[1], from_type))
1878 : code = EQ_EXPR;
1879 : }
1880 167049 : if (code == MAX_EXPR
1881 : )
1882 : {
1883 19751 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail622;
1884 19751 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail622;
1885 19751 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail622;
1886 19751 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail622;
1887 19751 : {
1888 19751 : tree res_op0;
1889 19751 : {
1890 19751 : tree _o1[2], _r1;
1891 19751 : _o1[0] = captures[0];
1892 19751 : {
1893 19751 : tree _o2[1], _r2;
1894 19751 : _o2[0] = captures[2];
1895 19751 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
1896 : {
1897 315 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
1898 : }
1899 : else
1900 : _r2 = _o2[0];
1901 19751 : _o1[1] = _r2;
1902 : }
1903 19751 : _r1 = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1904 19751 : res_op0 = _r1;
1905 : }
1906 19751 : tree _r;
1907 19751 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1908 19751 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 511, __FILE__, __LINE__, true);
1909 19751 : return _r;
1910 : }
1911 : next_after_fail622:;
1912 : }
1913 : else
1914 : {
1915 147310 : if (code == MIN_EXPR
1916 : )
1917 : {
1918 258 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail623;
1919 258 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail623;
1920 258 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail623;
1921 258 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail623;
1922 258 : {
1923 258 : tree res_op0;
1924 258 : {
1925 258 : tree _o1[2], _r1;
1926 258 : _o1[0] = captures[0];
1927 258 : {
1928 258 : tree _o2[1], _r2;
1929 258 : _o2[0] = captures[2];
1930 258 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
1931 : {
1932 100 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
1933 : }
1934 : else
1935 : _r2 = _o2[0];
1936 258 : _o1[1] = _r2;
1937 : }
1938 258 : _r1 = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1939 258 : res_op0 = _r1;
1940 : }
1941 258 : tree _r;
1942 258 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1943 258 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 512, __FILE__, __LINE__, true);
1944 258 : return _r;
1945 : }
1946 : next_after_fail623:;
1947 : }
1948 : else
1949 : {
1950 147052 : if (code == EQ_EXPR
1951 : )
1952 : {
1953 12 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail624;
1954 12 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail624;
1955 12 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail624;
1956 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail624;
1957 12 : {
1958 12 : if (! tree_invariant_p (captures[1])) goto next_after_fail624;
1959 12 : tree res_op0;
1960 12 : {
1961 12 : tree _o1[3], _r1;
1962 12 : {
1963 12 : tree _o2[2], _r2;
1964 12 : _o2[0] = captures[0];
1965 12 : {
1966 12 : tree _o3[1], _r3;
1967 12 : _o3[0] = unshare_expr (captures[1]);
1968 12 : if (TREE_TYPE (_o3[0]) != TREE_TYPE (_o2[0]))
1969 : {
1970 0 : _r3 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o2[0]), _o3[0]);
1971 : }
1972 : else
1973 : _r3 = _o3[0];
1974 12 : _o2[1] = _r3;
1975 : }
1976 12 : _r2 = fold_build2_loc (loc, EQ_EXPR, boolean_type_node, _o2[0], _o2[1]);
1977 12 : _o1[0] = _r2;
1978 : }
1979 12 : {
1980 12 : tree _o2[1], _r2;
1981 12 : _o2[0] = captures[1];
1982 12 : if (TREE_TYPE (_o2[0]) != from_type)
1983 : {
1984 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, from_type, _o2[0]);
1985 : }
1986 : else
1987 : _r2 = _o2[0];
1988 12 : _o1[1] = _r2;
1989 : }
1990 12 : {
1991 12 : tree _o2[1], _r2;
1992 12 : _o2[0] = captures[2];
1993 12 : if (TREE_TYPE (_o2[0]) != from_type)
1994 : {
1995 7 : _r2 = fold_build1_loc (loc, NOP_EXPR, from_type, _o2[0]);
1996 : }
1997 : else
1998 : _r2 = _o2[0];
1999 12 : _o1[2] = _r2;
2000 : }
2001 12 : _r1 = fold_build3_loc (loc, COND_EXPR, TREE_TYPE (_o1[1]), _o1[0], _o1[1], _o1[2]);
2002 12 : res_op0 = _r1;
2003 : }
2004 12 : tree _r;
2005 12 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2006 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 513, __FILE__, __LINE__, true);
2007 12 : return _r;
2008 : }
2009 : next_after_fail624:;
2010 : }
2011 : }
2012 : }
2013 : }
2014 : return NULL_TREE;
2015 : }
2016 :
2017 : tree
2018 0 : generic_simplify_389 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2019 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2020 : const enum tree_code ARG_UNUSED (legt))
2021 : {
2022 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2023 0 : if (!HONOR_NANS (captures[0])
2024 : )
2025 : {
2026 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail675;
2027 0 : {
2028 0 : tree _r;
2029 0 : _r = constant_boolean_node (legt == LE_EXPR, type);
2030 0 : if (TREE_SIDE_EFFECTS (captures[0]))
2031 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2032 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2033 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2034 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 562, __FILE__, __LINE__, true);
2035 0 : return _r;
2036 : }
2037 0 : next_after_fail675:;
2038 : }
2039 : return NULL_TREE;
2040 : }
2041 :
2042 : tree
2043 599 : generic_simplify_397 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2044 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2045 : const enum tree_code ARG_UNUSED (cmp))
2046 : {
2047 599 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2048 599 : if (wi::gt_p (wi::to_wide (captures[1]), 0, TYPE_SIGN (TREE_TYPE (captures[1])))
2049 : )
2050 : {
2051 599 : {
2052 599 : wi::overflow_type ovf;
2053 599 : wide_int prod = wi::mul (wi::to_wide (captures[2]), wi::to_wide (captures[1]),
2054 1198 : TYPE_SIGN (TREE_TYPE (captures[1])), &ovf);
2055 599 : if (ovf
2056 : )
2057 : {
2058 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail683;
2059 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail683;
2060 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail683;
2061 0 : {
2062 0 : tree _r;
2063 0 : _r = constant_boolean_node (wi::lt_p (wi::to_wide (captures[2]), 0,
2064 0 : TYPE_SIGN (TREE_TYPE (captures[2])))
2065 0 : != (cmp == LT_EXPR || cmp == LE_EXPR), type);
2066 0 : if (TREE_SIDE_EFFECTS (captures[0]))
2067 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2068 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 570, __FILE__, __LINE__, true);
2069 0 : return _r;
2070 : }
2071 0 : next_after_fail683:;
2072 : }
2073 : else
2074 : {
2075 599 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail684;
2076 599 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail684;
2077 599 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail684;
2078 599 : {
2079 599 : tree res_op0;
2080 599 : res_op0 = captures[0];
2081 599 : tree res_op1;
2082 599 : res_op1 = wide_int_to_tree (TREE_TYPE (captures[0]), prod);
2083 599 : tree _r;
2084 599 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2085 599 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 571, __FILE__, __LINE__, true);
2086 599 : return _r;
2087 : }
2088 0 : next_after_fail684:;
2089 : }
2090 599 : }
2091 : }
2092 : return NULL_TREE;
2093 : }
2094 :
2095 : tree
2096 755991 : generic_simplify_411 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2097 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2098 : const enum tree_code ARG_UNUSED (cmp),
2099 : const enum tree_code ARG_UNUSED (icmp))
2100 : {
2101 755991 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2102 1509680 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2103 755991 : && TYPE_UNSIGNED (TREE_TYPE (captures[0]))
2104 335763 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > 1
2105 1847745 : && (wi::to_wide (captures[2])
2106 1763280 : == wi::max_value (TYPE_PRECISION (TREE_TYPE (captures[0])), SIGNED) - 1)
2107 : )
2108 : {
2109 4543 : {
2110 4543 : tree stype = signed_type_for (TREE_TYPE (captures[0]));
2111 4543 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail736;
2112 4543 : {
2113 4543 : tree res_op0;
2114 4543 : {
2115 4543 : tree _o1[1], _r1;
2116 4543 : _o1[0] = captures[0];
2117 4543 : if (TREE_TYPE (_o1[0]) != stype)
2118 : {
2119 4543 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
2120 : }
2121 : else
2122 : _r1 = _o1[0];
2123 4543 : res_op0 = _r1;
2124 : }
2125 4543 : tree res_op1;
2126 4543 : res_op1 = build_int_cst (stype, 0);
2127 4543 : tree _r;
2128 4543 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
2129 4543 : if (TREE_SIDE_EFFECTS (captures[1]))
2130 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2131 4543 : if (TREE_SIDE_EFFECTS (captures[2]))
2132 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2133 4543 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 606, __FILE__, __LINE__, true);
2134 4543 : return _r;
2135 : }
2136 0 : next_after_fail736:;
2137 : }
2138 : }
2139 : return NULL_TREE;
2140 : }
2141 :
2142 : tree
2143 0 : generic_simplify_417 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2144 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2145 : const enum tree_code ARG_UNUSED (cmp),
2146 : const enum tree_code ARG_UNUSED (out))
2147 : {
2148 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2149 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2])) && !VECTOR_TYPE_P (TREE_TYPE (captures[2]))
2150 : )
2151 : {
2152 0 : {
2153 0 : tree t = TREE_TYPE (captures[2]), cpx = build_complex_type (t);
2154 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail742;
2155 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail742;
2156 0 : {
2157 0 : tree res_op0;
2158 0 : {
2159 0 : tree _o1[1], _r1;
2160 0 : {
2161 0 : tree _o2[2], _r2;
2162 0 : _o2[0] = captures[2];
2163 0 : _o2[1] = captures[1];
2164 0 : _r2 = maybe_build_call_expr_loc (loc, CFN_MUL_OVERFLOW, cpx, 2, _o2[0], _o2[1]);
2165 0 : if (!_r2)
2166 0 : goto next_after_fail742;
2167 0 : _o1[0] = _r2;
2168 : }
2169 0 : _r1 = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
2170 0 : res_op0 = _r1;
2171 : }
2172 0 : tree res_op1;
2173 0 : res_op1 = build_zero_cst (t);
2174 0 : tree _r;
2175 0 : _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
2176 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 594, __FILE__, __LINE__, true);
2177 0 : return _r;
2178 : }
2179 : next_after_fail742:;
2180 : }
2181 : }
2182 : return NULL_TREE;
2183 : }
2184 :
2185 : tree
2186 390 : generic_simplify_423 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2187 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2188 : const enum tree_code ARG_UNUSED (shift),
2189 : const enum tree_code ARG_UNUSED (mod))
2190 : {
2191 390 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2192 390 : if (integer_pow2p (captures[3]) && tree_int_cst_sgn (captures[3]) > 0
2193 : )
2194 : {
2195 312 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail752;
2196 312 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail752;
2197 312 : {
2198 312 : tree res_op0;
2199 312 : res_op0 = captures[0];
2200 312 : tree res_op1;
2201 312 : {
2202 312 : tree _o1[2], _r1;
2203 312 : _o1[0] = captures[1];
2204 312 : {
2205 312 : tree _o2[2], _r2;
2206 312 : _o2[0] = captures[2];
2207 312 : _o2[1] = build_int_cst (TREE_TYPE (captures[2]),
2208 : 1);
2209 312 : _r2 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
2210 312 : _o1[1] = _r2;
2211 : }
2212 312 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2213 312 : res_op1 = _r1;
2214 : }
2215 312 : tree _r;
2216 312 : _r = fold_build2_loc (loc, shift, type, res_op0, res_op1);
2217 312 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 618, __FILE__, __LINE__, true);
2218 312 : return _r;
2219 : }
2220 : next_after_fail752:;
2221 : }
2222 : return NULL_TREE;
2223 : }
2224 :
2225 : tree
2226 67 : generic_simplify_433 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2227 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2228 : {
2229 67 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2230 67 : if (wi::ltu_p (wi::to_wide (captures[1]), element_precision (type))
2231 : )
2232 : {
2233 67 : if (TYPE_UNSIGNED (type)
2234 : )
2235 : {
2236 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail765;
2237 2 : {
2238 2 : tree res_op0;
2239 2 : {
2240 2 : tree _o1[1], _r1;
2241 2 : _o1[0] = captures[0];
2242 2 : if (TREE_TYPE (_o1[0]) != type)
2243 : {
2244 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2245 : }
2246 : else
2247 : _r1 = _o1[0];
2248 2 : res_op0 = _r1;
2249 : }
2250 2 : tree res_op1;
2251 2 : {
2252 2 : tree _o1[2], _r1;
2253 2 : _o1[0] = build_minus_one_cst (type);
2254 2 : _o1[1] = captures[1];
2255 2 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2256 2 : res_op1 = _r1;
2257 : }
2258 2 : tree _r;
2259 2 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2260 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 629, __FILE__, __LINE__, true);
2261 2 : return _r;
2262 : }
2263 0 : next_after_fail765:;
2264 : }
2265 : else
2266 : {
2267 65 : if (INTEGRAL_TYPE_P (type)
2268 : )
2269 : {
2270 65 : {
2271 65 : int width = element_precision (type) - tree_to_uhwi (captures[1]);
2272 65 : tree stype = NULL_TREE;
2273 130 : if (width <= MAX_FIXED_MODE_SIZE)
2274 65 : stype = build_nonstandard_integer_type (width, 0);
2275 65 : if (stype && (width == 1 || type_has_mode_precision_p (stype))
2276 : )
2277 : {
2278 25 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail766;
2279 25 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail766;
2280 25 : {
2281 25 : tree res_op0;
2282 25 : {
2283 25 : tree _o1[1], _r1;
2284 25 : _o1[0] = captures[0];
2285 25 : if (TREE_TYPE (_o1[0]) != stype)
2286 : {
2287 25 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
2288 : }
2289 : else
2290 : _r1 = _o1[0];
2291 25 : res_op0 = _r1;
2292 : }
2293 25 : tree _r;
2294 25 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2295 25 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 630, __FILE__, __LINE__, true);
2296 25 : return _r;
2297 : }
2298 : next_after_fail766:;
2299 : }
2300 : }
2301 : }
2302 : }
2303 : }
2304 : return NULL_TREE;
2305 : }
2306 :
2307 : tree
2308 988734 : generic_simplify_440 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2309 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2310 : const enum tree_code ARG_UNUSED (op))
2311 : {
2312 988734 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2313 988734 : if (INTEGRAL_TYPE_P (type)
2314 880614 : && op != MULT_EXPR
2315 880614 : && op != RDIV_EXPR
2316 529593 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2317 468690 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2318 468690 : && type_has_mode_precision_p (TREE_TYPE (captures[2]))
2319 420096 : && type_has_mode_precision_p (TREE_TYPE (captures[4]))
2320 419813 : && type_has_mode_precision_p (type)
2321 419791 : && TYPE_PRECISION (TREE_TYPE (captures[1])) > TYPE_PRECISION (TREE_TYPE (captures[2]))
2322 24275 : && types_match (captures[2], type)
2323 991435 : && (types_match (captures[2], captures[4])
2324 2632 : || poly_int_tree_p (captures[3]))
2325 : )
2326 : {
2327 69 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))
2328 : )
2329 : {
2330 15 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail778;
2331 15 : {
2332 15 : tree res_op0;
2333 15 : res_op0 = captures[2];
2334 15 : tree res_op1;
2335 15 : {
2336 15 : tree _o1[1], _r1;
2337 15 : _o1[0] = captures[4];
2338 15 : if (TREE_TYPE (_o1[0]) != type)
2339 : {
2340 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2341 : }
2342 : else
2343 : _r1 = _o1[0];
2344 15 : res_op1 = _r1;
2345 : }
2346 15 : tree _r;
2347 15 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2348 15 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 642, __FILE__, __LINE__, true);
2349 15 : return _r;
2350 : }
2351 0 : next_after_fail778:;
2352 : }
2353 : else
2354 : {
2355 54 : {
2356 54 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
2357 54 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail779;
2358 54 : {
2359 54 : tree res_op0;
2360 54 : {
2361 54 : tree _o1[2], _r1;
2362 54 : {
2363 54 : tree _o2[1], _r2;
2364 54 : _o2[0] = captures[2];
2365 54 : if (TREE_TYPE (_o2[0]) != utype)
2366 : {
2367 54 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2368 : }
2369 : else
2370 : _r2 = _o2[0];
2371 54 : _o1[0] = _r2;
2372 : }
2373 54 : {
2374 54 : tree _o2[1], _r2;
2375 54 : _o2[0] = captures[4];
2376 54 : if (TREE_TYPE (_o2[0]) != utype)
2377 : {
2378 54 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2379 : }
2380 : else
2381 : _r2 = _o2[0];
2382 54 : _o1[1] = _r2;
2383 : }
2384 54 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2385 54 : res_op0 = _r1;
2386 : }
2387 54 : tree _r;
2388 54 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2389 54 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 643, __FILE__, __LINE__, true);
2390 54 : return _r;
2391 : }
2392 0 : next_after_fail779:;
2393 : }
2394 : }
2395 : }
2396 : else
2397 : {
2398 976096 : if (FLOAT_TYPE_P (type)
2399 1001234 : && DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
2400 12569 : == DECIMAL_FLOAT_TYPE_P (type)
2401 : )
2402 : {
2403 12546 : {
2404 12546 : tree arg0 = strip_float_extensions (captures[2]);
2405 12546 : tree arg1 = strip_float_extensions (captures[4]);
2406 12546 : tree itype = TREE_TYPE (captures[0]);
2407 12546 : tree ty1 = TREE_TYPE (arg0);
2408 12546 : tree ty2 = TREE_TYPE (arg1);
2409 12546 : enum tree_code code = TREE_CODE (itype);
2410 0 : if (FLOAT_TYPE_P (ty1)
2411 12546 : && FLOAT_TYPE_P (ty2)
2412 : )
2413 : {
2414 12546 : {
2415 12546 : tree newtype = type;
2416 12546 : if (TYPE_MODE (ty1) == SDmode
2417 12537 : || TYPE_MODE (ty2) == SDmode
2418 25083 : || TYPE_MODE (type) == SDmode)
2419 9 : newtype = dfloat32_type_node;
2420 12546 : if (TYPE_MODE (ty1) == DDmode
2421 12540 : || TYPE_MODE (ty2) == DDmode
2422 25086 : || TYPE_MODE (type) == DDmode)
2423 6 : newtype = dfloat64_type_node;
2424 12546 : if (TYPE_MODE (ty1) == TDmode
2425 12546 : || TYPE_MODE (ty2) == TDmode
2426 25092 : || TYPE_MODE (type) == TDmode)
2427 15 : newtype = dfloat128_type_node;
2428 12546 : if ((newtype == dfloat32_type_node
2429 12546 : || newtype == dfloat64_type_node
2430 12546 : || newtype == dfloat128_type_node)
2431 15 : && newtype == type
2432 12552 : && types_match (newtype, type)
2433 : )
2434 : {
2435 6 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail780;
2436 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail780;
2437 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail780;
2438 0 : {
2439 0 : tree res_op0;
2440 0 : {
2441 0 : tree _o1[1], _r1;
2442 0 : _o1[0] = captures[2];
2443 0 : if (TREE_TYPE (_o1[0]) != newtype)
2444 : {
2445 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
2446 : }
2447 : else
2448 : _r1 = _o1[0];
2449 0 : res_op0 = _r1;
2450 : }
2451 0 : tree res_op1;
2452 0 : {
2453 0 : tree _o1[1], _r1;
2454 0 : _o1[0] = captures[4];
2455 0 : if (TREE_TYPE (_o1[0]) != newtype)
2456 : {
2457 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
2458 : }
2459 : else
2460 : _r1 = _o1[0];
2461 0 : res_op1 = _r1;
2462 : }
2463 0 : tree _r;
2464 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2465 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 644, __FILE__, __LINE__, true);
2466 0 : return _r;
2467 : }
2468 : next_after_fail780:;
2469 : }
2470 : else
2471 : {
2472 12540 : {
2473 12540 : if (element_precision (ty1) > element_precision (newtype))
2474 4 : newtype = ty1;
2475 12540 : if (element_precision (ty2) > element_precision (newtype))
2476 10 : newtype = ty2;
2477 12540 : if (element_precision (newtype) < element_precision (itype)
2478 12268 : && (!VECTOR_MODE_P (TYPE_MODE (newtype))
2479 0 : || target_supports_op_p (newtype, op, optab_default))
2480 12268 : && (flag_unsafe_math_optimizations
2481 12251 : || (element_precision (newtype) == element_precision (type)
2482 12247 : && real_can_shorten_arithmetic (element_mode (itype),
2483 : element_mode (type))
2484 4448 : && !excess_precision_type (newtype)))
2485 12565 : && !types_match (itype, newtype)
2486 : )
2487 : {
2488 25 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail781;
2489 25 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail781;
2490 17 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail781;
2491 17 : {
2492 17 : tree res_op0;
2493 17 : {
2494 17 : tree _o1[2], _r1;
2495 17 : {
2496 17 : tree _o2[1], _r2;
2497 17 : _o2[0] = captures[2];
2498 17 : if (TREE_TYPE (_o2[0]) != newtype)
2499 : {
2500 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
2501 : }
2502 : else
2503 : _r2 = _o2[0];
2504 17 : _o1[0] = _r2;
2505 : }
2506 17 : {
2507 17 : tree _o2[1], _r2;
2508 17 : _o2[0] = captures[4];
2509 17 : if (TREE_TYPE (_o2[0]) != newtype)
2510 : {
2511 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
2512 : }
2513 : else
2514 : _r2 = _o2[0];
2515 17 : _o1[1] = _r2;
2516 : }
2517 17 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2518 17 : res_op0 = _r1;
2519 : }
2520 17 : tree _r;
2521 17 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2522 17 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 645, __FILE__, __LINE__, true);
2523 17 : return _r;
2524 : }
2525 : next_after_fail781:;
2526 : }
2527 : }
2528 : }
2529 : }
2530 : }
2531 : }
2532 : }
2533 : }
2534 : return NULL_TREE;
2535 : }
2536 :
2537 : tree
2538 104 : generic_simplify_471 (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 104 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2542 104 : {
2543 104 : bool wascmp;
2544 104 : if (bitwise_inverted_equal_p (captures[0], captures[2], wascmp)
2545 104 : && (!wascmp || element_precision (type) == 1)
2546 : )
2547 : {
2548 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail821;
2549 0 : {
2550 0 : tree res_op0;
2551 0 : res_op0 = captures[0];
2552 0 : tree res_op1;
2553 0 : res_op1 = captures[1];
2554 0 : tree _r;
2555 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2556 0 : if (TREE_SIDE_EFFECTS (captures[2]))
2557 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2558 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 672, __FILE__, __LINE__, true);
2559 0 : return _r;
2560 : }
2561 0 : next_after_fail821:;
2562 : }
2563 : }
2564 104 : return NULL_TREE;
2565 : }
2566 :
2567 : tree
2568 5711304 : generic_simplify_477 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2569 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2570 : {
2571 5711304 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2572 11234424 : if (POINTER_TYPE_P (TREE_TYPE (captures[0]))
2573 5711324 : && tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
2574 : )
2575 : {
2576 188204 : {
2577 188204 : unsigned int align;
2578 188204 : unsigned HOST_WIDE_INT bitpos;
2579 188204 : get_pointer_alignment_1 (captures[0], &align, &bitpos);
2580 188204 : if (wi::ltu_p (wi::to_wide (captures[1]), align / BITS_PER_UNIT)
2581 : )
2582 : {
2583 6886 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail827;
2584 6886 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail827;
2585 6886 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail827;
2586 6886 : {
2587 6886 : tree _r;
2588 13772 : _r = wide_int_to_tree (type, (wi::to_wide (captures[1])
2589 13772 : & (bitpos / BITS_PER_UNIT)));
2590 6886 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 677, __FILE__, __LINE__, true);
2591 6886 : return _r;
2592 : }
2593 181318 : next_after_fail827:;
2594 : }
2595 : }
2596 : }
2597 : return NULL_TREE;
2598 : }
2599 :
2600 : tree
2601 0 : generic_simplify_487 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2602 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2603 : const enum tree_code ARG_UNUSED (code2),
2604 : const enum tree_code ARG_UNUSED (code1))
2605 : {
2606 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2607 0 : if ((TREE_CODE (captures[2]) == INTEGER_CST
2608 0 : && TREE_CODE (captures[5]) == INTEGER_CST)
2609 0 : || ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2610 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[2]))
2611 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[2])))
2612 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, code2))
2613 0 : || POINTER_TYPE_P (TREE_TYPE (captures[2])))
2614 0 : && bitwise_equal_p (captures[2], captures[5]))
2615 : )
2616 : {
2617 0 : {
2618 0 : bool one_before = false;
2619 0 : bool one_after = false;
2620 0 : int cmp = 0;
2621 0 : bool allbits = true;
2622 0 : if (TREE_CODE (captures[2]) == INTEGER_CST
2623 0 : && TREE_CODE (captures[5]) == INTEGER_CST)
2624 : {
2625 0 : allbits = TYPE_PRECISION (TREE_TYPE (captures[2])) <= TYPE_PRECISION (TREE_TYPE (captures[5]));
2626 0 : auto t1 = wi::to_wide (fold_convert (TREE_TYPE (captures[5]), captures[2]));
2627 0 : auto t2 = wi::to_wide (captures[5]);
2628 0 : cmp = wi::cmp (t1, t2, TYPE_SIGN (TREE_TYPE (captures[5])));
2629 0 : if (cmp < 0
2630 0 : && t1 == t2 - 1)
2631 : one_before = true;
2632 0 : if (cmp > 0
2633 0 : && t1 == t2 + 1)
2634 : one_after = true;
2635 : }
2636 0 : bool val;
2637 0 : switch (code2)
2638 : {
2639 0 : case EQ_EXPR: val = (cmp == 0); break;
2640 0 : case NE_EXPR: val = (cmp != 0); break;
2641 0 : case LT_EXPR: val = (cmp < 0); break;
2642 0 : case GT_EXPR: val = (cmp > 0); break;
2643 0 : case LE_EXPR: val = (cmp <= 0); break;
2644 0 : case GE_EXPR: val = (cmp >= 0); break;
2645 0 : default: gcc_unreachable ();
2646 : }
2647 0 : if (code1 == EQ_EXPR && val
2648 : )
2649 : {
2650 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail859;
2651 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail859;
2652 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail859;
2653 0 : {
2654 0 : tree _r;
2655 0 : _r = captures[0];
2656 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 682, __FILE__, __LINE__, true);
2657 0 : return _r;
2658 : }
2659 : next_after_fail859:;
2660 : }
2661 : else
2662 : {
2663 0 : if (code1 == EQ_EXPR && !val
2664 : )
2665 : {
2666 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail860;
2667 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail860;
2668 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail860;
2669 0 : {
2670 0 : tree _r;
2671 0 : _r = constant_boolean_node (false, type);
2672 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2673 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2674 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 683, __FILE__, __LINE__, true);
2675 0 : return _r;
2676 : }
2677 : next_after_fail860:;
2678 : }
2679 : else
2680 : {
2681 0 : if (code1 == NE_EXPR && !val && allbits
2682 : )
2683 : {
2684 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail861;
2685 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail861;
2686 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail861;
2687 0 : {
2688 0 : tree _r;
2689 0 : _r = captures[3];
2690 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 684, __FILE__, __LINE__, true);
2691 0 : return _r;
2692 : }
2693 : next_after_fail861:;
2694 : }
2695 : else
2696 : {
2697 0 : if ((code1 == NE_EXPR
2698 0 : && code2 == GE_EXPR
2699 0 : && cmp == 0
2700 0 : && allbits)
2701 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
2702 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GT_EXPR))
2703 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
2704 : )
2705 : {
2706 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail862;
2707 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail862;
2708 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail862;
2709 0 : {
2710 0 : tree res_op0;
2711 0 : res_op0 = captures[4];
2712 0 : tree res_op1;
2713 0 : {
2714 0 : tree _o1[1], _r1;
2715 0 : _o1[0] = captures[2];
2716 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
2717 : {
2718 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
2719 : }
2720 : else
2721 : _r1 = _o1[0];
2722 0 : res_op1 = _r1;
2723 : }
2724 0 : tree _r;
2725 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
2726 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 685, __FILE__, __LINE__, true);
2727 0 : return _r;
2728 : }
2729 : next_after_fail862:;
2730 : }
2731 : else
2732 : {
2733 0 : if ((code1 == NE_EXPR
2734 0 : && code2 == LE_EXPR
2735 0 : && cmp == 0
2736 0 : && allbits)
2737 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
2738 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LT_EXPR))
2739 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
2740 : )
2741 : {
2742 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail863;
2743 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail863;
2744 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail863;
2745 0 : {
2746 0 : tree res_op0;
2747 0 : res_op0 = captures[4];
2748 0 : tree res_op1;
2749 0 : {
2750 0 : tree _o1[1], _r1;
2751 0 : _o1[0] = captures[2];
2752 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
2753 : {
2754 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
2755 : }
2756 : else
2757 : _r1 = _o1[0];
2758 0 : res_op1 = _r1;
2759 : }
2760 0 : tree _r;
2761 0 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
2762 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 686, __FILE__, __LINE__, true);
2763 0 : return _r;
2764 : }
2765 : next_after_fail863:;
2766 : }
2767 : else
2768 : {
2769 0 : if ((code1 == NE_EXPR
2770 0 : && code2 == GT_EXPR
2771 : && one_after
2772 0 : && allbits)
2773 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
2774 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GT_EXPR))
2775 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
2776 : )
2777 : {
2778 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail864;
2779 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail864;
2780 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail864;
2781 0 : {
2782 0 : tree res_op0;
2783 0 : res_op0 = captures[4];
2784 0 : tree res_op1;
2785 0 : {
2786 0 : tree _o1[1], _r1;
2787 0 : _o1[0] = captures[2];
2788 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
2789 : {
2790 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
2791 : }
2792 : else
2793 : _r1 = _o1[0];
2794 0 : res_op1 = _r1;
2795 : }
2796 0 : tree _r;
2797 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
2798 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 687, __FILE__, __LINE__, true);
2799 0 : return _r;
2800 : }
2801 : next_after_fail864:;
2802 : }
2803 : else
2804 : {
2805 0 : if ((code1 == NE_EXPR
2806 0 : && code2 == LT_EXPR
2807 : && one_before
2808 0 : && allbits)
2809 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
2810 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LT_EXPR))
2811 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
2812 : )
2813 : {
2814 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail865;
2815 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail865;
2816 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail865;
2817 0 : {
2818 0 : tree res_op0;
2819 0 : res_op0 = captures[4];
2820 0 : tree res_op1;
2821 0 : {
2822 0 : tree _o1[1], _r1;
2823 0 : _o1[0] = captures[2];
2824 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
2825 : {
2826 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
2827 : }
2828 : else
2829 : _r1 = _o1[0];
2830 0 : res_op1 = _r1;
2831 : }
2832 0 : tree _r;
2833 0 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
2834 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 688, __FILE__, __LINE__, true);
2835 0 : return _r;
2836 : }
2837 : next_after_fail865:;
2838 : }
2839 : }
2840 : }
2841 : }
2842 : }
2843 : }
2844 : }
2845 : }
2846 : }
2847 : return NULL_TREE;
2848 : }
2849 :
2850 : tree
2851 2 : generic_simplify_517 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2852 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2853 : const enum tree_code ARG_UNUSED (rotate))
2854 : {
2855 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2856 2 : if ((element_precision (TREE_TYPE (captures[2]))
2857 2 : <= element_precision (TREE_TYPE (captures[3]))
2858 0 : || !TYPE_UNSIGNED (TREE_TYPE (captures[3])))
2859 2 : && (element_precision (type) <= element_precision (TREE_TYPE (captures[2]))
2860 0 : || !TYPE_UNSIGNED (TREE_TYPE (captures[2])))
2861 : )
2862 : {
2863 2 : {
2864 2 : tree rotate_type = TREE_TYPE (captures[2]);
2865 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail911;
2866 2 : {
2867 2 : tree res_op0;
2868 2 : {
2869 2 : tree _o1[2], _r1;
2870 2 : {
2871 2 : tree _o2[1], _r2;
2872 2 : _o2[0] = captures[3];
2873 2 : if (TREE_TYPE (_o2[0]) != rotate_type)
2874 : {
2875 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, rotate_type, _o2[0]);
2876 : }
2877 : else
2878 : _r2 = _o2[0];
2879 2 : _o1[0] = _r2;
2880 : }
2881 2 : _o1[1] = captures[4];
2882 2 : _r1 = fold_build2_loc (loc, rotate, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2883 2 : res_op0 = _r1;
2884 : }
2885 2 : tree _r;
2886 2 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2887 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 720, __FILE__, __LINE__, true);
2888 2 : return _r;
2889 : }
2890 0 : next_after_fail911:;
2891 : }
2892 : }
2893 : return NULL_TREE;
2894 : }
2895 :
2896 : tree
2897 4 : generic_simplify_530 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2898 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2899 : {
2900 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2901 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail926;
2902 4 : {
2903 4 : tree _r;
2904 4 : _r = captures[1];
2905 4 : if (TREE_SIDE_EFFECTS (captures[0]))
2906 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2907 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 735, __FILE__, __LINE__, true);
2908 : return _r;
2909 : }
2910 0 : next_after_fail926:;
2911 0 : return NULL_TREE;
2912 : }
2913 :
2914 : tree
2915 20 : generic_simplify_539 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2916 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2917 : const enum tree_code ARG_UNUSED (minmax),
2918 : const enum tree_code ARG_UNUSED (cmp))
2919 : {
2920 20 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2921 20 : {
2922 20 : poly_int64 off0, off1;
2923 20 : tree base0, base1;
2924 20 : int equal = address_compare (cmp, TREE_TYPE (captures[0]), captures[1], captures[3], base0, base1,
2925 : off0, off1,
2926 : 1
2927 : );
2928 20 : if (equal == 1
2929 : )
2930 : {
2931 0 : if (minmax == MIN_EXPR
2932 : )
2933 : {
2934 0 : if (known_le (off0, off1)
2935 : )
2936 : {
2937 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail946;
2938 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail946;
2939 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail946;
2940 0 : {
2941 0 : tree _r;
2942 0 : _r = captures[0];
2943 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 743, __FILE__, __LINE__, true);
2944 0 : return _r;
2945 : }
2946 20 : next_after_fail946:;
2947 : }
2948 : else
2949 : {
2950 0 : if (known_gt (off0, off1)
2951 : )
2952 : {
2953 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail947;
2954 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail947;
2955 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail947;
2956 0 : {
2957 0 : tree _r;
2958 0 : _r = captures[2];
2959 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 744, __FILE__, __LINE__, true);
2960 0 : return _r;
2961 : }
2962 20 : next_after_fail947:;
2963 : }
2964 : }
2965 : }
2966 : else
2967 : {
2968 0 : if (known_ge (off0, off1)
2969 : )
2970 : {
2971 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail948;
2972 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail948;
2973 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail948;
2974 0 : {
2975 0 : tree _r;
2976 0 : _r = captures[0];
2977 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 745, __FILE__, __LINE__, true);
2978 0 : return _r;
2979 : }
2980 20 : next_after_fail948:;
2981 : }
2982 : else
2983 : {
2984 0 : if (known_lt (off0, off1)
2985 : )
2986 : {
2987 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail949;
2988 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail949;
2989 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail949;
2990 0 : {
2991 0 : tree _r;
2992 0 : _r = captures[2];
2993 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 746, __FILE__, __LINE__, true);
2994 0 : return _r;
2995 : }
2996 20 : next_after_fail949:;
2997 : }
2998 : }
2999 : }
3000 : }
3001 : }
3002 20 : return NULL_TREE;
3003 : }
3004 :
3005 : tree
3006 0 : generic_simplify_559 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3007 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
3008 : const combined_fn ARG_UNUSED (cond_len_op))
3009 : {
3010 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3011 0 : {
3012 0 : tree op_type = TREE_TYPE (captures[3]);
3013 0 : if (element_precision (type) == element_precision (op_type)
3014 : )
3015 : {
3016 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail969;
3017 0 : {
3018 0 : tree res_op0;
3019 0 : {
3020 0 : tree _o1[6], _r1;
3021 0 : _o1[0] = captures[0];
3022 0 : _o1[1] = captures[1];
3023 0 : _o1[2] = captures[2];
3024 0 : {
3025 0 : tree _o2[1], _r2;
3026 0 : _o2[0] = captures[6];
3027 0 : if (TREE_TYPE (_o2[0]) != op_type)
3028 : {
3029 0 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
3030 : }
3031 : else
3032 : _r2 = _o2[0];
3033 0 : _o1[3] = _r2;
3034 : }
3035 0 : _o1[4] = captures[4];
3036 0 : _o1[5] = captures[5];
3037 0 : _r1 = maybe_build_call_expr_loc (loc, cond_len_op, TREE_TYPE (_o1[1]), 6, _o1[0], _o1[1], _o1[2], _o1[3], _o1[4], _o1[5]);
3038 0 : if (!_r1)
3039 0 : goto next_after_fail969;
3040 0 : res_op0 = _r1;
3041 : }
3042 0 : tree _r;
3043 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3044 0 : if (TREE_SIDE_EFFECTS (captures[3]))
3045 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
3046 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 761, __FILE__, __LINE__, true);
3047 0 : return _r;
3048 : }
3049 : next_after_fail969:;
3050 : }
3051 : }
3052 : return NULL_TREE;
3053 : }
3054 :
3055 : tree
3056 1 : generic_simplify_568 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3057 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
3058 : {
3059 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3060 1 : if (tree_nop_conversion_p (TREE_TYPE (captures[0]), type)
3061 : )
3062 : {
3063 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail981;
3064 1 : {
3065 1 : tree res_op0;
3066 1 : {
3067 1 : tree _o1[1], _r1;
3068 1 : _o1[0] = captures[0];
3069 1 : if (TREE_TYPE (_o1[0]) != type)
3070 : {
3071 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3072 : }
3073 : else
3074 : _r1 = _o1[0];
3075 1 : res_op0 = _r1;
3076 : }
3077 1 : tree _r;
3078 1 : _r = non_lvalue_loc (loc, res_op0);
3079 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 773, __FILE__, __LINE__, true);
3080 1 : return _r;
3081 : }
3082 0 : next_after_fail981:;
3083 : }
3084 : return NULL_TREE;
3085 : }
3086 :
3087 : tree
3088 0 : generic_simplify_578 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3089 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3090 : const combined_fn ARG_UNUSED (logs))
3091 : {
3092 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3093 0 : if (flag_unsafe_math_optimizations
3094 : )
3095 : {
3096 0 : if (! HONOR_SIGN_DEPENDENT_ROUNDING (type)
3097 0 : && ! HONOR_NANS (type) && ! HONOR_INFINITIES (type)
3098 0 : && ! flag_trapping_math
3099 0 : && ! flag_errno_math
3100 : )
3101 : {
3102 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail991;
3103 0 : {
3104 0 : tree res_op0;
3105 0 : {
3106 0 : tree _o1[1], _r1;
3107 0 : _o1[0] = captures[1];
3108 0 : _r1 = maybe_build_call_expr_loc (loc, logs, TREE_TYPE (_o1[0]), 1, _o1[0]);
3109 0 : if (!_r1)
3110 0 : goto next_after_fail991;
3111 0 : if (EXPR_P (_r1))
3112 0 : goto next_after_fail991;
3113 0 : res_op0 = _r1;
3114 : }
3115 0 : tree res_op1;
3116 0 : {
3117 0 : tree _o1[1], _r1;
3118 0 : _o1[0] = captures[2];
3119 0 : _r1 = maybe_build_call_expr_loc (loc, logs, TREE_TYPE (_o1[0]), 1, _o1[0]);
3120 0 : if (!_r1)
3121 0 : goto next_after_fail991;
3122 0 : res_op1 = _r1;
3123 : }
3124 0 : tree _r;
3125 0 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
3126 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 783, __FILE__, __LINE__, true);
3127 0 : return _r;
3128 : }
3129 : next_after_fail991:;
3130 : }
3131 : }
3132 : return NULL_TREE;
3133 : }
3134 :
3135 : tree
3136 0 : generic_simplify_591 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3137 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3138 : const combined_fn ARG_UNUSED (froms),
3139 : const combined_fn ARG_UNUSED (tos))
3140 : {
3141 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3142 0 : if (optimize && canonicalize_math_p ()
3143 : )
3144 : {
3145 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1004;
3146 0 : {
3147 0 : tree res_op0;
3148 0 : res_op0 = captures[0];
3149 0 : tree _r;
3150 0 : _r = maybe_build_call_expr_loc (loc, tos, type, 1, res_op0);
3151 0 : if (!_r)
3152 0 : goto next_after_fail1004;
3153 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 796, __FILE__, __LINE__, true);
3154 0 : return _r;
3155 : }
3156 : next_after_fail1004:;
3157 : }
3158 : return NULL_TREE;
3159 : }
3160 :
3161 : tree
3162 0 : generic_simplify_599 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3163 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
3164 : const combined_fn ARG_UNUSED (fmas))
3165 : {
3166 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3167 0 : if (canonicalize_math_after_vectorization_p ()
3168 : )
3169 : {
3170 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1012;
3171 : {
3172 : tree res_op0;
3173 : res_op0 = captures[0];
3174 : tree res_op1;
3175 : res_op1 = captures[1];
3176 : tree res_op2;
3177 : res_op2 = captures[2];
3178 : tree _r;
3179 : _r = maybe_build_call_expr_loc (loc, CFN_FNMA, type, 3, res_op0, res_op1, res_op2);
3180 : if (!_r)
3181 : goto next_after_fail1012;
3182 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 804, __FILE__, __LINE__, true);
3183 : return _r;
3184 : }
3185 0 : next_after_fail1012:;
3186 : }
3187 0 : return NULL_TREE;
3188 : }
3189 :
3190 : tree
3191 0 : generic_simplify_609 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3192 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree ARG_UNUSED (_p3), tree ARG_UNUSED (_p4), tree *ARG_UNUSED (captures),
3193 : const combined_fn ARG_UNUSED (fmas))
3194 : {
3195 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3196 0 : if (canonicalize_math_after_vectorization_p ()
3197 : )
3198 : {
3199 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1022;
3200 : {
3201 : tree res_op0;
3202 : res_op0 = captures[0];
3203 : tree res_op1;
3204 : res_op1 = captures[1];
3205 : tree res_op2;
3206 : res_op2 = captures[2];
3207 : tree res_op3;
3208 : res_op3 = captures[3];
3209 : tree res_op4;
3210 : res_op4 = captures[4];
3211 : tree _r;
3212 : _r = maybe_build_call_expr_loc (loc, CFN_COND_FNMA, type, 5, res_op0, res_op1, res_op2, res_op3, res_op4);
3213 : if (!_r)
3214 : goto next_after_fail1022;
3215 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 814, __FILE__, __LINE__, true);
3216 : return _r;
3217 : }
3218 0 : next_after_fail1022:;
3219 : }
3220 0 : return NULL_TREE;
3221 : }
3222 :
3223 : tree
3224 0 : generic_simplify_618 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3225 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3226 : const combined_fn ARG_UNUSED (ctz))
3227 : {
3228 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3229 0 : {
3230 0 : tree t = TREE_TYPE (captures[0]);
3231 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1031;
3232 0 : {
3233 0 : tree res_op0;
3234 0 : {
3235 0 : tree _o1[1], _r1;
3236 0 : _o1[0] = captures[1];
3237 0 : if (TREE_TYPE (_o1[0]) != t)
3238 : {
3239 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, t, _o1[0]);
3240 : }
3241 : else
3242 : _r1 = _o1[0];
3243 0 : res_op0 = _r1;
3244 : }
3245 0 : tree _r;
3246 0 : _r = maybe_build_call_expr_loc (loc, ctz, type, 1, res_op0);
3247 0 : if (!_r)
3248 0 : goto next_after_fail1031;
3249 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 822, __FILE__, __LINE__, true);
3250 : return _r;
3251 : }
3252 : next_after_fail1031:;
3253 : }
3254 : return NULL_TREE;
3255 : }
3256 :
3257 : tree
3258 0 : generic_simplify_628 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3259 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3260 : const combined_fn ARG_UNUSED (bswap),
3261 : const combined_fn ARG_UNUSED (parity))
3262 : {
3263 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3264 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3265 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
3266 0 : && TYPE_PRECISION (TREE_TYPE (captures[0]))
3267 0 : >= TYPE_PRECISION (TREE_TYPE (captures[1]))
3268 : )
3269 : {
3270 0 : {
3271 0 : tree type0 = TREE_TYPE (captures[0]);
3272 0 : tree type1 = TREE_TYPE (captures[1]);
3273 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1043;
3274 0 : {
3275 0 : tree res_op0;
3276 0 : {
3277 0 : tree _o1[1], _r1;
3278 0 : {
3279 0 : tree _o2[1], _r2;
3280 0 : _o2[0] = captures[2];
3281 0 : if (TREE_TYPE (_o2[0]) != type1)
3282 : {
3283 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, type1, _o2[0]);
3284 : }
3285 : else
3286 : _r2 = _o2[0];
3287 0 : _o1[0] = _r2;
3288 : }
3289 0 : if (TREE_TYPE (_o1[0]) != type0)
3290 : {
3291 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type0, _o1[0]);
3292 : }
3293 : else
3294 : _r1 = _o1[0];
3295 0 : res_op0 = _r1;
3296 : }
3297 0 : tree _r;
3298 0 : _r = maybe_build_call_expr_loc (loc, parity, type, 1, res_op0);
3299 0 : if (!_r)
3300 0 : goto next_after_fail1043;
3301 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 830, __FILE__, __LINE__, true);
3302 0 : return _r;
3303 : }
3304 : next_after_fail1043:;
3305 : }
3306 : }
3307 : return NULL_TREE;
3308 : }
3309 :
3310 : tree
3311 872068504 : generic_simplify_CONVERT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0)
3312 : {
3313 872068504 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3314 872068504 : switch (TREE_CODE (_p0))
3315 : {
3316 772456 : case NEGATE_EXPR:
3317 772456 : {
3318 772456 : tree _q20 = TREE_OPERAND (_p0, 0);
3319 772456 : switch (TREE_CODE (_q20))
3320 : {
3321 447652 : CASE_CONVERT:
3322 447652 : {
3323 447652 : tree _q30 = TREE_OPERAND (_q20, 0);
3324 447652 : {
3325 447652 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q30 };
3326 447652 : if (INTEGRAL_TYPE_P (type)
3327 447351 : && tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
3328 443372 : && (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (captures[2]))
3329 442110 : || TYPE_UNSIGNED (type))
3330 465298 : && TREE_CODE (type) != BOOLEAN_TYPE
3331 : )
3332 : {
3333 17646 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1057;
3334 17646 : {
3335 17646 : tree res_op0;
3336 17646 : {
3337 17646 : tree _o1[1], _r1;
3338 17646 : _o1[0] = captures[2];
3339 17646 : if (TREE_TYPE (_o1[0]) != type)
3340 : {
3341 17604 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3342 : }
3343 : else
3344 : _r1 = _o1[0];
3345 17646 : res_op0 = _r1;
3346 : }
3347 17646 : tree _r;
3348 17646 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
3349 17646 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 842, __FILE__, __LINE__, true);
3350 17646 : return _r;
3351 : }
3352 0 : next_after_fail1057:;
3353 : }
3354 : }
3355 430006 : break;
3356 : }
3357 : default:;
3358 : }
3359 : break;
3360 : }
3361 1342679 : case BIT_AND_EXPR:
3362 1342679 : {
3363 1342679 : tree _q20 = TREE_OPERAND (_p0, 0);
3364 1342679 : tree _q21 = TREE_OPERAND (_p0, 1);
3365 1342679 : {
3366 1342679 : tree _q20_pops[1];
3367 1342679 : if (tree_nop_convert (_q20, _q20_pops))
3368 : {
3369 709590 : tree _q30 = _q20_pops[0];
3370 709590 : {
3371 709590 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3372 709590 : tree res = generic_simplify_435 (loc, type, _p0, captures, BIT_AND_EXPR);
3373 709590 : if (res) return res;
3374 : }
3375 : }
3376 : }
3377 1342679 : {
3378 1342679 : tree _q21_pops[1];
3379 1342679 : if (tree_nop_convert (_q21, _q21_pops))
3380 : {
3381 579515 : tree _q40 = _q21_pops[0];
3382 579515 : {
3383 579515 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3384 579515 : tree res = generic_simplify_435 (loc, type, _p0, captures, BIT_AND_EXPR);
3385 579515 : if (res) return res;
3386 : }
3387 : }
3388 : }
3389 1342679 : switch (TREE_CODE (_q20))
3390 : {
3391 785123 : CASE_CONVERT:
3392 785123 : {
3393 785123 : tree _q30 = TREE_OPERAND (_q20, 0);
3394 785123 : {
3395 785123 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3396 785123 : tree res = generic_simplify_436 (loc, type, _p0, captures, BIT_AND_EXPR);
3397 785123 : if (res) return res;
3398 : }
3399 785123 : break;
3400 : }
3401 1342679 : default:;
3402 : }
3403 1342679 : switch (TREE_CODE (_q21))
3404 : {
3405 580296 : CASE_CONVERT:
3406 580296 : {
3407 580296 : tree _q40 = TREE_OPERAND (_q21, 0);
3408 580296 : {
3409 580296 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3410 580296 : tree res = generic_simplify_436 (loc, type, _p0, captures, BIT_AND_EXPR);
3411 580296 : if (res) return res;
3412 : }
3413 580296 : break;
3414 : }
3415 : default:;
3416 : }
3417 : break;
3418 : }
3419 1193243 : case BIT_IOR_EXPR:
3420 1193243 : {
3421 1193243 : tree _q20 = TREE_OPERAND (_p0, 0);
3422 1193243 : tree _q21 = TREE_OPERAND (_p0, 1);
3423 1193243 : {
3424 1193243 : tree _q20_pops[1];
3425 1193243 : if (tree_nop_convert (_q20, _q20_pops))
3426 : {
3427 462739 : tree _q30 = _q20_pops[0];
3428 462739 : {
3429 462739 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3430 462739 : tree res = generic_simplify_435 (loc, type, _p0, captures, BIT_IOR_EXPR);
3431 462739 : if (res) return res;
3432 : }
3433 : }
3434 : }
3435 1193243 : {
3436 1193243 : tree _q21_pops[1];
3437 1193243 : if (tree_nop_convert (_q21, _q21_pops))
3438 : {
3439 1114359 : tree _q40 = _q21_pops[0];
3440 1114359 : {
3441 1114359 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3442 1114359 : tree res = generic_simplify_435 (loc, type, _p0, captures, BIT_IOR_EXPR);
3443 1114359 : if (res) return res;
3444 : }
3445 : }
3446 : }
3447 1193243 : switch (TREE_CODE (_q20))
3448 : {
3449 481007 : CASE_CONVERT:
3450 481007 : {
3451 481007 : tree _q30 = TREE_OPERAND (_q20, 0);
3452 481007 : {
3453 481007 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3454 481007 : tree res = generic_simplify_436 (loc, type, _p0, captures, BIT_IOR_EXPR);
3455 481007 : if (res) return res;
3456 : }
3457 481007 : break;
3458 : }
3459 1193243 : default:;
3460 : }
3461 1193243 : switch (TREE_CODE (_q21))
3462 : {
3463 1122695 : CASE_CONVERT:
3464 1122695 : {
3465 1122695 : tree _q40 = TREE_OPERAND (_q21, 0);
3466 1122695 : {
3467 1122695 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3468 1122695 : tree res = generic_simplify_436 (loc, type, _p0, captures, BIT_IOR_EXPR);
3469 1122695 : if (res) return res;
3470 : }
3471 1122695 : break;
3472 : }
3473 : default:;
3474 : }
3475 : break;
3476 : }
3477 636573 : case BIT_XOR_EXPR:
3478 636573 : {
3479 636573 : tree _q20 = TREE_OPERAND (_p0, 0);
3480 636573 : tree _q21 = TREE_OPERAND (_p0, 1);
3481 636573 : {
3482 636573 : tree _q20_pops[1];
3483 636573 : if (tree_nop_convert (_q20, _q20_pops))
3484 : {
3485 374246 : tree _q30 = _q20_pops[0];
3486 374246 : {
3487 374246 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3488 374246 : tree res = generic_simplify_435 (loc, type, _p0, captures, BIT_XOR_EXPR);
3489 374246 : if (res) return res;
3490 : }
3491 : }
3492 : }
3493 636573 : {
3494 636573 : tree _q21_pops[1];
3495 636573 : if (tree_nop_convert (_q21, _q21_pops))
3496 : {
3497 516493 : tree _q40 = _q21_pops[0];
3498 516493 : {
3499 516493 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3500 516493 : tree res = generic_simplify_435 (loc, type, _p0, captures, BIT_XOR_EXPR);
3501 516493 : if (res) return res;
3502 : }
3503 : }
3504 : }
3505 636573 : switch (TREE_CODE (_q20))
3506 : {
3507 416842 : CASE_CONVERT:
3508 416842 : {
3509 416842 : tree _q30 = TREE_OPERAND (_q20, 0);
3510 416842 : {
3511 416842 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3512 416842 : tree res = generic_simplify_436 (loc, type, _p0, captures, BIT_XOR_EXPR);
3513 416842 : if (res) return res;
3514 : }
3515 416842 : break;
3516 : }
3517 636573 : default:;
3518 : }
3519 636573 : switch (TREE_CODE (_q21))
3520 : {
3521 558082 : CASE_CONVERT:
3522 558082 : {
3523 558082 : tree _q40 = TREE_OPERAND (_q21, 0);
3524 558082 : {
3525 558082 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3526 558082 : tree res = generic_simplify_436 (loc, type, _p0, captures, BIT_XOR_EXPR);
3527 558082 : if (res) return res;
3528 : }
3529 558082 : break;
3530 : }
3531 : default:;
3532 : }
3533 : break;
3534 : }
3535 9418826 : case MULT_EXPR:
3536 9418826 : {
3537 9418826 : tree _q20 = TREE_OPERAND (_p0, 0);
3538 9418826 : tree _q21 = TREE_OPERAND (_p0, 1);
3539 9418826 : if (tree_zero_one_valued_p (_q20))
3540 : {
3541 57103 : switch (TREE_CODE (_q21))
3542 : {
3543 51626 : case INTEGER_CST:
3544 51626 : {
3545 51626 : {
3546 51626 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
3547 51626 : if (INTEGRAL_TYPE_P (type)
3548 51626 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3549 51626 : && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (captures[0]))
3550 51632 : && (TYPE_UNSIGNED (type) || TYPE_PRECISION (type) > 1)
3551 : )
3552 : {
3553 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1058;
3554 6 : {
3555 6 : tree res_op0;
3556 6 : {
3557 6 : tree _o1[1], _r1;
3558 6 : _o1[0] = captures[1];
3559 6 : if (TREE_TYPE (_o1[0]) != type)
3560 : {
3561 6 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3562 : }
3563 : else
3564 : _r1 = _o1[0];
3565 6 : res_op0 = _r1;
3566 : }
3567 6 : tree res_op1;
3568 6 : {
3569 6 : tree _o1[1], _r1;
3570 6 : _o1[0] = captures[2];
3571 6 : if (TREE_TYPE (_o1[0]) != type)
3572 : {
3573 6 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3574 : }
3575 : else
3576 : _r1 = _o1[0];
3577 6 : res_op1 = _r1;
3578 : }
3579 6 : tree _r;
3580 6 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
3581 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 843, __FILE__, __LINE__, true);
3582 6 : return _r;
3583 : }
3584 0 : next_after_fail1058:;
3585 : }
3586 : }
3587 51620 : break;
3588 : }
3589 : default:;
3590 : }
3591 : }
3592 : break;
3593 : }
3594 1193246 : case POINTER_DIFF_EXPR:
3595 1193246 : {
3596 1193246 : tree _q20 = TREE_OPERAND (_p0, 0);
3597 1193246 : tree _q21 = TREE_OPERAND (_p0, 1);
3598 1193246 : switch (TREE_CODE (_q21))
3599 : {
3600 200 : case INTEGER_CST:
3601 200 : {
3602 200 : {
3603 200 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3604 200 : if (POINTER_TYPE_P (type)
3605 : )
3606 : {
3607 18 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1059;
3608 18 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1059;
3609 18 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1059;
3610 18 : {
3611 18 : tree _r;
3612 18 : _r = build_fold_addr_expr_with_type
3613 : (build2 (MEM_REF, char_type_node, captures[0],
3614 : wide_int_to_tree (ptr_type_node, wi::neg (wi::to_wide (captures[1])))),
3615 : type);
3616 18 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 844, __FILE__, __LINE__, true);
3617 18 : return _r;
3618 : }
3619 182 : next_after_fail1059:;
3620 : }
3621 : }
3622 182 : break;
3623 : }
3624 : default:;
3625 : }
3626 : break;
3627 : }
3628 214372 : case EQ_EXPR:
3629 214372 : {
3630 214372 : tree _q20 = TREE_OPERAND (_p0, 0);
3631 214372 : tree _q21 = TREE_OPERAND (_p0, 1);
3632 214372 : if (tree_zero_one_valued_p (_q20))
3633 : {
3634 1583 : switch (TREE_CODE (_q21))
3635 : {
3636 654 : case INTEGER_CST:
3637 654 : {
3638 654 : {
3639 654 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3640 654 : tree res = generic_simplify_437 (loc, type, _p0, captures, EQ_EXPR);
3641 654 : if (res) return res;
3642 : }
3643 606 : break;
3644 : }
3645 : default:;
3646 : }
3647 : }
3648 : break;
3649 : }
3650 267828 : case NE_EXPR:
3651 267828 : {
3652 267828 : tree _q20 = TREE_OPERAND (_p0, 0);
3653 267828 : tree _q21 = TREE_OPERAND (_p0, 1);
3654 267828 : if (tree_zero_one_valued_p (_q20))
3655 : {
3656 1907 : switch (TREE_CODE (_q21))
3657 : {
3658 1573 : case INTEGER_CST:
3659 1573 : {
3660 1573 : {
3661 1573 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3662 1573 : tree res = generic_simplify_437 (loc, type, _p0, captures, NE_EXPR);
3663 1573 : if (res) return res;
3664 : }
3665 9 : break;
3666 : }
3667 : default:;
3668 : }
3669 : }
3670 : break;
3671 : }
3672 1999 : case MIN_EXPR:
3673 1999 : {
3674 1999 : tree _q20 = TREE_OPERAND (_p0, 0);
3675 1999 : tree _q21 = TREE_OPERAND (_p0, 1);
3676 1999 : switch (TREE_CODE (_q20))
3677 : {
3678 733 : CASE_CONVERT:
3679 733 : {
3680 733 : tree _q30 = TREE_OPERAND (_q20, 0);
3681 733 : switch (TREE_CODE (_q21))
3682 : {
3683 47 : CASE_CONVERT:
3684 47 : {
3685 47 : tree _q50 = TREE_OPERAND (_q21, 0);
3686 47 : {
3687 47 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q30, _q21, _q50 };
3688 47 : tree res = generic_simplify_438 (loc, type, _p0, captures, MIN_EXPR);
3689 47 : if (res) return res;
3690 : }
3691 47 : {
3692 47 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q50, _q20, _q30 };
3693 47 : tree res = generic_simplify_438 (loc, type, _p0, captures, MIN_EXPR);
3694 47 : if (res) return res;
3695 : }
3696 47 : break;
3697 : }
3698 659 : case INTEGER_CST:
3699 659 : {
3700 659 : {
3701 659 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q21 };
3702 659 : tree res = generic_simplify_439 (loc, type, _p0, captures, MIN_EXPR);
3703 659 : if (res) return res;
3704 : }
3705 659 : break;
3706 : }
3707 : default:;
3708 : }
3709 : break;
3710 : }
3711 : default:;
3712 : }
3713 : break;
3714 : }
3715 274742 : case MAX_EXPR:
3716 274742 : {
3717 274742 : tree _q20 = TREE_OPERAND (_p0, 0);
3718 274742 : tree _q21 = TREE_OPERAND (_p0, 1);
3719 274742 : switch (TREE_CODE (_q20))
3720 : {
3721 6721 : CASE_CONVERT:
3722 6721 : {
3723 6721 : tree _q30 = TREE_OPERAND (_q20, 0);
3724 6721 : switch (TREE_CODE (_q21))
3725 : {
3726 0 : CASE_CONVERT:
3727 0 : {
3728 0 : tree _q50 = TREE_OPERAND (_q21, 0);
3729 0 : {
3730 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q30, _q21, _q50 };
3731 0 : tree res = generic_simplify_438 (loc, type, _p0, captures, MAX_EXPR);
3732 0 : if (res) return res;
3733 : }
3734 0 : {
3735 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q50, _q20, _q30 };
3736 0 : tree res = generic_simplify_438 (loc, type, _p0, captures, MAX_EXPR);
3737 0 : if (res) return res;
3738 : }
3739 0 : break;
3740 : }
3741 6681 : case INTEGER_CST:
3742 6681 : {
3743 6681 : {
3744 6681 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q21 };
3745 6681 : tree res = generic_simplify_439 (loc, type, _p0, captures, MAX_EXPR);
3746 6681 : if (res) return res;
3747 : }
3748 6681 : break;
3749 : }
3750 : default:;
3751 : }
3752 : break;
3753 : }
3754 : default:;
3755 : }
3756 : break;
3757 : }
3758 468151 : case LSHIFT_EXPR:
3759 468151 : {
3760 468151 : tree _q20 = TREE_OPERAND (_p0, 0);
3761 468151 : tree _q21 = TREE_OPERAND (_p0, 1);
3762 468151 : switch (TREE_CODE (_q21))
3763 : {
3764 141573 : case INTEGER_CST:
3765 141573 : {
3766 141573 : {
3767 141573 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
3768 141573 : if (INTEGRAL_TYPE_P (type)
3769 141546 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3770 141546 : && !integer_zerop (captures[2])
3771 282346 : && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (captures[0]))
3772 : )
3773 : {
3774 139490 : if (TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (captures[0]))
3775 139490 : || wi::ltu_p (wi::to_wide (captures[2]), TYPE_PRECISION (type))
3776 : )
3777 : {
3778 139162 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1060;
3779 139162 : {
3780 139162 : tree res_op0;
3781 139162 : {
3782 139162 : tree _o1[1], _r1;
3783 139162 : _o1[0] = captures[1];
3784 139162 : if (TREE_TYPE (_o1[0]) != type)
3785 : {
3786 130088 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3787 : }
3788 : else
3789 : _r1 = _o1[0];
3790 139162 : res_op0 = _r1;
3791 : }
3792 139162 : tree res_op1;
3793 139162 : res_op1 = captures[2];
3794 139162 : tree _r;
3795 139162 : _r = fold_build2_loc (loc, LSHIFT_EXPR, type, res_op0, res_op1);
3796 139162 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 845, __FILE__, __LINE__, true);
3797 139162 : return _r;
3798 : }
3799 0 : next_after_fail1060:;
3800 : }
3801 : else
3802 : {
3803 328 : if (wi::ltu_p (wi::to_wide (captures[2]), TYPE_PRECISION (TREE_TYPE (captures[0])))
3804 : )
3805 : {
3806 279 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1061;
3807 279 : {
3808 279 : tree _r;
3809 279 : _r = build_zero_cst (type);
3810 279 : if (TREE_SIDE_EFFECTS (captures[1]))
3811 14 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3812 279 : if (TREE_SIDE_EFFECTS (captures[2]))
3813 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
3814 279 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 846, __FILE__, __LINE__, true);
3815 279 : return _r;
3816 : }
3817 0 : next_after_fail1061:;
3818 : }
3819 : }
3820 : }
3821 : }
3822 2132 : break;
3823 : }
3824 : default:;
3825 : }
3826 : break;
3827 : }
3828 871909781 : default:;
3829 : }
3830 871909781 : {
3831 871909781 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3832 1743819562 : if ((
3833 :
3834 : && useless_type_conversion_p (type, TREE_TYPE (captures[0])))
3835 : || (
3836 : 1
3837 871909781 : && type == TREE_TYPE (captures[0]))
3838 : )
3839 : {
3840 50718785 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1062;
3841 50718785 : {
3842 50718785 : tree _r;
3843 50718785 : _r = captures[0];
3844 50718785 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 847, __FILE__, __LINE__, true);
3845 50718785 : return _r;
3846 : }
3847 0 : next_after_fail1062:;
3848 : }
3849 : }
3850 821190996 : switch (TREE_CODE (_p0))
3851 : {
3852 135688210 : CASE_CONVERT:
3853 135688210 : {
3854 135688210 : tree _q20 = TREE_OPERAND (_p0, 0);
3855 135688210 : {
3856 135688210 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3857 135688210 : {
3858 135688210 : tree inside_type = TREE_TYPE (captures[1]);
3859 135688210 : tree inter_type = TREE_TYPE (captures[0]);
3860 135688210 : int inside_int = INTEGRAL_TYPE_P (inside_type);
3861 135688210 : int inside_ptr = POINTER_TYPE_P (inside_type);
3862 135688210 : int inside_float = FLOAT_TYPE_P (inside_type);
3863 135688210 : int inside_vec = VECTOR_TYPE_P (inside_type);
3864 135688210 : unsigned int inside_prec = element_precision (inside_type);
3865 135688210 : int inside_unsignedp = TYPE_UNSIGNED (inside_type);
3866 135688210 : int inter_int = INTEGRAL_TYPE_P (inter_type);
3867 135688210 : int inter_ptr = POINTER_TYPE_P (inter_type);
3868 135688210 : int inter_float = FLOAT_TYPE_P (inter_type);
3869 135688210 : int inter_vec = VECTOR_TYPE_P (inter_type);
3870 135688210 : unsigned int inter_prec = element_precision (inter_type);
3871 135688210 : int inter_unsignedp = TYPE_UNSIGNED (inter_type);
3872 135688210 : int final_int = INTEGRAL_TYPE_P (type);
3873 135688210 : int final_ptr = POINTER_TYPE_P (type);
3874 135688210 : int final_float = FLOAT_TYPE_P (type);
3875 135688210 : int final_vec = VECTOR_TYPE_P (type);
3876 135688210 : unsigned int final_prec = element_precision (type);
3877 135688210 : int final_unsignedp = TYPE_UNSIGNED (type);
3878 135688210 : if (((
3879 :
3880 : && useless_type_conversion_p (type, inside_type))
3881 : || (
3882 : 1
3883 135688210 : && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
3884 23253731 : && (((inter_int || inter_ptr) && final_int)
3885 17516083 : || (inter_float && final_float))
3886 141511071 : && inter_prec >= final_prec
3887 : )
3888 : {
3889 5292224 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1063;
3890 5292224 : {
3891 5292224 : tree res_op0;
3892 5292224 : res_op0 = captures[1];
3893 5292224 : tree _r;
3894 5292224 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3895 5292224 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 848, __FILE__, __LINE__, true);
3896 5292224 : return _r;
3897 : }
3898 0 : next_after_fail1063:;
3899 : }
3900 : else
3901 : {
3902 130395986 : if (((inter_int && inside_int) || (inter_float && inside_float))
3903 12879438 : && (final_int || final_float)
3904 12748190 : && inter_prec >= inside_prec
3905 11471682 : && (inter_float || inter_unsignedp == inside_unsignedp)
3906 : )
3907 : {
3908 7964622 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1064;
3909 7964622 : {
3910 7964622 : tree res_op0;
3911 7964622 : res_op0 = captures[1];
3912 7964622 : tree _r;
3913 7964622 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3914 7964622 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 849, __FILE__, __LINE__, true);
3915 7964622 : return _r;
3916 : }
3917 0 : next_after_fail1064:;
3918 0 : }
3919 : else
3920 : {
3921 122431364 : if (inside_int && inter_int && final_int
3922 4777258 : && ((inside_prec < inter_prec && inter_prec < final_prec
3923 180526 : && inside_unsignedp && !inter_unsignedp)
3924 4623536 : || final_prec == inter_prec
3925 2309018 : || (inside_prec < inter_prec && inter_prec > final_prec
3926 151475 : && !inside_unsignedp && inter_unsignedp))
3927 : )
3928 : {
3929 2532713 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1065;
3930 2532713 : {
3931 2532713 : tree res_op0;
3932 2532713 : res_op0 = captures[1];
3933 2532713 : tree _r;
3934 2532713 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3935 2532713 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 850, __FILE__, __LINE__, true);
3936 2532713 : return _r;
3937 : }
3938 0 : next_after_fail1065:;
3939 0 : }
3940 : else
3941 : {
3942 119898651 : if (! inside_float && ! inter_float && ! final_float
3943 : && ! inside_vec && ! inter_vec && ! final_vec
3944 119892337 : && (inter_prec >= inside_prec || inter_prec >= final_prec)
3945 119146325 : && ! (inside_int && inter_int
3946 1629777 : && inter_unsignedp != inside_unsignedp
3947 1629777 : && inter_prec < final_prec)
3948 117819788 : && ((inter_unsignedp && inter_prec > inside_prec)
3949 117819788 : == (final_unsignedp && final_prec > inter_prec))
3950 117796383 : && ! (inside_ptr && inter_prec != final_prec)
3951 117293975 : && ! (final_ptr && inside_prec != inter_prec)
3952 : )
3953 : {
3954 117273179 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1066;
3955 117273179 : {
3956 117273179 : tree res_op0;
3957 117273179 : res_op0 = captures[1];
3958 117273179 : tree _r;
3959 117273179 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3960 117273179 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 851, __FILE__, __LINE__, true);
3961 117273179 : return _r;
3962 : }
3963 0 : next_after_fail1066:;
3964 0 : }
3965 : else
3966 : {
3967 2625472 : if (inside_int && inter_int && final_int
3968 2102214 : && final_prec <= inside_prec
3969 686022 : && inter_prec >= inside_prec
3970 : )
3971 : {
3972 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1067;
3973 0 : {
3974 0 : tree res_op0;
3975 0 : res_op0 = captures[1];
3976 0 : tree _r;
3977 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3978 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 852, __FILE__, __LINE__, true);
3979 0 : return _r;
3980 : }
3981 0 : next_after_fail1067:;
3982 0 : }
3983 : else
3984 : {
3985 : if (0
3986 : && final_int && inter_int && inside_int
3987 : && final_prec >= inside_prec
3988 : && inside_prec > inter_prec
3989 : && inter_unsignedp
3990 : )
3991 : {
3992 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1068;
3993 : {
3994 : tree res_op0;
3995 : {
3996 : tree _o1[2], _r1;
3997 : _o1[0] = captures[1];
3998 : _o1[1] = wide_int_to_tree
3999 : (inside_type,
4000 : wi::mask (inter_prec, false,
4001 : TYPE_PRECISION (inside_type)));
4002 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4003 : res_op0 = _r1;
4004 : }
4005 : tree _r;
4006 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4007 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 853, __FILE__, __LINE__, true);
4008 : return _r;
4009 : }
4010 : next_after_fail1068:;
4011 : }
4012 : else
4013 : {
4014 : if (0
4015 : && inside_int && inter_float && final_int &&
4016 : (unsigned) significand_size (TYPE_MODE (inter_type))
4017 : >= inside_prec - !inside_unsignedp
4018 : )
4019 : {
4020 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1069;
4021 : {
4022 : tree res_op0;
4023 : res_op0 = captures[1];
4024 : tree _r;
4025 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4026 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 854, __FILE__, __LINE__, true);
4027 : return _r;
4028 : }
4029 : next_after_fail1069:;
4030 : }
4031 : }
4032 : }
4033 : }
4034 : }
4035 : }
4036 : }
4037 : }
4038 : }
4039 2625472 : break;
4040 : }
4041 3067 : case FLOAT_EXPR:
4042 3067 : {
4043 3067 : tree _q20 = TREE_OPERAND (_p0, 0);
4044 3067 : {
4045 3067 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
4046 3067 : {
4047 3067 : tree inside_type = TREE_TYPE (captures[1]);
4048 3067 : tree inter_type = TREE_TYPE (captures[0]);
4049 3067 : int inside_int = INTEGRAL_TYPE_P (inside_type);
4050 3067 : int inside_ptr = POINTER_TYPE_P (inside_type);
4051 3067 : int inside_float = FLOAT_TYPE_P (inside_type);
4052 3067 : int inside_vec = VECTOR_TYPE_P (inside_type);
4053 3067 : unsigned int inside_prec = element_precision (inside_type);
4054 3067 : int inside_unsignedp = TYPE_UNSIGNED (inside_type);
4055 3067 : int inter_int = INTEGRAL_TYPE_P (inter_type);
4056 3067 : int inter_ptr = POINTER_TYPE_P (inter_type);
4057 3067 : int inter_float = FLOAT_TYPE_P (inter_type);
4058 3067 : int inter_vec = VECTOR_TYPE_P (inter_type);
4059 3067 : unsigned int inter_prec = element_precision (inter_type);
4060 3067 : int inter_unsignedp = TYPE_UNSIGNED (inter_type);
4061 3067 : int final_int = INTEGRAL_TYPE_P (type);
4062 3067 : int final_ptr = POINTER_TYPE_P (type);
4063 3067 : int final_float = FLOAT_TYPE_P (type);
4064 3067 : int final_vec = VECTOR_TYPE_P (type);
4065 3067 : unsigned int final_prec = element_precision (type);
4066 3067 : int final_unsignedp = TYPE_UNSIGNED (type);
4067 3067 : if (((
4068 :
4069 : && useless_type_conversion_p (type, inside_type))
4070 : || (
4071 : 1
4072 3067 : && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
4073 0 : && (((inter_int || inter_ptr) && final_int)
4074 0 : || (inter_float && final_float))
4075 3067 : && inter_prec >= final_prec
4076 : )
4077 : {
4078 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1070;
4079 0 : {
4080 0 : tree res_op0;
4081 0 : res_op0 = captures[1];
4082 0 : tree _r;
4083 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4084 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 848, __FILE__, __LINE__, true);
4085 0 : return _r;
4086 : }
4087 0 : next_after_fail1070:;
4088 : }
4089 : else
4090 : {
4091 3067 : if (((inter_int && inside_int) || (inter_float && inside_float))
4092 0 : && (final_int || final_float)
4093 0 : && inter_prec >= inside_prec
4094 0 : && (inter_float || inter_unsignedp == inside_unsignedp)
4095 : )
4096 : {
4097 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1071;
4098 0 : {
4099 0 : tree res_op0;
4100 0 : res_op0 = captures[1];
4101 0 : tree _r;
4102 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4103 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 849, __FILE__, __LINE__, true);
4104 0 : return _r;
4105 : }
4106 0 : next_after_fail1071:;
4107 0 : }
4108 : else
4109 : {
4110 3067 : if (inside_int && inter_int && final_int
4111 0 : && ((inside_prec < inter_prec && inter_prec < final_prec
4112 0 : && inside_unsignedp && !inter_unsignedp)
4113 0 : || final_prec == inter_prec
4114 0 : || (inside_prec < inter_prec && inter_prec > final_prec
4115 0 : && !inside_unsignedp && inter_unsignedp))
4116 : )
4117 : {
4118 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1072;
4119 0 : {
4120 0 : tree res_op0;
4121 0 : res_op0 = captures[1];
4122 0 : tree _r;
4123 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4124 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 850, __FILE__, __LINE__, true);
4125 0 : return _r;
4126 : }
4127 0 : next_after_fail1072:;
4128 0 : }
4129 : else
4130 : {
4131 3067 : if (! inside_float && ! inter_float && ! final_float
4132 : && ! inside_vec && ! inter_vec && ! final_vec
4133 0 : && (inter_prec >= inside_prec || inter_prec >= final_prec)
4134 0 : && ! (inside_int && inter_int
4135 0 : && inter_unsignedp != inside_unsignedp
4136 0 : && inter_prec < final_prec)
4137 0 : && ((inter_unsignedp && inter_prec > inside_prec)
4138 0 : == (final_unsignedp && final_prec > inter_prec))
4139 0 : && ! (inside_ptr && inter_prec != final_prec)
4140 0 : && ! (final_ptr && inside_prec != inter_prec)
4141 : )
4142 : {
4143 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1073;
4144 0 : {
4145 0 : tree res_op0;
4146 0 : res_op0 = captures[1];
4147 0 : tree _r;
4148 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4149 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 851, __FILE__, __LINE__, true);
4150 0 : return _r;
4151 : }
4152 0 : next_after_fail1073:;
4153 0 : }
4154 : else
4155 : {
4156 3067 : if (inside_int && inter_int && final_int
4157 0 : && final_prec <= inside_prec
4158 0 : && inter_prec >= inside_prec
4159 : )
4160 : {
4161 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1074;
4162 0 : {
4163 0 : tree res_op0;
4164 0 : res_op0 = captures[1];
4165 0 : tree _r;
4166 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4167 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 852, __FILE__, __LINE__, true);
4168 0 : return _r;
4169 : }
4170 0 : next_after_fail1074:;
4171 0 : }
4172 : else
4173 : {
4174 : if (0
4175 : && final_int && inter_int && inside_int
4176 : && final_prec >= inside_prec
4177 : && inside_prec > inter_prec
4178 : && inter_unsignedp
4179 : )
4180 : {
4181 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1075;
4182 : {
4183 : tree res_op0;
4184 : {
4185 : tree _o1[2], _r1;
4186 : _o1[0] = captures[1];
4187 : _o1[1] = wide_int_to_tree
4188 : (inside_type,
4189 : wi::mask (inter_prec, false,
4190 : TYPE_PRECISION (inside_type)));
4191 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4192 : res_op0 = _r1;
4193 : }
4194 : tree _r;
4195 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4196 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 853, __FILE__, __LINE__, true);
4197 : return _r;
4198 : }
4199 : next_after_fail1075:;
4200 : }
4201 : else
4202 : {
4203 : if (0
4204 : && inside_int && inter_float && final_int &&
4205 : (unsigned) significand_size (TYPE_MODE (inter_type))
4206 : >= inside_prec - !inside_unsignedp
4207 : )
4208 : {
4209 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1076;
4210 : {
4211 : tree res_op0;
4212 : res_op0 = captures[1];
4213 : tree _r;
4214 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4215 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 854, __FILE__, __LINE__, true);
4216 : return _r;
4217 : }
4218 : next_after_fail1076:;
4219 : }
4220 : }
4221 : }
4222 : }
4223 : }
4224 : }
4225 : }
4226 : }
4227 : }
4228 3067 : break;
4229 : }
4230 984177 : case BIT_AND_EXPR:
4231 984177 : {
4232 984177 : tree _q20 = TREE_OPERAND (_p0, 0);
4233 984177 : tree _q21 = TREE_OPERAND (_p0, 1);
4234 984177 : switch (TREE_CODE (_q21))
4235 : {
4236 291081 : case INTEGER_CST:
4237 291081 : {
4238 291081 : {
4239 291081 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4240 291081 : if (INTEGRAL_TYPE_P (type)
4241 290573 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4242 290573 : && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (captures[0]))
4243 501112 : && operand_equal_p (captures[1], build_low_bits_mask (TREE_TYPE (captures[1]),
4244 210031 : TYPE_PRECISION (type)), 0)
4245 : )
4246 : {
4247 13060 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1077;
4248 13060 : {
4249 13060 : tree res_op0;
4250 13060 : res_op0 = captures[0];
4251 13060 : tree _r;
4252 13060 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4253 13060 : if (TREE_SIDE_EFFECTS (captures[1]))
4254 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4255 13060 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 855, __FILE__, __LINE__, true);
4256 13060 : return _r;
4257 : }
4258 0 : next_after_fail1077:;
4259 : }
4260 : }
4261 278021 : break;
4262 : }
4263 : default:;
4264 : }
4265 : break;
4266 : }
4267 5 : case VEC_COND_EXPR:
4268 5 : {
4269 5 : tree _q20 = TREE_OPERAND (_p0, 0);
4270 5 : tree _q21 = TREE_OPERAND (_p0, 1);
4271 5 : tree _q22 = TREE_OPERAND (_p0, 2);
4272 5 : {
4273 5 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
4274 5 : if (VECTOR_TYPE_P (type)
4275 0 : && types_match (TREE_TYPE (captures[1]), truth_type_for (type))
4276 5 : && (expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
4277 0 : || !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1])))
4278 : )
4279 : {
4280 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1078;
4281 0 : {
4282 0 : tree res_op0;
4283 0 : res_op0 = captures[1];
4284 0 : tree res_op1;
4285 0 : {
4286 0 : tree _o1[1], _r1;
4287 0 : _o1[0] = captures[2];
4288 0 : if (TREE_TYPE (_o1[0]) != type)
4289 : {
4290 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4291 0 : if (EXPR_P (_r1))
4292 0 : goto next_after_fail1078;
4293 : }
4294 : else
4295 : _r1 = _o1[0];
4296 0 : res_op1 = _r1;
4297 : }
4298 0 : tree res_op2;
4299 0 : {
4300 0 : tree _o1[1], _r1;
4301 0 : _o1[0] = captures[3];
4302 0 : if (TREE_TYPE (_o1[0]) != type)
4303 : {
4304 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4305 0 : if (EXPR_P (_r1))
4306 0 : goto next_after_fail1078;
4307 : }
4308 : else
4309 : _r1 = _o1[0];
4310 0 : res_op2 = _r1;
4311 : }
4312 0 : tree _r;
4313 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4314 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 856, __FILE__, __LINE__, true);
4315 0 : return _r;
4316 : }
4317 5 : next_after_fail1078:;
4318 : }
4319 : }
4320 5 : break;
4321 : }
4322 654482 : case COND_EXPR:
4323 654482 : {
4324 654482 : tree _q20 = TREE_OPERAND (_p0, 0);
4325 654482 : tree _q21 = TREE_OPERAND (_p0, 1);
4326 654482 : tree _q22 = TREE_OPERAND (_p0, 2);
4327 654482 : switch (TREE_CODE (_q21))
4328 : {
4329 184234 : case INTEGER_CST:
4330 184234 : {
4331 184234 : switch (TREE_CODE (_q22))
4332 : {
4333 117469 : case INTEGER_CST:
4334 117469 : {
4335 117469 : {
4336 117469 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
4337 117469 : if (INTEGRAL_TYPE_P (type)
4338 117469 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4339 : )
4340 : {
4341 117469 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1079;
4342 117469 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1079;
4343 117469 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1079;
4344 117469 : {
4345 117469 : tree res_op0;
4346 117469 : res_op0 = captures[1];
4347 117469 : tree res_op1;
4348 117469 : {
4349 117469 : tree _o1[1], _r1;
4350 117469 : _o1[0] = captures[2];
4351 117469 : if (TREE_TYPE (_o1[0]) != type)
4352 : {
4353 117469 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4354 : }
4355 : else
4356 : _r1 = _o1[0];
4357 117469 : res_op1 = _r1;
4358 : }
4359 117469 : tree res_op2;
4360 117469 : {
4361 117469 : tree _o1[1], _r1;
4362 117469 : _o1[0] = captures[3];
4363 117469 : if (TREE_TYPE (_o1[0]) != type)
4364 : {
4365 117469 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4366 : }
4367 : else
4368 : _r1 = _o1[0];
4369 117469 : res_op2 = _r1;
4370 : }
4371 117469 : tree _r;
4372 117469 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
4373 117469 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 857, __FILE__, __LINE__, true);
4374 117469 : return _r;
4375 : }
4376 0 : next_after_fail1079:;
4377 : }
4378 : }
4379 0 : break;
4380 : }
4381 : default:;
4382 : }
4383 : break;
4384 : }
4385 : default:;
4386 : }
4387 : break;
4388 : }
4389 11953733 : case PLUS_EXPR:
4390 11953733 : {
4391 11953733 : tree _q20 = TREE_OPERAND (_p0, 0);
4392 11953733 : tree _q21 = TREE_OPERAND (_p0, 1);
4393 11953733 : switch (TREE_CODE (_q20))
4394 : {
4395 4613662 : CASE_CONVERT:
4396 4613662 : {
4397 4613662 : tree _q30 = TREE_OPERAND (_q20, 0);
4398 4613662 : switch (TREE_CODE (_q21))
4399 : {
4400 357778 : CASE_CONVERT:
4401 357778 : {
4402 357778 : tree _q50 = TREE_OPERAND (_q21, 0);
4403 357778 : {
4404 357778 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4405 357778 : tree res = generic_simplify_440 (loc, type, _p0, captures, PLUS_EXPR);
4406 357778 : if (res) return res;
4407 : }
4408 357722 : break;
4409 : }
4410 4613606 : default:;
4411 : }
4412 4613606 : {
4413 4613606 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4414 4613606 : tree res = generic_simplify_441 (loc, type, _p0, captures, PLUS_EXPR);
4415 4613606 : if (res) return res;
4416 : }
4417 4601109 : break;
4418 : }
4419 11941180 : default:;
4420 : }
4421 11941180 : switch (TREE_CODE (_q21))
4422 : {
4423 1622864 : CASE_CONVERT:
4424 1622864 : {
4425 1622864 : tree _q40 = TREE_OPERAND (_q21, 0);
4426 1622864 : {
4427 1622864 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4428 1622864 : tree res = generic_simplify_442 (loc, type, _p0, captures, PLUS_EXPR);
4429 1622864 : if (res) return res;
4430 : }
4431 1622864 : break;
4432 : }
4433 11941180 : default:;
4434 : }
4435 11941180 : {
4436 11941180 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4437 11941180 : tree res = generic_simplify_443 (loc, type, _p0, captures, PLUS_EXPR);
4438 11941180 : if (res) return res;
4439 : }
4440 11941146 : break;
4441 : }
4442 1008532 : case MINUS_EXPR:
4443 1008532 : {
4444 1008532 : tree _q20 = TREE_OPERAND (_p0, 0);
4445 1008532 : tree _q21 = TREE_OPERAND (_p0, 1);
4446 1008532 : switch (TREE_CODE (_q20))
4447 : {
4448 427732 : CASE_CONVERT:
4449 427732 : {
4450 427732 : tree _q30 = TREE_OPERAND (_q20, 0);
4451 427732 : switch (TREE_CODE (_q21))
4452 : {
4453 272987 : CASE_CONVERT:
4454 272987 : {
4455 272987 : tree _q50 = TREE_OPERAND (_q21, 0);
4456 272987 : {
4457 272987 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4458 272987 : tree res = generic_simplify_440 (loc, type, _p0, captures, MINUS_EXPR);
4459 272987 : if (res) return res;
4460 : }
4461 272958 : break;
4462 : }
4463 427703 : default:;
4464 : }
4465 427703 : {
4466 427703 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4467 427703 : tree res = generic_simplify_441 (loc, type, _p0, captures, MINUS_EXPR);
4468 427703 : if (res) return res;
4469 : }
4470 426583 : break;
4471 : }
4472 1007383 : default:;
4473 : }
4474 1007383 : switch (TREE_CODE (_q21))
4475 : {
4476 332790 : CASE_CONVERT:
4477 332790 : {
4478 332790 : tree _q40 = TREE_OPERAND (_q21, 0);
4479 332790 : {
4480 332790 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4481 332790 : tree res = generic_simplify_442 (loc, type, _p0, captures, MINUS_EXPR);
4482 332790 : if (res) return res;
4483 : }
4484 332780 : break;
4485 : }
4486 1007373 : default:;
4487 : }
4488 1007373 : {
4489 1007373 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4490 1007373 : tree res = generic_simplify_443 (loc, type, _p0, captures, MINUS_EXPR);
4491 1007373 : if (res) return res;
4492 : }
4493 1007341 : break;
4494 : }
4495 9194380 : case MULT_EXPR:
4496 9194380 : {
4497 9194380 : tree _q20 = TREE_OPERAND (_p0, 0);
4498 9194380 : tree _q21 = TREE_OPERAND (_p0, 1);
4499 9194380 : switch (TREE_CODE (_q20))
4500 : {
4501 4127352 : CASE_CONVERT:
4502 4127352 : {
4503 4127352 : tree _q30 = TREE_OPERAND (_q20, 0);
4504 4127352 : switch (TREE_CODE (_q21))
4505 : {
4506 357278 : CASE_CONVERT:
4507 357278 : {
4508 357278 : tree _q50 = TREE_OPERAND (_q21, 0);
4509 357278 : {
4510 357278 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4511 357278 : tree res = generic_simplify_440 (loc, type, _p0, captures, MULT_EXPR);
4512 357278 : if (res) return res;
4513 : }
4514 357278 : break;
4515 : }
4516 4127352 : default:;
4517 : }
4518 4127352 : {
4519 4127352 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4520 4127352 : tree res = generic_simplify_441 (loc, type, _p0, captures, MULT_EXPR);
4521 4127352 : if (res) return res;
4522 : }
4523 4127225 : break;
4524 : }
4525 9194253 : default:;
4526 : }
4527 9194253 : switch (TREE_CODE (_q21))
4528 : {
4529 797257 : CASE_CONVERT:
4530 797257 : {
4531 797257 : tree _q40 = TREE_OPERAND (_q21, 0);
4532 797257 : {
4533 797257 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4534 797257 : tree res = generic_simplify_442 (loc, type, _p0, captures, MULT_EXPR);
4535 797257 : if (res) return res;
4536 : }
4537 797257 : break;
4538 : }
4539 9194253 : default:;
4540 : }
4541 9194253 : {
4542 9194253 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4543 9194253 : tree res = generic_simplify_443 (loc, type, _p0, captures, MULT_EXPR);
4544 9194253 : if (res) return res;
4545 : }
4546 9194220 : break;
4547 : }
4548 3113 : case RDIV_EXPR:
4549 3113 : {
4550 3113 : tree _q20 = TREE_OPERAND (_p0, 0);
4551 3113 : tree _q21 = TREE_OPERAND (_p0, 1);
4552 3113 : switch (TREE_CODE (_q20))
4553 : {
4554 1005 : CASE_CONVERT:
4555 1005 : {
4556 1005 : tree _q30 = TREE_OPERAND (_q20, 0);
4557 1005 : switch (TREE_CODE (_q21))
4558 : {
4559 691 : CASE_CONVERT:
4560 691 : {
4561 691 : tree _q50 = TREE_OPERAND (_q21, 0);
4562 691 : {
4563 691 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4564 691 : tree res = generic_simplify_440 (loc, type, _p0, captures, RDIV_EXPR);
4565 691 : if (res) return res;
4566 : }
4567 690 : break;
4568 : }
4569 1004 : default:;
4570 : }
4571 1004 : {
4572 1004 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4573 1004 : tree res = generic_simplify_441 (loc, type, _p0, captures, RDIV_EXPR);
4574 1004 : if (res) return res;
4575 : }
4576 1002 : break;
4577 : }
4578 3110 : default:;
4579 : }
4580 3110 : switch (TREE_CODE (_q21))
4581 : {
4582 1690 : CASE_CONVERT:
4583 1690 : {
4584 1690 : tree _q40 = TREE_OPERAND (_q21, 0);
4585 1690 : {
4586 1690 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4587 1690 : tree res = generic_simplify_442 (loc, type, _p0, captures, RDIV_EXPR);
4588 1690 : if (res) return res;
4589 : }
4590 1045 : break;
4591 : }
4592 2465 : default:;
4593 : }
4594 2465 : {
4595 2465 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4596 2465 : tree res = generic_simplify_443 (loc, type, _p0, captures, RDIV_EXPR);
4597 2465 : if (res) return res;
4598 : }
4599 2423 : break;
4600 : }
4601 739613 : case NEGATE_EXPR:
4602 739613 : {
4603 739613 : tree _q20 = TREE_OPERAND (_p0, 0);
4604 739613 : {
4605 739613 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4606 739613 : tree res = generic_simplify_444 (loc, type, _p0, captures);
4607 739613 : if (res) return res;
4608 : }
4609 739591 : break;
4610 : }
4611 : default:;
4612 : }
4613 : return NULL_TREE;
4614 : }
4615 :
4616 : tree
4617 7006 : generic_simplify_CEIL_DIV_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
4618 : {
4619 7006 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4620 7006 : if (integer_onep (_p1))
4621 : {
4622 1755 : {
4623 1755 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4624 1755 : tree res = generic_simplify_187 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4625 1755 : if (res) return res;
4626 : }
4627 : }
4628 5251 : if (integer_zerop (_p0))
4629 : {
4630 0 : {
4631 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4632 0 : tree res = generic_simplify_317 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4633 0 : if (res) return res;
4634 : }
4635 : }
4636 5251 : switch (TREE_CODE (_p1))
4637 : {
4638 34 : case SSA_NAME:
4639 34 : {
4640 34 : {
4641 34 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4642 34 : tree res = generic_simplify_319 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4643 34 : if (res) return res;
4644 : }
4645 34 : break;
4646 : }
4647 5251 : default:;
4648 : }
4649 5251 : if (integer_minus_onep (_p1))
4650 : {
4651 0 : {
4652 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4653 0 : tree res = generic_simplify_318 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4654 0 : if (res) return res;
4655 : }
4656 : }
4657 5251 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
4658 : {
4659 0 : {
4660 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4661 0 : tree res = generic_simplify_320 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4662 0 : if (res) return res;
4663 : }
4664 : }
4665 5251 : switch (TREE_CODE (_p1))
4666 : {
4667 0 : case ABS_EXPR:
4668 0 : {
4669 0 : tree _q30 = TREE_OPERAND (_p1, 0);
4670 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
4671 : {
4672 0 : {
4673 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4674 0 : tree res = generic_simplify_321 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4675 0 : if (res) return res;
4676 : }
4677 : }
4678 : break;
4679 : }
4680 5251 : default:;
4681 : }
4682 5251 : switch (TREE_CODE (_p0))
4683 : {
4684 0 : case ABS_EXPR:
4685 0 : {
4686 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4687 0 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4688 : {
4689 0 : {
4690 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4691 0 : tree res = generic_simplify_321 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4692 0 : if (res) return res;
4693 : }
4694 : }
4695 : break;
4696 : }
4697 5251 : default:;
4698 : }
4699 5251 : switch (TREE_CODE (_p1))
4700 : {
4701 0 : case NEGATE_EXPR:
4702 0 : {
4703 0 : tree _q30 = TREE_OPERAND (_p1, 0);
4704 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
4705 : {
4706 0 : {
4707 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4708 0 : tree res = generic_simplify_322 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4709 0 : if (res) return res;
4710 : }
4711 : }
4712 : break;
4713 : }
4714 5251 : default:;
4715 : }
4716 5251 : switch (TREE_CODE (_p0))
4717 : {
4718 0 : case NEGATE_EXPR:
4719 0 : {
4720 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4721 0 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4722 : {
4723 0 : {
4724 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4725 0 : tree res = generic_simplify_322 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4726 0 : if (res) return res;
4727 : }
4728 : }
4729 : break;
4730 : }
4731 536 : CASE_CONVERT:
4732 536 : {
4733 536 : tree _q20 = TREE_OPERAND (_p0, 0);
4734 536 : switch (TREE_CODE (_q20))
4735 : {
4736 0 : case BIT_AND_EXPR:
4737 0 : {
4738 0 : tree _q30 = TREE_OPERAND (_q20, 0);
4739 0 : tree _q31 = TREE_OPERAND (_q20, 1);
4740 0 : switch (TREE_CODE (_q31))
4741 : {
4742 0 : case INTEGER_CST:
4743 0 : {
4744 0 : switch (TREE_CODE (_p1))
4745 : {
4746 0 : case INTEGER_CST:
4747 0 : {
4748 0 : {
4749 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
4750 0 : tree res = generic_simplify_324 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4751 0 : if (res) return res;
4752 : }
4753 0 : break;
4754 : }
4755 : default:;
4756 : }
4757 : break;
4758 : }
4759 : default:;
4760 : }
4761 : break;
4762 : }
4763 : default:;
4764 : }
4765 : break;
4766 : }
4767 0 : case BIT_AND_EXPR:
4768 0 : {
4769 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4770 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4771 0 : switch (TREE_CODE (_q21))
4772 : {
4773 0 : case INTEGER_CST:
4774 0 : {
4775 0 : switch (TREE_CODE (_p1))
4776 : {
4777 0 : case INTEGER_CST:
4778 0 : {
4779 0 : {
4780 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4781 0 : tree res = generic_simplify_324 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4782 0 : if (res) return res;
4783 : }
4784 0 : break;
4785 : }
4786 : default:;
4787 : }
4788 : break;
4789 : }
4790 : default:;
4791 : }
4792 : break;
4793 : }
4794 0 : case MULT_EXPR:
4795 0 : {
4796 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4797 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4798 0 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
4799 : {
4800 0 : {
4801 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
4802 0 : tree res = generic_simplify_326 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4803 0 : if (res) return res;
4804 : }
4805 : }
4806 0 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4807 : {
4808 0 : {
4809 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
4810 0 : tree res = generic_simplify_326 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4811 0 : if (res) return res;
4812 : }
4813 : }
4814 0 : switch (TREE_CODE (_q21))
4815 : {
4816 0 : case INTEGER_CST:
4817 0 : {
4818 0 : switch (TREE_CODE (_p1))
4819 : {
4820 0 : case MULT_EXPR:
4821 0 : {
4822 0 : tree _q50 = TREE_OPERAND (_p1, 0);
4823 0 : tree _q51 = TREE_OPERAND (_p1, 1);
4824 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4825 : {
4826 0 : switch (TREE_CODE (_q51))
4827 : {
4828 0 : case INTEGER_CST:
4829 0 : {
4830 0 : {
4831 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
4832 0 : tree res = generic_simplify_327 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4833 0 : if (res) return res;
4834 : }
4835 0 : break;
4836 : }
4837 : default:;
4838 : }
4839 : }
4840 : break;
4841 : }
4842 : default:;
4843 : }
4844 : break;
4845 : }
4846 : default:;
4847 : }
4848 : break;
4849 : }
4850 0 : case VEC_COND_EXPR:
4851 0 : {
4852 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4853 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4854 0 : tree _q22 = TREE_OPERAND (_p0, 2);
4855 0 : switch (TREE_CODE (_p1))
4856 : {
4857 0 : case VEC_COND_EXPR:
4858 0 : {
4859 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4860 0 : tree _q61 = TREE_OPERAND (_p1, 1);
4861 0 : tree _q62 = TREE_OPERAND (_p1, 2);
4862 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4863 : {
4864 0 : {
4865 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
4866 0 : if (VECTOR_TYPE_P (type)
4867 0 : && (TREE_CODE_CLASS (CEIL_DIV_EXPR) != tcc_comparison
4868 : || types_match (type, TREE_TYPE (captures[2]))
4869 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
4870 : || (optimize_vectors_before_lowering_p ()
4871 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
4872 : )
4873 : {
4874 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1608;
4875 0 : {
4876 0 : tree res_op0;
4877 0 : res_op0 = captures[1];
4878 0 : tree res_op1;
4879 0 : {
4880 0 : tree _o1[2], _r1;
4881 0 : _o1[0] = captures[2];
4882 0 : _o1[1] = captures[5];
4883 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4884 0 : if (EXPR_P (_r1))
4885 0 : goto next_after_fail1608;
4886 0 : res_op1 = _r1;
4887 : }
4888 0 : tree res_op2;
4889 0 : {
4890 0 : tree _o1[2], _r1;
4891 0 : _o1[0] = captures[3];
4892 0 : _o1[1] = captures[6];
4893 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4894 0 : if (EXPR_P (_r1))
4895 0 : goto next_after_fail1608;
4896 0 : res_op2 = _r1;
4897 : }
4898 0 : tree _r;
4899 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4900 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 908, __FILE__, __LINE__, true);
4901 0 : return _r;
4902 : }
4903 0 : next_after_fail1608:;
4904 : }
4905 : }
4906 : }
4907 : break;
4908 : }
4909 0 : default:;
4910 : }
4911 0 : {
4912 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
4913 0 : if (VECTOR_TYPE_P (type)
4914 0 : && (TREE_CODE_CLASS (CEIL_DIV_EXPR) != tcc_comparison
4915 : || types_match (type, TREE_TYPE (captures[2]))
4916 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
4917 : || (optimize_vectors_before_lowering_p ()
4918 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
4919 : )
4920 : {
4921 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1609;
4922 0 : {
4923 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1609;
4924 0 : tree res_op0;
4925 0 : res_op0 = captures[1];
4926 0 : tree res_op1;
4927 0 : {
4928 0 : tree _o1[2], _r1;
4929 0 : _o1[0] = captures[2];
4930 0 : _o1[1] = unshare_expr (captures[4]);
4931 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4932 0 : if (EXPR_P (_r1))
4933 0 : goto next_after_fail1609;
4934 0 : res_op1 = _r1;
4935 : }
4936 0 : tree res_op2;
4937 0 : {
4938 0 : tree _o1[2], _r1;
4939 0 : _o1[0] = captures[3];
4940 0 : _o1[1] = captures[4];
4941 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4942 0 : if (EXPR_P (_r1))
4943 0 : goto next_after_fail1609;
4944 0 : res_op2 = _r1;
4945 : }
4946 0 : tree _r;
4947 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4948 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 910, __FILE__, __LINE__, true);
4949 0 : return _r;
4950 : }
4951 0 : next_after_fail1609:;
4952 : }
4953 : }
4954 0 : break;
4955 : }
4956 5251 : default:;
4957 : }
4958 5251 : switch (TREE_CODE (_p1))
4959 : {
4960 0 : case VEC_COND_EXPR:
4961 0 : {
4962 0 : tree _q30 = TREE_OPERAND (_p1, 0);
4963 0 : tree _q31 = TREE_OPERAND (_p1, 1);
4964 0 : tree _q32 = TREE_OPERAND (_p1, 2);
4965 0 : {
4966 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
4967 0 : if (VECTOR_TYPE_P (type)
4968 0 : && (TREE_CODE_CLASS (CEIL_DIV_EXPR) != tcc_comparison
4969 : || types_match (type, TREE_TYPE (captures[3]))
4970 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
4971 : || (optimize_vectors_before_lowering_p ()
4972 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
4973 : )
4974 : {
4975 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1610;
4976 0 : {
4977 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1610;
4978 0 : tree res_op0;
4979 0 : res_op0 = captures[2];
4980 0 : tree res_op1;
4981 0 : {
4982 0 : tree _o1[2], _r1;
4983 0 : _o1[0] = unshare_expr (captures[0]);
4984 0 : _o1[1] = captures[3];
4985 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4986 0 : if (EXPR_P (_r1))
4987 0 : goto next_after_fail1610;
4988 0 : res_op1 = _r1;
4989 : }
4990 0 : tree res_op2;
4991 0 : {
4992 0 : tree _o1[2], _r1;
4993 0 : _o1[0] = captures[0];
4994 0 : _o1[1] = captures[4];
4995 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4996 0 : if (EXPR_P (_r1))
4997 0 : goto next_after_fail1610;
4998 0 : res_op2 = _r1;
4999 : }
5000 0 : tree _r;
5001 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
5002 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 911, __FILE__, __LINE__, true);
5003 0 : return _r;
5004 : }
5005 0 : next_after_fail1610:;
5006 : }
5007 : }
5008 0 : break;
5009 : }
5010 : default:;
5011 : }
5012 : return NULL_TREE;
5013 : }
5014 :
5015 : tree
5016 3544629 : generic_simplify_EXACT_DIV_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
5017 : {
5018 3544629 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
5019 3544629 : if (integer_onep (_p1))
5020 : {
5021 2137578 : {
5022 2137578 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
5023 2137578 : tree res = generic_simplify_187 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5024 2137578 : if (res) return res;
5025 : }
5026 : }
5027 1407051 : switch (TREE_CODE (_p0))
5028 : {
5029 9076 : CASE_CONVERT:
5030 9076 : {
5031 9076 : tree _q20 = TREE_OPERAND (_p0, 0);
5032 9076 : switch (TREE_CODE (_p1))
5033 : {
5034 0 : CASE_CONVERT:
5035 0 : {
5036 0 : tree _q40 = TREE_OPERAND (_p1, 0);
5037 0 : switch (TREE_CODE (_q40))
5038 : {
5039 0 : case LSHIFT_EXPR:
5040 0 : {
5041 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5042 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5043 0 : if (integer_onep (_q50))
5044 : {
5045 0 : {
5046 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q50, _q51 };
5047 0 : tree res = generic_simplify_315 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5048 0 : if (res) return res;
5049 : }
5050 : }
5051 : break;
5052 : }
5053 : default:;
5054 : }
5055 : break;
5056 : }
5057 0 : case LSHIFT_EXPR:
5058 0 : {
5059 0 : tree _q40 = TREE_OPERAND (_p1, 0);
5060 0 : tree _q41 = TREE_OPERAND (_p1, 1);
5061 0 : if (integer_onep (_q40))
5062 : {
5063 0 : {
5064 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q41 };
5065 0 : tree res = generic_simplify_315 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5066 0 : if (res) return res;
5067 : }
5068 : }
5069 : break;
5070 : }
5071 : default:;
5072 : }
5073 : break;
5074 : }
5075 1407051 : default:;
5076 : }
5077 1407051 : switch (TREE_CODE (_p1))
5078 : {
5079 2 : CASE_CONVERT:
5080 2 : {
5081 2 : tree _q30 = TREE_OPERAND (_p1, 0);
5082 2 : switch (TREE_CODE (_q30))
5083 : {
5084 0 : case LSHIFT_EXPR:
5085 0 : {
5086 0 : tree _q40 = TREE_OPERAND (_q30, 0);
5087 0 : tree _q41 = TREE_OPERAND (_q30, 1);
5088 0 : if (integer_onep (_q40))
5089 : {
5090 0 : {
5091 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q40, _q41 };
5092 0 : tree res = generic_simplify_316 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5093 0 : if (res) return res;
5094 : }
5095 : }
5096 : break;
5097 : }
5098 : default:;
5099 : }
5100 : break;
5101 : }
5102 0 : case LSHIFT_EXPR:
5103 0 : {
5104 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5105 0 : tree _q31 = TREE_OPERAND (_p1, 1);
5106 0 : if (integer_onep (_q30))
5107 : {
5108 0 : {
5109 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q30, _q31 };
5110 0 : tree res = generic_simplify_316 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5111 0 : if (res) return res;
5112 : }
5113 : }
5114 : break;
5115 : }
5116 1407051 : default:;
5117 : }
5118 1407051 : if (integer_zerop (_p0))
5119 : {
5120 0 : {
5121 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
5122 0 : tree res = generic_simplify_317 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5123 0 : if (res) return res;
5124 : }
5125 : }
5126 1407051 : switch (TREE_CODE (_p1))
5127 : {
5128 0 : case SSA_NAME:
5129 0 : {
5130 0 : {
5131 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
5132 0 : tree res = generic_simplify_319 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5133 0 : if (res) return res;
5134 : }
5135 0 : break;
5136 : }
5137 1407051 : default:;
5138 : }
5139 1407051 : if (integer_minus_onep (_p1))
5140 : {
5141 0 : {
5142 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
5143 0 : tree res = generic_simplify_318 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5144 0 : if (res) return res;
5145 : }
5146 : }
5147 1407051 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
5148 : {
5149 0 : {
5150 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
5151 0 : tree res = generic_simplify_320 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5152 0 : if (res) return res;
5153 : }
5154 : }
5155 1407051 : switch (TREE_CODE (_p1))
5156 : {
5157 0 : case ABS_EXPR:
5158 0 : {
5159 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5160 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5161 : {
5162 0 : {
5163 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
5164 0 : tree res = generic_simplify_321 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5165 0 : if (res) return res;
5166 : }
5167 : }
5168 : break;
5169 : }
5170 1407051 : default:;
5171 : }
5172 1407051 : switch (TREE_CODE (_p0))
5173 : {
5174 0 : case ABS_EXPR:
5175 0 : {
5176 0 : tree _q20 = TREE_OPERAND (_p0, 0);
5177 0 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5178 : {
5179 0 : {
5180 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
5181 0 : tree res = generic_simplify_321 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5182 0 : if (res) return res;
5183 : }
5184 : }
5185 : break;
5186 : }
5187 1407051 : default:;
5188 : }
5189 1407051 : switch (TREE_CODE (_p1))
5190 : {
5191 0 : case NEGATE_EXPR:
5192 0 : {
5193 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5194 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5195 : {
5196 0 : {
5197 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
5198 0 : tree res = generic_simplify_322 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5199 0 : if (res) return res;
5200 : }
5201 : }
5202 : break;
5203 : }
5204 1407051 : default:;
5205 : }
5206 1407051 : switch (TREE_CODE (_p0))
5207 : {
5208 1241 : case NEGATE_EXPR:
5209 1241 : {
5210 1241 : tree _q20 = TREE_OPERAND (_p0, 0);
5211 1241 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5212 : {
5213 0 : {
5214 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
5215 0 : tree res = generic_simplify_322 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5216 0 : if (res) return res;
5217 : }
5218 : }
5219 : break;
5220 : }
5221 0 : case EXACT_DIV_EXPR:
5222 0 : {
5223 0 : tree _q20 = TREE_OPERAND (_p0, 0);
5224 0 : tree _q21 = TREE_OPERAND (_p0, 1);
5225 0 : switch (TREE_CODE (_q21))
5226 : {
5227 0 : case INTEGER_CST:
5228 0 : {
5229 0 : switch (TREE_CODE (_p1))
5230 : {
5231 0 : case INTEGER_CST:
5232 0 : {
5233 0 : {
5234 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
5235 0 : tree res = generic_simplify_323 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5236 0 : if (res) return res;
5237 : }
5238 0 : break;
5239 : }
5240 : default:;
5241 : }
5242 : break;
5243 : }
5244 : default:;
5245 : }
5246 : break;
5247 : }
5248 9076 : CASE_CONVERT:
5249 9076 : {
5250 9076 : tree _q20 = TREE_OPERAND (_p0, 0);
5251 9076 : switch (TREE_CODE (_q20))
5252 : {
5253 0 : case BIT_AND_EXPR:
5254 0 : {
5255 0 : tree _q30 = TREE_OPERAND (_q20, 0);
5256 0 : tree _q31 = TREE_OPERAND (_q20, 1);
5257 0 : switch (TREE_CODE (_q31))
5258 : {
5259 0 : case INTEGER_CST:
5260 0 : {
5261 0 : switch (TREE_CODE (_p1))
5262 : {
5263 0 : case INTEGER_CST:
5264 0 : {
5265 0 : {
5266 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
5267 0 : tree res = generic_simplify_324 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5268 0 : if (res) return res;
5269 : }
5270 0 : break;
5271 : }
5272 : default:;
5273 : }
5274 : break;
5275 : }
5276 : default:;
5277 : }
5278 : break;
5279 : }
5280 : default:;
5281 : }
5282 : break;
5283 : }
5284 0 : case BIT_AND_EXPR:
5285 0 : {
5286 0 : tree _q20 = TREE_OPERAND (_p0, 0);
5287 0 : tree _q21 = TREE_OPERAND (_p0, 1);
5288 0 : switch (TREE_CODE (_q21))
5289 : {
5290 0 : case INTEGER_CST:
5291 0 : {
5292 0 : switch (TREE_CODE (_p1))
5293 : {
5294 0 : case INTEGER_CST:
5295 0 : {
5296 0 : {
5297 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5298 0 : tree res = generic_simplify_324 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5299 0 : if (res) return res;
5300 : }
5301 0 : break;
5302 : }
5303 : default:;
5304 : }
5305 : break;
5306 : }
5307 : default:;
5308 : }
5309 : break;
5310 : }
5311 19454 : case MULT_EXPR:
5312 19454 : {
5313 19454 : tree _q20 = TREE_OPERAND (_p0, 0);
5314 19454 : tree _q21 = TREE_OPERAND (_p0, 1);
5315 19454 : if (integer_pow2p (_q21))
5316 : {
5317 18228 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5318 : {
5319 18200 : {
5320 18200 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5321 18200 : tree res = generic_simplify_325 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5322 18200 : if (res) return res;
5323 : }
5324 : }
5325 : }
5326 1261 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5327 : {
5328 7 : {
5329 7 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
5330 7 : tree res = generic_simplify_326 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5331 7 : if (res) return res;
5332 : }
5333 : }
5334 1254 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5335 : {
5336 0 : {
5337 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
5338 0 : tree res = generic_simplify_326 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5339 0 : if (res) return res;
5340 : }
5341 : }
5342 1254 : switch (TREE_CODE (_q21))
5343 : {
5344 1254 : case INTEGER_CST:
5345 1254 : {
5346 1254 : switch (TREE_CODE (_p1))
5347 : {
5348 0 : case MULT_EXPR:
5349 0 : {
5350 0 : tree _q50 = TREE_OPERAND (_p1, 0);
5351 0 : tree _q51 = TREE_OPERAND (_p1, 1);
5352 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5353 : {
5354 0 : switch (TREE_CODE (_q51))
5355 : {
5356 0 : case INTEGER_CST:
5357 0 : {
5358 0 : {
5359 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
5360 0 : tree res = generic_simplify_327 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5361 0 : if (res) return res;
5362 : }
5363 0 : break;
5364 : }
5365 : default:;
5366 : }
5367 : }
5368 : break;
5369 : }
5370 : default:;
5371 : }
5372 : break;
5373 : }
5374 : default:;
5375 : }
5376 : break;
5377 : }
5378 0 : case VEC_COND_EXPR:
5379 0 : {
5380 0 : tree _q20 = TREE_OPERAND (_p0, 0);
5381 0 : tree _q21 = TREE_OPERAND (_p0, 1);
5382 0 : tree _q22 = TREE_OPERAND (_p0, 2);
5383 0 : switch (TREE_CODE (_p1))
5384 : {
5385 0 : case VEC_COND_EXPR:
5386 0 : {
5387 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5388 0 : tree _q61 = TREE_OPERAND (_p1, 1);
5389 0 : tree _q62 = TREE_OPERAND (_p1, 2);
5390 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
5391 : {
5392 0 : {
5393 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
5394 0 : if (VECTOR_TYPE_P (type)
5395 0 : && (TREE_CODE_CLASS (EXACT_DIV_EXPR) != tcc_comparison
5396 : || types_match (type, TREE_TYPE (captures[2]))
5397 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
5398 : || (optimize_vectors_before_lowering_p ()
5399 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
5400 : )
5401 : {
5402 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1617;
5403 0 : {
5404 0 : tree res_op0;
5405 0 : res_op0 = captures[1];
5406 0 : tree res_op1;
5407 0 : {
5408 0 : tree _o1[2], _r1;
5409 0 : _o1[0] = captures[2];
5410 0 : _o1[1] = captures[5];
5411 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5412 0 : if (EXPR_P (_r1))
5413 0 : goto next_after_fail1617;
5414 0 : res_op1 = _r1;
5415 : }
5416 0 : tree res_op2;
5417 0 : {
5418 0 : tree _o1[2], _r1;
5419 0 : _o1[0] = captures[3];
5420 0 : _o1[1] = captures[6];
5421 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5422 0 : if (EXPR_P (_r1))
5423 0 : goto next_after_fail1617;
5424 0 : res_op2 = _r1;
5425 : }
5426 0 : tree _r;
5427 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
5428 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 908, __FILE__, __LINE__, true);
5429 0 : return _r;
5430 : }
5431 0 : next_after_fail1617:;
5432 : }
5433 : }
5434 : }
5435 : break;
5436 : }
5437 0 : default:;
5438 : }
5439 0 : {
5440 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
5441 0 : if (VECTOR_TYPE_P (type)
5442 0 : && (TREE_CODE_CLASS (EXACT_DIV_EXPR) != tcc_comparison
5443 : || types_match (type, TREE_TYPE (captures[2]))
5444 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
5445 : || (optimize_vectors_before_lowering_p ()
5446 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
5447 : )
5448 : {
5449 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1618;
5450 0 : {
5451 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1618;
5452 0 : tree res_op0;
5453 0 : res_op0 = captures[1];
5454 0 : tree res_op1;
5455 0 : {
5456 0 : tree _o1[2], _r1;
5457 0 : _o1[0] = captures[2];
5458 0 : _o1[1] = unshare_expr (captures[4]);
5459 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5460 0 : if (EXPR_P (_r1))
5461 0 : goto next_after_fail1618;
5462 0 : res_op1 = _r1;
5463 : }
5464 0 : tree res_op2;
5465 0 : {
5466 0 : tree _o1[2], _r1;
5467 0 : _o1[0] = captures[3];
5468 0 : _o1[1] = captures[4];
5469 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5470 0 : if (EXPR_P (_r1))
5471 0 : goto next_after_fail1618;
5472 0 : res_op2 = _r1;
5473 : }
5474 0 : tree _r;
5475 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
5476 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 910, __FILE__, __LINE__, true);
5477 0 : return _r;
5478 : }
5479 0 : next_after_fail1618:;
5480 : }
5481 : }
5482 0 : break;
5483 : }
5484 1388851 : default:;
5485 : }
5486 1388851 : switch (TREE_CODE (_p1))
5487 : {
5488 0 : case VEC_COND_EXPR:
5489 0 : {
5490 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5491 0 : tree _q31 = TREE_OPERAND (_p1, 1);
5492 0 : tree _q32 = TREE_OPERAND (_p1, 2);
5493 0 : {
5494 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
5495 0 : if (VECTOR_TYPE_P (type)
5496 0 : && (TREE_CODE_CLASS (EXACT_DIV_EXPR) != tcc_comparison
5497 : || types_match (type, TREE_TYPE (captures[3]))
5498 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
5499 : || (optimize_vectors_before_lowering_p ()
5500 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
5501 : )
5502 : {
5503 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1619;
5504 0 : {
5505 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1619;
5506 0 : tree res_op0;
5507 0 : res_op0 = captures[2];
5508 0 : tree res_op1;
5509 0 : {
5510 0 : tree _o1[2], _r1;
5511 0 : _o1[0] = unshare_expr (captures[0]);
5512 0 : _o1[1] = captures[3];
5513 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5514 0 : if (EXPR_P (_r1))
5515 0 : goto next_after_fail1619;
5516 0 : res_op1 = _r1;
5517 : }
5518 0 : tree res_op2;
5519 0 : {
5520 0 : tree _o1[2], _r1;
5521 0 : _o1[0] = captures[0];
5522 0 : _o1[1] = captures[4];
5523 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5524 0 : if (EXPR_P (_r1))
5525 0 : goto next_after_fail1619;
5526 0 : res_op2 = _r1;
5527 : }
5528 0 : tree _r;
5529 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
5530 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 911, __FILE__, __LINE__, true);
5531 0 : return _r;
5532 : }
5533 0 : next_after_fail1619:;
5534 : }
5535 : }
5536 0 : break;
5537 : }
5538 : default:;
5539 : }
5540 : return NULL_TREE;
5541 : }
5542 :
5543 : tree
5544 9354494 : generic_simplify_LE_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
5545 : {
5546 9354494 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
5547 9354494 : switch (TREE_CODE (_p0))
5548 : {
5549 2314 : case RDIV_EXPR:
5550 2314 : {
5551 2314 : tree _q20 = TREE_OPERAND (_p0, 0);
5552 2314 : tree _q21 = TREE_OPERAND (_p0, 1);
5553 2314 : switch (TREE_CODE (_q20))
5554 : {
5555 544 : case REAL_CST:
5556 544 : {
5557 544 : if (real_zerop (_p1))
5558 : {
5559 2 : {
5560 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5561 2 : tree res = generic_simplify_380 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
5562 2 : if (res) return res;
5563 : }
5564 : }
5565 : break;
5566 : }
5567 : default:;
5568 : }
5569 : break;
5570 : }
5571 9354492 : default:;
5572 : }
5573 9354492 : switch (TREE_CODE (_p1))
5574 : {
5575 7 : case TRUNC_MOD_EXPR:
5576 7 : {
5577 7 : tree _q30 = TREE_OPERAND (_p1, 0);
5578 7 : tree _q31 = TREE_OPERAND (_p1, 1);
5579 7 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5580 : {
5581 0 : {
5582 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
5583 0 : tree res = generic_simplify_381 (loc, type, _p0, _p1, captures, GE_EXPR, LT_EXPR);
5584 0 : if (res) return res;
5585 : }
5586 : }
5587 : break;
5588 : }
5589 9354492 : default:;
5590 : }
5591 9354492 : switch (TREE_CODE (_p0))
5592 : {
5593 62697 : case MULT_EXPR:
5594 62697 : {
5595 62697 : tree _q20 = TREE_OPERAND (_p0, 0);
5596 62697 : tree _q21 = TREE_OPERAND (_p0, 1);
5597 62697 : switch (TREE_CODE (_p1))
5598 : {
5599 2714 : case MULT_EXPR:
5600 2714 : {
5601 2714 : tree _q50 = TREE_OPERAND (_p1, 0);
5602 2714 : tree _q51 = TREE_OPERAND (_p1, 1);
5603 2714 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5604 : {
5605 1901 : {
5606 1901 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5607 1901 : tree res = generic_simplify_382 (loc, type, _p0, _p1, captures, LE_EXPR);
5608 1901 : if (res) return res;
5609 : }
5610 : }
5611 1719 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5612 : {
5613 1 : {
5614 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5615 1 : tree res = generic_simplify_382 (loc, type, _p0, _p1, captures, LE_EXPR);
5616 1 : if (res) return res;
5617 : }
5618 : }
5619 1719 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5620 : {
5621 4 : {
5622 4 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
5623 4 : tree res = generic_simplify_382 (loc, type, _p0, _p1, captures, LE_EXPR);
5624 4 : if (res) return res;
5625 : }
5626 : }
5627 1719 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5628 : {
5629 307 : {
5630 307 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
5631 307 : tree res = generic_simplify_382 (loc, type, _p0, _p1, captures, LE_EXPR);
5632 307 : if (res) return res;
5633 : }
5634 : }
5635 : break;
5636 : }
5637 : default:;
5638 : }
5639 : break;
5640 : }
5641 1630195 : case PLUS_EXPR:
5642 1630195 : {
5643 1630195 : tree _q20 = TREE_OPERAND (_p0, 0);
5644 1630195 : tree _q21 = TREE_OPERAND (_p0, 1);
5645 1630195 : if (integer_minus_onep (_q21))
5646 : {
5647 530950 : switch (TREE_CODE (_p1))
5648 : {
5649 331717 : case INTEGER_CST:
5650 331717 : {
5651 331717 : {
5652 331717 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5653 331717 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR);
5654 331717 : if (res) return res;
5655 : }
5656 331715 : break;
5657 : }
5658 : default:;
5659 : }
5660 : }
5661 1630193 : switch (TREE_CODE (_p1))
5662 : {
5663 91127 : case PLUS_EXPR:
5664 91127 : {
5665 91127 : tree _q50 = TREE_OPERAND (_p1, 0);
5666 91127 : tree _q51 = TREE_OPERAND (_p1, 1);
5667 91127 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5668 : {
5669 7199 : {
5670 7199 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5671 7199 : tree res = generic_simplify_383 (loc, type, _p0, _p1, captures, LE_EXPR);
5672 7199 : if (res) return res;
5673 : }
5674 : }
5675 86923 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5676 : {
5677 13 : {
5678 13 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5679 13 : tree res = generic_simplify_383 (loc, type, _p0, _p1, captures, LE_EXPR);
5680 13 : if (res) return res;
5681 : }
5682 : }
5683 86923 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5684 : {
5685 213 : {
5686 213 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
5687 213 : tree res = generic_simplify_383 (loc, type, _p0, _p1, captures, LE_EXPR);
5688 213 : if (res) return res;
5689 : }
5690 : }
5691 86923 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5692 : {
5693 7737 : {
5694 7737 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
5695 7737 : tree res = generic_simplify_383 (loc, type, _p0, _p1, captures, LE_EXPR);
5696 7737 : if (res) return res;
5697 : }
5698 : }
5699 : break;
5700 : }
5701 1625390 : default:;
5702 : }
5703 1625390 : switch (TREE_CODE (_q21))
5704 : {
5705 1498861 : case INTEGER_CST:
5706 1498861 : {
5707 1498861 : switch (TREE_CODE (_p1))
5708 : {
5709 84262 : case PLUS_EXPR:
5710 84262 : {
5711 84262 : tree _q50 = TREE_OPERAND (_p1, 0);
5712 84262 : tree _q51 = TREE_OPERAND (_p1, 1);
5713 84262 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5714 : {
5715 2937 : {
5716 2937 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5717 2937 : tree res = generic_simplify_384 (loc, type, _p0, _p1, captures, LE_EXPR);
5718 2937 : if (res) return res;
5719 : }
5720 : }
5721 : break;
5722 : }
5723 : default:;
5724 : }
5725 : break;
5726 : }
5727 1625390 : default:;
5728 : }
5729 1625390 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5730 : {
5731 69705 : {
5732 69705 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
5733 69705 : tree res = generic_simplify_385 (loc, type, _p0, _p1, captures, LE_EXPR);
5734 69705 : if (res) return res;
5735 : }
5736 : }
5737 1586478 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5738 : {
5739 3130 : {
5740 3130 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
5741 3130 : tree res = generic_simplify_385 (loc, type, _p0, _p1, captures, LE_EXPR);
5742 3130 : if (res) return res;
5743 : }
5744 : }
5745 : break;
5746 : }
5747 1669608 : CASE_CONVERT:
5748 1669608 : {
5749 1669608 : tree _q20 = TREE_OPERAND (_p0, 0);
5750 1669608 : switch (TREE_CODE (_q20))
5751 : {
5752 0 : case EXACT_DIV_EXPR:
5753 0 : {
5754 0 : tree _q30 = TREE_OPERAND (_q20, 0);
5755 0 : tree _q31 = TREE_OPERAND (_q20, 1);
5756 0 : switch (TREE_CODE (_q31))
5757 : {
5758 0 : case INTEGER_CST:
5759 0 : {
5760 0 : switch (TREE_CODE (_p1))
5761 : {
5762 0 : CASE_CONVERT:
5763 0 : {
5764 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5765 0 : switch (TREE_CODE (_q60))
5766 : {
5767 0 : case EXACT_DIV_EXPR:
5768 0 : {
5769 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5770 0 : tree _q71 = TREE_OPERAND (_q60, 1);
5771 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
5772 : {
5773 0 : {
5774 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q70 };
5775 0 : tree res = generic_simplify_213 (loc, type, _p0, _p1, captures, LE_EXPR);
5776 0 : if (res) return res;
5777 : }
5778 : }
5779 : break;
5780 : }
5781 : default:;
5782 : }
5783 : break;
5784 : }
5785 : default:;
5786 : }
5787 : break;
5788 : }
5789 : default:;
5790 : }
5791 : break;
5792 : }
5793 : default:;
5794 : }
5795 : break;
5796 : }
5797 476 : case EXACT_DIV_EXPR:
5798 476 : {
5799 476 : tree _q20 = TREE_OPERAND (_p0, 0);
5800 476 : tree _q21 = TREE_OPERAND (_p0, 1);
5801 476 : switch (TREE_CODE (_q21))
5802 : {
5803 476 : case INTEGER_CST:
5804 476 : {
5805 476 : switch (TREE_CODE (_p1))
5806 : {
5807 0 : case EXACT_DIV_EXPR:
5808 0 : {
5809 0 : tree _q50 = TREE_OPERAND (_p1, 0);
5810 0 : tree _q51 = TREE_OPERAND (_p1, 1);
5811 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5812 : {
5813 0 : {
5814 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
5815 0 : tree res = generic_simplify_213 (loc, type, _p0, _p1, captures, LE_EXPR);
5816 0 : if (res) return res;
5817 : }
5818 : }
5819 : break;
5820 : }
5821 : default:;
5822 : }
5823 : break;
5824 : }
5825 : default:;
5826 : }
5827 : break;
5828 : }
5829 10912 : case TRUNC_DIV_EXPR:
5830 10912 : {
5831 10912 : tree _q20 = TREE_OPERAND (_p0, 0);
5832 10912 : tree _q21 = TREE_OPERAND (_p0, 1);
5833 10912 : switch (TREE_CODE (_q21))
5834 : {
5835 2772 : case INTEGER_CST:
5836 2772 : {
5837 2772 : switch (TREE_CODE (_p1))
5838 : {
5839 1345 : case INTEGER_CST:
5840 1345 : {
5841 1345 : {
5842 1345 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
5843 1345 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, LE_EXPR);
5844 1345 : if (res) return res;
5845 : }
5846 679 : break;
5847 : }
5848 : default:;
5849 : }
5850 : break;
5851 : }
5852 : default:;
5853 : }
5854 : break;
5855 : }
5856 65955 : case MINUS_EXPR:
5857 65955 : {
5858 65955 : tree _q20 = TREE_OPERAND (_p0, 0);
5859 65955 : tree _q21 = TREE_OPERAND (_p0, 1);
5860 65955 : switch (TREE_CODE (_p1))
5861 : {
5862 490 : case MINUS_EXPR:
5863 490 : {
5864 490 : tree _q50 = TREE_OPERAND (_p1, 0);
5865 490 : tree _q51 = TREE_OPERAND (_p1, 1);
5866 490 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5867 : {
5868 54 : {
5869 54 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5870 54 : tree res = generic_simplify_386 (loc, type, _p0, _p1, captures, LE_EXPR);
5871 54 : if (res) return res;
5872 : }
5873 : }
5874 490 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5875 : {
5876 26 : {
5877 26 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5878 26 : tree res = generic_simplify_387 (loc, type, _p0, _p1, captures, LE_EXPR);
5879 26 : if (res) return res;
5880 : }
5881 : }
5882 : break;
5883 : }
5884 : default:;
5885 : }
5886 : break;
5887 : }
5888 5471 : case POINTER_DIFF_EXPR:
5889 5471 : {
5890 5471 : tree _q20 = TREE_OPERAND (_p0, 0);
5891 5471 : tree _q21 = TREE_OPERAND (_p0, 1);
5892 5471 : switch (TREE_CODE (_p1))
5893 : {
5894 259 : case POINTER_DIFF_EXPR:
5895 259 : {
5896 259 : tree _q50 = TREE_OPERAND (_p1, 0);
5897 259 : tree _q51 = TREE_OPERAND (_p1, 1);
5898 259 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5899 : {
5900 0 : {
5901 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
5902 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, LE_EXPR);
5903 0 : if (res) return res;
5904 : }
5905 : }
5906 259 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5907 : {
5908 0 : {
5909 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
5910 0 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, LE_EXPR);
5911 0 : if (res) return res;
5912 : }
5913 : }
5914 : break;
5915 : }
5916 : default:;
5917 : }
5918 : break;
5919 : }
5920 9308803 : default:;
5921 : }
5922 9308803 : switch (TREE_CODE (_p1))
5923 : {
5924 123112 : case PLUS_EXPR:
5925 123112 : {
5926 123112 : tree _q30 = TREE_OPERAND (_p1, 0);
5927 123112 : tree _q31 = TREE_OPERAND (_p1, 1);
5928 123112 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5929 : {
5930 0 : {
5931 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
5932 0 : tree res = generic_simplify_385 (loc, type, _p0, _p1, captures, GE_EXPR);
5933 0 : if (res) return res;
5934 : }
5935 : }
5936 123112 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5937 : {
5938 57 : {
5939 57 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q31, _p0 };
5940 57 : tree res = generic_simplify_385 (loc, type, _p0, _p1, captures, GE_EXPR);
5941 57 : if (res) return res;
5942 : }
5943 : }
5944 : break;
5945 : }
5946 1196 : case MINUS_EXPR:
5947 1196 : {
5948 1196 : tree _q30 = TREE_OPERAND (_p1, 0);
5949 1196 : tree _q31 = TREE_OPERAND (_p1, 1);
5950 1196 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5951 : {
5952 0 : {
5953 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
5954 0 : tree res = generic_simplify_225 (loc, type, _p0, _p1, captures, LE_EXPR);
5955 0 : if (res) return res;
5956 : }
5957 : }
5958 : break;
5959 : }
5960 9308776 : default:;
5961 : }
5962 9308776 : switch (TREE_CODE (_p0))
5963 : {
5964 65955 : case MINUS_EXPR:
5965 65955 : {
5966 65955 : tree _q20 = TREE_OPERAND (_p0, 0);
5967 65955 : tree _q21 = TREE_OPERAND (_p0, 1);
5968 65955 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5969 : {
5970 2509 : {
5971 2509 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
5972 2509 : tree res = generic_simplify_225 (loc, type, _p0, _p1, captures, GE_EXPR);
5973 2509 : if (res) return res;
5974 : }
5975 : }
5976 : break;
5977 : }
5978 5433 : case BIT_AND_EXPR:
5979 5433 : {
5980 5433 : tree _q20 = TREE_OPERAND (_p0, 0);
5981 5433 : tree _q21 = TREE_OPERAND (_p0, 1);
5982 5433 : if (tree_expr_nonnegative_p (_q20))
5983 : {
5984 4509 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5985 : {
5986 0 : {
5987 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5988 0 : tree res = generic_simplify_388 (loc, type, _p0, _p1, captures, LE_EXPR, BIT_AND_EXPR);
5989 0 : if (res) return res;
5990 : }
5991 : }
5992 : }
5993 5433 : if (tree_expr_nonnegative_p (_q21))
5994 : {
5995 5040 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5996 : {
5997 0 : {
5998 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
5999 0 : tree res = generic_simplify_388 (loc, type, _p0, _p1, captures, LE_EXPR, BIT_AND_EXPR);
6000 0 : if (res) return res;
6001 : }
6002 : }
6003 : }
6004 : break;
6005 : }
6006 9308776 : default:;
6007 : }
6008 9308776 : switch (TREE_CODE (_p1))
6009 : {
6010 46 : case BIT_IOR_EXPR:
6011 46 : {
6012 46 : tree _q30 = TREE_OPERAND (_p1, 0);
6013 46 : tree _q31 = TREE_OPERAND (_p1, 1);
6014 46 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
6015 : {
6016 0 : if (tree_expr_nonnegative_p (_q30))
6017 : {
6018 0 : {
6019 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
6020 0 : tree res = generic_simplify_388 (loc, type, _p0, _p1, captures, GE_EXPR, BIT_IOR_EXPR);
6021 0 : if (res) return res;
6022 : }
6023 : }
6024 : }
6025 46 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6026 : {
6027 0 : if (tree_expr_nonnegative_p (_q31))
6028 : {
6029 0 : {
6030 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
6031 0 : tree res = generic_simplify_388 (loc, type, _p0, _p1, captures, GE_EXPR, BIT_IOR_EXPR);
6032 0 : if (res) return res;
6033 : }
6034 : }
6035 : }
6036 : break;
6037 : }
6038 9308776 : default:;
6039 : }
6040 9308776 : switch (TREE_CODE (_p0))
6041 : {
6042 10425 : case MIN_EXPR:
6043 10425 : {
6044 10425 : tree _q20 = TREE_OPERAND (_p0, 0);
6045 10425 : tree _q21 = TREE_OPERAND (_p0, 1);
6046 10425 : switch (TREE_CODE (_p1))
6047 : {
6048 32 : case MAX_EXPR:
6049 32 : {
6050 32 : tree _q50 = TREE_OPERAND (_p1, 0);
6051 32 : tree _q51 = TREE_OPERAND (_p1, 1);
6052 32 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6053 : {
6054 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6055 : {
6056 0 : {
6057 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6058 0 : tree res = generic_simplify_389 (loc, type, _p0, _p1, captures, LE_EXPR);
6059 0 : if (res) return res;
6060 : }
6061 : }
6062 : }
6063 : break;
6064 : }
6065 : default:;
6066 : }
6067 : break;
6068 : }
6069 4392 : case MAX_EXPR:
6070 4392 : {
6071 4392 : tree _q20 = TREE_OPERAND (_p0, 0);
6072 4392 : tree _q21 = TREE_OPERAND (_p0, 1);
6073 4392 : switch (TREE_CODE (_p1))
6074 : {
6075 4 : case MIN_EXPR:
6076 4 : {
6077 4 : tree _q50 = TREE_OPERAND (_p1, 0);
6078 4 : tree _q51 = TREE_OPERAND (_p1, 1);
6079 4 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6080 : {
6081 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6082 : {
6083 0 : {
6084 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6085 0 : tree res = generic_simplify_390 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
6086 0 : if (res) return res;
6087 : }
6088 : }
6089 : }
6090 : break;
6091 : }
6092 4392 : default:;
6093 : }
6094 4392 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
6095 : {
6096 0 : {
6097 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6098 0 : tree res = generic_simplify_235 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR, GE_EXPR);
6099 0 : if (res) return res;
6100 : }
6101 : }
6102 4392 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
6103 : {
6104 1 : {
6105 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6106 1 : tree res = generic_simplify_235 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR, GE_EXPR);
6107 1 : if (res) return res;
6108 : }
6109 : }
6110 : break;
6111 : }
6112 9308775 : default:;
6113 : }
6114 9308775 : switch (TREE_CODE (_p1))
6115 : {
6116 308 : case MIN_EXPR:
6117 308 : {
6118 308 : tree _q30 = TREE_OPERAND (_p1, 0);
6119 308 : tree _q31 = TREE_OPERAND (_p1, 1);
6120 308 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
6121 : {
6122 0 : {
6123 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
6124 0 : tree res = generic_simplify_235 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR, LE_EXPR);
6125 0 : if (res) return res;
6126 : }
6127 : }
6128 308 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6129 : {
6130 0 : {
6131 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
6132 0 : tree res = generic_simplify_235 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR, LE_EXPR);
6133 0 : if (res) return res;
6134 : }
6135 : }
6136 : break;
6137 : }
6138 42 : case MAX_EXPR:
6139 42 : {
6140 42 : tree _q30 = TREE_OPERAND (_p1, 0);
6141 42 : tree _q31 = TREE_OPERAND (_p1, 1);
6142 42 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
6143 : {
6144 0 : {
6145 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
6146 0 : tree res = generic_simplify_391 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR);
6147 0 : if (res) return res;
6148 : }
6149 : }
6150 42 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6151 : {
6152 0 : {
6153 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
6154 0 : tree res = generic_simplify_391 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR);
6155 0 : if (res) return res;
6156 : }
6157 : }
6158 : break;
6159 : }
6160 9308775 : default:;
6161 : }
6162 9308775 : switch (TREE_CODE (_p0))
6163 : {
6164 10425 : case MIN_EXPR:
6165 10425 : {
6166 10425 : tree _q20 = TREE_OPERAND (_p0, 0);
6167 10425 : tree _q21 = TREE_OPERAND (_p0, 1);
6168 10425 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
6169 : {
6170 0 : {
6171 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6172 0 : tree res = generic_simplify_391 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR);
6173 0 : if (res) return res;
6174 : }
6175 : }
6176 10425 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
6177 : {
6178 0 : {
6179 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6180 0 : tree res = generic_simplify_391 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR);
6181 0 : if (res) return res;
6182 : }
6183 : }
6184 10425 : switch (TREE_CODE (_q21))
6185 : {
6186 939 : case INTEGER_CST:
6187 939 : {
6188 939 : switch (TREE_CODE (_p1))
6189 : {
6190 0 : case INTEGER_CST:
6191 0 : {
6192 0 : {
6193 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6194 0 : tree res = generic_simplify_392 (loc, type, _p0, _p1, captures, MIN_EXPR, LE_EXPR, BIT_IOR_EXPR);
6195 0 : if (res) return res;
6196 : }
6197 0 : break;
6198 : }
6199 : default:;
6200 : }
6201 : break;
6202 : }
6203 : default:;
6204 : }
6205 : break;
6206 : }
6207 4391 : case MAX_EXPR:
6208 4391 : {
6209 4391 : tree _q20 = TREE_OPERAND (_p0, 0);
6210 4391 : tree _q21 = TREE_OPERAND (_p0, 1);
6211 4391 : switch (TREE_CODE (_q21))
6212 : {
6213 4151 : case INTEGER_CST:
6214 4151 : {
6215 4151 : switch (TREE_CODE (_p1))
6216 : {
6217 0 : case INTEGER_CST:
6218 0 : {
6219 0 : {
6220 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6221 0 : tree res = generic_simplify_392 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR, BIT_AND_EXPR);
6222 0 : if (res) return res;
6223 : }
6224 0 : break;
6225 : }
6226 : default:;
6227 : }
6228 : break;
6229 : }
6230 : default:;
6231 : }
6232 : break;
6233 : }
6234 9 : case VEC_COND_EXPR:
6235 9 : {
6236 9 : tree _q20 = TREE_OPERAND (_p0, 0);
6237 9 : tree _q21 = TREE_OPERAND (_p0, 1);
6238 9 : tree _q22 = TREE_OPERAND (_p0, 2);
6239 9 : switch (TREE_CODE (_p1))
6240 : {
6241 2 : case VEC_COND_EXPR:
6242 2 : {
6243 2 : tree _q60 = TREE_OPERAND (_p1, 0);
6244 2 : tree _q61 = TREE_OPERAND (_p1, 1);
6245 2 : tree _q62 = TREE_OPERAND (_p1, 2);
6246 2 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6247 : {
6248 0 : {
6249 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
6250 0 : if (VECTOR_TYPE_P (type)
6251 0 : && (TREE_CODE_CLASS (LE_EXPR) != tcc_comparison
6252 0 : || types_match (type, TREE_TYPE (captures[2]))
6253 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
6254 : || (optimize_vectors_before_lowering_p ()
6255 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
6256 : )
6257 : {
6258 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1665;
6259 0 : {
6260 0 : tree res_op0;
6261 0 : res_op0 = captures[1];
6262 0 : tree res_op1;
6263 0 : {
6264 0 : tree _o1[2], _r1;
6265 0 : _o1[0] = captures[2];
6266 0 : _o1[1] = captures[5];
6267 0 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6268 0 : if (EXPR_P (_r1))
6269 0 : goto next_after_fail1665;
6270 0 : res_op1 = _r1;
6271 : }
6272 0 : tree res_op2;
6273 0 : {
6274 0 : tree _o1[2], _r1;
6275 0 : _o1[0] = captures[3];
6276 0 : _o1[1] = captures[6];
6277 0 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6278 0 : if (EXPR_P (_r1))
6279 0 : goto next_after_fail1665;
6280 0 : res_op2 = _r1;
6281 : }
6282 0 : tree _r;
6283 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
6284 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 908, __FILE__, __LINE__, true);
6285 0 : return _r;
6286 : }
6287 0 : next_after_fail1665:;
6288 : }
6289 : }
6290 : }
6291 : break;
6292 : }
6293 9 : default:;
6294 : }
6295 9 : {
6296 9 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
6297 9 : if (VECTOR_TYPE_P (type)
6298 9 : && (TREE_CODE_CLASS (LE_EXPR) != tcc_comparison
6299 9 : || types_match (type, TREE_TYPE (captures[2]))
6300 9 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
6301 : || (optimize_vectors_before_lowering_p ()
6302 1 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
6303 : )
6304 : {
6305 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1666;
6306 9 : {
6307 9 : if (! tree_invariant_p (captures[4])) goto next_after_fail1666;
6308 7 : tree res_op0;
6309 7 : res_op0 = captures[1];
6310 7 : tree res_op1;
6311 7 : {
6312 7 : tree _o1[2], _r1;
6313 7 : _o1[0] = captures[2];
6314 7 : _o1[1] = unshare_expr (captures[4]);
6315 7 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6316 7 : if (EXPR_P (_r1))
6317 0 : goto next_after_fail1666;
6318 7 : res_op1 = _r1;
6319 : }
6320 7 : tree res_op2;
6321 7 : {
6322 7 : tree _o1[2], _r1;
6323 7 : _o1[0] = captures[3];
6324 7 : _o1[1] = captures[4];
6325 7 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6326 7 : if (EXPR_P (_r1))
6327 0 : goto next_after_fail1666;
6328 7 : res_op2 = _r1;
6329 : }
6330 7 : tree _r;
6331 7 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
6332 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 910, __FILE__, __LINE__, true);
6333 7 : return _r;
6334 : }
6335 2 : next_after_fail1666:;
6336 : }
6337 : }
6338 2 : break;
6339 : }
6340 9308768 : default:;
6341 : }
6342 9308768 : switch (TREE_CODE (_p1))
6343 : {
6344 2 : case VEC_COND_EXPR:
6345 2 : {
6346 2 : tree _q30 = TREE_OPERAND (_p1, 0);
6347 2 : tree _q31 = TREE_OPERAND (_p1, 1);
6348 2 : tree _q32 = TREE_OPERAND (_p1, 2);
6349 2 : {
6350 2 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
6351 2 : if (VECTOR_TYPE_P (type)
6352 2 : && (TREE_CODE_CLASS (LE_EXPR) != tcc_comparison
6353 2 : || types_match (type, TREE_TYPE (captures[3]))
6354 2 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
6355 : || (optimize_vectors_before_lowering_p ()
6356 1 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
6357 : )
6358 : {
6359 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1667;
6360 2 : {
6361 2 : if (! tree_invariant_p (captures[0])) goto next_after_fail1667;
6362 0 : tree res_op0;
6363 0 : res_op0 = captures[2];
6364 0 : tree res_op1;
6365 0 : {
6366 0 : tree _o1[2], _r1;
6367 0 : _o1[0] = unshare_expr (captures[0]);
6368 0 : _o1[1] = captures[3];
6369 0 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6370 0 : if (EXPR_P (_r1))
6371 0 : goto next_after_fail1667;
6372 0 : res_op1 = _r1;
6373 : }
6374 0 : tree res_op2;
6375 0 : {
6376 0 : tree _o1[2], _r1;
6377 0 : _o1[0] = captures[0];
6378 0 : _o1[1] = captures[4];
6379 0 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6380 0 : if (EXPR_P (_r1))
6381 0 : goto next_after_fail1667;
6382 0 : res_op2 = _r1;
6383 : }
6384 0 : tree _r;
6385 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
6386 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 911, __FILE__, __LINE__, true);
6387 0 : return _r;
6388 : }
6389 2 : next_after_fail1667:;
6390 : }
6391 : }
6392 2 : break;
6393 : }
6394 9308768 : default:;
6395 : }
6396 9308768 : if (uniform_integer_cst_p (_p1))
6397 : {
6398 6794473 : {
6399 6794473 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
6400 6794473 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, LE_EXPR, LT_EXPR);
6401 6794473 : if (res) return res;
6402 : }
6403 : }
6404 9211221 : switch (TREE_CODE (_p0))
6405 : {
6406 61281 : case MULT_EXPR:
6407 61281 : {
6408 61281 : tree _q20 = TREE_OPERAND (_p0, 0);
6409 61281 : tree _q21 = TREE_OPERAND (_p0, 1);
6410 61281 : switch (TREE_CODE (_q21))
6411 : {
6412 53412 : case INTEGER_CST:
6413 53412 : {
6414 53412 : if (integer_zerop (_p1))
6415 : {
6416 808 : {
6417 808 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
6418 808 : tree res = generic_simplify_255 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6419 808 : if (res) return res;
6420 : }
6421 : }
6422 : break;
6423 : }
6424 : default:;
6425 : }
6426 : break;
6427 : }
6428 9210580 : default:;
6429 : }
6430 9210580 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
6431 : {
6432 4591 : {
6433 4591 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
6434 4591 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, LE_EXPR);
6435 4591 : if (res) return res;
6436 : }
6437 : }
6438 9206026 : switch (TREE_CODE (_p0))
6439 : {
6440 2592 : case BIT_NOT_EXPR:
6441 2592 : {
6442 2592 : tree _q20 = TREE_OPERAND (_p0, 0);
6443 2592 : switch (TREE_CODE (_p1))
6444 : {
6445 0 : case BIT_NOT_EXPR:
6446 0 : {
6447 0 : tree _q40 = TREE_OPERAND (_p1, 0);
6448 0 : {
6449 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _p1, _q40 };
6450 0 : tree res = generic_simplify_261 (loc, type, _p0, _p1, captures, LE_EXPR);
6451 0 : if (res) return res;
6452 : }
6453 0 : break;
6454 : }
6455 2592 : default:;
6456 : }
6457 2592 : {
6458 2592 : tree _p1_pops[1];
6459 2592 : if (tree_nop_convert (_p1, _p1_pops))
6460 : {
6461 0 : tree _q40 = _p1_pops[0];
6462 0 : switch (TREE_CODE (_q40))
6463 : {
6464 0 : case BIT_NOT_EXPR:
6465 0 : {
6466 0 : tree _q50 = TREE_OPERAND (_q40, 0);
6467 0 : {
6468 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40, _q50 };
6469 0 : tree res = generic_simplify_261 (loc, type, _p0, _p1, captures, LE_EXPR);
6470 0 : if (res) return res;
6471 : }
6472 0 : break;
6473 : }
6474 : default:;
6475 : }
6476 : }
6477 : }
6478 2592 : if (CONSTANT_CLASS_P (_p1))
6479 : {
6480 2300 : {
6481 2300 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
6482 2300 : tree res = generic_simplify_260 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6483 2300 : if (res) return res;
6484 : }
6485 : }
6486 : break;
6487 : }
6488 9203726 : default:;
6489 : }
6490 9203726 : {
6491 9203726 : tree _p0_pops[1];
6492 9203726 : if (tree_nop_convert (_p0, _p0_pops))
6493 : {
6494 844948 : tree _q20 = _p0_pops[0];
6495 844948 : switch (TREE_CODE (_q20))
6496 : {
6497 0 : case BIT_NOT_EXPR:
6498 0 : {
6499 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6500 0 : switch (TREE_CODE (_p1))
6501 : {
6502 0 : case BIT_NOT_EXPR:
6503 0 : {
6504 0 : tree _q50 = TREE_OPERAND (_p1, 0);
6505 0 : {
6506 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _p1, _q50 };
6507 0 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, LE_EXPR);
6508 0 : if (res) return res;
6509 : }
6510 0 : break;
6511 : }
6512 0 : default:;
6513 : }
6514 0 : {
6515 0 : tree _p1_pops[1];
6516 0 : if (tree_nop_convert (_p1, _p1_pops))
6517 : {
6518 0 : tree _q50 = _p1_pops[0];
6519 0 : switch (TREE_CODE (_q50))
6520 : {
6521 0 : case BIT_NOT_EXPR:
6522 0 : {
6523 0 : tree _q60 = TREE_OPERAND (_q50, 0);
6524 0 : {
6525 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50, _q60 };
6526 0 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, LE_EXPR);
6527 0 : if (res) return res;
6528 : }
6529 0 : break;
6530 : }
6531 : default:;
6532 : }
6533 : }
6534 : }
6535 0 : if (CONSTANT_CLASS_P (_p1))
6536 : {
6537 0 : {
6538 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
6539 0 : tree res = generic_simplify_260 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6540 0 : if (res) return res;
6541 : }
6542 : }
6543 : break;
6544 : }
6545 : default:;
6546 : }
6547 : }
6548 : }
6549 9203726 : switch (TREE_CODE (_p1))
6550 : {
6551 196053 : case REAL_CST:
6552 196053 : {
6553 196053 : {
6554 196053 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
6555 196053 : tree res = generic_simplify_262 (loc, type, _p0, _p1, captures, LE_EXPR);
6556 196053 : if (res) return res;
6557 : }
6558 195976 : break;
6559 : }
6560 9203649 : default:;
6561 : }
6562 9203649 : switch (TREE_CODE (_p0))
6563 : {
6564 1584869 : case PLUS_EXPR:
6565 1584869 : {
6566 1584869 : tree _q20 = TREE_OPERAND (_p0, 0);
6567 1584869 : tree _q21 = TREE_OPERAND (_p0, 1);
6568 1584869 : switch (TREE_CODE (_q21))
6569 : {
6570 86 : case REAL_CST:
6571 86 : {
6572 86 : switch (TREE_CODE (_p1))
6573 : {
6574 81 : case REAL_CST:
6575 81 : {
6576 81 : {
6577 81 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6578 81 : tree res = generic_simplify_263 (loc, type, _p0, _p1, captures, PLUS_EXPR, LE_EXPR);
6579 81 : if (res) return res;
6580 : }
6581 81 : break;
6582 : }
6583 : default:;
6584 : }
6585 : break;
6586 : }
6587 1479172 : case INTEGER_CST:
6588 1479172 : {
6589 1479172 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
6590 : {
6591 1974 : {
6592 1974 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q20, _q21 };
6593 1974 : tree res = generic_simplify_396 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR);
6594 1974 : if (res) return res;
6595 : }
6596 : }
6597 : break;
6598 : }
6599 : default:;
6600 : }
6601 : break;
6602 : }
6603 60297 : case MINUS_EXPR:
6604 60297 : {
6605 60297 : tree _q20 = TREE_OPERAND (_p0, 0);
6606 60297 : tree _q21 = TREE_OPERAND (_p0, 1);
6607 60297 : switch (TREE_CODE (_q21))
6608 : {
6609 1225 : case REAL_CST:
6610 1225 : {
6611 1225 : switch (TREE_CODE (_p1))
6612 : {
6613 1202 : case REAL_CST:
6614 1202 : {
6615 1202 : {
6616 1202 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6617 1202 : tree res = generic_simplify_263 (loc, type, _p0, _p1, captures, MINUS_EXPR, LE_EXPR);
6618 1202 : if (res) return res;
6619 : }
6620 1202 : break;
6621 : }
6622 : default:;
6623 : }
6624 : break;
6625 : }
6626 60297 : default:;
6627 : }
6628 60297 : switch (TREE_CODE (_q20))
6629 : {
6630 2 : case REAL_CST:
6631 2 : {
6632 2 : switch (TREE_CODE (_p1))
6633 : {
6634 0 : case REAL_CST:
6635 0 : {
6636 0 : {
6637 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6638 0 : tree res = generic_simplify_264 (loc, type, _p0, _p1, captures, LE_EXPR);
6639 0 : if (res) return res;
6640 : }
6641 0 : break;
6642 : }
6643 : default:;
6644 : }
6645 : break;
6646 : }
6647 : default:;
6648 : }
6649 : break;
6650 : }
6651 12084 : case FLOAT_EXPR:
6652 12084 : {
6653 12084 : tree _q20 = TREE_OPERAND (_p0, 0);
6654 12084 : switch (TREE_CODE (_p1))
6655 : {
6656 1 : case FLOAT_EXPR:
6657 1 : {
6658 1 : tree _q40 = TREE_OPERAND (_p1, 0);
6659 1 : {
6660 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
6661 1 : tree res = generic_simplify_267 (loc, type, _p0, _p1, captures, LE_EXPR, LE_EXPR);
6662 1 : if (res) return res;
6663 : }
6664 1 : break;
6665 : }
6666 274 : case REAL_CST:
6667 274 : {
6668 274 : {
6669 274 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
6670 274 : tree res = generic_simplify_268 (loc, type, _p0, _p1, captures, LE_EXPR, LE_EXPR);
6671 274 : if (res) return res;
6672 : }
6673 174 : break;
6674 : }
6675 : default:;
6676 : }
6677 : break;
6678 : }
6679 476 : case EXACT_DIV_EXPR:
6680 476 : {
6681 476 : tree _q20 = TREE_OPERAND (_p0, 0);
6682 476 : tree _q21 = TREE_OPERAND (_p0, 1);
6683 476 : switch (TREE_CODE (_q21))
6684 : {
6685 476 : case INTEGER_CST:
6686 476 : {
6687 476 : switch (TREE_CODE (_p1))
6688 : {
6689 399 : case INTEGER_CST:
6690 399 : {
6691 399 : {
6692 399 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6693 399 : tree res = generic_simplify_397 (loc, type, _p0, _p1, captures, LE_EXPR);
6694 399 : if (res) return res;
6695 : }
6696 0 : break;
6697 : }
6698 : default:;
6699 : }
6700 : break;
6701 : }
6702 : default:;
6703 : }
6704 : break;
6705 : }
6706 1666231 : CASE_CONVERT:
6707 1666231 : {
6708 1666231 : tree _q20 = TREE_OPERAND (_p0, 0);
6709 1666231 : switch (TREE_CODE (_q20))
6710 : {
6711 0 : case EXACT_DIV_EXPR:
6712 0 : {
6713 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6714 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6715 0 : switch (TREE_CODE (_q31))
6716 : {
6717 0 : case INTEGER_CST:
6718 0 : {
6719 0 : switch (TREE_CODE (_p1))
6720 : {
6721 0 : case INTEGER_CST:
6722 0 : {
6723 0 : {
6724 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
6725 0 : tree res = generic_simplify_398 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6726 0 : if (res) return res;
6727 : }
6728 0 : break;
6729 : }
6730 : default:;
6731 : }
6732 : break;
6733 : }
6734 : default:;
6735 : }
6736 : break;
6737 : }
6738 1666231 : default:;
6739 : }
6740 1666231 : switch (TREE_CODE (_p1))
6741 : {
6742 80443 : CASE_CONVERT:
6743 80443 : {
6744 80443 : tree _q40 = TREE_OPERAND (_p1, 0);
6745 80443 : {
6746 80443 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
6747 80443 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, LE_EXPR);
6748 80443 : if (res) return res;
6749 : }
6750 30030 : break;
6751 : }
6752 1615818 : default:;
6753 : }
6754 1615818 : {
6755 1615818 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
6756 1615818 : tree res = generic_simplify_273 (loc, type, _p0, _p1, captures, LE_EXPR);
6757 1615818 : if (res) return res;
6758 : }
6759 953630 : switch (TREE_CODE (_q20))
6760 : {
6761 10313 : case ADDR_EXPR:
6762 10313 : {
6763 10313 : switch (TREE_CODE (_p1))
6764 : {
6765 6188 : CASE_CONVERT:
6766 6188 : {
6767 6188 : tree _q40 = TREE_OPERAND (_p1, 0);
6768 6188 : switch (TREE_CODE (_q40))
6769 : {
6770 6188 : case ADDR_EXPR:
6771 6188 : {
6772 6188 : {
6773 6188 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
6774 6188 : tree res = generic_simplify_291 (loc, type, _p0, _p1, captures, LE_EXPR);
6775 6188 : if (res) return res;
6776 : }
6777 160 : break;
6778 : }
6779 : default:;
6780 : }
6781 : break;
6782 : }
6783 7 : case ADDR_EXPR:
6784 7 : {
6785 7 : {
6786 7 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
6787 7 : tree res = generic_simplify_291 (loc, type, _p0, _p1, captures, LE_EXPR);
6788 7 : if (res) return res;
6789 : }
6790 0 : break;
6791 : }
6792 : default:;
6793 : }
6794 : break;
6795 : }
6796 947595 : default:;
6797 : }
6798 947595 : if (uniform_integer_cst_p (_p1))
6799 : {
6800 499305 : {
6801 499305 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
6802 499305 : tree res = generic_simplify_399 (loc, type, _p0, _p1, captures, LE_EXPR);
6803 499305 : if (res) return res;
6804 : }
6805 : }
6806 : break;
6807 : }
6808 5433 : case BIT_AND_EXPR:
6809 5433 : {
6810 5433 : tree _q20 = TREE_OPERAND (_p0, 0);
6811 5433 : tree _q21 = TREE_OPERAND (_p0, 1);
6812 5433 : switch (TREE_CODE (_q21))
6813 : {
6814 4957 : case INTEGER_CST:
6815 4957 : {
6816 4957 : switch (TREE_CODE (_p1))
6817 : {
6818 2807 : case INTEGER_CST:
6819 2807 : {
6820 2807 : {
6821 2807 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
6822 2807 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR);
6823 2807 : if (res) return res;
6824 : }
6825 2760 : break;
6826 : }
6827 : default:;
6828 : }
6829 : break;
6830 : }
6831 : default:;
6832 : }
6833 : break;
6834 : }
6835 5592 : case NEGATE_EXPR:
6836 5592 : {
6837 5592 : tree _q20 = TREE_OPERAND (_p0, 0);
6838 5592 : switch (TREE_CODE (_p1))
6839 : {
6840 32 : case NEGATE_EXPR:
6841 32 : {
6842 32 : tree _q40 = TREE_OPERAND (_p1, 0);
6843 32 : {
6844 32 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6845 32 : tree res = generic_simplify_270 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6846 32 : if (res) return res;
6847 : }
6848 32 : break;
6849 : }
6850 5592 : default:;
6851 : }
6852 5592 : if (CONSTANT_CLASS_P (_p1))
6853 : {
6854 457 : {
6855 457 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6856 457 : tree res = generic_simplify_271 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6857 457 : if (res) return res;
6858 : }
6859 : }
6860 : break;
6861 : }
6862 1504 : case ADDR_EXPR:
6863 1504 : {
6864 1504 : switch (TREE_CODE (_p1))
6865 : {
6866 19 : CASE_CONVERT:
6867 19 : {
6868 19 : tree _q30 = TREE_OPERAND (_p1, 0);
6869 19 : switch (TREE_CODE (_q30))
6870 : {
6871 19 : case ADDR_EXPR:
6872 19 : {
6873 19 : {
6874 19 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q30 };
6875 19 : tree res = generic_simplify_292 (loc, type, _p0, _p1, captures, LE_EXPR);
6876 19 : if (res) return res;
6877 : }
6878 0 : break;
6879 : }
6880 : default:;
6881 : }
6882 : break;
6883 : }
6884 676 : case ADDR_EXPR:
6885 676 : {
6886 676 : {
6887 676 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
6888 676 : tree res = generic_simplify_292 (loc, type, _p0, _p1, captures, LE_EXPR);
6889 676 : if (res) return res;
6890 : }
6891 302 : break;
6892 : }
6893 : default:;
6894 : }
6895 : break;
6896 : }
6897 133891 : case CALL_EXPR:
6898 133891 : switch (get_call_combined_fn (_p0))
6899 : {
6900 2 : case CFN_BUILT_IN_SQRTF:
6901 2 : if (call_expr_nargs (_p0) == 1)
6902 : {
6903 2 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
6904 2 : switch (TREE_CODE (_p1))
6905 : {
6906 2 : case REAL_CST:
6907 2 : {
6908 2 : {
6909 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6910 2 : tree res = generic_simplify_265 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, LE_EXPR);
6911 2 : if (res) return res;
6912 : }
6913 0 : break;
6914 : }
6915 0 : case CALL_EXPR:
6916 0 : switch (get_call_combined_fn (_p1))
6917 : {
6918 0 : case CFN_BUILT_IN_SQRTF:
6919 0 : if (call_expr_nargs (_p1) == 1)
6920 : {
6921 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
6922 0 : {
6923 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6924 0 : tree res = generic_simplify_266 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, LE_EXPR);
6925 0 : if (res) return res;
6926 : }
6927 : }
6928 : break;
6929 : default:;
6930 : }
6931 : break;
6932 : default:;
6933 : }
6934 : }
6935 : break;
6936 0 : case CFN_BUILT_IN_SQRTL:
6937 0 : if (call_expr_nargs (_p0) == 1)
6938 : {
6939 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
6940 0 : switch (TREE_CODE (_p1))
6941 : {
6942 0 : case REAL_CST:
6943 0 : {
6944 0 : {
6945 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6946 0 : tree res = generic_simplify_265 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, LE_EXPR);
6947 0 : if (res) return res;
6948 : }
6949 0 : break;
6950 : }
6951 0 : case CALL_EXPR:
6952 0 : switch (get_call_combined_fn (_p1))
6953 : {
6954 0 : case CFN_BUILT_IN_SQRTL:
6955 0 : if (call_expr_nargs (_p1) == 1)
6956 : {
6957 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
6958 0 : {
6959 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6960 0 : tree res = generic_simplify_266 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, LE_EXPR);
6961 0 : if (res) return res;
6962 : }
6963 : }
6964 : break;
6965 : default:;
6966 : }
6967 : break;
6968 : default:;
6969 : }
6970 : }
6971 : break;
6972 2 : case CFN_BUILT_IN_SQRT:
6973 2 : if (call_expr_nargs (_p0) == 1)
6974 : {
6975 2 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
6976 2 : switch (TREE_CODE (_p1))
6977 : {
6978 2 : case REAL_CST:
6979 2 : {
6980 2 : {
6981 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6982 2 : tree res = generic_simplify_265 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, LE_EXPR);
6983 2 : if (res) return res;
6984 : }
6985 2 : break;
6986 : }
6987 0 : case CALL_EXPR:
6988 0 : switch (get_call_combined_fn (_p1))
6989 : {
6990 0 : case CFN_BUILT_IN_SQRT:
6991 0 : if (call_expr_nargs (_p1) == 1)
6992 : {
6993 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
6994 0 : {
6995 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6996 0 : tree res = generic_simplify_266 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, LE_EXPR);
6997 0 : if (res) return res;
6998 : }
6999 : }
7000 : break;
7001 : default:;
7002 : }
7003 : break;
7004 : default:;
7005 : }
7006 : }
7007 : break;
7008 0 : case CFN_SQRT:
7009 0 : if (call_expr_nargs (_p0) == 1)
7010 : {
7011 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7012 0 : switch (TREE_CODE (_p1))
7013 : {
7014 0 : case REAL_CST:
7015 0 : {
7016 0 : {
7017 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7018 0 : tree res = generic_simplify_265 (loc, type, _p0, _p1, captures, CFN_SQRT, LE_EXPR);
7019 0 : if (res) return res;
7020 : }
7021 0 : break;
7022 : }
7023 0 : case CALL_EXPR:
7024 0 : switch (get_call_combined_fn (_p1))
7025 : {
7026 0 : case CFN_SQRT:
7027 0 : if (call_expr_nargs (_p1) == 1)
7028 : {
7029 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7030 0 : {
7031 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
7032 0 : tree res = generic_simplify_266 (loc, type, _p0, _p1, captures, CFN_SQRT, LE_EXPR);
7033 0 : if (res) return res;
7034 : }
7035 : }
7036 : break;
7037 : default:;
7038 : }
7039 : break;
7040 : default:;
7041 : }
7042 : }
7043 : break;
7044 : default:;
7045 : }
7046 : break;
7047 8460982 : default:;
7048 : }
7049 8460982 : if (uniform_integer_cst_p (_p1))
7050 : {
7051 6010341 : {
7052 6010341 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
7053 6010341 : tree res = generic_simplify_400 (loc, type, _p0, _p1, captures, LE_EXPR);
7054 6010341 : if (res) return res;
7055 : }
7056 : }
7057 8056541 : switch (TREE_CODE (_p0))
7058 : {
7059 911485 : CASE_CONVERT:
7060 911485 : {
7061 911485 : tree _q20 = TREE_OPERAND (_p0, 0);
7062 911485 : switch (TREE_CODE (_q20))
7063 : {
7064 94186 : case PLUS_EXPR:
7065 94186 : {
7066 94186 : tree _q30 = TREE_OPERAND (_q20, 0);
7067 94186 : tree _q31 = TREE_OPERAND (_q20, 1);
7068 94186 : switch (TREE_CODE (_q30))
7069 : {
7070 79487 : CASE_CONVERT:
7071 79487 : {
7072 79487 : tree _q40 = TREE_OPERAND (_q30, 0);
7073 79487 : switch (TREE_CODE (_q31))
7074 : {
7075 78914 : case INTEGER_CST:
7076 78914 : {
7077 78914 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
7078 : {
7079 4 : {
7080 4 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q40, _q31 };
7081 4 : tree res = generic_simplify_401 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR);
7082 4 : if (res) return res;
7083 : }
7084 : }
7085 : break;
7086 : }
7087 : default:;
7088 : }
7089 : break;
7090 : }
7091 : default:;
7092 : }
7093 : break;
7094 : }
7095 : default:;
7096 : }
7097 : break;
7098 : }
7099 8056537 : default:;
7100 : }
7101 8056537 : switch (TREE_CODE (_p1))
7102 : {
7103 197970 : CASE_CONVERT:
7104 197970 : {
7105 197970 : tree _q30 = TREE_OPERAND (_p1, 0);
7106 197970 : switch (TREE_CODE (_q30))
7107 : {
7108 2013 : case PLUS_EXPR:
7109 2013 : {
7110 2013 : tree _q40 = TREE_OPERAND (_q30, 0);
7111 2013 : tree _q41 = TREE_OPERAND (_q30, 1);
7112 2013 : switch (TREE_CODE (_q40))
7113 : {
7114 461 : CASE_CONVERT:
7115 461 : {
7116 461 : tree _q50 = TREE_OPERAND (_q40, 0);
7117 461 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
7118 : {
7119 0 : switch (TREE_CODE (_q41))
7120 : {
7121 0 : case INTEGER_CST:
7122 0 : {
7123 0 : {
7124 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0, _q41 };
7125 0 : tree res = generic_simplify_401 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR);
7126 0 : if (res) return res;
7127 : }
7128 0 : break;
7129 : }
7130 : default:;
7131 : }
7132 : }
7133 : break;
7134 : }
7135 : default:;
7136 : }
7137 : break;
7138 : }
7139 : default:;
7140 : }
7141 : break;
7142 : }
7143 122769 : case PLUS_EXPR:
7144 122769 : {
7145 122769 : tree _q30 = TREE_OPERAND (_p1, 0);
7146 122769 : tree _q31 = TREE_OPERAND (_p1, 1);
7147 122769 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
7148 : {
7149 30 : switch (TREE_CODE (_q31))
7150 : {
7151 30 : case INTEGER_CST:
7152 30 : {
7153 30 : {
7154 30 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0, _q31 };
7155 30 : tree res = generic_simplify_396 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR);
7156 30 : if (res) return res;
7157 : }
7158 0 : break;
7159 : }
7160 : default:;
7161 : }
7162 : }
7163 : break;
7164 : }
7165 8056507 : default:;
7166 : }
7167 8056507 : switch (TREE_CODE (_p0))
7168 : {
7169 58144 : case MINUS_EXPR:
7170 58144 : {
7171 58144 : tree _q20 = TREE_OPERAND (_p0, 0);
7172 58144 : tree _q21 = TREE_OPERAND (_p0, 1);
7173 58144 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
7174 : {
7175 2509 : {
7176 2509 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
7177 2509 : tree res = generic_simplify_402 (loc, type, _p0, _p1, captures, LE_EXPR);
7178 2509 : if (res) return res;
7179 : }
7180 : }
7181 : break;
7182 : }
7183 8056380 : default:;
7184 : }
7185 8056380 : switch (TREE_CODE (_p1))
7186 : {
7187 122739 : case PLUS_EXPR:
7188 122739 : {
7189 122739 : tree _q30 = TREE_OPERAND (_p1, 0);
7190 122739 : tree _q31 = TREE_OPERAND (_p1, 1);
7191 122739 : switch (TREE_CODE (_q30))
7192 : {
7193 4 : case MINUS_EXPR:
7194 4 : {
7195 4 : tree _q40 = TREE_OPERAND (_q30, 0);
7196 4 : tree _q41 = TREE_OPERAND (_q30, 1);
7197 4 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
7198 : {
7199 0 : if (integer_minus_onep (_q31))
7200 : {
7201 0 : {
7202 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
7203 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GE_EXPR);
7204 0 : if (res) return res;
7205 : }
7206 : }
7207 : }
7208 : break;
7209 : }
7210 : default:;
7211 : }
7212 : break;
7213 : }
7214 8056380 : default:;
7215 : }
7216 8056380 : switch (TREE_CODE (_p0))
7217 : {
7218 12 : case REALPART_EXPR:
7219 12 : {
7220 12 : tree _q20 = TREE_OPERAND (_p0, 0);
7221 12 : switch (TREE_CODE (_q20))
7222 : {
7223 0 : case CALL_EXPR:
7224 0 : switch (get_call_combined_fn (_q20))
7225 : {
7226 0 : case CFN_SUB_OVERFLOW:
7227 0 : if (call_expr_nargs (_q20) == 2)
7228 : {
7229 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
7230 0 : tree _q31 = CALL_EXPR_ARG (_q20, 1);
7231 0 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
7232 : {
7233 0 : {
7234 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7235 0 : tree res = generic_simplify_415 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR);
7236 0 : if (res) return res;
7237 : }
7238 : }
7239 : }
7240 : break;
7241 : default:;
7242 : }
7243 : break;
7244 : default:;
7245 : }
7246 : break;
7247 : }
7248 8056380 : default:;
7249 : }
7250 8056380 : switch (TREE_CODE (_p1))
7251 : {
7252 0 : case REALPART_EXPR:
7253 0 : {
7254 0 : tree _q30 = TREE_OPERAND (_p1, 0);
7255 0 : switch (TREE_CODE (_q30))
7256 : {
7257 0 : case CALL_EXPR:
7258 0 : switch (get_call_combined_fn (_q30))
7259 : {
7260 0 : case CFN_ADD_OVERFLOW:
7261 0 : if (call_expr_nargs (_q30) == 2)
7262 : {
7263 0 : tree _q40 = CALL_EXPR_ARG (_q30, 0);
7264 0 : tree _q41 = CALL_EXPR_ARG (_q30, 1);
7265 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
7266 : {
7267 0 : {
7268 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p0, _q41 };
7269 0 : tree res = generic_simplify_416 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
7270 0 : if (res) return res;
7271 : }
7272 : }
7273 0 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
7274 : {
7275 0 : {
7276 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p0, _q40 };
7277 0 : tree res = generic_simplify_416 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
7278 0 : if (res) return res;
7279 : }
7280 : }
7281 : }
7282 : break;
7283 : default:;
7284 : }
7285 : break;
7286 : default:;
7287 : }
7288 : break;
7289 : }
7290 337 : case TRUNC_DIV_EXPR:
7291 337 : {
7292 337 : tree _q30 = TREE_OPERAND (_p1, 0);
7293 337 : tree _q31 = TREE_OPERAND (_p1, 1);
7294 337 : if (integer_all_onesp (_q30))
7295 : {
7296 0 : {
7297 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q31, _p0 };
7298 0 : tree res = generic_simplify_417 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
7299 0 : if (res) return res;
7300 : }
7301 : }
7302 : break;
7303 : }
7304 8056380 : default:;
7305 : }
7306 8056380 : switch (TREE_CODE (_p0))
7307 : {
7308 58319 : case MULT_EXPR:
7309 58319 : {
7310 58319 : tree _q20 = TREE_OPERAND (_p0, 0);
7311 58319 : tree _q21 = TREE_OPERAND (_p0, 1);
7312 58319 : switch (TREE_CODE (_q20))
7313 : {
7314 4576 : CASE_CONVERT:
7315 4576 : {
7316 4576 : tree _q30 = TREE_OPERAND (_q20, 0);
7317 4576 : switch (TREE_CODE (_q21))
7318 : {
7319 25 : CASE_CONVERT:
7320 25 : {
7321 25 : tree _q50 = TREE_OPERAND (_q21, 0);
7322 25 : switch (TREE_CODE (_p1))
7323 : {
7324 25 : case INTEGER_CST:
7325 25 : {
7326 25 : {
7327 25 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50, _p1 };
7328 25 : tree res = generic_simplify_418 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR);
7329 25 : if (res) return res;
7330 : }
7331 0 : break;
7332 : }
7333 : default:;
7334 : }
7335 : break;
7336 : }
7337 : default:;
7338 : }
7339 : break;
7340 : }
7341 58294 : default:;
7342 : }
7343 58294 : switch (TREE_CODE (_q21))
7344 : {
7345 821 : case REAL_CST:
7346 821 : {
7347 821 : switch (TREE_CODE (_p1))
7348 : {
7349 553 : case REAL_CST:
7350 553 : {
7351 553 : {
7352 553 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7353 553 : tree res = generic_simplify_407 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
7354 553 : if (res) return res;
7355 : }
7356 551 : break;
7357 : }
7358 : default:;
7359 : }
7360 : break;
7361 : }
7362 : default:;
7363 : }
7364 : break;
7365 : }
7366 22 : case REAL_CST:
7367 22 : {
7368 22 : switch (TREE_CODE (_p1))
7369 : {
7370 0 : case CALL_EXPR:
7371 0 : switch (get_call_combined_fn (_p1))
7372 : {
7373 0 : case CFN_BUILT_IN_EXP:
7374 0 : if (call_expr_nargs (_p1) == 1)
7375 : {
7376 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7377 0 : {
7378 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7379 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, GE_EXPR);
7380 0 : if (res) return res;
7381 : }
7382 : }
7383 : break;
7384 0 : case CFN_BUILT_IN_LOG:
7385 0 : if (call_expr_nargs (_p1) == 1)
7386 : {
7387 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7388 0 : {
7389 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7390 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, GE_EXPR);
7391 0 : if (res) return res;
7392 : }
7393 : }
7394 : break;
7395 0 : case CFN_BUILT_IN_EXP10F:
7396 0 : if (call_expr_nargs (_p1) == 1)
7397 : {
7398 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7399 0 : {
7400 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7401 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, GE_EXPR);
7402 0 : if (res) return res;
7403 : }
7404 : }
7405 : break;
7406 0 : case CFN_BUILT_IN_EXP10L:
7407 0 : if (call_expr_nargs (_p1) == 1)
7408 : {
7409 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7410 0 : {
7411 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7412 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, GE_EXPR);
7413 0 : if (res) return res;
7414 : }
7415 : }
7416 : break;
7417 0 : case CFN_BUILT_IN_EXP2:
7418 0 : if (call_expr_nargs (_p1) == 1)
7419 : {
7420 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7421 0 : {
7422 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7423 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, GE_EXPR);
7424 0 : if (res) return res;
7425 : }
7426 : }
7427 : break;
7428 0 : case CFN_BUILT_IN_EXPF:
7429 0 : if (call_expr_nargs (_p1) == 1)
7430 : {
7431 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7432 0 : {
7433 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7434 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, GE_EXPR);
7435 0 : if (res) return res;
7436 : }
7437 : }
7438 : break;
7439 0 : case CFN_BUILT_IN_EXPL:
7440 0 : if (call_expr_nargs (_p1) == 1)
7441 : {
7442 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7443 0 : {
7444 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7445 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, GE_EXPR);
7446 0 : if (res) return res;
7447 : }
7448 : }
7449 : break;
7450 0 : case CFN_BUILT_IN_LOG2:
7451 0 : if (call_expr_nargs (_p1) == 1)
7452 : {
7453 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7454 0 : {
7455 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7456 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, GE_EXPR);
7457 0 : if (res) return res;
7458 : }
7459 : }
7460 : break;
7461 0 : case CFN_BUILT_IN_LOGF:
7462 0 : if (call_expr_nargs (_p1) == 1)
7463 : {
7464 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7465 0 : {
7466 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7467 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, GE_EXPR);
7468 0 : if (res) return res;
7469 : }
7470 : }
7471 : break;
7472 0 : case CFN_BUILT_IN_LOGL:
7473 0 : if (call_expr_nargs (_p1) == 1)
7474 : {
7475 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7476 0 : {
7477 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7478 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, GE_EXPR);
7479 0 : if (res) return res;
7480 : }
7481 : }
7482 : break;
7483 0 : case CFN_BUILT_IN_LOG10F:
7484 0 : if (call_expr_nargs (_p1) == 1)
7485 : {
7486 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7487 0 : {
7488 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7489 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, GE_EXPR);
7490 0 : if (res) return res;
7491 : }
7492 : }
7493 : break;
7494 0 : case CFN_BUILT_IN_LOG10L:
7495 0 : if (call_expr_nargs (_p1) == 1)
7496 : {
7497 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7498 0 : {
7499 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7500 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, GE_EXPR);
7501 0 : if (res) return res;
7502 : }
7503 : }
7504 : break;
7505 0 : case CFN_EXP:
7506 0 : if (call_expr_nargs (_p1) == 1)
7507 : {
7508 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7509 0 : {
7510 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7511 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, GE_EXPR);
7512 0 : if (res) return res;
7513 : }
7514 : }
7515 : break;
7516 0 : case CFN_LOG:
7517 0 : if (call_expr_nargs (_p1) == 1)
7518 : {
7519 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7520 0 : {
7521 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7522 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, GE_EXPR);
7523 0 : if (res) return res;
7524 : }
7525 : }
7526 : break;
7527 0 : case CFN_EXP2:
7528 0 : if (call_expr_nargs (_p1) == 1)
7529 : {
7530 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7531 0 : {
7532 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7533 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, GE_EXPR);
7534 0 : if (res) return res;
7535 : }
7536 : }
7537 : break;
7538 0 : case CFN_LOG2:
7539 0 : if (call_expr_nargs (_p1) == 1)
7540 : {
7541 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7542 0 : {
7543 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7544 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, GE_EXPR);
7545 0 : if (res) return res;
7546 : }
7547 : }
7548 : break;
7549 0 : case CFN_EXP10:
7550 0 : if (call_expr_nargs (_p1) == 1)
7551 : {
7552 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7553 0 : {
7554 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7555 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, GE_EXPR);
7556 0 : if (res) return res;
7557 : }
7558 : }
7559 : break;
7560 0 : case CFN_LOG10:
7561 0 : if (call_expr_nargs (_p1) == 1)
7562 : {
7563 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7564 0 : {
7565 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7566 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, GE_EXPR);
7567 0 : if (res) return res;
7568 : }
7569 : }
7570 : break;
7571 0 : case CFN_BUILT_IN_EXP10:
7572 0 : if (call_expr_nargs (_p1) == 1)
7573 : {
7574 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7575 0 : {
7576 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7577 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, GE_EXPR);
7578 0 : if (res) return res;
7579 : }
7580 : }
7581 : break;
7582 0 : case CFN_BUILT_IN_EXP2F:
7583 0 : if (call_expr_nargs (_p1) == 1)
7584 : {
7585 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7586 0 : {
7587 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7588 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, GE_EXPR);
7589 0 : if (res) return res;
7590 : }
7591 : }
7592 : break;
7593 0 : case CFN_BUILT_IN_EXP2L:
7594 0 : if (call_expr_nargs (_p1) == 1)
7595 : {
7596 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7597 0 : {
7598 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7599 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, GE_EXPR);
7600 0 : if (res) return res;
7601 : }
7602 : }
7603 : break;
7604 0 : case CFN_BUILT_IN_LOG10:
7605 0 : if (call_expr_nargs (_p1) == 1)
7606 : {
7607 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7608 0 : {
7609 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7610 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, GE_EXPR);
7611 0 : if (res) return res;
7612 : }
7613 : }
7614 : break;
7615 0 : case CFN_BUILT_IN_LOG2F:
7616 0 : if (call_expr_nargs (_p1) == 1)
7617 : {
7618 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7619 0 : {
7620 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7621 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, GE_EXPR);
7622 0 : if (res) return res;
7623 : }
7624 : }
7625 : break;
7626 0 : case CFN_BUILT_IN_LOG2L:
7627 0 : if (call_expr_nargs (_p1) == 1)
7628 : {
7629 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7630 0 : {
7631 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7632 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, GE_EXPR);
7633 0 : if (res) return res;
7634 : }
7635 : }
7636 : break;
7637 : default:;
7638 : }
7639 : break;
7640 : default:;
7641 : }
7642 : break;
7643 : }
7644 1498076 : case PLUS_EXPR:
7645 1498076 : {
7646 1498076 : tree _q20 = TREE_OPERAND (_p0, 0);
7647 1498076 : tree _q21 = TREE_OPERAND (_p0, 1);
7648 1498076 : switch (TREE_CODE (_q21))
7649 : {
7650 1394877 : case INTEGER_CST:
7651 1394877 : {
7652 1394877 : switch (TREE_CODE (_p1))
7653 : {
7654 870690 : case INTEGER_CST:
7655 870690 : {
7656 870690 : {
7657 870690 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
7658 870690 : tree res = generic_simplify_408 (loc, type, _p0, _p1, captures, PLUS_EXPR, MINUS_EXPR, LE_EXPR, GE_EXPR);
7659 870690 : if (res) return res;
7660 : }
7661 687152 : break;
7662 : }
7663 : default:;
7664 : }
7665 : break;
7666 : }
7667 : default:;
7668 : }
7669 : break;
7670 : }
7671 58017 : case MINUS_EXPR:
7672 58017 : {
7673 58017 : tree _q20 = TREE_OPERAND (_p0, 0);
7674 58017 : tree _q21 = TREE_OPERAND (_p0, 1);
7675 58017 : switch (TREE_CODE (_q21))
7676 : {
7677 2203 : case INTEGER_CST:
7678 2203 : {
7679 2203 : switch (TREE_CODE (_p1))
7680 : {
7681 2203 : case INTEGER_CST:
7682 2203 : {
7683 2203 : {
7684 2203 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
7685 2203 : tree res = generic_simplify_408 (loc, type, _p0, _p1, captures, MINUS_EXPR, PLUS_EXPR, LE_EXPR, GE_EXPR);
7686 2203 : if (res) return res;
7687 : }
7688 2203 : break;
7689 : }
7690 : default:;
7691 : }
7692 : break;
7693 : }
7694 58017 : default:;
7695 : }
7696 58017 : switch (TREE_CODE (_q20))
7697 : {
7698 2058 : case INTEGER_CST:
7699 2058 : {
7700 2058 : switch (TREE_CODE (_p1))
7701 : {
7702 1100 : case INTEGER_CST:
7703 1100 : {
7704 1100 : {
7705 1100 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7706 1100 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
7707 1100 : if (res) return res;
7708 : }
7709 0 : break;
7710 : }
7711 : default:;
7712 : }
7713 : break;
7714 : }
7715 : default:;
7716 : }
7717 : break;
7718 : }
7719 133083 : case CALL_EXPR:
7720 133083 : switch (get_call_combined_fn (_p0))
7721 : {
7722 18 : case CFN_BUILT_IN_CTZ:
7723 18 : if (call_expr_nargs (_p0) == 1)
7724 : {
7725 18 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7726 18 : switch (TREE_CODE (_p1))
7727 : {
7728 18 : case INTEGER_CST:
7729 18 : {
7730 18 : {
7731 18 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7732 18 : tree res = generic_simplify_409 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_BUILT_IN_CTZ);
7733 18 : if (res) return res;
7734 : }
7735 16 : break;
7736 : }
7737 : default:;
7738 : }
7739 : }
7740 : break;
7741 0 : case CFN_BUILT_IN_EXP:
7742 0 : if (call_expr_nargs (_p0) == 1)
7743 : {
7744 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7745 0 : switch (TREE_CODE (_p1))
7746 : {
7747 0 : case REAL_CST:
7748 0 : {
7749 0 : {
7750 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7751 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, LE_EXPR);
7752 0 : if (res) return res;
7753 : }
7754 0 : break;
7755 : }
7756 : default:;
7757 : }
7758 : }
7759 : break;
7760 8 : case CFN_BUILT_IN_FFS:
7761 8 : if (call_expr_nargs (_p0) == 1)
7762 : {
7763 8 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7764 8 : switch (TREE_CODE (_p1))
7765 : {
7766 8 : case INTEGER_CST:
7767 8 : {
7768 8 : {
7769 8 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7770 8 : tree res = generic_simplify_421 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_FFS);
7771 8 : if (res) return res;
7772 : }
7773 2 : break;
7774 : }
7775 : default:;
7776 : }
7777 : }
7778 : break;
7779 0 : case CFN_BUILT_IN_LOG:
7780 0 : if (call_expr_nargs (_p0) == 1)
7781 : {
7782 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7783 0 : switch (TREE_CODE (_p1))
7784 : {
7785 0 : case REAL_CST:
7786 0 : {
7787 0 : {
7788 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7789 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, LE_EXPR);
7790 0 : if (res) return res;
7791 : }
7792 0 : break;
7793 : }
7794 : default:;
7795 : }
7796 : }
7797 : break;
7798 0 : case CFN_BUILT_IN_FFSIMAX:
7799 0 : if (call_expr_nargs (_p0) == 1)
7800 : {
7801 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7802 0 : switch (TREE_CODE (_p1))
7803 : {
7804 0 : case INTEGER_CST:
7805 0 : {
7806 0 : {
7807 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7808 0 : tree res = generic_simplify_421 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_FFSIMAX);
7809 0 : if (res) return res;
7810 : }
7811 0 : break;
7812 : }
7813 : default:;
7814 : }
7815 : }
7816 : break;
7817 0 : case CFN_BUILT_IN_EXP10F:
7818 0 : if (call_expr_nargs (_p0) == 1)
7819 : {
7820 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7821 0 : switch (TREE_CODE (_p1))
7822 : {
7823 0 : case REAL_CST:
7824 0 : {
7825 0 : {
7826 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7827 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, LE_EXPR);
7828 0 : if (res) return res;
7829 : }
7830 0 : break;
7831 : }
7832 : default:;
7833 : }
7834 : }
7835 : break;
7836 0 : case CFN_BUILT_IN_EXP10L:
7837 0 : if (call_expr_nargs (_p0) == 1)
7838 : {
7839 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7840 0 : switch (TREE_CODE (_p1))
7841 : {
7842 0 : case REAL_CST:
7843 0 : {
7844 0 : {
7845 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7846 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, LE_EXPR);
7847 0 : if (res) return res;
7848 : }
7849 0 : break;
7850 : }
7851 : default:;
7852 : }
7853 : }
7854 : break;
7855 37 : case CFN_BUILT_IN_POPCOUNT:
7856 37 : if (call_expr_nargs (_p0) == 1)
7857 : {
7858 37 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7859 37 : if (integer_zerop (_p1))
7860 : {
7861 1 : {
7862 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
7863 1 : tree res = generic_simplify_303 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNT);
7864 1 : if (res) return res;
7865 : }
7866 : }
7867 : }
7868 : break;
7869 0 : case CFN_BUILT_IN_CTZL:
7870 0 : if (call_expr_nargs (_p0) == 1)
7871 : {
7872 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7873 0 : switch (TREE_CODE (_p1))
7874 : {
7875 0 : case INTEGER_CST:
7876 0 : {
7877 0 : {
7878 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7879 0 : tree res = generic_simplify_409 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_BUILT_IN_CTZL);
7880 0 : if (res) return res;
7881 : }
7882 0 : break;
7883 : }
7884 : default:;
7885 : }
7886 : }
7887 : break;
7888 0 : case CFN_BUILT_IN_EXP2:
7889 0 : if (call_expr_nargs (_p0) == 1)
7890 : {
7891 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7892 0 : switch (TREE_CODE (_p1))
7893 : {
7894 0 : case REAL_CST:
7895 0 : {
7896 0 : {
7897 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7898 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, LE_EXPR);
7899 0 : if (res) return res;
7900 : }
7901 0 : break;
7902 : }
7903 : default:;
7904 : }
7905 : }
7906 : break;
7907 0 : case CFN_BUILT_IN_EXPF:
7908 0 : if (call_expr_nargs (_p0) == 1)
7909 : {
7910 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7911 0 : switch (TREE_CODE (_p1))
7912 : {
7913 0 : case REAL_CST:
7914 0 : {
7915 0 : {
7916 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7917 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, LE_EXPR);
7918 0 : if (res) return res;
7919 : }
7920 0 : break;
7921 : }
7922 : default:;
7923 : }
7924 : }
7925 : break;
7926 0 : case CFN_BUILT_IN_EXPL:
7927 0 : if (call_expr_nargs (_p0) == 1)
7928 : {
7929 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7930 0 : switch (TREE_CODE (_p1))
7931 : {
7932 0 : case REAL_CST:
7933 0 : {
7934 0 : {
7935 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7936 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, LE_EXPR);
7937 0 : if (res) return res;
7938 : }
7939 0 : break;
7940 : }
7941 : default:;
7942 : }
7943 : }
7944 : break;
7945 3 : case CFN_BUILT_IN_FFSL:
7946 3 : if (call_expr_nargs (_p0) == 1)
7947 : {
7948 3 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7949 3 : switch (TREE_CODE (_p1))
7950 : {
7951 3 : case INTEGER_CST:
7952 3 : {
7953 3 : {
7954 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7955 3 : tree res = generic_simplify_421 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_FFSL);
7956 3 : if (res) return res;
7957 : }
7958 0 : break;
7959 : }
7960 : default:;
7961 : }
7962 : }
7963 : break;
7964 0 : case CFN_BUILT_IN_LOG2:
7965 0 : if (call_expr_nargs (_p0) == 1)
7966 : {
7967 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7968 0 : switch (TREE_CODE (_p1))
7969 : {
7970 0 : case REAL_CST:
7971 0 : {
7972 0 : {
7973 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7974 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, LE_EXPR);
7975 0 : if (res) return res;
7976 : }
7977 0 : break;
7978 : }
7979 : default:;
7980 : }
7981 : }
7982 : break;
7983 0 : case CFN_BUILT_IN_LOGF:
7984 0 : if (call_expr_nargs (_p0) == 1)
7985 : {
7986 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7987 0 : switch (TREE_CODE (_p1))
7988 : {
7989 0 : case REAL_CST:
7990 0 : {
7991 0 : {
7992 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7993 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, LE_EXPR);
7994 0 : if (res) return res;
7995 : }
7996 0 : break;
7997 : }
7998 : default:;
7999 : }
8000 : }
8001 : break;
8002 0 : case CFN_BUILT_IN_LOGL:
8003 0 : if (call_expr_nargs (_p0) == 1)
8004 : {
8005 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8006 0 : switch (TREE_CODE (_p1))
8007 : {
8008 0 : case REAL_CST:
8009 0 : {
8010 0 : {
8011 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8012 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, LE_EXPR);
8013 0 : if (res) return res;
8014 : }
8015 0 : break;
8016 : }
8017 : default:;
8018 : }
8019 : }
8020 : break;
8021 1 : case CFN_BUILT_IN_POPCOUNTLL:
8022 1 : if (call_expr_nargs (_p0) == 1)
8023 : {
8024 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8025 1 : if (integer_zerop (_p1))
8026 : {
8027 1 : {
8028 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8029 1 : tree res = generic_simplify_303 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNTLL);
8030 1 : if (res) return res;
8031 : }
8032 : }
8033 : }
8034 : break;
8035 0 : case CFN_BUILT_IN_LOG10F:
8036 0 : if (call_expr_nargs (_p0) == 1)
8037 : {
8038 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8039 0 : switch (TREE_CODE (_p1))
8040 : {
8041 0 : case REAL_CST:
8042 0 : {
8043 0 : {
8044 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8045 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, LE_EXPR);
8046 0 : if (res) return res;
8047 : }
8048 0 : break;
8049 : }
8050 : default:;
8051 : }
8052 : }
8053 : break;
8054 0 : case CFN_BUILT_IN_LOG10L:
8055 0 : if (call_expr_nargs (_p0) == 1)
8056 : {
8057 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8058 0 : switch (TREE_CODE (_p1))
8059 : {
8060 0 : case REAL_CST:
8061 0 : {
8062 0 : {
8063 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8064 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, LE_EXPR);
8065 0 : if (res) return res;
8066 : }
8067 0 : break;
8068 : }
8069 : default:;
8070 : }
8071 : }
8072 : break;
8073 0 : case CFN_BUILT_IN_CTZIMAX:
8074 0 : if (call_expr_nargs (_p0) == 1)
8075 : {
8076 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8077 0 : switch (TREE_CODE (_p1))
8078 : {
8079 0 : case INTEGER_CST:
8080 0 : {
8081 0 : {
8082 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8083 0 : tree res = generic_simplify_409 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_BUILT_IN_CTZIMAX);
8084 0 : if (res) return res;
8085 : }
8086 0 : break;
8087 : }
8088 : default:;
8089 : }
8090 : }
8091 : break;
8092 0 : case CFN_POPCOUNT:
8093 0 : if (call_expr_nargs (_p0) == 1)
8094 : {
8095 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8096 0 : if (integer_zerop (_p1))
8097 : {
8098 0 : {
8099 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8100 0 : tree res = generic_simplify_303 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_POPCOUNT);
8101 0 : if (res) return res;
8102 : }
8103 : }
8104 : }
8105 : break;
8106 0 : case CFN_CTZ:
8107 0 : if (call_expr_nargs (_p0) == 2)
8108 : {
8109 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8110 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
8111 0 : switch (TREE_CODE (_p1))
8112 : {
8113 0 : case INTEGER_CST:
8114 0 : {
8115 0 : {
8116 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
8117 0 : tree res = generic_simplify_410 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR);
8118 0 : if (res) return res;
8119 : }
8120 0 : break;
8121 : }
8122 : default:;
8123 : }
8124 : }
8125 0 : if (call_expr_nargs (_p0) == 1)
8126 : {
8127 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8128 0 : switch (TREE_CODE (_p1))
8129 : {
8130 0 : case INTEGER_CST:
8131 0 : {
8132 0 : {
8133 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8134 0 : tree res = generic_simplify_409 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_CTZ);
8135 0 : if (res) return res;
8136 : }
8137 0 : break;
8138 : }
8139 : default:;
8140 : }
8141 : }
8142 : break;
8143 0 : case CFN_EXP:
8144 0 : if (call_expr_nargs (_p0) == 1)
8145 : {
8146 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8147 0 : switch (TREE_CODE (_p1))
8148 : {
8149 0 : case REAL_CST:
8150 0 : {
8151 0 : {
8152 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8153 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, LE_EXPR);
8154 0 : if (res) return res;
8155 : }
8156 0 : break;
8157 : }
8158 : default:;
8159 : }
8160 : }
8161 : break;
8162 0 : case CFN_FFS:
8163 0 : if (call_expr_nargs (_p0) == 1)
8164 : {
8165 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8166 0 : switch (TREE_CODE (_p1))
8167 : {
8168 0 : case INTEGER_CST:
8169 0 : {
8170 0 : {
8171 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8172 0 : tree res = generic_simplify_421 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_FFS);
8173 0 : if (res) return res;
8174 : }
8175 0 : break;
8176 : }
8177 : default:;
8178 : }
8179 : }
8180 : break;
8181 0 : case CFN_LOG:
8182 0 : if (call_expr_nargs (_p0) == 1)
8183 : {
8184 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8185 0 : switch (TREE_CODE (_p1))
8186 : {
8187 0 : case REAL_CST:
8188 0 : {
8189 0 : {
8190 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8191 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, LE_EXPR);
8192 0 : if (res) return res;
8193 : }
8194 0 : break;
8195 : }
8196 : default:;
8197 : }
8198 : }
8199 : break;
8200 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
8201 0 : if (call_expr_nargs (_p0) == 1)
8202 : {
8203 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8204 0 : if (integer_zerop (_p1))
8205 : {
8206 0 : {
8207 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8208 0 : tree res = generic_simplify_303 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
8209 0 : if (res) return res;
8210 : }
8211 : }
8212 : }
8213 : break;
8214 0 : case CFN_EXP2:
8215 0 : if (call_expr_nargs (_p0) == 1)
8216 : {
8217 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8218 0 : switch (TREE_CODE (_p1))
8219 : {
8220 0 : case REAL_CST:
8221 0 : {
8222 0 : {
8223 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8224 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, LE_EXPR);
8225 0 : if (res) return res;
8226 : }
8227 0 : break;
8228 : }
8229 : default:;
8230 : }
8231 : }
8232 : break;
8233 0 : case CFN_LOG2:
8234 0 : if (call_expr_nargs (_p0) == 1)
8235 : {
8236 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8237 0 : switch (TREE_CODE (_p1))
8238 : {
8239 0 : case REAL_CST:
8240 0 : {
8241 0 : {
8242 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8243 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, LE_EXPR);
8244 0 : if (res) return res;
8245 : }
8246 0 : break;
8247 : }
8248 : default:;
8249 : }
8250 : }
8251 : break;
8252 0 : case CFN_EXP10:
8253 0 : if (call_expr_nargs (_p0) == 1)
8254 : {
8255 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8256 0 : switch (TREE_CODE (_p1))
8257 : {
8258 0 : case REAL_CST:
8259 0 : {
8260 0 : {
8261 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8262 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, LE_EXPR);
8263 0 : if (res) return res;
8264 : }
8265 0 : break;
8266 : }
8267 : default:;
8268 : }
8269 : }
8270 : break;
8271 1 : case CFN_BUILT_IN_POPCOUNTL:
8272 1 : if (call_expr_nargs (_p0) == 1)
8273 : {
8274 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8275 1 : if (integer_zerop (_p1))
8276 : {
8277 1 : {
8278 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8279 1 : tree res = generic_simplify_303 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNTL);
8280 1 : if (res) return res;
8281 : }
8282 : }
8283 : }
8284 : break;
8285 0 : case CFN_BUILT_IN_CTZLL:
8286 0 : if (call_expr_nargs (_p0) == 1)
8287 : {
8288 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8289 0 : switch (TREE_CODE (_p1))
8290 : {
8291 0 : case INTEGER_CST:
8292 0 : {
8293 0 : {
8294 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8295 0 : tree res = generic_simplify_409 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_BUILT_IN_CTZLL);
8296 0 : if (res) return res;
8297 : }
8298 0 : break;
8299 : }
8300 : default:;
8301 : }
8302 : }
8303 : break;
8304 0 : case CFN_LOG10:
8305 0 : if (call_expr_nargs (_p0) == 1)
8306 : {
8307 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8308 0 : switch (TREE_CODE (_p1))
8309 : {
8310 0 : case REAL_CST:
8311 0 : {
8312 0 : {
8313 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8314 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, LE_EXPR);
8315 0 : if (res) return res;
8316 : }
8317 0 : break;
8318 : }
8319 : default:;
8320 : }
8321 : }
8322 : break;
8323 0 : case CFN_BUILT_IN_EXP10:
8324 0 : if (call_expr_nargs (_p0) == 1)
8325 : {
8326 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8327 0 : switch (TREE_CODE (_p1))
8328 : {
8329 0 : case REAL_CST:
8330 0 : {
8331 0 : {
8332 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8333 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, LE_EXPR);
8334 0 : if (res) return res;
8335 : }
8336 0 : break;
8337 : }
8338 : default:;
8339 : }
8340 : }
8341 : break;
8342 0 : case CFN_BUILT_IN_EXP2F:
8343 0 : if (call_expr_nargs (_p0) == 1)
8344 : {
8345 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8346 0 : switch (TREE_CODE (_p1))
8347 : {
8348 0 : case REAL_CST:
8349 0 : {
8350 0 : {
8351 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8352 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, LE_EXPR);
8353 0 : if (res) return res;
8354 : }
8355 0 : break;
8356 : }
8357 : default:;
8358 : }
8359 : }
8360 : break;
8361 0 : case CFN_BUILT_IN_EXP2L:
8362 0 : if (call_expr_nargs (_p0) == 1)
8363 : {
8364 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8365 0 : switch (TREE_CODE (_p1))
8366 : {
8367 0 : case REAL_CST:
8368 0 : {
8369 0 : {
8370 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8371 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, LE_EXPR);
8372 0 : if (res) return res;
8373 : }
8374 0 : break;
8375 : }
8376 : default:;
8377 : }
8378 : }
8379 : break;
8380 3 : case CFN_BUILT_IN_FFSLL:
8381 3 : if (call_expr_nargs (_p0) == 1)
8382 : {
8383 3 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8384 3 : switch (TREE_CODE (_p1))
8385 : {
8386 3 : case INTEGER_CST:
8387 3 : {
8388 3 : {
8389 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8390 3 : tree res = generic_simplify_421 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_FFSLL);
8391 3 : if (res) return res;
8392 : }
8393 0 : break;
8394 : }
8395 : default:;
8396 : }
8397 : }
8398 : break;
8399 0 : case CFN_BUILT_IN_LOG10:
8400 0 : if (call_expr_nargs (_p0) == 1)
8401 : {
8402 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8403 0 : switch (TREE_CODE (_p1))
8404 : {
8405 0 : case REAL_CST:
8406 0 : {
8407 0 : {
8408 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8409 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, LE_EXPR);
8410 0 : if (res) return res;
8411 : }
8412 0 : break;
8413 : }
8414 : default:;
8415 : }
8416 : }
8417 : break;
8418 0 : case CFN_BUILT_IN_LOG2F:
8419 0 : if (call_expr_nargs (_p0) == 1)
8420 : {
8421 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8422 0 : switch (TREE_CODE (_p1))
8423 : {
8424 0 : case REAL_CST:
8425 0 : {
8426 0 : {
8427 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8428 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, LE_EXPR);
8429 0 : if (res) return res;
8430 : }
8431 0 : break;
8432 : }
8433 : default:;
8434 : }
8435 : }
8436 : break;
8437 0 : case CFN_BUILT_IN_LOG2L:
8438 0 : if (call_expr_nargs (_p0) == 1)
8439 : {
8440 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8441 0 : switch (TREE_CODE (_p1))
8442 : {
8443 0 : case REAL_CST:
8444 0 : {
8445 0 : {
8446 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8447 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, LE_EXPR);
8448 0 : if (res) return res;
8449 : }
8450 0 : break;
8451 : }
8452 : default:;
8453 : }
8454 : }
8455 : break;
8456 : default:;
8457 : }
8458 : break;
8459 : default:;
8460 : }
8461 : return NULL_TREE;
8462 : }
8463 :
8464 : tree
8465 4140 : generic_simplify_CEIL_MOD_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
8466 : {
8467 4140 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8468 4140 : if (integer_zerop (_p0))
8469 : {
8470 0 : {
8471 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8472 0 : tree res = generic_simplify_329 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8473 0 : if (res) return res;
8474 : }
8475 : }
8476 4140 : if (integer_onep (_p1))
8477 : {
8478 0 : {
8479 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8480 0 : tree res = generic_simplify_330 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8481 0 : if (res) return res;
8482 : }
8483 : }
8484 4140 : if (integer_minus_onep (_p1))
8485 : {
8486 0 : {
8487 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8488 0 : tree res = generic_simplify_331 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8489 0 : if (res) return res;
8490 : }
8491 : }
8492 4140 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
8493 : {
8494 0 : {
8495 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8496 0 : tree res = generic_simplify_332 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8497 0 : if (res) return res;
8498 : }
8499 : }
8500 4140 : switch (TREE_CODE (_p0))
8501 : {
8502 0 : case CEIL_MOD_EXPR:
8503 0 : {
8504 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8505 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8506 0 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8507 : {
8508 0 : {
8509 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8510 0 : tree res = generic_simplify_333 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8511 0 : if (res) return res;
8512 : }
8513 : }
8514 : break;
8515 : }
8516 0 : case MULT_EXPR:
8517 0 : {
8518 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8519 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8520 0 : switch (TREE_CODE (_q21))
8521 : {
8522 0 : case INTEGER_CST:
8523 0 : {
8524 0 : switch (TREE_CODE (_p1))
8525 : {
8526 0 : case INTEGER_CST:
8527 0 : {
8528 0 : {
8529 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8530 0 : tree res = generic_simplify_334 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8531 0 : if (res) return res;
8532 : }
8533 0 : break;
8534 : }
8535 : default:;
8536 : }
8537 : break;
8538 : }
8539 : default:;
8540 : }
8541 : break;
8542 : }
8543 0 : case VEC_COND_EXPR:
8544 0 : {
8545 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8546 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8547 0 : tree _q22 = TREE_OPERAND (_p0, 2);
8548 0 : switch (TREE_CODE (_p1))
8549 : {
8550 0 : case VEC_COND_EXPR:
8551 0 : {
8552 0 : tree _q60 = TREE_OPERAND (_p1, 0);
8553 0 : tree _q61 = TREE_OPERAND (_p1, 1);
8554 0 : tree _q62 = TREE_OPERAND (_p1, 2);
8555 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
8556 : {
8557 0 : {
8558 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
8559 0 : if (VECTOR_TYPE_P (type)
8560 0 : && (TREE_CODE_CLASS (CEIL_MOD_EXPR) != tcc_comparison
8561 : || types_match (type, TREE_TYPE (captures[2]))
8562 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8563 : || (optimize_vectors_before_lowering_p ()
8564 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8565 : )
8566 : {
8567 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1675;
8568 0 : {
8569 0 : tree res_op0;
8570 0 : res_op0 = captures[1];
8571 0 : tree res_op1;
8572 0 : {
8573 0 : tree _o1[2], _r1;
8574 0 : _o1[0] = captures[2];
8575 0 : _o1[1] = captures[5];
8576 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8577 0 : if (EXPR_P (_r1))
8578 0 : goto next_after_fail1675;
8579 0 : res_op1 = _r1;
8580 : }
8581 0 : tree res_op2;
8582 0 : {
8583 0 : tree _o1[2], _r1;
8584 0 : _o1[0] = captures[3];
8585 0 : _o1[1] = captures[6];
8586 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8587 0 : if (EXPR_P (_r1))
8588 0 : goto next_after_fail1675;
8589 0 : res_op2 = _r1;
8590 : }
8591 0 : tree _r;
8592 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8593 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 908, __FILE__, __LINE__, true);
8594 0 : return _r;
8595 : }
8596 0 : next_after_fail1675:;
8597 : }
8598 : }
8599 : }
8600 : break;
8601 : }
8602 0 : default:;
8603 : }
8604 0 : {
8605 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
8606 0 : if (VECTOR_TYPE_P (type)
8607 0 : && (TREE_CODE_CLASS (CEIL_MOD_EXPR) != tcc_comparison
8608 : || types_match (type, TREE_TYPE (captures[2]))
8609 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8610 : || (optimize_vectors_before_lowering_p ()
8611 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8612 : )
8613 : {
8614 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1676;
8615 0 : {
8616 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1676;
8617 0 : tree res_op0;
8618 0 : res_op0 = captures[1];
8619 0 : tree res_op1;
8620 0 : {
8621 0 : tree _o1[2], _r1;
8622 0 : _o1[0] = captures[2];
8623 0 : _o1[1] = unshare_expr (captures[4]);
8624 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8625 0 : if (EXPR_P (_r1))
8626 0 : goto next_after_fail1676;
8627 0 : res_op1 = _r1;
8628 : }
8629 0 : tree res_op2;
8630 0 : {
8631 0 : tree _o1[2], _r1;
8632 0 : _o1[0] = captures[3];
8633 0 : _o1[1] = captures[4];
8634 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8635 0 : if (EXPR_P (_r1))
8636 0 : goto next_after_fail1676;
8637 0 : res_op2 = _r1;
8638 : }
8639 0 : tree _r;
8640 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8641 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 910, __FILE__, __LINE__, true);
8642 0 : return _r;
8643 : }
8644 0 : next_after_fail1676:;
8645 : }
8646 : }
8647 0 : break;
8648 : }
8649 4140 : default:;
8650 : }
8651 4140 : switch (TREE_CODE (_p1))
8652 : {
8653 0 : case VEC_COND_EXPR:
8654 0 : {
8655 0 : tree _q30 = TREE_OPERAND (_p1, 0);
8656 0 : tree _q31 = TREE_OPERAND (_p1, 1);
8657 0 : tree _q32 = TREE_OPERAND (_p1, 2);
8658 0 : {
8659 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
8660 0 : if (VECTOR_TYPE_P (type)
8661 0 : && (TREE_CODE_CLASS (CEIL_MOD_EXPR) != tcc_comparison
8662 : || types_match (type, TREE_TYPE (captures[3]))
8663 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
8664 : || (optimize_vectors_before_lowering_p ()
8665 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
8666 : )
8667 : {
8668 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1677;
8669 0 : {
8670 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1677;
8671 0 : tree res_op0;
8672 0 : res_op0 = captures[2];
8673 0 : tree res_op1;
8674 0 : {
8675 0 : tree _o1[2], _r1;
8676 0 : _o1[0] = unshare_expr (captures[0]);
8677 0 : _o1[1] = captures[3];
8678 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8679 0 : if (EXPR_P (_r1))
8680 0 : goto next_after_fail1677;
8681 0 : res_op1 = _r1;
8682 : }
8683 0 : tree res_op2;
8684 0 : {
8685 0 : tree _o1[2], _r1;
8686 0 : _o1[0] = captures[0];
8687 0 : _o1[1] = captures[4];
8688 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8689 0 : if (EXPR_P (_r1))
8690 0 : goto next_after_fail1677;
8691 0 : res_op2 = _r1;
8692 : }
8693 0 : tree _r;
8694 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8695 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 911, __FILE__, __LINE__, true);
8696 0 : return _r;
8697 : }
8698 0 : next_after_fail1677:;
8699 : }
8700 : }
8701 0 : break;
8702 : }
8703 : default:;
8704 : }
8705 : return NULL_TREE;
8706 : }
8707 :
8708 : tree
8709 0 : generic_simplify_ROUND_MOD_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
8710 : {
8711 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8712 0 : if (integer_zerop (_p0))
8713 : {
8714 0 : {
8715 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8716 0 : tree res = generic_simplify_329 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8717 0 : if (res) return res;
8718 : }
8719 : }
8720 0 : if (integer_onep (_p1))
8721 : {
8722 0 : {
8723 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8724 0 : tree res = generic_simplify_330 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8725 0 : if (res) return res;
8726 : }
8727 : }
8728 0 : if (integer_minus_onep (_p1))
8729 : {
8730 0 : {
8731 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8732 0 : tree res = generic_simplify_331 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8733 0 : if (res) return res;
8734 : }
8735 : }
8736 0 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
8737 : {
8738 0 : {
8739 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8740 0 : tree res = generic_simplify_332 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8741 0 : if (res) return res;
8742 : }
8743 : }
8744 0 : switch (TREE_CODE (_p0))
8745 : {
8746 0 : case ROUND_MOD_EXPR:
8747 0 : {
8748 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8749 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8750 0 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8751 : {
8752 0 : {
8753 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8754 0 : tree res = generic_simplify_333 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8755 0 : if (res) return res;
8756 : }
8757 : }
8758 : break;
8759 : }
8760 0 : case MULT_EXPR:
8761 0 : {
8762 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8763 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8764 0 : switch (TREE_CODE (_q21))
8765 : {
8766 0 : case INTEGER_CST:
8767 0 : {
8768 0 : switch (TREE_CODE (_p1))
8769 : {
8770 0 : case INTEGER_CST:
8771 0 : {
8772 0 : {
8773 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8774 0 : tree res = generic_simplify_334 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8775 0 : if (res) return res;
8776 : }
8777 0 : break;
8778 : }
8779 : default:;
8780 : }
8781 : break;
8782 : }
8783 : default:;
8784 : }
8785 : break;
8786 : }
8787 0 : case VEC_COND_EXPR:
8788 0 : {
8789 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8790 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8791 0 : tree _q22 = TREE_OPERAND (_p0, 2);
8792 0 : switch (TREE_CODE (_p1))
8793 : {
8794 0 : case VEC_COND_EXPR:
8795 0 : {
8796 0 : tree _q60 = TREE_OPERAND (_p1, 0);
8797 0 : tree _q61 = TREE_OPERAND (_p1, 1);
8798 0 : tree _q62 = TREE_OPERAND (_p1, 2);
8799 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
8800 : {
8801 0 : {
8802 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
8803 0 : if (VECTOR_TYPE_P (type)
8804 0 : && (TREE_CODE_CLASS (ROUND_MOD_EXPR) != tcc_comparison
8805 : || types_match (type, TREE_TYPE (captures[2]))
8806 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8807 : || (optimize_vectors_before_lowering_p ()
8808 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8809 : )
8810 : {
8811 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1678;
8812 0 : {
8813 0 : tree res_op0;
8814 0 : res_op0 = captures[1];
8815 0 : tree res_op1;
8816 0 : {
8817 0 : tree _o1[2], _r1;
8818 0 : _o1[0] = captures[2];
8819 0 : _o1[1] = captures[5];
8820 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8821 0 : if (EXPR_P (_r1))
8822 0 : goto next_after_fail1678;
8823 0 : res_op1 = _r1;
8824 : }
8825 0 : tree res_op2;
8826 0 : {
8827 0 : tree _o1[2], _r1;
8828 0 : _o1[0] = captures[3];
8829 0 : _o1[1] = captures[6];
8830 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8831 0 : if (EXPR_P (_r1))
8832 0 : goto next_after_fail1678;
8833 0 : res_op2 = _r1;
8834 : }
8835 0 : tree _r;
8836 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8837 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 908, __FILE__, __LINE__, true);
8838 0 : return _r;
8839 : }
8840 0 : next_after_fail1678:;
8841 : }
8842 : }
8843 : }
8844 : break;
8845 : }
8846 0 : default:;
8847 : }
8848 0 : {
8849 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
8850 0 : if (VECTOR_TYPE_P (type)
8851 0 : && (TREE_CODE_CLASS (ROUND_MOD_EXPR) != tcc_comparison
8852 : || types_match (type, TREE_TYPE (captures[2]))
8853 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8854 : || (optimize_vectors_before_lowering_p ()
8855 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8856 : )
8857 : {
8858 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1679;
8859 0 : {
8860 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1679;
8861 0 : tree res_op0;
8862 0 : res_op0 = captures[1];
8863 0 : tree res_op1;
8864 0 : {
8865 0 : tree _o1[2], _r1;
8866 0 : _o1[0] = captures[2];
8867 0 : _o1[1] = unshare_expr (captures[4]);
8868 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8869 0 : if (EXPR_P (_r1))
8870 0 : goto next_after_fail1679;
8871 0 : res_op1 = _r1;
8872 : }
8873 0 : tree res_op2;
8874 0 : {
8875 0 : tree _o1[2], _r1;
8876 0 : _o1[0] = captures[3];
8877 0 : _o1[1] = captures[4];
8878 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8879 0 : if (EXPR_P (_r1))
8880 0 : goto next_after_fail1679;
8881 0 : res_op2 = _r1;
8882 : }
8883 0 : tree _r;
8884 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8885 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 910, __FILE__, __LINE__, true);
8886 0 : return _r;
8887 : }
8888 0 : next_after_fail1679:;
8889 : }
8890 : }
8891 0 : break;
8892 : }
8893 0 : default:;
8894 : }
8895 0 : switch (TREE_CODE (_p1))
8896 : {
8897 0 : case VEC_COND_EXPR:
8898 0 : {
8899 0 : tree _q30 = TREE_OPERAND (_p1, 0);
8900 0 : tree _q31 = TREE_OPERAND (_p1, 1);
8901 0 : tree _q32 = TREE_OPERAND (_p1, 2);
8902 0 : {
8903 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
8904 0 : if (VECTOR_TYPE_P (type)
8905 0 : && (TREE_CODE_CLASS (ROUND_MOD_EXPR) != tcc_comparison
8906 : || types_match (type, TREE_TYPE (captures[3]))
8907 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
8908 : || (optimize_vectors_before_lowering_p ()
8909 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
8910 : )
8911 : {
8912 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1680;
8913 0 : {
8914 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1680;
8915 0 : tree res_op0;
8916 0 : res_op0 = captures[2];
8917 0 : tree res_op1;
8918 0 : {
8919 0 : tree _o1[2], _r1;
8920 0 : _o1[0] = unshare_expr (captures[0]);
8921 0 : _o1[1] = captures[3];
8922 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8923 0 : if (EXPR_P (_r1))
8924 0 : goto next_after_fail1680;
8925 0 : res_op1 = _r1;
8926 : }
8927 0 : tree res_op2;
8928 0 : {
8929 0 : tree _o1[2], _r1;
8930 0 : _o1[0] = captures[0];
8931 0 : _o1[1] = captures[4];
8932 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8933 0 : if (EXPR_P (_r1))
8934 0 : goto next_after_fail1680;
8935 0 : res_op2 = _r1;
8936 : }
8937 0 : tree _r;
8938 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8939 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 911, __FILE__, __LINE__, true);
8940 0 : return _r;
8941 : }
8942 0 : next_after_fail1680:;
8943 : }
8944 : }
8945 0 : break;
8946 : }
8947 : default:;
8948 : }
8949 : return NULL_TREE;
8950 : }
8951 :
8952 : tree
8953 2102651 : generic_simplify_TRUNC_MOD_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
8954 : {
8955 2102651 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8956 2102651 : if (integer_zerop (_p0))
8957 : {
8958 929 : {
8959 929 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8960 929 : tree res = generic_simplify_329 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8961 929 : if (res) return res;
8962 : }
8963 : }
8964 2101859 : if (integer_onep (_p1))
8965 : {
8966 216658 : {
8967 216658 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8968 216658 : tree res = generic_simplify_330 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8969 216658 : if (res) return res;
8970 : }
8971 : }
8972 1885201 : if (integer_minus_onep (_p1))
8973 : {
8974 529 : {
8975 529 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8976 529 : tree res = generic_simplify_331 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8977 529 : if (res) return res;
8978 : }
8979 : }
8980 1885181 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
8981 : {
8982 230 : {
8983 230 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8984 230 : tree res = generic_simplify_332 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8985 230 : if (res) return res;
8986 : }
8987 : }
8988 1885088 : switch (TREE_CODE (_p0))
8989 : {
8990 107 : case TRUNC_MOD_EXPR:
8991 107 : {
8992 107 : tree _q20 = TREE_OPERAND (_p0, 0);
8993 107 : tree _q21 = TREE_OPERAND (_p0, 1);
8994 107 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8995 : {
8996 52 : {
8997 52 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8998 52 : tree res = generic_simplify_333 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8999 52 : if (res) return res;
9000 : }
9001 : }
9002 : break;
9003 : }
9004 7343 : case MULT_EXPR:
9005 7343 : {
9006 7343 : tree _q20 = TREE_OPERAND (_p0, 0);
9007 7343 : tree _q21 = TREE_OPERAND (_p0, 1);
9008 7343 : switch (TREE_CODE (_q21))
9009 : {
9010 7250 : case INTEGER_CST:
9011 7250 : {
9012 7250 : switch (TREE_CODE (_p1))
9013 : {
9014 7228 : case INTEGER_CST:
9015 7228 : {
9016 7228 : {
9017 7228 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
9018 7228 : tree res = generic_simplify_334 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
9019 7228 : if (res) return res;
9020 : }
9021 7228 : break;
9022 : }
9023 : default:;
9024 : }
9025 : break;
9026 : }
9027 : default:;
9028 : }
9029 : break;
9030 : }
9031 1885036 : default:;
9032 : }
9033 1885036 : switch (TREE_CODE (_p1))
9034 : {
9035 1605307 : case INTEGER_CST:
9036 1605307 : {
9037 1605307 : {
9038 1605307 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9039 1605307 : if (TYPE_SIGN (type) == SIGNED
9040 286114 : && !TREE_OVERFLOW (captures[1])
9041 1605311 : && wi::neg_p (wi::to_wide (captures[1]))
9042 313 : && !TYPE_OVERFLOW_TRAPS (type)
9043 1605620 : && !sign_bit_p (captures[1], captures[1])
9044 : )
9045 : {
9046 309 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1681;
9047 309 : {
9048 309 : tree res_op0;
9049 309 : res_op0 = captures[0];
9050 309 : tree res_op1;
9051 309 : {
9052 309 : tree _o1[1], _r1;
9053 309 : _o1[0] = captures[1];
9054 309 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
9055 309 : res_op1 = _r1;
9056 : }
9057 309 : tree _r;
9058 309 : _r = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, res_op0, res_op1);
9059 309 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1014, __FILE__, __LINE__, true);
9060 309 : return _r;
9061 : }
9062 0 : next_after_fail1681:;
9063 : }
9064 : }
9065 1604998 : break;
9066 : }
9067 58295 : CASE_CONVERT:
9068 58295 : {
9069 58295 : tree _q30 = TREE_OPERAND (_p1, 0);
9070 58295 : switch (TREE_CODE (_q30))
9071 : {
9072 0 : case NEGATE_EXPR:
9073 0 : {
9074 0 : tree _q40 = TREE_OPERAND (_q30, 0);
9075 0 : {
9076 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q40 };
9077 0 : tree res = generic_simplify_422 (loc, type, _p0, _p1, captures);
9078 0 : if (res) return res;
9079 : }
9080 0 : break;
9081 : }
9082 58295 : default:;
9083 : }
9084 58295 : {
9085 58295 : tree _q30_pops[1];
9086 58295 : if (tree_power_of_two_cand (_q30, _q30_pops))
9087 : {
9088 7 : tree _q40 = _q30_pops[0];
9089 7 : {
9090 7 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q40 };
9091 7 : tree res = generic_simplify_335 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
9092 7 : if (res) return res;
9093 : }
9094 : }
9095 : }
9096 58288 : break;
9097 : }
9098 94 : case NEGATE_EXPR:
9099 94 : {
9100 94 : tree _q30 = TREE_OPERAND (_p1, 0);
9101 94 : {
9102 94 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q30 };
9103 94 : tree res = generic_simplify_422 (loc, type, _p0, _p1, captures);
9104 94 : if (res) return res;
9105 : }
9106 94 : break;
9107 : }
9108 1884720 : default:;
9109 : }
9110 1884720 : {
9111 1884720 : tree _p1_pops[1];
9112 1884720 : if (tree_power_of_two_cand (_p1, _p1_pops))
9113 : {
9114 1605007 : tree _q30 = _p1_pops[0];
9115 1605007 : {
9116 1605007 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q30 };
9117 1605007 : tree res = generic_simplify_335 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
9118 1605007 : if (res) return res;
9119 : }
9120 : }
9121 : }
9122 917922 : switch (TREE_CODE (_p0))
9123 : {
9124 0 : case VEC_COND_EXPR:
9125 0 : {
9126 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9127 0 : tree _q21 = TREE_OPERAND (_p0, 1);
9128 0 : tree _q22 = TREE_OPERAND (_p0, 2);
9129 0 : switch (TREE_CODE (_p1))
9130 : {
9131 0 : case VEC_COND_EXPR:
9132 0 : {
9133 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9134 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9135 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9136 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9137 : {
9138 0 : {
9139 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
9140 0 : if (VECTOR_TYPE_P (type)
9141 0 : && (TREE_CODE_CLASS (TRUNC_MOD_EXPR) != tcc_comparison
9142 : || types_match (type, TREE_TYPE (captures[2]))
9143 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9144 : || (optimize_vectors_before_lowering_p ()
9145 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9146 : )
9147 : {
9148 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1682;
9149 0 : {
9150 0 : tree res_op0;
9151 0 : res_op0 = captures[1];
9152 0 : tree res_op1;
9153 0 : {
9154 0 : tree _o1[2], _r1;
9155 0 : _o1[0] = captures[2];
9156 0 : _o1[1] = captures[5];
9157 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9158 0 : if (EXPR_P (_r1))
9159 0 : goto next_after_fail1682;
9160 0 : res_op1 = _r1;
9161 : }
9162 0 : tree res_op2;
9163 0 : {
9164 0 : tree _o1[2], _r1;
9165 0 : _o1[0] = captures[3];
9166 0 : _o1[1] = captures[6];
9167 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9168 0 : if (EXPR_P (_r1))
9169 0 : goto next_after_fail1682;
9170 0 : res_op2 = _r1;
9171 : }
9172 0 : tree _r;
9173 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9174 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 908, __FILE__, __LINE__, true);
9175 0 : return _r;
9176 : }
9177 0 : next_after_fail1682:;
9178 : }
9179 : }
9180 : }
9181 : break;
9182 : }
9183 0 : default:;
9184 : }
9185 0 : {
9186 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
9187 0 : if (VECTOR_TYPE_P (type)
9188 0 : && (TREE_CODE_CLASS (TRUNC_MOD_EXPR) != tcc_comparison
9189 : || types_match (type, TREE_TYPE (captures[2]))
9190 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9191 : || (optimize_vectors_before_lowering_p ()
9192 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9193 : )
9194 : {
9195 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1683;
9196 0 : {
9197 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1683;
9198 0 : tree res_op0;
9199 0 : res_op0 = captures[1];
9200 0 : tree res_op1;
9201 0 : {
9202 0 : tree _o1[2], _r1;
9203 0 : _o1[0] = captures[2];
9204 0 : _o1[1] = unshare_expr (captures[4]);
9205 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9206 0 : if (EXPR_P (_r1))
9207 0 : goto next_after_fail1683;
9208 0 : res_op1 = _r1;
9209 : }
9210 0 : tree res_op2;
9211 0 : {
9212 0 : tree _o1[2], _r1;
9213 0 : _o1[0] = captures[3];
9214 0 : _o1[1] = captures[4];
9215 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9216 0 : if (EXPR_P (_r1))
9217 0 : goto next_after_fail1683;
9218 0 : res_op2 = _r1;
9219 : }
9220 0 : tree _r;
9221 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9222 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 910, __FILE__, __LINE__, true);
9223 0 : return _r;
9224 : }
9225 0 : next_after_fail1683:;
9226 : }
9227 : }
9228 0 : break;
9229 : }
9230 917922 : default:;
9231 : }
9232 917922 : switch (TREE_CODE (_p1))
9233 : {
9234 7 : case VEC_COND_EXPR:
9235 7 : {
9236 7 : tree _q30 = TREE_OPERAND (_p1, 0);
9237 7 : tree _q31 = TREE_OPERAND (_p1, 1);
9238 7 : tree _q32 = TREE_OPERAND (_p1, 2);
9239 7 : {
9240 7 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
9241 7 : if (VECTOR_TYPE_P (type)
9242 7 : && (TREE_CODE_CLASS (TRUNC_MOD_EXPR) != tcc_comparison
9243 : || types_match (type, TREE_TYPE (captures[3]))
9244 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
9245 : || (optimize_vectors_before_lowering_p ()
9246 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
9247 : )
9248 : {
9249 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1684;
9250 7 : {
9251 7 : if (! tree_invariant_p (captures[0])) goto next_after_fail1684;
9252 0 : tree res_op0;
9253 0 : res_op0 = captures[2];
9254 0 : tree res_op1;
9255 0 : {
9256 0 : tree _o1[2], _r1;
9257 0 : _o1[0] = unshare_expr (captures[0]);
9258 0 : _o1[1] = captures[3];
9259 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9260 0 : if (EXPR_P (_r1))
9261 0 : goto next_after_fail1684;
9262 0 : res_op1 = _r1;
9263 : }
9264 0 : tree res_op2;
9265 0 : {
9266 0 : tree _o1[2], _r1;
9267 0 : _o1[0] = captures[0];
9268 0 : _o1[1] = captures[4];
9269 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9270 0 : if (EXPR_P (_r1))
9271 0 : goto next_after_fail1684;
9272 0 : res_op2 = _r1;
9273 : }
9274 0 : tree _r;
9275 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9276 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 911, __FILE__, __LINE__, true);
9277 0 : return _r;
9278 : }
9279 7 : next_after_fail1684:;
9280 : }
9281 : }
9282 7 : break;
9283 : }
9284 : default:;
9285 : }
9286 : return NULL_TREE;
9287 : }
9288 :
9289 : tree
9290 1022620 : generic_simplify_RSHIFT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
9291 : {
9292 1022620 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
9293 1022620 : switch (TREE_CODE (_p1))
9294 : {
9295 135 : case TRUNC_MOD_EXPR:
9296 135 : {
9297 135 : tree _q30 = TREE_OPERAND (_p1, 0);
9298 135 : tree _q31 = TREE_OPERAND (_p1, 1);
9299 135 : {
9300 135 : tree _q31_pops[1];
9301 135 : if (tree_power_of_two_cand (_q31, _q31_pops))
9302 : {
9303 127 : tree _q50 = _q31_pops[0];
9304 127 : {
9305 127 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q50 };
9306 127 : tree res = generic_simplify_423 (loc, type, _p0, _p1, captures, RSHIFT_EXPR, TRUNC_MOD_EXPR);
9307 127 : if (res) return res;
9308 : }
9309 : }
9310 : }
9311 14 : break;
9312 : }
9313 0 : case FLOOR_MOD_EXPR:
9314 0 : {
9315 0 : tree _q30 = TREE_OPERAND (_p1, 0);
9316 0 : tree _q31 = TREE_OPERAND (_p1, 1);
9317 0 : {
9318 0 : tree _q31_pops[1];
9319 0 : if (tree_power_of_two_cand (_q31, _q31_pops))
9320 : {
9321 0 : tree _q50 = _q31_pops[0];
9322 0 : {
9323 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q50 };
9324 0 : tree res = generic_simplify_423 (loc, type, _p0, _p1, captures, RSHIFT_EXPR, FLOOR_MOD_EXPR);
9325 0 : if (res) return res;
9326 : }
9327 : }
9328 : }
9329 0 : break;
9330 : }
9331 1022499 : default:;
9332 : }
9333 1022499 : if (uniform_integer_cst_p (_p1))
9334 : {
9335 820061 : {
9336 820061 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9337 820061 : tree res = generic_simplify_424 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9338 820061 : if (res) return res;
9339 : }
9340 : }
9341 1021742 : switch (TREE_CODE (_p0))
9342 : {
9343 60 : case NEGATE_EXPR:
9344 60 : {
9345 60 : tree _q20 = TREE_OPERAND (_p0, 0);
9346 60 : switch (TREE_CODE (_p1))
9347 : {
9348 59 : case INTEGER_CST:
9349 59 : {
9350 59 : {
9351 59 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9352 59 : if (!TYPE_UNSIGNED (type)
9353 59 : && TYPE_OVERFLOW_UNDEFINED (type)
9354 : )
9355 : {
9356 32 : {
9357 32 : tree stype = TREE_TYPE (captures[2]);
9358 32 : tree bt = truth_type_for (type);
9359 32 : tree zeros = build_zero_cst (type);
9360 32 : tree INTEGER_CST = NULL_TREE;
9361 32 : if (INTEGRAL_TYPE_P (type)
9362 : && canonicalize_math_after_vectorization_p ()
9363 : && wi::eq_p (wi::to_wide (captures[2]), TYPE_PRECISION (type) - 1)
9364 : )
9365 : {
9366 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1693;
9367 : {
9368 : tree res_op0;
9369 : {
9370 : tree _o1[1], _r1;
9371 : {
9372 : tree _o2[2], _r2;
9373 : _o2[0] = captures[1];
9374 : _o2[1] = zeros;
9375 : _r2 = fold_build2_loc (loc, GT_EXPR, boolean_type_node, _o2[0], _o2[1]);
9376 : _o1[0] = _r2;
9377 : }
9378 : if (TREE_TYPE (_o1[0]) != type)
9379 : {
9380 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
9381 : }
9382 : else
9383 : _r1 = _o1[0];
9384 : res_op0 = _r1;
9385 : }
9386 : tree _r;
9387 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
9388 : if (TREE_SIDE_EFFECTS (captures[2]))
9389 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
9390 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1019, __FILE__, __LINE__, true);
9391 : return _r;
9392 : }
9393 : next_after_fail1693:;
9394 : }
9395 : else
9396 : {
9397 0 : if (VECTOR_INTEGER_TYPE_P (type)
9398 0 : && TYPE_MODE (bt) == TYPE_MODE (type)
9399 0 : && expand_vec_cmp_expr_p (type, bt, GT_EXPR)
9400 0 : && (INTEGER_CST = uniform_integer_cst_p (captures[2])) != NULL
9401 32 : && wi::eq_p (wi::to_wide (INTEGER_CST), element_precision (type) - 1)
9402 : )
9403 : {
9404 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1694;
9405 0 : {
9406 0 : tree res_op0;
9407 0 : {
9408 0 : tree _o1[2], _r1;
9409 0 : _o1[0] = captures[1];
9410 0 : _o1[1] = zeros;
9411 0 : _r1 = fold_build2_loc (loc, GT_EXPR, bt, _o1[0], _o1[1]);
9412 0 : res_op0 = _r1;
9413 : }
9414 0 : tree _r;
9415 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
9416 0 : if (TREE_SIDE_EFFECTS (captures[2]))
9417 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
9418 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1020, __FILE__, __LINE__, true);
9419 0 : return _r;
9420 : }
9421 0 : next_after_fail1694:;
9422 : }
9423 : }
9424 : }
9425 : }
9426 : }
9427 59 : break;
9428 : }
9429 0 : case VECTOR_CST:
9430 0 : {
9431 0 : {
9432 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9433 0 : if (!TYPE_UNSIGNED (type)
9434 0 : && TYPE_OVERFLOW_UNDEFINED (type)
9435 : )
9436 : {
9437 0 : {
9438 0 : tree stype = TREE_TYPE (captures[2]);
9439 0 : tree bt = truth_type_for (type);
9440 0 : tree zeros = build_zero_cst (type);
9441 0 : tree VECTOR_CST = NULL_TREE;
9442 0 : if (INTEGRAL_TYPE_P (type)
9443 : && canonicalize_math_after_vectorization_p ()
9444 : && wi::eq_p (wi::to_wide (captures[2]), TYPE_PRECISION (type) - 1)
9445 : )
9446 : {
9447 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1695;
9448 : {
9449 : tree res_op0;
9450 : {
9451 : tree _o1[1], _r1;
9452 : {
9453 : tree _o2[2], _r2;
9454 : _o2[0] = captures[1];
9455 : _o2[1] = zeros;
9456 : _r2 = fold_build2_loc (loc, GT_EXPR, boolean_type_node, _o2[0], _o2[1]);
9457 : _o1[0] = _r2;
9458 : }
9459 : if (TREE_TYPE (_o1[0]) != type)
9460 : {
9461 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
9462 : }
9463 : else
9464 : _r1 = _o1[0];
9465 : res_op0 = _r1;
9466 : }
9467 : tree _r;
9468 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
9469 : if (TREE_SIDE_EFFECTS (captures[2]))
9470 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
9471 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1019, __FILE__, __LINE__, true);
9472 : return _r;
9473 : }
9474 : next_after_fail1695:;
9475 : }
9476 : else
9477 : {
9478 0 : if (VECTOR_INTEGER_TYPE_P (type)
9479 0 : && TYPE_MODE (bt) == TYPE_MODE (type)
9480 0 : && expand_vec_cmp_expr_p (type, bt, GT_EXPR)
9481 0 : && (VECTOR_CST = uniform_integer_cst_p (captures[2])) != NULL
9482 0 : && wi::eq_p (wi::to_wide (VECTOR_CST), element_precision (type) - 1)
9483 : )
9484 : {
9485 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1696;
9486 0 : {
9487 0 : tree res_op0;
9488 0 : {
9489 0 : tree _o1[2], _r1;
9490 0 : _o1[0] = captures[1];
9491 0 : _o1[1] = zeros;
9492 0 : _r1 = fold_build2_loc (loc, GT_EXPR, bt, _o1[0], _o1[1]);
9493 0 : res_op0 = _r1;
9494 : }
9495 0 : tree _r;
9496 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
9497 0 : if (TREE_SIDE_EFFECTS (captures[2]))
9498 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
9499 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1020, __FILE__, __LINE__, true);
9500 0 : return _r;
9501 : }
9502 0 : next_after_fail1696:;
9503 : }
9504 : }
9505 : }
9506 : }
9507 : }
9508 0 : break;
9509 : }
9510 : default:;
9511 : }
9512 : break;
9513 : }
9514 441 : case LSHIFT_EXPR:
9515 441 : {
9516 441 : tree _q20 = TREE_OPERAND (_p0, 0);
9517 441 : tree _q21 = TREE_OPERAND (_p0, 1);
9518 441 : switch (TREE_CODE (_q21))
9519 : {
9520 362 : case INTEGER_CST:
9521 362 : {
9522 362 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q21, 0))
9523 : {
9524 67 : {
9525 67 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p1, _q21 };
9526 67 : tree res = generic_simplify_433 (loc, type, _p0, _p1, captures);
9527 67 : if (res) return res;
9528 : }
9529 : }
9530 : break;
9531 : }
9532 : default:;
9533 : }
9534 : break;
9535 : }
9536 1021715 : default:;
9537 : }
9538 1021715 : {
9539 1021715 : tree _p0_pops[1];
9540 1021715 : if (tree_nop_convert (_p0, _p0_pops))
9541 : {
9542 172031 : tree _q20 = _p0_pops[0];
9543 172031 : switch (TREE_CODE (_q20))
9544 : {
9545 20 : case LSHIFT_EXPR:
9546 20 : {
9547 20 : tree _q30 = TREE_OPERAND (_q20, 0);
9548 20 : tree _q31 = TREE_OPERAND (_q20, 1);
9549 20 : switch (TREE_CODE (_q31))
9550 : {
9551 0 : case INTEGER_CST:
9552 0 : {
9553 0 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q31, 0))
9554 : {
9555 0 : {
9556 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p1, _q31 };
9557 0 : tree res = generic_simplify_433 (loc, type, _p0, _p1, captures);
9558 0 : if (res) return res;
9559 : }
9560 : }
9561 : break;
9562 : }
9563 : default:;
9564 : }
9565 : break;
9566 : }
9567 : default:;
9568 : }
9569 : }
9570 : }
9571 1021715 : if (integer_all_onesp (_p0))
9572 : {
9573 11623 : {
9574 11623 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9575 11623 : if (!TYPE_UNSIGNED (type)
9576 : )
9577 : {
9578 119 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1697;
9579 119 : {
9580 119 : tree _r;
9581 119 : _r = captures[0];
9582 119 : if (TREE_SIDE_EFFECTS (captures[1]))
9583 1 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
9584 119 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1021, __FILE__, __LINE__, true);
9585 119 : return _r;
9586 : }
9587 0 : next_after_fail1697:;
9588 : }
9589 : }
9590 : }
9591 1021596 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
9592 : {
9593 25 : {
9594 25 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
9595 25 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1698;
9596 25 : {
9597 25 : tree _r;
9598 25 : _r = build_zero_cst (type);
9599 25 : if (TREE_SIDE_EFFECTS (captures[0]))
9600 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
9601 25 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1022, __FILE__, __LINE__, true);
9602 25 : return _r;
9603 : }
9604 0 : next_after_fail1698:;
9605 : }
9606 : }
9607 1021571 : if (integer_zerop (_p1))
9608 : {
9609 1333 : {
9610 1333 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
9611 1333 : tree res = generic_simplify_426 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9612 1333 : if (res) return res;
9613 : }
9614 : }
9615 1020238 : if (integer_zerop (_p0))
9616 : {
9617 152 : {
9618 152 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9619 152 : tree res = generic_simplify_427 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9620 152 : if (res) return res;
9621 : }
9622 : }
9623 1020086 : switch (TREE_CODE (_p1))
9624 : {
9625 0 : case VECTOR_CST:
9626 0 : {
9627 0 : {
9628 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9629 0 : tree res = generic_simplify_428 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9630 0 : if (res) return res;
9631 : }
9632 0 : break;
9633 : }
9634 0 : case CONSTRUCTOR:
9635 0 : {
9636 0 : {
9637 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9638 0 : tree res = generic_simplify_429 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9639 0 : if (res) return res;
9640 : }
9641 0 : break;
9642 : }
9643 1020086 : default:;
9644 : }
9645 1020086 : switch (TREE_CODE (_p0))
9646 : {
9647 122 : case RSHIFT_EXPR:
9648 122 : {
9649 122 : tree _q20 = TREE_OPERAND (_p0, 0);
9650 122 : tree _q21 = TREE_OPERAND (_p0, 1);
9651 122 : switch (TREE_CODE (_q21))
9652 : {
9653 77 : case INTEGER_CST:
9654 77 : {
9655 77 : switch (TREE_CODE (_p1))
9656 : {
9657 51 : case INTEGER_CST:
9658 51 : {
9659 51 : {
9660 51 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
9661 51 : tree res = generic_simplify_430 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9662 51 : if (res) return res;
9663 : }
9664 0 : break;
9665 : }
9666 : default:;
9667 : }
9668 : break;
9669 : }
9670 : default:;
9671 : }
9672 : break;
9673 : }
9674 196163 : CASE_CONVERT:
9675 196163 : {
9676 196163 : tree _q20 = TREE_OPERAND (_p0, 0);
9677 196163 : switch (TREE_CODE (_q20))
9678 : {
9679 6 : case BIT_AND_EXPR:
9680 6 : {
9681 6 : tree _q30 = TREE_OPERAND (_q20, 0);
9682 6 : tree _q31 = TREE_OPERAND (_q20, 1);
9683 6 : switch (TREE_CODE (_q31))
9684 : {
9685 0 : case INTEGER_CST:
9686 0 : {
9687 0 : switch (TREE_CODE (_p1))
9688 : {
9689 0 : case INTEGER_CST:
9690 0 : {
9691 0 : {
9692 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
9693 0 : tree res = generic_simplify_431 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, RSHIFT_EXPR);
9694 0 : if (res) return res;
9695 : }
9696 0 : break;
9697 : }
9698 : default:;
9699 : }
9700 : break;
9701 : }
9702 : default:;
9703 : }
9704 : break;
9705 : }
9706 14 : case BIT_XOR_EXPR:
9707 14 : {
9708 14 : tree _q30 = TREE_OPERAND (_q20, 0);
9709 14 : tree _q31 = TREE_OPERAND (_q20, 1);
9710 14 : switch (TREE_CODE (_q31))
9711 : {
9712 0 : case INTEGER_CST:
9713 0 : {
9714 0 : switch (TREE_CODE (_p1))
9715 : {
9716 0 : case INTEGER_CST:
9717 0 : {
9718 0 : {
9719 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
9720 0 : tree res = generic_simplify_431 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, RSHIFT_EXPR);
9721 0 : if (res) return res;
9722 : }
9723 0 : break;
9724 : }
9725 : default:;
9726 : }
9727 : break;
9728 : }
9729 : default:;
9730 : }
9731 : break;
9732 : }
9733 43 : case BIT_IOR_EXPR:
9734 43 : {
9735 43 : tree _q30 = TREE_OPERAND (_q20, 0);
9736 43 : tree _q31 = TREE_OPERAND (_q20, 1);
9737 43 : switch (TREE_CODE (_q31))
9738 : {
9739 24 : case INTEGER_CST:
9740 24 : {
9741 24 : switch (TREE_CODE (_p1))
9742 : {
9743 7 : case INTEGER_CST:
9744 7 : {
9745 7 : {
9746 7 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
9747 7 : tree res = generic_simplify_431 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, RSHIFT_EXPR);
9748 7 : if (res) return res;
9749 : }
9750 0 : break;
9751 : }
9752 : default:;
9753 : }
9754 : break;
9755 : }
9756 : default:;
9757 : }
9758 : break;
9759 : }
9760 203 : case CALL_EXPR:
9761 203 : switch (get_call_combined_fn (_q20))
9762 : {
9763 0 : case CFN_BSWAP:
9764 0 : if (call_expr_nargs (_q20) == 1)
9765 : {
9766 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
9767 0 : switch (TREE_CODE (_p1))
9768 : {
9769 0 : case INTEGER_CST:
9770 0 : {
9771 0 : {
9772 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9773 0 : tree res = generic_simplify_434 (loc, type, _p0, _p1, captures, CFN_BSWAP);
9774 0 : if (res) return res;
9775 : }
9776 0 : break;
9777 : }
9778 : default:;
9779 : }
9780 : }
9781 : break;
9782 0 : case CFN_BUILT_IN_BSWAP128:
9783 0 : if (call_expr_nargs (_q20) == 1)
9784 : {
9785 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
9786 0 : switch (TREE_CODE (_p1))
9787 : {
9788 0 : case INTEGER_CST:
9789 0 : {
9790 0 : {
9791 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9792 0 : tree res = generic_simplify_434 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP128);
9793 0 : if (res) return res;
9794 : }
9795 0 : break;
9796 : }
9797 : default:;
9798 : }
9799 : }
9800 : break;
9801 8 : case CFN_BUILT_IN_BSWAP16:
9802 8 : if (call_expr_nargs (_q20) == 1)
9803 : {
9804 8 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
9805 8 : switch (TREE_CODE (_p1))
9806 : {
9807 7 : case INTEGER_CST:
9808 7 : {
9809 7 : {
9810 7 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9811 7 : tree res = generic_simplify_434 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP16);
9812 7 : if (res) return res;
9813 : }
9814 2 : break;
9815 : }
9816 : default:;
9817 : }
9818 : }
9819 : break;
9820 13 : case CFN_BUILT_IN_BSWAP32:
9821 13 : if (call_expr_nargs (_q20) == 1)
9822 : {
9823 13 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
9824 13 : switch (TREE_CODE (_p1))
9825 : {
9826 13 : case INTEGER_CST:
9827 13 : {
9828 13 : {
9829 13 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9830 13 : tree res = generic_simplify_434 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP32);
9831 13 : if (res) return res;
9832 : }
9833 9 : break;
9834 : }
9835 : default:;
9836 : }
9837 : }
9838 : break;
9839 18 : case CFN_BUILT_IN_BSWAP64:
9840 18 : if (call_expr_nargs (_q20) == 1)
9841 : {
9842 18 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
9843 18 : switch (TREE_CODE (_p1))
9844 : {
9845 18 : case INTEGER_CST:
9846 18 : {
9847 18 : {
9848 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9849 18 : tree res = generic_simplify_434 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP64);
9850 18 : if (res) return res;
9851 : }
9852 12 : break;
9853 : }
9854 : default:;
9855 : }
9856 : }
9857 : break;
9858 : default:;
9859 : }
9860 : break;
9861 : default:;
9862 : }
9863 : break;
9864 : }
9865 13922 : case BIT_AND_EXPR:
9866 13922 : {
9867 13922 : tree _q20 = TREE_OPERAND (_p0, 0);
9868 13922 : tree _q21 = TREE_OPERAND (_p0, 1);
9869 13922 : switch (TREE_CODE (_q21))
9870 : {
9871 13872 : case INTEGER_CST:
9872 13872 : {
9873 13872 : switch (TREE_CODE (_p1))
9874 : {
9875 13849 : case INTEGER_CST:
9876 13849 : {
9877 13849 : {
9878 13849 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
9879 13849 : tree res = generic_simplify_432 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, RSHIFT_EXPR);
9880 13849 : if (res) return res;
9881 : }
9882 0 : break;
9883 : }
9884 : default:;
9885 : }
9886 : break;
9887 : }
9888 : default:;
9889 : }
9890 : break;
9891 : }
9892 240 : case BIT_XOR_EXPR:
9893 240 : {
9894 240 : tree _q20 = TREE_OPERAND (_p0, 0);
9895 240 : tree _q21 = TREE_OPERAND (_p0, 1);
9896 240 : switch (TREE_CODE (_q21))
9897 : {
9898 97 : case INTEGER_CST:
9899 97 : {
9900 97 : switch (TREE_CODE (_p1))
9901 : {
9902 97 : case INTEGER_CST:
9903 97 : {
9904 97 : {
9905 97 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
9906 97 : tree res = generic_simplify_432 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, RSHIFT_EXPR);
9907 97 : if (res) return res;
9908 : }
9909 0 : break;
9910 : }
9911 : default:;
9912 : }
9913 : break;
9914 : }
9915 : default:;
9916 : }
9917 : break;
9918 : }
9919 47 : case BIT_IOR_EXPR:
9920 47 : {
9921 47 : tree _q20 = TREE_OPERAND (_p0, 0);
9922 47 : tree _q21 = TREE_OPERAND (_p0, 1);
9923 47 : switch (TREE_CODE (_q21))
9924 : {
9925 2 : case INTEGER_CST:
9926 2 : {
9927 2 : switch (TREE_CODE (_p1))
9928 : {
9929 0 : case INTEGER_CST:
9930 0 : {
9931 0 : {
9932 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
9933 0 : tree res = generic_simplify_432 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, RSHIFT_EXPR);
9934 0 : if (res) return res;
9935 : }
9936 0 : break;
9937 : }
9938 : default:;
9939 : }
9940 : break;
9941 : }
9942 : default:;
9943 : }
9944 : break;
9945 : }
9946 0 : case VEC_COND_EXPR:
9947 0 : {
9948 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9949 0 : tree _q21 = TREE_OPERAND (_p0, 1);
9950 0 : tree _q22 = TREE_OPERAND (_p0, 2);
9951 0 : switch (TREE_CODE (_p1))
9952 : {
9953 0 : case VEC_COND_EXPR:
9954 0 : {
9955 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9956 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9957 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9958 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9959 : {
9960 0 : {
9961 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
9962 0 : if (VECTOR_TYPE_P (type)
9963 0 : && (TREE_CODE_CLASS (RSHIFT_EXPR) != tcc_comparison
9964 : || types_match (type, TREE_TYPE (captures[2]))
9965 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9966 : || (optimize_vectors_before_lowering_p ()
9967 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9968 : )
9969 : {
9970 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1699;
9971 0 : {
9972 0 : tree res_op0;
9973 0 : res_op0 = captures[1];
9974 0 : tree res_op1;
9975 0 : {
9976 0 : tree _o1[2], _r1;
9977 0 : _o1[0] = captures[2];
9978 0 : _o1[1] = captures[5];
9979 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
9980 0 : if (EXPR_P (_r1))
9981 0 : goto next_after_fail1699;
9982 0 : res_op1 = _r1;
9983 : }
9984 0 : tree res_op2;
9985 0 : {
9986 0 : tree _o1[2], _r1;
9987 0 : _o1[0] = captures[3];
9988 0 : _o1[1] = captures[6];
9989 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
9990 0 : if (EXPR_P (_r1))
9991 0 : goto next_after_fail1699;
9992 0 : res_op2 = _r1;
9993 : }
9994 0 : tree _r;
9995 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9996 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 908, __FILE__, __LINE__, true);
9997 0 : return _r;
9998 : }
9999 0 : next_after_fail1699:;
10000 : }
10001 : }
10002 : }
10003 : break;
10004 : }
10005 0 : default:;
10006 : }
10007 0 : {
10008 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
10009 0 : if (VECTOR_TYPE_P (type)
10010 0 : && (TREE_CODE_CLASS (RSHIFT_EXPR) != tcc_comparison
10011 : || types_match (type, TREE_TYPE (captures[2]))
10012 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10013 : || (optimize_vectors_before_lowering_p ()
10014 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10015 : )
10016 : {
10017 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1700;
10018 0 : {
10019 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1700;
10020 0 : tree res_op0;
10021 0 : res_op0 = captures[1];
10022 0 : tree res_op1;
10023 0 : {
10024 0 : tree _o1[2], _r1;
10025 0 : _o1[0] = captures[2];
10026 0 : _o1[1] = unshare_expr (captures[4]);
10027 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
10028 0 : if (EXPR_P (_r1))
10029 0 : goto next_after_fail1700;
10030 0 : res_op1 = _r1;
10031 : }
10032 0 : tree res_op2;
10033 0 : {
10034 0 : tree _o1[2], _r1;
10035 0 : _o1[0] = captures[3];
10036 0 : _o1[1] = captures[4];
10037 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
10038 0 : if (EXPR_P (_r1))
10039 0 : goto next_after_fail1700;
10040 0 : res_op2 = _r1;
10041 : }
10042 0 : tree _r;
10043 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10044 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 910, __FILE__, __LINE__, true);
10045 0 : return _r;
10046 : }
10047 0 : next_after_fail1700:;
10048 : }
10049 : }
10050 0 : break;
10051 : }
10052 704 : case CALL_EXPR:
10053 704 : switch (get_call_combined_fn (_p0))
10054 : {
10055 0 : case CFN_BSWAP:
10056 0 : if (call_expr_nargs (_p0) == 1)
10057 : {
10058 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10059 0 : switch (TREE_CODE (_p1))
10060 : {
10061 0 : case INTEGER_CST:
10062 0 : {
10063 0 : {
10064 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10065 0 : tree res = generic_simplify_434 (loc, type, _p0, _p1, captures, CFN_BSWAP);
10066 0 : if (res) return res;
10067 : }
10068 0 : break;
10069 : }
10070 : default:;
10071 : }
10072 : }
10073 : break;
10074 0 : case CFN_BUILT_IN_BSWAP128:
10075 0 : if (call_expr_nargs (_p0) == 1)
10076 : {
10077 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10078 0 : switch (TREE_CODE (_p1))
10079 : {
10080 0 : case INTEGER_CST:
10081 0 : {
10082 0 : {
10083 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10084 0 : tree res = generic_simplify_434 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP128);
10085 0 : if (res) return res;
10086 : }
10087 0 : break;
10088 : }
10089 : default:;
10090 : }
10091 : }
10092 : break;
10093 32 : case CFN_BUILT_IN_BSWAP16:
10094 32 : if (call_expr_nargs (_p0) == 1)
10095 : {
10096 32 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10097 32 : switch (TREE_CODE (_p1))
10098 : {
10099 32 : case INTEGER_CST:
10100 32 : {
10101 32 : {
10102 32 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10103 32 : tree res = generic_simplify_434 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP16);
10104 32 : if (res) return res;
10105 : }
10106 9 : break;
10107 : }
10108 : default:;
10109 : }
10110 : }
10111 : break;
10112 101 : case CFN_BUILT_IN_BSWAP32:
10113 101 : if (call_expr_nargs (_p0) == 1)
10114 : {
10115 101 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10116 101 : switch (TREE_CODE (_p1))
10117 : {
10118 100 : case INTEGER_CST:
10119 100 : {
10120 100 : {
10121 100 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10122 100 : tree res = generic_simplify_434 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP32);
10123 100 : if (res) return res;
10124 : }
10125 61 : break;
10126 : }
10127 : default:;
10128 : }
10129 : }
10130 : break;
10131 102 : case CFN_BUILT_IN_BSWAP64:
10132 102 : if (call_expr_nargs (_p0) == 1)
10133 : {
10134 102 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10135 102 : switch (TREE_CODE (_p1))
10136 : {
10137 101 : case INTEGER_CST:
10138 101 : {
10139 101 : {
10140 101 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10141 101 : tree res = generic_simplify_434 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP64);
10142 101 : if (res) return res;
10143 : }
10144 75 : break;
10145 : }
10146 : default:;
10147 : }
10148 : }
10149 : break;
10150 : default:;
10151 : }
10152 : break;
10153 1005979 : default:;
10154 : }
10155 1005979 : if (integer_onep (_p0))
10156 : {
10157 524 : {
10158 524 : tree captures[1] ATTRIBUTE_UNUSED = { _p1 };
10159 524 : if (INTEGRAL_TYPE_P (type)
10160 : )
10161 : {
10162 524 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1701;
10163 524 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1701;
10164 524 : {
10165 524 : tree res_op0;
10166 524 : {
10167 524 : tree _o1[2], _r1;
10168 524 : _o1[0] = captures[0];
10169 524 : _o1[1] = build_zero_cst (TREE_TYPE (captures[0]));
10170 524 : _r1 = fold_build2_loc (loc, EQ_EXPR, boolean_type_node, _o1[0], _o1[1]);
10171 524 : res_op0 = _r1;
10172 : }
10173 524 : tree _r;
10174 524 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
10175 524 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1023, __FILE__, __LINE__, true);
10176 524 : return _r;
10177 : }
10178 : next_after_fail1701:;
10179 : }
10180 : }
10181 : }
10182 1005455 : switch (TREE_CODE (_p1))
10183 : {
10184 11 : case VEC_COND_EXPR:
10185 11 : {
10186 11 : tree _q30 = TREE_OPERAND (_p1, 0);
10187 11 : tree _q31 = TREE_OPERAND (_p1, 1);
10188 11 : tree _q32 = TREE_OPERAND (_p1, 2);
10189 11 : {
10190 11 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
10191 11 : if (VECTOR_TYPE_P (type)
10192 11 : && (TREE_CODE_CLASS (RSHIFT_EXPR) != tcc_comparison
10193 : || types_match (type, TREE_TYPE (captures[3]))
10194 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
10195 : || (optimize_vectors_before_lowering_p ()
10196 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
10197 : )
10198 : {
10199 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1702;
10200 11 : {
10201 11 : if (! tree_invariant_p (captures[0])) goto next_after_fail1702;
10202 0 : tree res_op0;
10203 0 : res_op0 = captures[2];
10204 0 : tree res_op1;
10205 0 : {
10206 0 : tree _o1[2], _r1;
10207 0 : _o1[0] = unshare_expr (captures[0]);
10208 0 : _o1[1] = captures[3];
10209 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
10210 0 : if (EXPR_P (_r1))
10211 0 : goto next_after_fail1702;
10212 0 : res_op1 = _r1;
10213 : }
10214 0 : tree res_op2;
10215 0 : {
10216 0 : tree _o1[2], _r1;
10217 0 : _o1[0] = captures[0];
10218 0 : _o1[1] = captures[4];
10219 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
10220 0 : if (EXPR_P (_r1))
10221 0 : goto next_after_fail1702;
10222 0 : res_op2 = _r1;
10223 : }
10224 0 : tree _r;
10225 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10226 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 911, __FILE__, __LINE__, true);
10227 0 : return _r;
10228 : }
10229 11 : next_after_fail1702:;
10230 : }
10231 : }
10232 11 : break;
10233 : }
10234 1005455 : default:;
10235 : }
10236 1005455 : switch (TREE_CODE (_p0))
10237 : {
10238 0 : case VEC_PERM_EXPR:
10239 0 : {
10240 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10241 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10242 0 : tree _q22 = TREE_OPERAND (_p0, 2);
10243 0 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
10244 : {
10245 0 : switch (TREE_CODE (_p1))
10246 : {
10247 0 : case VEC_PERM_EXPR:
10248 0 : {
10249 0 : tree _q60 = TREE_OPERAND (_p1, 0);
10250 0 : tree _q61 = TREE_OPERAND (_p1, 1);
10251 0 : tree _q62 = TREE_OPERAND (_p1, 2);
10252 0 : if ((_q61 == _q60 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q60, 0) && types_match (_q61, _q60)))
10253 : {
10254 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
10255 : {
10256 0 : {
10257 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q22, _q60 };
10258 0 : if (VECTOR_INTEGER_TYPE_P (type)
10259 : )
10260 : {
10261 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1703;
10262 0 : {
10263 0 : tree res_op0;
10264 0 : {
10265 0 : tree _o1[2], _r1;
10266 0 : _o1[0] = captures[0];
10267 0 : _o1[1] = captures[2];
10268 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10269 0 : captures[3] = _r1;
10270 : }
10271 0 : res_op0 = unshare_expr (captures[3]);
10272 0 : tree res_op1;
10273 0 : res_op1 = captures[3];
10274 0 : tree res_op2;
10275 0 : res_op2 = captures[1];
10276 0 : tree _r;
10277 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
10278 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 912, __FILE__, __LINE__, true);
10279 0 : return _r;
10280 : }
10281 0 : next_after_fail1703:;
10282 : }
10283 : }
10284 : }
10285 : }
10286 : break;
10287 : }
10288 : default:;
10289 : }
10290 : }
10291 : break;
10292 : }
10293 : default:;
10294 : }
10295 : return NULL_TREE;
10296 : }
10297 :
10298 : tree
10299 82923 : generic_simplify_MIN_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
10300 : {
10301 82923 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10302 82923 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
10303 : {
10304 0 : {
10305 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10306 0 : tree res = generic_simplify_527 (loc, type, _p0, _p1, captures, MIN_EXPR);
10307 0 : if (res) return res;
10308 : }
10309 : }
10310 82923 : switch (TREE_CODE (_p0))
10311 : {
10312 47 : case MIN_EXPR:
10313 47 : {
10314 47 : tree _q20 = TREE_OPERAND (_p0, 0);
10315 47 : tree _q21 = TREE_OPERAND (_p0, 1);
10316 47 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
10317 : {
10318 0 : {
10319 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
10320 0 : tree res = generic_simplify_528 (loc, type, _p0, _p1, captures, MIN_EXPR);
10321 0 : if (res) return res;
10322 : }
10323 : }
10324 47 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
10325 : {
10326 0 : {
10327 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
10328 0 : tree res = generic_simplify_528 (loc, type, _p0, _p1, captures, MIN_EXPR);
10329 0 : if (res) return res;
10330 : }
10331 : }
10332 : break;
10333 : }
10334 82923 : default:;
10335 : }
10336 82923 : switch (TREE_CODE (_p1))
10337 : {
10338 0 : case MIN_EXPR:
10339 0 : {
10340 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10341 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10342 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10343 : {
10344 0 : {
10345 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q31 };
10346 0 : tree res = generic_simplify_529 (loc, type, _p0, _p1, captures, MIN_EXPR);
10347 0 : if (res) return res;
10348 : }
10349 : }
10350 0 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
10351 : {
10352 0 : {
10353 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q30 };
10354 0 : tree res = generic_simplify_529 (loc, type, _p0, _p1, captures, MIN_EXPR);
10355 0 : if (res) return res;
10356 : }
10357 : }
10358 : break;
10359 : }
10360 82923 : default:;
10361 : }
10362 82923 : switch (TREE_CODE (_p0))
10363 : {
10364 4 : case MAX_EXPR:
10365 4 : {
10366 4 : tree _q20 = TREE_OPERAND (_p0, 0);
10367 4 : tree _q21 = TREE_OPERAND (_p0, 1);
10368 4 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
10369 : {
10370 3 : {
10371 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10372 3 : tree res = generic_simplify_530 (loc, type, _p0, _p1, captures);
10373 3 : if (res) return res;
10374 : }
10375 : }
10376 1 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
10377 : {
10378 1 : {
10379 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10380 1 : tree res = generic_simplify_530 (loc, type, _p0, _p1, captures);
10381 1 : if (res) return res;
10382 : }
10383 : }
10384 : break;
10385 : }
10386 82919 : default:;
10387 : }
10388 82919 : switch (TREE_CODE (_p1))
10389 : {
10390 0 : case MAX_EXPR:
10391 0 : {
10392 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10393 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10394 0 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
10395 : {
10396 0 : {
10397 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
10398 0 : tree res = generic_simplify_530 (loc, type, _p0, _p1, captures);
10399 0 : if (res) return res;
10400 : }
10401 : }
10402 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10403 : {
10404 0 : {
10405 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _p0 };
10406 0 : tree res = generic_simplify_530 (loc, type, _p0, _p1, captures);
10407 0 : if (res) return res;
10408 : }
10409 : }
10410 : break;
10411 : }
10412 0 : case NEGATE_EXPR:
10413 0 : {
10414 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10415 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10416 : {
10417 0 : {
10418 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10419 0 : tree res = generic_simplify_531 (loc, type, _p0, _p1, captures);
10420 0 : if (res) return res;
10421 : }
10422 : }
10423 : break;
10424 : }
10425 82919 : default:;
10426 : }
10427 82919 : switch (TREE_CODE (_p0))
10428 : {
10429 2 : case NEGATE_EXPR:
10430 2 : {
10431 2 : tree _q20 = TREE_OPERAND (_p0, 0);
10432 2 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
10433 : {
10434 2 : {
10435 2 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10436 2 : tree res = generic_simplify_531 (loc, type, _p0, _p1, captures);
10437 2 : if (res) return res;
10438 : }
10439 : }
10440 : break;
10441 : }
10442 82917 : default:;
10443 : }
10444 82917 : {
10445 82917 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
10446 82917 : if (INTEGRAL_TYPE_P (type)
10447 81070 : && TYPE_MIN_VALUE (type)
10448 163987 : && operand_equal_p (captures[1], TYPE_MIN_VALUE (type), OEP_ONLY_CONST)
10449 : )
10450 : {
10451 556 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1784;
10452 556 : {
10453 556 : tree _r;
10454 556 : _r = captures[1];
10455 556 : if (TREE_SIDE_EFFECTS (captures[0]))
10456 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
10457 556 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1033, __FILE__, __LINE__, true);
10458 556 : return _r;
10459 : }
10460 0 : next_after_fail1784:;
10461 : }
10462 : else
10463 : {
10464 82361 : if (INTEGRAL_TYPE_P (type)
10465 80514 : && TYPE_MAX_VALUE (type)
10466 162875 : && operand_equal_p (captures[1], TYPE_MAX_VALUE (type), OEP_ONLY_CONST)
10467 : )
10468 : {
10469 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1785;
10470 1 : {
10471 1 : tree _r;
10472 1 : _r = captures[0];
10473 1 : if (TREE_SIDE_EFFECTS (captures[1]))
10474 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
10475 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1034, __FILE__, __LINE__, true);
10476 1 : return _r;
10477 : }
10478 0 : next_after_fail1785:;
10479 : }
10480 : }
10481 : }
10482 82360 : switch (TREE_CODE (_p0))
10483 : {
10484 5604 : case PLUS_EXPR:
10485 5604 : {
10486 5604 : tree _q20 = TREE_OPERAND (_p0, 0);
10487 5604 : tree _q21 = TREE_OPERAND (_p0, 1);
10488 5604 : switch (TREE_CODE (_p1))
10489 : {
10490 15 : case PLUS_EXPR:
10491 15 : {
10492 15 : tree _q50 = TREE_OPERAND (_p1, 0);
10493 15 : tree _q51 = TREE_OPERAND (_p1, 1);
10494 15 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10495 : {
10496 0 : {
10497 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
10498 0 : tree res = generic_simplify_532 (loc, type, _p0, _p1, captures, MIN_EXPR);
10499 0 : if (res) return res;
10500 : }
10501 0 : {
10502 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q50, _q21, _p0, _q20 };
10503 0 : tree res = generic_simplify_532 (loc, type, _p0, _p1, captures, MIN_EXPR);
10504 0 : if (res) return res;
10505 : }
10506 : }
10507 15 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10508 : {
10509 0 : {
10510 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q50 };
10511 0 : tree res = generic_simplify_532 (loc, type, _p0, _p1, captures, MIN_EXPR);
10512 0 : if (res) return res;
10513 : }
10514 : }
10515 15 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10516 : {
10517 1 : {
10518 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q51, _q21, _p0, _q20 };
10519 1 : tree res = generic_simplify_532 (loc, type, _p0, _p1, captures, MIN_EXPR);
10520 1 : if (res) return res;
10521 : }
10522 : }
10523 : break;
10524 : }
10525 5603 : default:;
10526 : }
10527 5603 : switch (TREE_CODE (_q21))
10528 : {
10529 5475 : case INTEGER_CST:
10530 5475 : {
10531 5475 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
10532 : {
10533 0 : {
10534 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
10535 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
10536 : )
10537 : {
10538 0 : if (tree_int_cst_sgn (captures[2]) > 0
10539 : )
10540 : {
10541 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1786;
10542 0 : {
10543 0 : tree _r;
10544 0 : _r = captures[0];
10545 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10546 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10547 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1035, __FILE__, __LINE__, true);
10548 0 : return _r;
10549 : }
10550 0 : next_after_fail1786:;
10551 : }
10552 : else
10553 : {
10554 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1787;
10555 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1787;
10556 0 : {
10557 0 : tree _r;
10558 0 : _r = captures[1];
10559 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1036, __FILE__, __LINE__, true);
10560 0 : return _r;
10561 : }
10562 0 : next_after_fail1787:;
10563 : }
10564 : }
10565 : }
10566 : }
10567 : break;
10568 : }
10569 : default:;
10570 : }
10571 : break;
10572 : }
10573 1006 : case MINUS_EXPR:
10574 1006 : {
10575 1006 : tree _q20 = TREE_OPERAND (_p0, 0);
10576 1006 : tree _q21 = TREE_OPERAND (_p0, 1);
10577 1006 : switch (TREE_CODE (_p1))
10578 : {
10579 988 : case MINUS_EXPR:
10580 988 : {
10581 988 : tree _q50 = TREE_OPERAND (_p1, 0);
10582 988 : tree _q51 = TREE_OPERAND (_p1, 1);
10583 988 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10584 : {
10585 0 : {
10586 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
10587 0 : tree res = generic_simplify_533 (loc, type, _p0, _p1, captures, MIN_EXPR);
10588 0 : if (res) return res;
10589 : }
10590 0 : {
10591 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q50, _q21, _p0, _q20 };
10592 0 : tree res = generic_simplify_533 (loc, type, _p0, _p1, captures, MIN_EXPR);
10593 0 : if (res) return res;
10594 : }
10595 : }
10596 : break;
10597 : }
10598 : default:;
10599 : }
10600 : break;
10601 : }
10602 82359 : default:;
10603 : }
10604 82359 : switch (TREE_CODE (_p1))
10605 : {
10606 21 : case PLUS_EXPR:
10607 21 : {
10608 21 : tree _q30 = TREE_OPERAND (_p1, 0);
10609 21 : tree _q31 = TREE_OPERAND (_p1, 1);
10610 21 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10611 : {
10612 0 : switch (TREE_CODE (_q31))
10613 : {
10614 0 : case INTEGER_CST:
10615 0 : {
10616 0 : {
10617 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
10618 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
10619 : )
10620 : {
10621 0 : if (tree_int_cst_sgn (captures[2]) > 0
10622 : )
10623 : {
10624 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1788;
10625 0 : {
10626 0 : tree _r;
10627 0 : _r = captures[0];
10628 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10629 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10630 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1035, __FILE__, __LINE__, true);
10631 0 : return _r;
10632 : }
10633 0 : next_after_fail1788:;
10634 : }
10635 : else
10636 : {
10637 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1789;
10638 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1789;
10639 0 : {
10640 0 : tree _r;
10641 0 : _r = captures[1];
10642 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1036, __FILE__, __LINE__, true);
10643 0 : return _r;
10644 : }
10645 0 : next_after_fail1789:;
10646 : }
10647 : }
10648 : }
10649 0 : break;
10650 : }
10651 : default:;
10652 : }
10653 : }
10654 : break;
10655 : }
10656 82359 : default:;
10657 : }
10658 82359 : switch (TREE_CODE (_p0))
10659 : {
10660 47 : case MIN_EXPR:
10661 47 : {
10662 47 : tree _q20 = TREE_OPERAND (_p0, 0);
10663 47 : tree _q21 = TREE_OPERAND (_p0, 1);
10664 47 : switch (TREE_CODE (_p1))
10665 : {
10666 0 : case MAX_EXPR:
10667 0 : {
10668 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10669 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10670 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10671 : {
10672 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10673 : {
10674 0 : {
10675 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10676 0 : if (!HONOR_NANS (captures[0])
10677 : )
10678 : {
10679 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1790;
10680 0 : {
10681 0 : tree res_op0;
10682 0 : res_op0 = captures[0];
10683 0 : tree res_op1;
10684 0 : res_op1 = captures[1];
10685 0 : tree _r;
10686 0 : _r = fold_build2_loc (loc, MIN_EXPR, type, res_op0, res_op1);
10687 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 907, __FILE__, __LINE__, true);
10688 0 : return _r;
10689 : }
10690 0 : next_after_fail1790:;
10691 : }
10692 : }
10693 : }
10694 : }
10695 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10696 : {
10697 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10698 : {
10699 0 : {
10700 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10701 0 : if (!HONOR_NANS (captures[0])
10702 : )
10703 : {
10704 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1791;
10705 0 : {
10706 0 : tree res_op0;
10707 0 : res_op0 = captures[0];
10708 0 : tree res_op1;
10709 0 : res_op1 = captures[1];
10710 0 : tree _r;
10711 0 : _r = fold_build2_loc (loc, MIN_EXPR, type, res_op0, res_op1);
10712 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 907, __FILE__, __LINE__, true);
10713 0 : return _r;
10714 : }
10715 0 : next_after_fail1791:;
10716 : }
10717 : }
10718 : }
10719 : }
10720 : break;
10721 : }
10722 : default:;
10723 : }
10724 : break;
10725 : }
10726 0 : case MAX_EXPR:
10727 0 : {
10728 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10729 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10730 0 : switch (TREE_CODE (_p1))
10731 : {
10732 0 : case MIN_EXPR:
10733 0 : {
10734 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10735 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10736 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10737 : {
10738 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10739 : {
10740 0 : {
10741 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10742 0 : if (!HONOR_NANS (captures[0])
10743 : )
10744 : {
10745 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1792;
10746 0 : {
10747 0 : tree res_op0;
10748 0 : res_op0 = captures[0];
10749 0 : tree res_op1;
10750 0 : res_op1 = captures[1];
10751 0 : tree _r;
10752 0 : _r = fold_build2_loc (loc, MIN_EXPR, type, res_op0, res_op1);
10753 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 907, __FILE__, __LINE__, true);
10754 0 : return _r;
10755 : }
10756 0 : next_after_fail1792:;
10757 : }
10758 : }
10759 : }
10760 : }
10761 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10762 : {
10763 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10764 : {
10765 0 : {
10766 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10767 0 : if (!HONOR_NANS (captures[0])
10768 : )
10769 : {
10770 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1793;
10771 0 : {
10772 0 : tree res_op0;
10773 0 : res_op0 = captures[0];
10774 0 : tree res_op1;
10775 0 : res_op1 = captures[1];
10776 0 : tree _r;
10777 0 : _r = fold_build2_loc (loc, MIN_EXPR, type, res_op0, res_op1);
10778 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 907, __FILE__, __LINE__, true);
10779 0 : return _r;
10780 : }
10781 0 : next_after_fail1793:;
10782 : }
10783 : }
10784 : }
10785 : }
10786 : break;
10787 : }
10788 : default:;
10789 : }
10790 : break;
10791 : }
10792 1 : case BIT_AND_EXPR:
10793 1 : {
10794 1 : tree _q20 = TREE_OPERAND (_p0, 0);
10795 1 : tree _q21 = TREE_OPERAND (_p0, 1);
10796 1 : switch (TREE_CODE (_q21))
10797 : {
10798 1 : case INTEGER_CST:
10799 1 : {
10800 1 : switch (TREE_CODE (_p1))
10801 : {
10802 0 : case BIT_AND_EXPR:
10803 0 : {
10804 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10805 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10806 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10807 : {
10808 0 : switch (TREE_CODE (_q51))
10809 : {
10810 0 : case INTEGER_CST:
10811 0 : {
10812 0 : {
10813 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
10814 0 : tree res = generic_simplify_534 (loc, type, _p0, _p1, captures, MIN_EXPR);
10815 0 : if (res) return res;
10816 : }
10817 0 : break;
10818 : }
10819 : default:;
10820 : }
10821 : }
10822 : break;
10823 : }
10824 : default:;
10825 : }
10826 : break;
10827 : }
10828 : default:;
10829 : }
10830 : break;
10831 : }
10832 82359 : default:;
10833 : }
10834 82359 : switch (TREE_CODE (_p1))
10835 : {
10836 0 : case BIT_AND_EXPR:
10837 0 : {
10838 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10839 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10840 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10841 : {
10842 0 : switch (TREE_CODE (_q31))
10843 : {
10844 0 : case INTEGER_CST:
10845 0 : {
10846 0 : {
10847 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
10848 0 : tree res = generic_simplify_535 (loc, type, _p0, _p1, captures, MIN_EXPR);
10849 0 : if (res) return res;
10850 : }
10851 0 : break;
10852 : }
10853 : default:;
10854 : }
10855 : }
10856 : break;
10857 : }
10858 82359 : default:;
10859 : }
10860 82359 : switch (TREE_CODE (_p0))
10861 : {
10862 672 : CASE_CONVERT:
10863 672 : {
10864 672 : tree _q20 = TREE_OPERAND (_p0, 0);
10865 672 : switch (TREE_CODE (_q20))
10866 : {
10867 47 : case ADDR_EXPR:
10868 47 : {
10869 47 : switch (TREE_CODE (_p1))
10870 : {
10871 47 : CASE_CONVERT:
10872 47 : {
10873 47 : tree _q40 = TREE_OPERAND (_p1, 0);
10874 47 : switch (TREE_CODE (_q40))
10875 : {
10876 47 : case ADDR_EXPR:
10877 47 : {
10878 47 : {
10879 47 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10880 47 : tree res = generic_simplify_536 (loc, type, _p0, _p1, captures, MIN_EXPR, LT_EXPR);
10881 47 : if (res) return res;
10882 : }
10883 47 : break;
10884 : }
10885 : default:;
10886 : }
10887 : break;
10888 : }
10889 0 : case ADDR_EXPR:
10890 0 : {
10891 0 : {
10892 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
10893 0 : tree res = generic_simplify_537 (loc, type, _p0, _p1, captures, MIN_EXPR, LT_EXPR);
10894 0 : if (res) return res;
10895 : }
10896 0 : break;
10897 : }
10898 : default:;
10899 : }
10900 : break;
10901 : }
10902 : default:;
10903 : }
10904 : break;
10905 : }
10906 10 : case ADDR_EXPR:
10907 10 : {
10908 10 : switch (TREE_CODE (_p1))
10909 : {
10910 0 : CASE_CONVERT:
10911 0 : {
10912 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10913 0 : switch (TREE_CODE (_q30))
10914 : {
10915 0 : case ADDR_EXPR:
10916 0 : {
10917 0 : {
10918 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _p1, _q30 };
10919 0 : tree res = generic_simplify_538 (loc, type, _p0, _p1, captures, MIN_EXPR, LT_EXPR);
10920 0 : if (res) return res;
10921 : }
10922 0 : break;
10923 : }
10924 : default:;
10925 : }
10926 : break;
10927 : }
10928 10 : case ADDR_EXPR:
10929 10 : {
10930 10 : {
10931 10 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _p1, _p1 };
10932 10 : tree res = generic_simplify_539 (loc, type, _p0, _p1, captures, MIN_EXPR, LT_EXPR);
10933 10 : if (res) return res;
10934 : }
10935 10 : break;
10936 : }
10937 : default:;
10938 : }
10939 : break;
10940 : }
10941 0 : case NEGATE_EXPR:
10942 0 : {
10943 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10944 0 : switch (TREE_CODE (_p1))
10945 : {
10946 0 : case NEGATE_EXPR:
10947 0 : {
10948 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10949 0 : {
10950 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10951 0 : if (FLOAT_TYPE_P (TREE_TYPE (captures[1]))
10952 0 : || (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
10953 0 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1])))
10954 : )
10955 : {
10956 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1794;
10957 0 : {
10958 0 : tree res_op0;
10959 0 : {
10960 0 : tree _o1[2], _r1;
10961 0 : _o1[0] = captures[1];
10962 0 : _o1[1] = captures[3];
10963 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10964 0 : res_op0 = _r1;
10965 : }
10966 0 : tree _r;
10967 0 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
10968 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1037, __FILE__, __LINE__, true);
10969 0 : return _r;
10970 : }
10971 0 : next_after_fail1794:;
10972 : }
10973 : }
10974 0 : break;
10975 : }
10976 : default:;
10977 : }
10978 : break;
10979 : }
10980 0 : case BIT_NOT_EXPR:
10981 0 : {
10982 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10983 0 : switch (TREE_CODE (_p1))
10984 : {
10985 0 : case BIT_NOT_EXPR:
10986 0 : {
10987 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10988 0 : {
10989 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10990 0 : tree res = generic_simplify_540 (loc, type, _p0, _p1, captures, MIN_EXPR, MAX_EXPR);
10991 0 : if (res) return res;
10992 : }
10993 0 : break;
10994 : }
10995 : default:;
10996 : }
10997 : break;
10998 : }
10999 0 : case VEC_COND_EXPR:
11000 0 : {
11001 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11002 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11003 0 : tree _q22 = TREE_OPERAND (_p0, 2);
11004 0 : switch (TREE_CODE (_p1))
11005 : {
11006 0 : case VEC_COND_EXPR:
11007 0 : {
11008 0 : tree _q60 = TREE_OPERAND (_p1, 0);
11009 0 : tree _q61 = TREE_OPERAND (_p1, 1);
11010 0 : tree _q62 = TREE_OPERAND (_p1, 2);
11011 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
11012 : {
11013 0 : {
11014 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
11015 0 : if (VECTOR_TYPE_P (type)
11016 0 : && (TREE_CODE_CLASS (MIN_EXPR) != tcc_comparison
11017 : || types_match (type, TREE_TYPE (captures[2]))
11018 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
11019 : || (optimize_vectors_before_lowering_p ()
11020 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
11021 : )
11022 : {
11023 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1795;
11024 0 : {
11025 0 : tree res_op0;
11026 0 : res_op0 = captures[1];
11027 0 : tree res_op1;
11028 0 : {
11029 0 : tree _o1[2], _r1;
11030 0 : _o1[0] = captures[2];
11031 0 : _o1[1] = captures[5];
11032 0 : _r1 = fold_build2_loc (loc, MIN_EXPR, type, _o1[0], _o1[1]);
11033 0 : if (EXPR_P (_r1))
11034 0 : goto next_after_fail1795;
11035 0 : res_op1 = _r1;
11036 : }
11037 0 : tree res_op2;
11038 0 : {
11039 0 : tree _o1[2], _r1;
11040 0 : _o1[0] = captures[3];
11041 0 : _o1[1] = captures[6];
11042 0 : _r1 = fold_build2_loc (loc, MIN_EXPR, type, _o1[0], _o1[1]);
11043 0 : if (EXPR_P (_r1))
11044 0 : goto next_after_fail1795;
11045 0 : res_op2 = _r1;
11046 : }
11047 0 : tree _r;
11048 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11049 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 908, __FILE__, __LINE__, true);
11050 0 : return _r;
11051 : }
11052 0 : next_after_fail1795:;
11053 : }
11054 : }
11055 : }
11056 : break;
11057 : }
11058 0 : default:;
11059 : }
11060 0 : {
11061 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
11062 0 : if (VECTOR_TYPE_P (type)
11063 0 : && (TREE_CODE_CLASS (MIN_EXPR) != tcc_comparison
11064 : || types_match (type, TREE_TYPE (captures[2]))
11065 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
11066 : || (optimize_vectors_before_lowering_p ()
11067 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
11068 : )
11069 : {
11070 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1796;
11071 0 : {
11072 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1796;
11073 0 : tree res_op0;
11074 0 : res_op0 = captures[1];
11075 0 : tree res_op1;
11076 0 : {
11077 0 : tree _o1[2], _r1;
11078 0 : _o1[0] = captures[2];
11079 0 : _o1[1] = unshare_expr (captures[4]);
11080 0 : _r1 = fold_build2_loc (loc, MIN_EXPR, type, _o1[0], _o1[1]);
11081 0 : if (EXPR_P (_r1))
11082 0 : goto next_after_fail1796;
11083 0 : res_op1 = _r1;
11084 : }
11085 0 : tree res_op2;
11086 0 : {
11087 0 : tree _o1[2], _r1;
11088 0 : _o1[0] = captures[3];
11089 0 : _o1[1] = captures[4];
11090 0 : _r1 = fold_build2_loc (loc, MIN_EXPR, type, _o1[0], _o1[1]);
11091 0 : if (EXPR_P (_r1))
11092 0 : goto next_after_fail1796;
11093 0 : res_op2 = _r1;
11094 : }
11095 0 : tree _r;
11096 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11097 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 910, __FILE__, __LINE__, true);
11098 0 : return _r;
11099 : }
11100 0 : next_after_fail1796:;
11101 : }
11102 : }
11103 0 : break;
11104 : }
11105 82359 : default:;
11106 : }
11107 82359 : switch (TREE_CODE (_p1))
11108 : {
11109 0 : case VEC_COND_EXPR:
11110 0 : {
11111 0 : tree _q30 = TREE_OPERAND (_p1, 0);
11112 0 : tree _q31 = TREE_OPERAND (_p1, 1);
11113 0 : tree _q32 = TREE_OPERAND (_p1, 2);
11114 0 : {
11115 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
11116 0 : if (VECTOR_TYPE_P (type)
11117 0 : && (TREE_CODE_CLASS (MIN_EXPR) != tcc_comparison
11118 : || types_match (type, TREE_TYPE (captures[3]))
11119 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
11120 : || (optimize_vectors_before_lowering_p ()
11121 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
11122 : )
11123 : {
11124 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1797;
11125 0 : {
11126 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1797;
11127 0 : tree res_op0;
11128 0 : res_op0 = captures[2];
11129 0 : tree res_op1;
11130 0 : {
11131 0 : tree _o1[2], _r1;
11132 0 : _o1[0] = unshare_expr (captures[0]);
11133 0 : _o1[1] = captures[3];
11134 0 : _r1 = fold_build2_loc (loc, MIN_EXPR, type, _o1[0], _o1[1]);
11135 0 : if (EXPR_P (_r1))
11136 0 : goto next_after_fail1797;
11137 0 : res_op1 = _r1;
11138 : }
11139 0 : tree res_op2;
11140 0 : {
11141 0 : tree _o1[2], _r1;
11142 0 : _o1[0] = captures[0];
11143 0 : _o1[1] = captures[4];
11144 0 : _r1 = fold_build2_loc (loc, MIN_EXPR, type, _o1[0], _o1[1]);
11145 0 : if (EXPR_P (_r1))
11146 0 : goto next_after_fail1797;
11147 0 : res_op2 = _r1;
11148 : }
11149 0 : tree _r;
11150 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11151 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 911, __FILE__, __LINE__, true);
11152 0 : return _r;
11153 : }
11154 0 : next_after_fail1797:;
11155 : }
11156 : }
11157 0 : break;
11158 : }
11159 82359 : default:;
11160 : }
11161 82359 : switch (TREE_CODE (_p0))
11162 : {
11163 4 : case CALL_EXPR:
11164 4 : switch (get_call_combined_fn (_p0))
11165 : {
11166 1 : case CFN_BUILT_IN_CLZ:
11167 1 : if (call_expr_nargs (_p0) == 1)
11168 : {
11169 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11170 1 : switch (TREE_CODE (_p1))
11171 : {
11172 1 : case CALL_EXPR:
11173 1 : switch (get_call_combined_fn (_p1))
11174 : {
11175 1 : case CFN_BUILT_IN_CLZ:
11176 1 : if (call_expr_nargs (_p1) == 1)
11177 : {
11178 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11179 1 : {
11180 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11181 1 : tree res = generic_simplify_542 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_CLZ);
11182 1 : if (res) return res;
11183 : }
11184 : }
11185 : break;
11186 : default:;
11187 : }
11188 : break;
11189 : default:;
11190 : }
11191 : }
11192 : break;
11193 1 : case CFN_BUILT_IN_CTZ:
11194 1 : if (call_expr_nargs (_p0) == 1)
11195 : {
11196 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11197 1 : switch (TREE_CODE (_p1))
11198 : {
11199 1 : case CALL_EXPR:
11200 1 : switch (get_call_combined_fn (_p1))
11201 : {
11202 1 : case CFN_BUILT_IN_CTZ:
11203 1 : if (call_expr_nargs (_p1) == 1)
11204 : {
11205 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11206 1 : {
11207 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11208 1 : tree res = generic_simplify_542 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_CTZ);
11209 1 : if (res) return res;
11210 : }
11211 : }
11212 : break;
11213 : default:;
11214 : }
11215 : break;
11216 : default:;
11217 : }
11218 : }
11219 : break;
11220 0 : case CFN_BUILT_IN_CLZL:
11221 0 : if (call_expr_nargs (_p0) == 1)
11222 : {
11223 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11224 0 : switch (TREE_CODE (_p1))
11225 : {
11226 0 : case CALL_EXPR:
11227 0 : switch (get_call_combined_fn (_p1))
11228 : {
11229 0 : case CFN_BUILT_IN_CLZL:
11230 0 : if (call_expr_nargs (_p1) == 1)
11231 : {
11232 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11233 0 : {
11234 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11235 0 : tree res = generic_simplify_542 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_CLZL);
11236 0 : if (res) return res;
11237 : }
11238 : }
11239 : break;
11240 : default:;
11241 : }
11242 : break;
11243 : default:;
11244 : }
11245 : }
11246 : break;
11247 0 : case CFN_BUILT_IN_CTZL:
11248 0 : if (call_expr_nargs (_p0) == 1)
11249 : {
11250 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11251 0 : switch (TREE_CODE (_p1))
11252 : {
11253 0 : case CALL_EXPR:
11254 0 : switch (get_call_combined_fn (_p1))
11255 : {
11256 0 : case CFN_BUILT_IN_CTZL:
11257 0 : if (call_expr_nargs (_p1) == 1)
11258 : {
11259 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11260 0 : {
11261 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11262 0 : tree res = generic_simplify_542 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_CTZL);
11263 0 : if (res) return res;
11264 : }
11265 : }
11266 : break;
11267 : default:;
11268 : }
11269 : break;
11270 : default:;
11271 : }
11272 : }
11273 : break;
11274 0 : case CFN_BUILT_IN_CTZIMAX:
11275 0 : if (call_expr_nargs (_p0) == 1)
11276 : {
11277 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11278 0 : switch (TREE_CODE (_p1))
11279 : {
11280 0 : case CALL_EXPR:
11281 0 : switch (get_call_combined_fn (_p1))
11282 : {
11283 0 : case CFN_BUILT_IN_CTZIMAX:
11284 0 : if (call_expr_nargs (_p1) == 1)
11285 : {
11286 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11287 0 : {
11288 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11289 0 : tree res = generic_simplify_542 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_CTZIMAX);
11290 0 : if (res) return res;
11291 : }
11292 : }
11293 : break;
11294 : default:;
11295 : }
11296 : break;
11297 : default:;
11298 : }
11299 : }
11300 : break;
11301 1 : case CFN_CLZ:
11302 1 : if (call_expr_nargs (_p0) == 1)
11303 : {
11304 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11305 0 : switch (TREE_CODE (_p1))
11306 : {
11307 0 : case CALL_EXPR:
11308 0 : switch (get_call_combined_fn (_p1))
11309 : {
11310 0 : case CFN_CLZ:
11311 0 : if (call_expr_nargs (_p1) == 1)
11312 : {
11313 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11314 0 : {
11315 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11316 0 : tree res = generic_simplify_542 (loc, type, _p0, _p1, captures, CFN_CLZ);
11317 0 : if (res) return res;
11318 : }
11319 : }
11320 : break;
11321 : default:;
11322 : }
11323 : break;
11324 : default:;
11325 : }
11326 : }
11327 1 : if (call_expr_nargs (_p0) == 2)
11328 : {
11329 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11330 1 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
11331 1 : switch (TREE_CODE (_q21))
11332 : {
11333 1 : case INTEGER_CST:
11334 1 : {
11335 1 : switch (TREE_CODE (_p1))
11336 : {
11337 1 : case CALL_EXPR:
11338 1 : switch (get_call_combined_fn (_p1))
11339 : {
11340 1 : case CFN_CLZ:
11341 1 : if (call_expr_nargs (_p1) == 2)
11342 : {
11343 1 : tree _q50 = CALL_EXPR_ARG (_p1, 0);
11344 1 : tree _q51 = CALL_EXPR_ARG (_p1, 1);
11345 1 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11346 : {
11347 1 : {
11348 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
11349 1 : tree res = generic_simplify_543 (loc, type, _p0, _p1, captures, CFN_CLZ);
11350 1 : if (res) return res;
11351 : }
11352 : }
11353 : }
11354 : break;
11355 : default:;
11356 : }
11357 : break;
11358 : default:;
11359 : }
11360 : break;
11361 : }
11362 : default:;
11363 : }
11364 : }
11365 : break;
11366 1 : case CFN_CTZ:
11367 1 : if (call_expr_nargs (_p0) == 1)
11368 : {
11369 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11370 0 : switch (TREE_CODE (_p1))
11371 : {
11372 0 : case CALL_EXPR:
11373 0 : switch (get_call_combined_fn (_p1))
11374 : {
11375 0 : case CFN_CTZ:
11376 0 : if (call_expr_nargs (_p1) == 1)
11377 : {
11378 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11379 0 : {
11380 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11381 0 : tree res = generic_simplify_542 (loc, type, _p0, _p1, captures, CFN_CTZ);
11382 0 : if (res) return res;
11383 : }
11384 : }
11385 : break;
11386 : default:;
11387 : }
11388 : break;
11389 : default:;
11390 : }
11391 : }
11392 1 : if (call_expr_nargs (_p0) == 2)
11393 : {
11394 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11395 1 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
11396 1 : switch (TREE_CODE (_q21))
11397 : {
11398 1 : case INTEGER_CST:
11399 1 : {
11400 1 : switch (TREE_CODE (_p1))
11401 : {
11402 1 : case CALL_EXPR:
11403 1 : switch (get_call_combined_fn (_p1))
11404 : {
11405 1 : case CFN_CTZ:
11406 1 : if (call_expr_nargs (_p1) == 2)
11407 : {
11408 1 : tree _q50 = CALL_EXPR_ARG (_p1, 0);
11409 1 : tree _q51 = CALL_EXPR_ARG (_p1, 1);
11410 1 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11411 : {
11412 1 : {
11413 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
11414 1 : tree res = generic_simplify_543 (loc, type, _p0, _p1, captures, CFN_CTZ);
11415 1 : if (res) return res;
11416 : }
11417 : }
11418 : }
11419 : break;
11420 : default:;
11421 : }
11422 : break;
11423 : default:;
11424 : }
11425 : break;
11426 : }
11427 : default:;
11428 : }
11429 : }
11430 : break;
11431 0 : case CFN_BUILT_IN_CLZIMAX:
11432 0 : if (call_expr_nargs (_p0) == 1)
11433 : {
11434 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11435 0 : switch (TREE_CODE (_p1))
11436 : {
11437 0 : case CALL_EXPR:
11438 0 : switch (get_call_combined_fn (_p1))
11439 : {
11440 0 : case CFN_BUILT_IN_CLZIMAX:
11441 0 : if (call_expr_nargs (_p1) == 1)
11442 : {
11443 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11444 0 : {
11445 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11446 0 : tree res = generic_simplify_542 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_CLZIMAX);
11447 0 : if (res) return res;
11448 : }
11449 : }
11450 : break;
11451 : default:;
11452 : }
11453 : break;
11454 : default:;
11455 : }
11456 : }
11457 : break;
11458 0 : case CFN_BUILT_IN_CLZLL:
11459 0 : if (call_expr_nargs (_p0) == 1)
11460 : {
11461 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11462 0 : switch (TREE_CODE (_p1))
11463 : {
11464 0 : case CALL_EXPR:
11465 0 : switch (get_call_combined_fn (_p1))
11466 : {
11467 0 : case CFN_BUILT_IN_CLZLL:
11468 0 : if (call_expr_nargs (_p1) == 1)
11469 : {
11470 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11471 0 : {
11472 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11473 0 : tree res = generic_simplify_542 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_CLZLL);
11474 0 : if (res) return res;
11475 : }
11476 : }
11477 : break;
11478 : default:;
11479 : }
11480 : break;
11481 : default:;
11482 : }
11483 : }
11484 : break;
11485 0 : case CFN_BUILT_IN_CTZLL:
11486 0 : if (call_expr_nargs (_p0) == 1)
11487 : {
11488 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11489 0 : switch (TREE_CODE (_p1))
11490 : {
11491 0 : case CALL_EXPR:
11492 0 : switch (get_call_combined_fn (_p1))
11493 : {
11494 0 : case CFN_BUILT_IN_CTZLL:
11495 0 : if (call_expr_nargs (_p1) == 1)
11496 : {
11497 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11498 0 : {
11499 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11500 0 : tree res = generic_simplify_542 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_CTZLL);
11501 0 : if (res) return res;
11502 : }
11503 : }
11504 : break;
11505 : default:;
11506 : }
11507 : break;
11508 : default:;
11509 : }
11510 : }
11511 : break;
11512 : default:;
11513 : }
11514 : break;
11515 82355 : default:;
11516 : }
11517 82355 : if (tree_zero_one_valued_p (_p0))
11518 : {
11519 3 : if (tree_zero_one_valued_p (_p1))
11520 : {
11521 2 : {
11522 2 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
11523 2 : tree res = generic_simplify_541 (loc, type, _p0, _p1, captures, MIN_EXPR, BIT_AND_EXPR);
11524 2 : if (res) return res;
11525 : }
11526 : }
11527 : }
11528 : return NULL_TREE;
11529 : }
11530 :
11531 : tree
11532 1635495 : generic_simplify_UNLE_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
11533 : {
11534 1635495 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
11535 1635495 : switch (TREE_CODE (_p0))
11536 : {
11537 0 : case VEC_COND_EXPR:
11538 0 : {
11539 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11540 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11541 0 : tree _q22 = TREE_OPERAND (_p0, 2);
11542 0 : switch (TREE_CODE (_p1))
11543 : {
11544 0 : case VEC_COND_EXPR:
11545 0 : {
11546 0 : tree _q60 = TREE_OPERAND (_p1, 0);
11547 0 : tree _q61 = TREE_OPERAND (_p1, 1);
11548 0 : tree _q62 = TREE_OPERAND (_p1, 2);
11549 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
11550 : {
11551 0 : {
11552 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
11553 0 : if (VECTOR_TYPE_P (type)
11554 0 : && (TREE_CODE_CLASS (UNLE_EXPR) != tcc_comparison
11555 0 : || types_match (type, TREE_TYPE (captures[2]))
11556 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
11557 : || (optimize_vectors_before_lowering_p ()
11558 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
11559 : )
11560 : {
11561 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1827;
11562 0 : {
11563 0 : tree res_op0;
11564 0 : res_op0 = captures[1];
11565 0 : tree res_op1;
11566 0 : {
11567 0 : tree _o1[2], _r1;
11568 0 : _o1[0] = captures[2];
11569 0 : _o1[1] = captures[5];
11570 0 : _r1 = fold_build2_loc (loc, UNLE_EXPR, type, _o1[0], _o1[1]);
11571 0 : if (EXPR_P (_r1))
11572 0 : goto next_after_fail1827;
11573 0 : res_op1 = _r1;
11574 : }
11575 0 : tree res_op2;
11576 0 : {
11577 0 : tree _o1[2], _r1;
11578 0 : _o1[0] = captures[3];
11579 0 : _o1[1] = captures[6];
11580 0 : _r1 = fold_build2_loc (loc, UNLE_EXPR, type, _o1[0], _o1[1]);
11581 0 : if (EXPR_P (_r1))
11582 0 : goto next_after_fail1827;
11583 0 : res_op2 = _r1;
11584 : }
11585 0 : tree _r;
11586 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11587 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 908, __FILE__, __LINE__, true);
11588 0 : return _r;
11589 : }
11590 0 : next_after_fail1827:;
11591 : }
11592 : }
11593 : }
11594 : break;
11595 : }
11596 0 : default:;
11597 : }
11598 0 : {
11599 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
11600 0 : if (VECTOR_TYPE_P (type)
11601 0 : && (TREE_CODE_CLASS (UNLE_EXPR) != tcc_comparison
11602 0 : || types_match (type, TREE_TYPE (captures[2]))
11603 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
11604 : || (optimize_vectors_before_lowering_p ()
11605 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
11606 : )
11607 : {
11608 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1828;
11609 0 : {
11610 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1828;
11611 0 : tree res_op0;
11612 0 : res_op0 = captures[1];
11613 0 : tree res_op1;
11614 0 : {
11615 0 : tree _o1[2], _r1;
11616 0 : _o1[0] = captures[2];
11617 0 : _o1[1] = unshare_expr (captures[4]);
11618 0 : _r1 = fold_build2_loc (loc, UNLE_EXPR, type, _o1[0], _o1[1]);
11619 0 : if (EXPR_P (_r1))
11620 0 : goto next_after_fail1828;
11621 0 : res_op1 = _r1;
11622 : }
11623 0 : tree res_op2;
11624 0 : {
11625 0 : tree _o1[2], _r1;
11626 0 : _o1[0] = captures[3];
11627 0 : _o1[1] = captures[4];
11628 0 : _r1 = fold_build2_loc (loc, UNLE_EXPR, type, _o1[0], _o1[1]);
11629 0 : if (EXPR_P (_r1))
11630 0 : goto next_after_fail1828;
11631 0 : res_op2 = _r1;
11632 : }
11633 0 : tree _r;
11634 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11635 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 910, __FILE__, __LINE__, true);
11636 0 : return _r;
11637 : }
11638 0 : next_after_fail1828:;
11639 : }
11640 : }
11641 0 : break;
11642 : }
11643 1635495 : default:;
11644 : }
11645 1635495 : switch (TREE_CODE (_p1))
11646 : {
11647 0 : case VEC_COND_EXPR:
11648 0 : {
11649 0 : tree _q30 = TREE_OPERAND (_p1, 0);
11650 0 : tree _q31 = TREE_OPERAND (_p1, 1);
11651 0 : tree _q32 = TREE_OPERAND (_p1, 2);
11652 0 : {
11653 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
11654 0 : if (VECTOR_TYPE_P (type)
11655 0 : && (TREE_CODE_CLASS (UNLE_EXPR) != tcc_comparison
11656 0 : || types_match (type, TREE_TYPE (captures[3]))
11657 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
11658 : || (optimize_vectors_before_lowering_p ()
11659 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
11660 : )
11661 : {
11662 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1829;
11663 0 : {
11664 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1829;
11665 0 : tree res_op0;
11666 0 : res_op0 = captures[2];
11667 0 : tree res_op1;
11668 0 : {
11669 0 : tree _o1[2], _r1;
11670 0 : _o1[0] = unshare_expr (captures[0]);
11671 0 : _o1[1] = captures[3];
11672 0 : _r1 = fold_build2_loc (loc, UNLE_EXPR, type, _o1[0], _o1[1]);
11673 0 : if (EXPR_P (_r1))
11674 0 : goto next_after_fail1829;
11675 0 : res_op1 = _r1;
11676 : }
11677 0 : tree res_op2;
11678 0 : {
11679 0 : tree _o1[2], _r1;
11680 0 : _o1[0] = captures[0];
11681 0 : _o1[1] = captures[4];
11682 0 : _r1 = fold_build2_loc (loc, UNLE_EXPR, type, _o1[0], _o1[1]);
11683 0 : if (EXPR_P (_r1))
11684 0 : goto next_after_fail1829;
11685 0 : res_op2 = _r1;
11686 : }
11687 0 : tree _r;
11688 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11689 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 911, __FILE__, __LINE__, true);
11690 0 : return _r;
11691 : }
11692 0 : next_after_fail1829:;
11693 : }
11694 : }
11695 0 : break;
11696 : }
11697 1635495 : default:;
11698 : }
11699 1635495 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
11700 : {
11701 30 : {
11702 30 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
11703 30 : tree res = generic_simplify_574 (loc, type, _p0, _p1, captures, UNLE_EXPR);
11704 30 : if (res) return res;
11705 : }
11706 : }
11707 1635465 : switch (TREE_CODE (_p0))
11708 : {
11709 96 : case FLOAT_EXPR:
11710 96 : {
11711 96 : tree _q20 = TREE_OPERAND (_p0, 0);
11712 96 : switch (TREE_CODE (_p1))
11713 : {
11714 0 : case FLOAT_EXPR:
11715 0 : {
11716 0 : tree _q40 = TREE_OPERAND (_p1, 0);
11717 0 : {
11718 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11719 0 : tree res = generic_simplify_267 (loc, type, _p0, _p1, captures, UNLE_EXPR, LE_EXPR);
11720 0 : if (res) return res;
11721 : }
11722 0 : break;
11723 : }
11724 : default:;
11725 : }
11726 : break;
11727 : }
11728 112 : case NEGATE_EXPR:
11729 112 : {
11730 112 : tree _q20 = TREE_OPERAND (_p0, 0);
11731 112 : switch (TREE_CODE (_p1))
11732 : {
11733 0 : case NEGATE_EXPR:
11734 0 : {
11735 0 : tree _q40 = TREE_OPERAND (_p1, 0);
11736 0 : {
11737 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
11738 0 : tree res = generic_simplify_270 (loc, type, _p0, _p1, captures, UNLE_EXPR, UNGE_EXPR);
11739 0 : if (res) return res;
11740 : }
11741 0 : break;
11742 : }
11743 112 : default:;
11744 : }
11745 112 : if (CONSTANT_CLASS_P (_p1))
11746 : {
11747 112 : {
11748 112 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
11749 112 : tree res = generic_simplify_271 (loc, type, _p0, _p1, captures, UNLE_EXPR, UNGE_EXPR);
11750 112 : if (res) return res;
11751 : }
11752 : }
11753 : break;
11754 : }
11755 1635353 : default:;
11756 : }
11757 1635353 : switch (TREE_CODE (_p1))
11758 : {
11759 1258541 : case REAL_CST:
11760 1258541 : {
11761 1258541 : {
11762 1258541 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
11763 1258541 : tree res = generic_simplify_572 (loc, type, _p0, _p1, captures, UNLE_EXPR);
11764 1258541 : if (res) return res;
11765 : }
11766 1258539 : break;
11767 : }
11768 : default:;
11769 : }
11770 : return NULL_TREE;
11771 : }
11772 :
11773 : tree
11774 3479176 : 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)
11775 : {
11776 3479176 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
11777 3479176 : switch (TREE_CODE (_p0))
11778 : {
11779 362875 : case LE_EXPR:
11780 362875 : {
11781 362875 : tree _q20 = TREE_OPERAND (_p0, 0);
11782 362875 : tree _q21 = TREE_OPERAND (_p0, 1);
11783 362875 : switch (TREE_CODE (_q20))
11784 : {
11785 90 : case POINTER_PLUS_EXPR:
11786 90 : {
11787 90 : tree _q30 = TREE_OPERAND (_q20, 0);
11788 90 : tree _q31 = TREE_OPERAND (_q20, 1);
11789 90 : switch (TREE_CODE (_q31))
11790 : {
11791 2 : case INTEGER_CST:
11792 2 : {
11793 2 : switch (TREE_CODE (_p1))
11794 : {
11795 2 : case LE_EXPR:
11796 2 : {
11797 2 : tree _q70 = TREE_OPERAND (_p1, 0);
11798 2 : tree _q71 = TREE_OPERAND (_p1, 1);
11799 2 : switch (TREE_CODE (_q70))
11800 : {
11801 2 : case POINTER_PLUS_EXPR:
11802 2 : {
11803 2 : tree _q80 = TREE_OPERAND (_q70, 0);
11804 2 : tree _q81 = TREE_OPERAND (_q70, 1);
11805 2 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
11806 : {
11807 2 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
11808 : {
11809 2 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
11810 : {
11811 2 : {
11812 2 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70 };
11813 2 : const enum tree_code cmp = LE_EXPR;
11814 2 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11815 1 : && TYPE_OVERFLOW_WRAPS (sizetype)
11816 3 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11817 : )
11818 : {
11819 1 : {
11820 1 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11821 1 : offset_int rhs = off * 2;
11822 1 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11823 : )
11824 : {
11825 1 : {
11826 1 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11827 1 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11828 1 : if (cmp == LT_EXPR
11829 : )
11830 : {
11831 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1843;
11832 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1843;
11833 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1843;
11834 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1843;
11835 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1843;
11836 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1843;
11837 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1843;
11838 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1843;
11839 : {
11840 : tree res_op0;
11841 : {
11842 : tree _o1[1], _r1;
11843 : {
11844 : tree _o2[2], _r2;
11845 : _o2[0] = swap_p ? captures[6] : captures[1];
11846 : _o2[1] = swap_p ? captures[2] : captures[4];
11847 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11848 : _o1[0] = _r2;
11849 : }
11850 : if (TREE_TYPE (_o1[0]) != sizetype)
11851 : {
11852 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11853 : }
11854 : else
11855 : _r1 = _o1[0];
11856 : res_op0 = _r1;
11857 : }
11858 : tree res_op1;
11859 : res_op1 = rhs_tree;
11860 : tree _r;
11861 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11862 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 956, __FILE__, __LINE__, true);
11863 1 : return _r;
11864 : }
11865 : next_after_fail1843:;
11866 : }
11867 : else
11868 : {
11869 1 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1844;
11870 1 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1844;
11871 1 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1844;
11872 1 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1844;
11873 1 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1844;
11874 1 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1844;
11875 1 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1844;
11876 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1844;
11877 1 : {
11878 1 : tree res_op0;
11879 1 : {
11880 1 : tree _o1[1], _r1;
11881 1 : {
11882 1 : tree _o2[2], _r2;
11883 1 : {
11884 1 : tree _o3[2], _r3;
11885 1 : _o3[0] = swap_p ? captures[4] : captures[2];
11886 1 : _o3[1] = wide_int_to_tree (sizetype, off);
11887 1 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11888 1 : _o2[0] = _r3;
11889 : }
11890 1 : _o2[1] = swap_p ? captures[2] : captures[4];
11891 1 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11892 1 : _o1[0] = _r2;
11893 : }
11894 1 : if (TREE_TYPE (_o1[0]) != sizetype)
11895 : {
11896 1 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11897 : }
11898 : else
11899 : _r1 = _o1[0];
11900 1 : res_op0 = _r1;
11901 : }
11902 1 : tree res_op1;
11903 1 : res_op1 = rhs_tree;
11904 1 : tree _r;
11905 1 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11906 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 957, __FILE__, __LINE__, true);
11907 1 : return _r;
11908 : }
11909 0 : next_after_fail1844:;
11910 : }
11911 : }
11912 : }
11913 : }
11914 : }
11915 : }
11916 : }
11917 : }
11918 : }
11919 : break;
11920 : }
11921 : default:;
11922 : }
11923 : break;
11924 : }
11925 0 : case GE_EXPR:
11926 0 : {
11927 0 : tree _q70 = TREE_OPERAND (_p1, 0);
11928 0 : tree _q71 = TREE_OPERAND (_p1, 1);
11929 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
11930 : {
11931 0 : switch (TREE_CODE (_q71))
11932 : {
11933 0 : case POINTER_PLUS_EXPR:
11934 0 : {
11935 0 : tree _q90 = TREE_OPERAND (_q71, 0);
11936 0 : tree _q91 = TREE_OPERAND (_q71, 1);
11937 0 : if ((_q90 == _q21 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q21, 0) && types_match (_q90, _q21)))
11938 : {
11939 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
11940 : {
11941 0 : {
11942 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q71 };
11943 0 : const enum tree_code cmp = LE_EXPR;
11944 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11945 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
11946 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11947 : )
11948 : {
11949 0 : {
11950 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11951 0 : offset_int rhs = off * 2;
11952 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11953 : )
11954 : {
11955 0 : {
11956 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11957 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11958 0 : if (cmp == LT_EXPR
11959 : )
11960 : {
11961 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1845;
11962 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1845;
11963 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1845;
11964 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1845;
11965 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1845;
11966 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1845;
11967 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1845;
11968 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1845;
11969 : {
11970 : tree res_op0;
11971 : {
11972 : tree _o1[1], _r1;
11973 : {
11974 : tree _o2[2], _r2;
11975 : _o2[0] = swap_p ? captures[6] : captures[1];
11976 : _o2[1] = swap_p ? captures[2] : captures[4];
11977 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11978 : _o1[0] = _r2;
11979 : }
11980 : if (TREE_TYPE (_o1[0]) != sizetype)
11981 : {
11982 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11983 : }
11984 : else
11985 : _r1 = _o1[0];
11986 : res_op0 = _r1;
11987 : }
11988 : tree res_op1;
11989 : res_op1 = rhs_tree;
11990 : tree _r;
11991 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11992 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 956, __FILE__, __LINE__, true);
11993 0 : return _r;
11994 : }
11995 : next_after_fail1845:;
11996 : }
11997 : else
11998 : {
11999 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1846;
12000 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1846;
12001 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1846;
12002 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1846;
12003 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1846;
12004 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1846;
12005 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1846;
12006 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1846;
12007 0 : {
12008 0 : tree res_op0;
12009 0 : {
12010 0 : tree _o1[1], _r1;
12011 0 : {
12012 0 : tree _o2[2], _r2;
12013 0 : {
12014 0 : tree _o3[2], _r3;
12015 0 : _o3[0] = swap_p ? captures[4] : captures[2];
12016 0 : _o3[1] = wide_int_to_tree (sizetype, off);
12017 0 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
12018 0 : _o2[0] = _r3;
12019 : }
12020 0 : _o2[1] = swap_p ? captures[2] : captures[4];
12021 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12022 0 : _o1[0] = _r2;
12023 : }
12024 0 : if (TREE_TYPE (_o1[0]) != sizetype)
12025 : {
12026 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12027 : }
12028 : else
12029 : _r1 = _o1[0];
12030 0 : res_op0 = _r1;
12031 : }
12032 0 : tree res_op1;
12033 0 : res_op1 = rhs_tree;
12034 0 : tree _r;
12035 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12036 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 957, __FILE__, __LINE__, true);
12037 0 : return _r;
12038 : }
12039 0 : next_after_fail1846:;
12040 : }
12041 : }
12042 : }
12043 : }
12044 : }
12045 : }
12046 : }
12047 : }
12048 : break;
12049 : }
12050 : default:;
12051 : }
12052 : }
12053 : break;
12054 : }
12055 : default:;
12056 : }
12057 : break;
12058 : }
12059 : default:;
12060 : }
12061 : break;
12062 : }
12063 : default:;
12064 : }
12065 : break;
12066 : }
12067 781518 : case LT_EXPR:
12068 781518 : {
12069 781518 : tree _q20 = TREE_OPERAND (_p0, 0);
12070 781518 : tree _q21 = TREE_OPERAND (_p0, 1);
12071 781518 : switch (TREE_CODE (_q20))
12072 : {
12073 13 : case POINTER_PLUS_EXPR:
12074 13 : {
12075 13 : tree _q30 = TREE_OPERAND (_q20, 0);
12076 13 : tree _q31 = TREE_OPERAND (_q20, 1);
12077 13 : switch (TREE_CODE (_q31))
12078 : {
12079 7 : case INTEGER_CST:
12080 7 : {
12081 7 : switch (TREE_CODE (_p1))
12082 : {
12083 2 : case LT_EXPR:
12084 2 : {
12085 2 : tree _q70 = TREE_OPERAND (_p1, 0);
12086 2 : tree _q71 = TREE_OPERAND (_p1, 1);
12087 2 : switch (TREE_CODE (_q70))
12088 : {
12089 2 : case POINTER_PLUS_EXPR:
12090 2 : {
12091 2 : tree _q80 = TREE_OPERAND (_q70, 0);
12092 2 : tree _q81 = TREE_OPERAND (_q70, 1);
12093 2 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
12094 : {
12095 2 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
12096 : {
12097 2 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
12098 : {
12099 2 : {
12100 2 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70 };
12101 2 : const enum tree_code cmp = LT_EXPR;
12102 2 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
12103 1 : && TYPE_OVERFLOW_WRAPS (sizetype)
12104 3 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
12105 : )
12106 : {
12107 1 : {
12108 1 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
12109 1 : offset_int rhs = off * 2;
12110 1 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
12111 : )
12112 : {
12113 1 : {
12114 1 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
12115 1 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
12116 1 : if (cmp == LT_EXPR
12117 : )
12118 : {
12119 1 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1847;
12120 1 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1847;
12121 1 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1847;
12122 1 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1847;
12123 1 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1847;
12124 1 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1847;
12125 1 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1847;
12126 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1847;
12127 1 : {
12128 1 : tree res_op0;
12129 1 : {
12130 1 : tree _o1[1], _r1;
12131 1 : {
12132 1 : tree _o2[2], _r2;
12133 1 : _o2[0] = swap_p ? captures[6] : captures[1];
12134 1 : _o2[1] = swap_p ? captures[2] : captures[4];
12135 1 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12136 1 : _o1[0] = _r2;
12137 : }
12138 1 : if (TREE_TYPE (_o1[0]) != sizetype)
12139 : {
12140 1 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12141 : }
12142 : else
12143 : _r1 = _o1[0];
12144 1 : res_op0 = _r1;
12145 : }
12146 1 : tree res_op1;
12147 1 : res_op1 = rhs_tree;
12148 1 : tree _r;
12149 1 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12150 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 956, __FILE__, __LINE__, true);
12151 1 : return _r;
12152 : }
12153 0 : next_after_fail1847:;
12154 : }
12155 : else
12156 : {
12157 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1848;
12158 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1848;
12159 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1848;
12160 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1848;
12161 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1848;
12162 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1848;
12163 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1848;
12164 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1848;
12165 : {
12166 : tree res_op0;
12167 : {
12168 : tree _o1[1], _r1;
12169 : {
12170 : tree _o2[2], _r2;
12171 : {
12172 : tree _o3[2], _r3;
12173 : _o3[0] = swap_p ? captures[4] : captures[2];
12174 : _o3[1] = wide_int_to_tree (sizetype, off);
12175 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
12176 : _o2[0] = _r3;
12177 : }
12178 : _o2[1] = swap_p ? captures[2] : captures[4];
12179 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12180 : _o1[0] = _r2;
12181 : }
12182 : if (TREE_TYPE (_o1[0]) != sizetype)
12183 : {
12184 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12185 : }
12186 : else
12187 : _r1 = _o1[0];
12188 : res_op0 = _r1;
12189 : }
12190 : tree res_op1;
12191 : res_op1 = rhs_tree;
12192 : tree _r;
12193 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12194 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 957, __FILE__, __LINE__, true);
12195 : return _r;
12196 : }
12197 : next_after_fail1848:;
12198 : }
12199 : }
12200 : }
12201 : }
12202 : }
12203 : }
12204 : }
12205 : }
12206 : }
12207 : break;
12208 : }
12209 : default:;
12210 : }
12211 : break;
12212 : }
12213 0 : case GT_EXPR:
12214 0 : {
12215 0 : tree _q70 = TREE_OPERAND (_p1, 0);
12216 0 : tree _q71 = TREE_OPERAND (_p1, 1);
12217 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
12218 : {
12219 0 : switch (TREE_CODE (_q71))
12220 : {
12221 0 : case POINTER_PLUS_EXPR:
12222 0 : {
12223 0 : tree _q90 = TREE_OPERAND (_q71, 0);
12224 0 : tree _q91 = TREE_OPERAND (_q71, 1);
12225 0 : if ((_q90 == _q21 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q21, 0) && types_match (_q90, _q21)))
12226 : {
12227 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
12228 : {
12229 0 : {
12230 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q71 };
12231 0 : const enum tree_code cmp = LT_EXPR;
12232 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
12233 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
12234 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
12235 : )
12236 : {
12237 0 : {
12238 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
12239 0 : offset_int rhs = off * 2;
12240 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
12241 : )
12242 : {
12243 0 : {
12244 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
12245 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
12246 0 : if (cmp == LT_EXPR
12247 : )
12248 : {
12249 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1849;
12250 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1849;
12251 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1849;
12252 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1849;
12253 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1849;
12254 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1849;
12255 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1849;
12256 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1849;
12257 0 : {
12258 0 : tree res_op0;
12259 0 : {
12260 0 : tree _o1[1], _r1;
12261 0 : {
12262 0 : tree _o2[2], _r2;
12263 0 : _o2[0] = swap_p ? captures[6] : captures[1];
12264 0 : _o2[1] = swap_p ? captures[2] : captures[4];
12265 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12266 0 : _o1[0] = _r2;
12267 : }
12268 0 : if (TREE_TYPE (_o1[0]) != sizetype)
12269 : {
12270 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12271 : }
12272 : else
12273 : _r1 = _o1[0];
12274 0 : res_op0 = _r1;
12275 : }
12276 0 : tree res_op1;
12277 0 : res_op1 = rhs_tree;
12278 0 : tree _r;
12279 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12280 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 956, __FILE__, __LINE__, true);
12281 0 : return _r;
12282 : }
12283 0 : next_after_fail1849:;
12284 : }
12285 : else
12286 : {
12287 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1850;
12288 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1850;
12289 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1850;
12290 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1850;
12291 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1850;
12292 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1850;
12293 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1850;
12294 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1850;
12295 : {
12296 : tree res_op0;
12297 : {
12298 : tree _o1[1], _r1;
12299 : {
12300 : tree _o2[2], _r2;
12301 : {
12302 : tree _o3[2], _r3;
12303 : _o3[0] = swap_p ? captures[4] : captures[2];
12304 : _o3[1] = wide_int_to_tree (sizetype, off);
12305 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
12306 : _o2[0] = _r3;
12307 : }
12308 : _o2[1] = swap_p ? captures[2] : captures[4];
12309 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12310 : _o1[0] = _r2;
12311 : }
12312 : if (TREE_TYPE (_o1[0]) != sizetype)
12313 : {
12314 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12315 : }
12316 : else
12317 : _r1 = _o1[0];
12318 : res_op0 = _r1;
12319 : }
12320 : tree res_op1;
12321 : res_op1 = rhs_tree;
12322 : tree _r;
12323 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12324 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 957, __FILE__, __LINE__, true);
12325 : return _r;
12326 : }
12327 : next_after_fail1850:;
12328 : }
12329 : }
12330 : }
12331 : }
12332 : }
12333 : }
12334 : }
12335 : }
12336 : break;
12337 : }
12338 : default:;
12339 : }
12340 : }
12341 : break;
12342 : }
12343 : default:;
12344 : }
12345 : break;
12346 : }
12347 : default:;
12348 : }
12349 : break;
12350 : }
12351 : default:;
12352 : }
12353 : break;
12354 : }
12355 20896 : case GE_EXPR:
12356 20896 : {
12357 20896 : tree _q20 = TREE_OPERAND (_p0, 0);
12358 20896 : tree _q21 = TREE_OPERAND (_p0, 1);
12359 20896 : switch (TREE_CODE (_q21))
12360 : {
12361 0 : case POINTER_PLUS_EXPR:
12362 0 : {
12363 0 : tree _q40 = TREE_OPERAND (_q21, 0);
12364 0 : tree _q41 = TREE_OPERAND (_q21, 1);
12365 0 : switch (TREE_CODE (_q41))
12366 : {
12367 0 : case INTEGER_CST:
12368 0 : {
12369 0 : switch (TREE_CODE (_p1))
12370 : {
12371 0 : case LE_EXPR:
12372 0 : {
12373 0 : tree _q70 = TREE_OPERAND (_p1, 0);
12374 0 : tree _q71 = TREE_OPERAND (_p1, 1);
12375 0 : switch (TREE_CODE (_q70))
12376 : {
12377 0 : case POINTER_PLUS_EXPR:
12378 0 : {
12379 0 : tree _q80 = TREE_OPERAND (_q70, 0);
12380 0 : tree _q81 = TREE_OPERAND (_q70, 1);
12381 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
12382 : {
12383 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
12384 : {
12385 0 : if ((_q71 == _q40 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q40, 0) && types_match (_q71, _q40)))
12386 : {
12387 0 : {
12388 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q70 };
12389 0 : const enum tree_code cmp = LE_EXPR;
12390 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
12391 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
12392 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
12393 : )
12394 : {
12395 0 : {
12396 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
12397 0 : offset_int rhs = off * 2;
12398 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
12399 : )
12400 : {
12401 0 : {
12402 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
12403 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
12404 0 : if (cmp == LT_EXPR
12405 : )
12406 : {
12407 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1851;
12408 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1851;
12409 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1851;
12410 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1851;
12411 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1851;
12412 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1851;
12413 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1851;
12414 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1851;
12415 : {
12416 : tree res_op0;
12417 : {
12418 : tree _o1[1], _r1;
12419 : {
12420 : tree _o2[2], _r2;
12421 : _o2[0] = swap_p ? captures[6] : captures[1];
12422 : _o2[1] = swap_p ? captures[2] : captures[4];
12423 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12424 : _o1[0] = _r2;
12425 : }
12426 : if (TREE_TYPE (_o1[0]) != sizetype)
12427 : {
12428 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12429 : }
12430 : else
12431 : _r1 = _o1[0];
12432 : res_op0 = _r1;
12433 : }
12434 : tree res_op1;
12435 : res_op1 = rhs_tree;
12436 : tree _r;
12437 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12438 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 956, __FILE__, __LINE__, true);
12439 0 : return _r;
12440 : }
12441 : next_after_fail1851:;
12442 : }
12443 : else
12444 : {
12445 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1852;
12446 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1852;
12447 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1852;
12448 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1852;
12449 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1852;
12450 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1852;
12451 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1852;
12452 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1852;
12453 0 : {
12454 0 : tree res_op0;
12455 0 : {
12456 0 : tree _o1[1], _r1;
12457 0 : {
12458 0 : tree _o2[2], _r2;
12459 0 : {
12460 0 : tree _o3[2], _r3;
12461 0 : _o3[0] = swap_p ? captures[4] : captures[2];
12462 0 : _o3[1] = wide_int_to_tree (sizetype, off);
12463 0 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
12464 0 : _o2[0] = _r3;
12465 : }
12466 0 : _o2[1] = swap_p ? captures[2] : captures[4];
12467 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12468 0 : _o1[0] = _r2;
12469 : }
12470 0 : if (TREE_TYPE (_o1[0]) != sizetype)
12471 : {
12472 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12473 : }
12474 : else
12475 : _r1 = _o1[0];
12476 0 : res_op0 = _r1;
12477 : }
12478 0 : tree res_op1;
12479 0 : res_op1 = rhs_tree;
12480 0 : tree _r;
12481 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12482 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 957, __FILE__, __LINE__, true);
12483 0 : return _r;
12484 : }
12485 0 : next_after_fail1852:;
12486 : }
12487 : }
12488 : }
12489 : }
12490 : }
12491 : }
12492 : }
12493 : }
12494 : }
12495 : break;
12496 : }
12497 : default:;
12498 : }
12499 : break;
12500 : }
12501 0 : case GE_EXPR:
12502 0 : {
12503 0 : tree _q70 = TREE_OPERAND (_p1, 0);
12504 0 : tree _q71 = TREE_OPERAND (_p1, 1);
12505 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
12506 : {
12507 0 : switch (TREE_CODE (_q71))
12508 : {
12509 0 : case POINTER_PLUS_EXPR:
12510 0 : {
12511 0 : tree _q90 = TREE_OPERAND (_q71, 0);
12512 0 : tree _q91 = TREE_OPERAND (_q71, 1);
12513 0 : if ((_q90 == _q20 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q20, 0) && types_match (_q90, _q20)))
12514 : {
12515 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
12516 : {
12517 0 : {
12518 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q71 };
12519 0 : const enum tree_code cmp = LE_EXPR;
12520 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
12521 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
12522 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
12523 : )
12524 : {
12525 0 : {
12526 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
12527 0 : offset_int rhs = off * 2;
12528 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
12529 : )
12530 : {
12531 0 : {
12532 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
12533 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
12534 0 : if (cmp == LT_EXPR
12535 : )
12536 : {
12537 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1853;
12538 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1853;
12539 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1853;
12540 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1853;
12541 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1853;
12542 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1853;
12543 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1853;
12544 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1853;
12545 : {
12546 : tree res_op0;
12547 : {
12548 : tree _o1[1], _r1;
12549 : {
12550 : tree _o2[2], _r2;
12551 : _o2[0] = swap_p ? captures[6] : captures[1];
12552 : _o2[1] = swap_p ? captures[2] : captures[4];
12553 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12554 : _o1[0] = _r2;
12555 : }
12556 : if (TREE_TYPE (_o1[0]) != sizetype)
12557 : {
12558 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12559 : }
12560 : else
12561 : _r1 = _o1[0];
12562 : res_op0 = _r1;
12563 : }
12564 : tree res_op1;
12565 : res_op1 = rhs_tree;
12566 : tree _r;
12567 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12568 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 956, __FILE__, __LINE__, true);
12569 0 : return _r;
12570 : }
12571 : next_after_fail1853:;
12572 : }
12573 : else
12574 : {
12575 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1854;
12576 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1854;
12577 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1854;
12578 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1854;
12579 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1854;
12580 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1854;
12581 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1854;
12582 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1854;
12583 0 : {
12584 0 : tree res_op0;
12585 0 : {
12586 0 : tree _o1[1], _r1;
12587 0 : {
12588 0 : tree _o2[2], _r2;
12589 0 : {
12590 0 : tree _o3[2], _r3;
12591 0 : _o3[0] = swap_p ? captures[4] : captures[2];
12592 0 : _o3[1] = wide_int_to_tree (sizetype, off);
12593 0 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
12594 0 : _o2[0] = _r3;
12595 : }
12596 0 : _o2[1] = swap_p ? captures[2] : captures[4];
12597 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12598 0 : _o1[0] = _r2;
12599 : }
12600 0 : if (TREE_TYPE (_o1[0]) != sizetype)
12601 : {
12602 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12603 : }
12604 : else
12605 : _r1 = _o1[0];
12606 0 : res_op0 = _r1;
12607 : }
12608 0 : tree res_op1;
12609 0 : res_op1 = rhs_tree;
12610 0 : tree _r;
12611 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12612 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 957, __FILE__, __LINE__, true);
12613 0 : return _r;
12614 : }
12615 0 : next_after_fail1854:;
12616 : }
12617 : }
12618 : }
12619 : }
12620 : }
12621 : }
12622 : }
12623 : }
12624 : break;
12625 : }
12626 : default:;
12627 : }
12628 : }
12629 : break;
12630 : }
12631 : default:;
12632 : }
12633 : break;
12634 : }
12635 : default:;
12636 : }
12637 : break;
12638 : }
12639 : default:;
12640 : }
12641 : break;
12642 : }
12643 124138 : case GT_EXPR:
12644 124138 : {
12645 124138 : tree _q20 = TREE_OPERAND (_p0, 0);
12646 124138 : tree _q21 = TREE_OPERAND (_p0, 1);
12647 124138 : switch (TREE_CODE (_q21))
12648 : {
12649 0 : case POINTER_PLUS_EXPR:
12650 0 : {
12651 0 : tree _q40 = TREE_OPERAND (_q21, 0);
12652 0 : tree _q41 = TREE_OPERAND (_q21, 1);
12653 0 : switch (TREE_CODE (_q41))
12654 : {
12655 0 : case INTEGER_CST:
12656 0 : {
12657 0 : switch (TREE_CODE (_p1))
12658 : {
12659 0 : case LT_EXPR:
12660 0 : {
12661 0 : tree _q70 = TREE_OPERAND (_p1, 0);
12662 0 : tree _q71 = TREE_OPERAND (_p1, 1);
12663 0 : switch (TREE_CODE (_q70))
12664 : {
12665 0 : case POINTER_PLUS_EXPR:
12666 0 : {
12667 0 : tree _q80 = TREE_OPERAND (_q70, 0);
12668 0 : tree _q81 = TREE_OPERAND (_q70, 1);
12669 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
12670 : {
12671 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
12672 : {
12673 0 : if ((_q71 == _q40 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q40, 0) && types_match (_q71, _q40)))
12674 : {
12675 0 : {
12676 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q70 };
12677 0 : const enum tree_code cmp = LT_EXPR;
12678 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
12679 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
12680 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
12681 : )
12682 : {
12683 0 : {
12684 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
12685 0 : offset_int rhs = off * 2;
12686 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
12687 : )
12688 : {
12689 0 : {
12690 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
12691 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
12692 0 : if (cmp == LT_EXPR
12693 : )
12694 : {
12695 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1855;
12696 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1855;
12697 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1855;
12698 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1855;
12699 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1855;
12700 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1855;
12701 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1855;
12702 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1855;
12703 0 : {
12704 0 : tree res_op0;
12705 0 : {
12706 0 : tree _o1[1], _r1;
12707 0 : {
12708 0 : tree _o2[2], _r2;
12709 0 : _o2[0] = swap_p ? captures[6] : captures[1];
12710 0 : _o2[1] = swap_p ? captures[2] : captures[4];
12711 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12712 0 : _o1[0] = _r2;
12713 : }
12714 0 : if (TREE_TYPE (_o1[0]) != sizetype)
12715 : {
12716 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12717 : }
12718 : else
12719 : _r1 = _o1[0];
12720 0 : res_op0 = _r1;
12721 : }
12722 0 : tree res_op1;
12723 0 : res_op1 = rhs_tree;
12724 0 : tree _r;
12725 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12726 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 956, __FILE__, __LINE__, true);
12727 0 : return _r;
12728 : }
12729 0 : next_after_fail1855:;
12730 : }
12731 : else
12732 : {
12733 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1856;
12734 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1856;
12735 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1856;
12736 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1856;
12737 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1856;
12738 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1856;
12739 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1856;
12740 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1856;
12741 : {
12742 : tree res_op0;
12743 : {
12744 : tree _o1[1], _r1;
12745 : {
12746 : tree _o2[2], _r2;
12747 : {
12748 : tree _o3[2], _r3;
12749 : _o3[0] = swap_p ? captures[4] : captures[2];
12750 : _o3[1] = wide_int_to_tree (sizetype, off);
12751 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
12752 : _o2[0] = _r3;
12753 : }
12754 : _o2[1] = swap_p ? captures[2] : captures[4];
12755 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12756 : _o1[0] = _r2;
12757 : }
12758 : if (TREE_TYPE (_o1[0]) != sizetype)
12759 : {
12760 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12761 : }
12762 : else
12763 : _r1 = _o1[0];
12764 : res_op0 = _r1;
12765 : }
12766 : tree res_op1;
12767 : res_op1 = rhs_tree;
12768 : tree _r;
12769 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12770 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 957, __FILE__, __LINE__, true);
12771 : return _r;
12772 : }
12773 : next_after_fail1856:;
12774 : }
12775 : }
12776 : }
12777 : }
12778 : }
12779 : }
12780 : }
12781 : }
12782 : }
12783 : break;
12784 : }
12785 : default:;
12786 : }
12787 : break;
12788 : }
12789 0 : case GT_EXPR:
12790 0 : {
12791 0 : tree _q70 = TREE_OPERAND (_p1, 0);
12792 0 : tree _q71 = TREE_OPERAND (_p1, 1);
12793 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
12794 : {
12795 0 : switch (TREE_CODE (_q71))
12796 : {
12797 0 : case POINTER_PLUS_EXPR:
12798 0 : {
12799 0 : tree _q90 = TREE_OPERAND (_q71, 0);
12800 0 : tree _q91 = TREE_OPERAND (_q71, 1);
12801 0 : if ((_q90 == _q20 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q20, 0) && types_match (_q90, _q20)))
12802 : {
12803 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
12804 : {
12805 0 : {
12806 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q71 };
12807 0 : const enum tree_code cmp = LT_EXPR;
12808 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
12809 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
12810 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
12811 : )
12812 : {
12813 0 : {
12814 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
12815 0 : offset_int rhs = off * 2;
12816 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
12817 : )
12818 : {
12819 0 : {
12820 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
12821 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
12822 0 : if (cmp == LT_EXPR
12823 : )
12824 : {
12825 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1857;
12826 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1857;
12827 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1857;
12828 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1857;
12829 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1857;
12830 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1857;
12831 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1857;
12832 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1857;
12833 0 : {
12834 0 : tree res_op0;
12835 0 : {
12836 0 : tree _o1[1], _r1;
12837 0 : {
12838 0 : tree _o2[2], _r2;
12839 0 : _o2[0] = swap_p ? captures[6] : captures[1];
12840 0 : _o2[1] = swap_p ? captures[2] : captures[4];
12841 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12842 0 : _o1[0] = _r2;
12843 : }
12844 0 : if (TREE_TYPE (_o1[0]) != sizetype)
12845 : {
12846 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12847 : }
12848 : else
12849 : _r1 = _o1[0];
12850 0 : res_op0 = _r1;
12851 : }
12852 0 : tree res_op1;
12853 0 : res_op1 = rhs_tree;
12854 0 : tree _r;
12855 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12856 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 956, __FILE__, __LINE__, true);
12857 0 : return _r;
12858 : }
12859 0 : next_after_fail1857:;
12860 : }
12861 : else
12862 : {
12863 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1858;
12864 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1858;
12865 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1858;
12866 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1858;
12867 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1858;
12868 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1858;
12869 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1858;
12870 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1858;
12871 : {
12872 : tree res_op0;
12873 : {
12874 : tree _o1[1], _r1;
12875 : {
12876 : tree _o2[2], _r2;
12877 : {
12878 : tree _o3[2], _r3;
12879 : _o3[0] = swap_p ? captures[4] : captures[2];
12880 : _o3[1] = wide_int_to_tree (sizetype, off);
12881 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
12882 : _o2[0] = _r3;
12883 : }
12884 : _o2[1] = swap_p ? captures[2] : captures[4];
12885 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12886 : _o1[0] = _r2;
12887 : }
12888 : if (TREE_TYPE (_o1[0]) != sizetype)
12889 : {
12890 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12891 : }
12892 : else
12893 : _r1 = _o1[0];
12894 : res_op0 = _r1;
12895 : }
12896 : tree res_op1;
12897 : res_op1 = rhs_tree;
12898 : tree _r;
12899 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12900 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 957, __FILE__, __LINE__, true);
12901 : return _r;
12902 : }
12903 : next_after_fail1858:;
12904 : }
12905 : }
12906 : }
12907 : }
12908 : }
12909 : }
12910 : }
12911 : }
12912 : break;
12913 : }
12914 : default:;
12915 : }
12916 : }
12917 : break;
12918 : }
12919 : default:;
12920 : }
12921 : break;
12922 : }
12923 : default:;
12924 : }
12925 : break;
12926 : }
12927 : default:;
12928 : }
12929 : break;
12930 : }
12931 : default:;
12932 : }
12933 : return NULL_TREE;
12934 : }
12935 : #pragma GCC diagnostic pop
|
