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 106611180 : tree_maybe_cmp (tree t, tree *res_ops)
11 : {
12 106611180 : const tree type = TREE_TYPE (t);
13 106611180 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 106611180 : if (TREE_SIDE_EFFECTS (t)) return false;
15 106611180 : switch (TREE_CODE (t))
16 : {
17 449330 : case LT_EXPR:
18 449330 : case LE_EXPR:
19 449330 : case EQ_EXPR:
20 449330 : case NE_EXPR:
21 449330 : case GE_EXPR:
22 449330 : case GT_EXPR:
23 449330 : case UNORDERED_EXPR:
24 449330 : case ORDERED_EXPR:
25 449330 : case UNLT_EXPR:
26 449330 : case UNLE_EXPR:
27 449330 : case UNGT_EXPR:
28 449330 : case UNGE_EXPR:
29 449330 : case UNEQ_EXPR:
30 449330 : case LTGT_EXPR:
31 449330 : {
32 449330 : tree _p0 = TREE_OPERAND (t, 0);
33 449330 : tree _p1 = TREE_OPERAND (t, 1);
34 449330 : {
35 449330 : tree captures[3] ATTRIBUTE_UNUSED = { t, _p0, _p1 };
36 449330 : {
37 449330 : res_ops[0] = captures[0];
38 449330 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 5, __FILE__, __LINE__, false);
39 449330 : return true;
40 : }
41 : }
42 21151126 : break;
43 : }
44 21151126 : CASE_CONVERT:
45 21151126 : {
46 21151126 : tree _p0 = TREE_OPERAND (t, 0);
47 21151126 : switch (TREE_CODE (_p0))
48 : {
49 1437 : case LT_EXPR:
50 1437 : case LE_EXPR:
51 1437 : case EQ_EXPR:
52 1437 : case NE_EXPR:
53 1437 : case GE_EXPR:
54 1437 : case GT_EXPR:
55 1437 : case UNORDERED_EXPR:
56 1437 : case ORDERED_EXPR:
57 1437 : case UNLT_EXPR:
58 1437 : case UNLE_EXPR:
59 1437 : case UNGT_EXPR:
60 1437 : case UNGE_EXPR:
61 1437 : case UNEQ_EXPR:
62 1437 : case LTGT_EXPR:
63 1437 : {
64 1437 : tree _q20 = TREE_OPERAND (_p0, 0);
65 1437 : tree _q21 = TREE_OPERAND (_p0, 1);
66 1437 : {
67 1437 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
68 1437 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
69 : )
70 : {
71 774 : {
72 774 : res_ops[0] = captures[0];
73 774 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 6, __FILE__, __LINE__, false);
74 774 : return true;
75 : }
76 : }
77 : }
78 : break;
79 : }
80 : default:;
81 : }
82 : break;
83 : }
84 178272 : case BIT_XOR_EXPR:
85 178272 : {
86 178272 : tree _p0 = TREE_OPERAND (t, 0);
87 178272 : tree _p1 = TREE_OPERAND (t, 1);
88 178272 : {
89 178272 : tree captures[3] ATTRIBUTE_UNUSED = { t, _p0, _p1 };
90 178272 : if (INTEGRAL_TYPE_P (type)
91 178272 : && TYPE_PRECISION (type) == 1
92 : )
93 : {
94 86274 : {
95 86274 : res_ops[0] = captures[0];
96 86274 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 7, __FILE__, __LINE__, false);
97 86274 : return true;
98 : }
99 : }
100 : }
101 : break;
102 : }
103 : default:;
104 : }
105 : return false;
106 : }
107 :
108 : bool
109 0 : tree_float_value_p (tree t)
110 : {
111 0 : const tree type = TREE_TYPE (t);
112 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
113 0 : if (TREE_SIDE_EFFECTS (t)) return false;
114 0 : {
115 0 : tree captures[1] ATTRIBUTE_UNUSED = { t };
116 0 : if (TYPE_MAIN_VARIANT (TREE_TYPE (captures[0])) == float_type_node
117 : )
118 : {
119 0 : {
120 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 45, __FILE__, __LINE__, false);
121 0 : return true;
122 : }
123 : }
124 : }
125 : return false;
126 : }
127 :
128 : tree
129 0 : generic_simplify_7 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
130 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
131 : {
132 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
133 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail78;
134 0 : {
135 0 : tree res_op0;
136 0 : res_op0 = captures[1];
137 0 : tree res_op1;
138 0 : res_op1 = captures[2];
139 0 : tree _r;
140 0 : _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
141 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 55, __FILE__, __LINE__, true);
142 : return _r;
143 : }
144 0 : next_after_fail78:;
145 0 : return NULL_TREE;
146 : }
147 :
148 : tree
149 196 : generic_simplify_13 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
150 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
151 : {
152 196 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
153 196 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail88;
154 196 : {
155 196 : if (! tree_invariant_p (captures[3])) goto next_after_fail88;
156 15 : tree res_op0;
157 15 : {
158 15 : tree _o1[2], _r1;
159 15 : _o1[0] = captures[2];
160 15 : _o1[1] = unshare_expr (captures[3]);
161 15 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
162 15 : res_op0 = _r1;
163 : }
164 15 : tree res_op1;
165 15 : {
166 15 : tree _o1[2], _r1;
167 15 : _o1[0] = captures[4];
168 15 : _o1[1] = captures[3];
169 15 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
170 15 : if (EXPR_P (_r1))
171 14 : goto next_after_fail88;
172 1 : res_op1 = _r1;
173 : }
174 1 : tree _r;
175 1 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
176 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 61, __FILE__, __LINE__, true);
177 : return _r;
178 : }
179 : next_after_fail88:;
180 : return NULL_TREE;
181 : }
182 :
183 : tree
184 11 : generic_simplify_23 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
185 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
186 : {
187 11 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
188 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail98;
189 11 : {
190 11 : tree res_op0;
191 11 : res_op0 = captures[0];
192 11 : tree _r;
193 11 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
194 11 : if (TREE_SIDE_EFFECTS (captures[2]))
195 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
196 11 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 71, __FILE__, __LINE__, true);
197 : return _r;
198 : }
199 0 : next_after_fail98:;
200 0 : return NULL_TREE;
201 : }
202 :
203 : tree
204 1970452 : generic_simplify_31 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
205 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
206 : const enum tree_code ARG_UNUSED (bitop))
207 : {
208 1970452 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
209 1970452 : if (((TREE_CODE (captures[3]) == INTEGER_CST
210 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
211 0 : && (int_fits_type_p (captures[3], TREE_TYPE (captures[1]))
212 0 : || tree_nop_conversion_p (TREE_TYPE (captures[1]), type)))
213 1970452 : || types_match (captures[1], captures[3]))
214 1838003 : && !POINTER_TYPE_P (TREE_TYPE (captures[1]))
215 1837740 : && !VECTOR_TYPE_P (TREE_TYPE (captures[1]))
216 1837677 : && TREE_CODE (TREE_TYPE (captures[1])) != OFFSET_TYPE
217 1837677 : && (bitop != BIT_AND_EXPR ||
218 :
219 : )
220 1970452 : && (
221 1070026 : TYPE_PRECISION (TREE_TYPE (captures[1])) < TYPE_PRECISION (type)
222 : || (
223 :
224 : && TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (type))
225 982724 : || GET_MODE_CLASS (TYPE_MODE (type)) != MODE_INT
226 982724 : || !type_has_mode_precision_p (type)
227 982724 : || (
228 :
229 : && TREE_CODE (captures[3]) != INTEGER_CST
230 : && tree_nop_conversion_p (type, TREE_TYPE (captures[1]))
231 : && single_use (captures[0])
232 : && single_use (captures[2])))
233 : )
234 : {
235 87302 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail106;
236 87302 : {
237 87302 : tree res_op0;
238 87302 : {
239 87302 : tree _o1[2], _r1;
240 87302 : _o1[0] = captures[1];
241 87302 : {
242 87302 : tree _o2[1], _r2;
243 87302 : _o2[0] = captures[3];
244 87302 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
245 : {
246 50184 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
247 : }
248 : else
249 : _r2 = _o2[0];
250 87302 : _o1[1] = _r2;
251 : }
252 87302 : _r1 = fold_build2_loc (loc, bitop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
253 87302 : res_op0 = _r1;
254 : }
255 87302 : tree _r;
256 87302 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
257 87302 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 79, __FILE__, __LINE__, true);
258 87302 : return _r;
259 : }
260 0 : next_after_fail106:;
261 : }
262 : return NULL_TREE;
263 : }
264 :
265 : tree
266 2 : generic_simplify_45 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
267 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
268 : {
269 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
270 2 : if (INTEGRAL_TYPE_P (type)
271 2 : && (
272 :
273 2 : || !TREE_SIDE_EFFECTS (captures[1]))
274 : )
275 : {
276 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail123;
277 2 : {
278 2 : tree res_op0;
279 2 : {
280 2 : tree _o1[1], _r1;
281 2 : _o1[0] = captures[2];
282 2 : if (TREE_TYPE (_o1[0]) != boolean_type_node)
283 : {
284 2 : _r1 = fold_build1_loc (loc, NOP_EXPR, boolean_type_node, _o1[0]);
285 : }
286 : else
287 : _r1 = _o1[0];
288 2 : res_op0 = _r1;
289 : }
290 2 : tree res_op1;
291 2 : res_op1 = captures[1];
292 2 : tree res_op2;
293 2 : res_op2 = captures[0];
294 2 : tree _r;
295 2 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
296 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 91, __FILE__, __LINE__, true);
297 2 : return _r;
298 : }
299 0 : next_after_fail123:;
300 : }
301 : return NULL_TREE;
302 : }
303 :
304 : tree
305 11 : generic_simplify_51 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
306 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
307 : const combined_fn ARG_UNUSED (PARITY))
308 : {
309 11 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
310 11 : if (types_match (TREE_TYPE (captures[1]), TREE_TYPE (captures[3]))
311 : )
312 : {
313 10 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail130;
314 10 : {
315 10 : tree res_op0;
316 10 : {
317 10 : tree _o1[2], _r1;
318 10 : _o1[0] = captures[1];
319 10 : _o1[1] = captures[3];
320 10 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
321 10 : res_op0 = _r1;
322 : }
323 10 : tree _r;
324 10 : _r = maybe_build_call_expr_loc (loc, PARITY, type, 1, res_op0);
325 10 : if (!_r)
326 0 : goto next_after_fail130;
327 10 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 98, __FILE__, __LINE__, true);
328 10 : return _r;
329 : }
330 : next_after_fail130:;
331 : }
332 : else
333 : {
334 2 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
335 2 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[3]))
336 : )
337 : {
338 1 : {
339 1 : tree utype = TREE_TYPE (captures[1]);
340 1 : if (TYPE_PRECISION (utype) < TYPE_PRECISION (TREE_TYPE (captures[3])))
341 1 : utype = TREE_TYPE (captures[3]);
342 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail131;
343 1 : {
344 1 : tree res_op0;
345 1 : {
346 1 : tree _o1[2], _r1;
347 1 : {
348 1 : tree _o2[1], _r2;
349 1 : _o2[0] = captures[1];
350 1 : if (TREE_TYPE (_o2[0]) != utype)
351 : {
352 1 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
353 : }
354 : else
355 : _r2 = _o2[0];
356 1 : _o1[0] = _r2;
357 : }
358 1 : {
359 1 : tree _o2[1], _r2;
360 1 : _o2[0] = captures[3];
361 1 : if (TREE_TYPE (_o2[0]) != utype)
362 : {
363 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
364 : }
365 : else
366 : _r2 = _o2[0];
367 1 : _o1[1] = _r2;
368 : }
369 1 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
370 1 : res_op0 = _r1;
371 : }
372 1 : tree _r;
373 1 : _r = maybe_build_call_expr_loc (loc, PARITY, type, 1, res_op0);
374 1 : if (!_r)
375 1 : goto next_after_fail131;
376 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 99, __FILE__, __LINE__, true);
377 0 : return _r;
378 : }
379 : next_after_fail131:;
380 : }
381 : }
382 : }
383 : return NULL_TREE;
384 : }
385 :
386 : tree
387 112523 : generic_simplify_68 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
388 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
389 : {
390 112523 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
391 112523 : if (!TYPE_SATURATING (type)
392 : )
393 : {
394 112523 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
395 225046 : && !FIXED_POINT_TYPE_P (type)
396 : )
397 : {
398 112523 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
399 : )
400 : {
401 111663 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail157;
402 111663 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail157;
403 111663 : {
404 111663 : tree res_op0;
405 111663 : {
406 111663 : tree _o1[1], _r1;
407 111663 : _o1[0] = captures[0];
408 111663 : if (TREE_TYPE (_o1[0]) != type)
409 : {
410 109034 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
411 : }
412 : else
413 : _r1 = _o1[0];
414 111663 : res_op0 = _r1;
415 : }
416 111663 : tree _r;
417 111663 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
418 111663 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 125, __FILE__, __LINE__, true);
419 111663 : return _r;
420 : }
421 : next_after_fail157:;
422 : }
423 : }
424 : }
425 : return NULL_TREE;
426 : }
427 :
428 : tree
429 56 : generic_simplify_76 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
430 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
431 : const enum tree_code ARG_UNUSED (cmp),
432 : const enum tree_code ARG_UNUSED (icmp),
433 : const enum tree_code ARG_UNUSED (ncmp))
434 : {
435 56 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
436 56 : if (TYPE_PRECISION (type) > 1
437 56 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
438 : )
439 : {
440 0 : {
441 0 : enum tree_code ic = invert_tree_comparison
442 0 : (cmp, HONOR_NANS (captures[1]));
443 0 : tree cmptype = TREE_TYPE (captures[0]);
444 0 : if (ic == icmp
445 : )
446 : {
447 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail166;
448 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail166;
449 0 : {
450 0 : tree res_op0;
451 0 : {
452 0 : tree _o1[1], _r1;
453 0 : {
454 0 : tree _o2[2], _r2;
455 0 : _o2[0] = captures[1];
456 0 : _o2[1] = captures[2];
457 0 : _r2 = fold_build2_loc (loc, icmp, cmptype, _o2[0], _o2[1]);
458 0 : _o1[0] = _r2;
459 : }
460 0 : if (TREE_TYPE (_o1[0]) != type)
461 : {
462 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
463 : }
464 : else
465 : _r1 = _o1[0];
466 0 : res_op0 = _r1;
467 : }
468 0 : tree _r;
469 0 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
470 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 134, __FILE__, __LINE__, true);
471 0 : return _r;
472 : }
473 : next_after_fail166:;
474 : }
475 : else
476 : {
477 0 : if (ic == ncmp
478 : )
479 : {
480 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail167;
481 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail167;
482 0 : {
483 0 : tree res_op0;
484 0 : {
485 0 : tree _o1[1], _r1;
486 0 : {
487 0 : tree _o2[2], _r2;
488 0 : _o2[0] = captures[1];
489 0 : _o2[1] = captures[2];
490 0 : _r2 = fold_build2_loc (loc, ncmp, cmptype, _o2[0], _o2[1]);
491 0 : _o1[0] = _r2;
492 : }
493 0 : if (TREE_TYPE (_o1[0]) != type)
494 : {
495 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
496 : }
497 : else
498 : _r1 = _o1[0];
499 0 : res_op0 = _r1;
500 : }
501 0 : tree _r;
502 0 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
503 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 135, __FILE__, __LINE__, true);
504 0 : return _r;
505 : }
506 : next_after_fail167:;
507 : }
508 : }
509 : }
510 : }
511 : return NULL_TREE;
512 : }
513 :
514 : tree
515 5 : generic_simplify_90 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
516 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
517 : {
518 5 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
519 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail181;
520 5 : {
521 5 : tree res_op0;
522 5 : res_op0 = captures[1];
523 5 : tree res_op1;
524 5 : {
525 5 : tree _o1[1], _r1;
526 5 : _o1[0] = captures[2];
527 5 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
528 5 : res_op1 = _r1;
529 : }
530 5 : tree _r;
531 5 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
532 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 149, __FILE__, __LINE__, true);
533 : return _r;
534 : }
535 0 : next_after_fail181:;
536 0 : return NULL_TREE;
537 : }
538 :
539 : tree
540 339 : generic_simplify_97 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
541 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
542 : {
543 339 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
544 339 : if (!TYPE_SATURATING (type)
545 : )
546 : {
547 339 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
548 678 : && !FIXED_POINT_TYPE_P (type)
549 : )
550 : {
551 339 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail190;
552 339 : {
553 339 : tree res_op0;
554 339 : res_op0 = captures[1];
555 339 : tree _r;
556 339 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
557 339 : if (TREE_SIDE_EFFECTS (captures[0]))
558 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
559 339 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 157, __FILE__, __LINE__, true);
560 339 : return _r;
561 : }
562 0 : next_after_fail190:;
563 : }
564 : }
565 : return NULL_TREE;
566 : }
567 :
568 : tree
569 152644 : generic_simplify_103 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
570 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
571 : {
572 152644 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
573 152644 : if (!TYPE_SATURATING (type)
574 : )
575 : {
576 152644 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
577 305288 : && !FIXED_POINT_TYPE_P (type)
578 : )
579 : {
580 152644 : if (INTEGRAL_TYPE_P (type)
581 152644 : && TYPE_OVERFLOW_UNDEFINED (type)
582 67 : && element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
583 152711 : && element_precision (type) <= element_precision (TREE_TYPE (captures[2]))
584 : )
585 : {
586 67 : {
587 67 : tree utype = unsigned_type_for (type);
588 67 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail199;
589 67 : {
590 67 : tree res_op0;
591 67 : {
592 67 : tree _o1[2], _r1;
593 67 : {
594 67 : tree _o2[1], _r2;
595 67 : _o2[0] = captures[1];
596 67 : if (TREE_TYPE (_o2[0]) != utype)
597 : {
598 52 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
599 : }
600 : else
601 : _r2 = _o2[0];
602 67 : _o1[0] = _r2;
603 : }
604 67 : {
605 67 : tree _o2[1], _r2;
606 67 : _o2[0] = captures[2];
607 67 : if (TREE_TYPE (_o2[0]) != utype)
608 : {
609 52 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
610 : }
611 : else
612 : _r2 = _o2[0];
613 67 : _o1[1] = _r2;
614 : }
615 67 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
616 67 : res_op0 = _r1;
617 : }
618 67 : tree _r;
619 67 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
620 67 : if (TREE_SIDE_EFFECTS (captures[3]))
621 2 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
622 67 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 166, __FILE__, __LINE__, true);
623 67 : return _r;
624 : }
625 0 : next_after_fail199:;
626 : }
627 : }
628 : else
629 : {
630 152577 : if (((element_precision (type) <= element_precision (TREE_TYPE (captures[1])))
631 152577 : == (element_precision (type) <= element_precision (TREE_TYPE (captures[2]))))
632 152577 : && (element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
633 53 : || (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
634 53 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
635 53 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
636 53 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))))
637 : )
638 : {
639 135912 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail200;
640 135912 : {
641 135912 : tree res_op0;
642 135912 : {
643 135912 : tree _o1[1], _r1;
644 135912 : _o1[0] = captures[1];
645 135912 : if (TREE_TYPE (_o1[0]) != type)
646 : {
647 135912 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
648 : }
649 : else
650 : _r1 = _o1[0];
651 135912 : res_op0 = _r1;
652 : }
653 135912 : tree res_op1;
654 135912 : {
655 135912 : tree _o1[1], _r1;
656 135912 : _o1[0] = captures[2];
657 135912 : if (TREE_TYPE (_o1[0]) != type)
658 : {
659 135912 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
660 : }
661 : else
662 : _r1 = _o1[0];
663 135912 : res_op1 = _r1;
664 : }
665 135912 : tree _r;
666 135912 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
667 135912 : if (TREE_SIDE_EFFECTS (captures[3]))
668 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
669 135912 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 167, __FILE__, __LINE__, true);
670 135912 : return _r;
671 : }
672 0 : next_after_fail200:;
673 : }
674 : }
675 : }
676 : }
677 : return NULL_TREE;
678 : }
679 :
680 : tree
681 93 : generic_simplify_131 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
682 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
683 : const enum tree_code ARG_UNUSED (op),
684 : const enum tree_code ARG_UNUSED (rop))
685 : {
686 93 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
687 93 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[0]))
688 93 : && element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
689 : )
690 : {
691 61 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail228;
692 61 : {
693 61 : tree res_op0;
694 61 : {
695 61 : tree _o1[2], _r1;
696 61 : {
697 61 : tree _o2[1], _r2;
698 61 : _o2[0] = captures[0];
699 61 : if (TREE_TYPE (_o2[0]) != type)
700 : {
701 1 : _r2 = fold_build1_loc (loc, NOP_EXPR, type, _o2[0]);
702 : }
703 : else
704 : _r2 = _o2[0];
705 61 : _o1[0] = _r2;
706 : }
707 61 : {
708 61 : tree _o2[1], _r2;
709 61 : _o2[0] = captures[1];
710 61 : if (TREE_TYPE (_o2[0]) != type)
711 : {
712 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, type, _o2[0]);
713 : }
714 : else
715 : _r2 = _o2[0];
716 61 : _o1[1] = _r2;
717 : }
718 61 : _r1 = fold_build2_loc (loc, rop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
719 61 : res_op0 = _r1;
720 : }
721 61 : tree _r;
722 61 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
723 61 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 190, __FILE__, __LINE__, true);
724 61 : return _r;
725 : }
726 0 : next_after_fail228:;
727 : }
728 : return NULL_TREE;
729 : }
730 :
731 : tree
732 700 : generic_simplify_144 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
733 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
734 : const enum tree_code ARG_UNUSED (op))
735 : {
736 700 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
737 700 : if (bitwise_equal_p (captures[4], captures[7])
738 : )
739 : {
740 40 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail245;
741 40 : {
742 40 : tree res_op0;
743 40 : {
744 40 : tree _o1[2], _r1;
745 40 : {
746 40 : tree _o2[2], _r2;
747 40 : _o2[0] = captures[5];
748 40 : {
749 40 : tree _o3[1], _r3;
750 40 : _o3[0] = captures[6];
751 40 : if (TREE_TYPE (_o3[0]) != TREE_TYPE (_o2[0]))
752 : {
753 0 : _r3 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o2[0]), _o3[0]);
754 : }
755 : else
756 : _r3 = _o3[0];
757 40 : _o2[1] = _r3;
758 : }
759 40 : _r2 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
760 40 : _o1[0] = _r2;
761 : }
762 40 : {
763 40 : tree _o2[1], _r2;
764 40 : _o2[0] = captures[4];
765 40 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
766 : {
767 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
768 : }
769 : else
770 : _r2 = _o2[0];
771 40 : _o1[1] = _r2;
772 : }
773 40 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
774 40 : res_op0 = _r1;
775 : }
776 40 : tree _r;
777 40 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
778 40 : if (TREE_SIDE_EFFECTS (captures[7]))
779 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[7]), _r);
780 40 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 198, __FILE__, __LINE__, true);
781 40 : return _r;
782 : }
783 0 : next_after_fail245:;
784 : }
785 : return NULL_TREE;
786 : }
787 :
788 : tree
789 429 : generic_simplify_157 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
790 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
791 : const enum tree_code ARG_UNUSED (code2),
792 : const enum tree_code ARG_UNUSED (code1))
793 : {
794 429 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
795 429 : if ((TREE_CODE (captures[2]) == INTEGER_CST
796 398 : && TREE_CODE (captures[5]) == INTEGER_CST)
797 429 : || ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
798 3 : || (VECTOR_TYPE_P (TREE_TYPE (captures[2])))
799 0 : || POINTER_TYPE_P (TREE_TYPE (captures[2])))
800 31 : && bitwise_equal_p (captures[2], captures[5]))
801 : )
802 : {
803 400 : {
804 400 : bool one_before = false;
805 400 : bool one_after = false;
806 400 : int cmp = 0;
807 400 : bool allbits = true;
808 400 : if (TREE_CODE (captures[2]) == INTEGER_CST
809 398 : && TREE_CODE (captures[5]) == INTEGER_CST)
810 : {
811 398 : allbits = TYPE_PRECISION (TREE_TYPE (captures[2])) <= TYPE_PRECISION (TREE_TYPE (captures[5]));
812 398 : auto t1 = wi::to_wide (fold_convert (TREE_TYPE (captures[5]), captures[2]));
813 398 : auto t2 = wi::to_wide (captures[5]);
814 398 : cmp = wi::cmp (t1, t2, TYPE_SIGN (TREE_TYPE (captures[5])));
815 398 : if (cmp < 0
816 398 : && t1 == t2 - 1)
817 : one_before = true;
818 398 : if (cmp > 0
819 398 : && t1 == t2 + 1)
820 : one_after = true;
821 : }
822 400 : bool val;
823 400 : switch (code2)
824 : {
825 384 : case EQ_EXPR: val = (cmp == 0); break;
826 0 : case NE_EXPR: val = (cmp != 0); break;
827 2 : case LT_EXPR: val = (cmp < 0); break;
828 0 : case GT_EXPR: val = (cmp > 0); break;
829 14 : case LE_EXPR: val = (cmp <= 0); break;
830 0 : case GE_EXPR: val = (cmp >= 0); break;
831 0 : default: gcc_unreachable ();
832 : }
833 400 : if (code1 == EQ_EXPR && val
834 : )
835 : {
836 7 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail268;
837 7 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail268;
838 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail268;
839 7 : {
840 7 : tree _r;
841 7 : _r = captures[3];
842 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 210, __FILE__, __LINE__, true);
843 7 : return _r;
844 : }
845 : next_after_fail268:;
846 : }
847 : else
848 : {
849 393 : if (code1 == NE_EXPR && val && allbits
850 : )
851 : {
852 7 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail269;
853 7 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail269;
854 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail269;
855 7 : {
856 7 : tree _r;
857 7 : _r = constant_boolean_node (true, type);
858 7 : if (TREE_SIDE_EFFECTS (captures[4]))
859 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
860 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 211, __FILE__, __LINE__, true);
861 7 : return _r;
862 : }
863 : next_after_fail269:;
864 : }
865 : else
866 : {
867 386 : if (code1 == NE_EXPR && !val && allbits
868 : )
869 : {
870 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail270;
871 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail270;
872 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail270;
873 0 : {
874 0 : tree _r;
875 0 : _r = captures[0];
876 0 : if (TREE_SIDE_EFFECTS (captures[4]))
877 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
878 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 212, __FILE__, __LINE__, true);
879 0 : return _r;
880 : }
881 : next_after_fail270:;
882 : }
883 : else
884 : {
885 386 : if (code1 == EQ_EXPR
886 386 : && code2 == GT_EXPR
887 0 : && cmp == 0
888 0 : && allbits
889 386 : && ((VECTOR_BOOLEAN_TYPE_P (type)
890 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GE_EXPR))
891 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
892 : )
893 : {
894 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail271;
895 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail271;
896 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail271;
897 0 : {
898 0 : tree res_op0;
899 0 : res_op0 = captures[4];
900 0 : tree res_op1;
901 0 : res_op1 = captures[5];
902 0 : tree _r;
903 0 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
904 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 213, __FILE__, __LINE__, true);
905 0 : return _r;
906 : }
907 : next_after_fail271:;
908 : }
909 : else
910 : {
911 386 : if (code1 == EQ_EXPR
912 386 : && code2 == LT_EXPR
913 2 : && cmp == 0
914 2 : && allbits
915 388 : && ((VECTOR_BOOLEAN_TYPE_P (type)
916 2 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LE_EXPR))
917 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
918 : )
919 : {
920 2 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail272;
921 2 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail272;
922 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail272;
923 2 : {
924 2 : tree res_op0;
925 2 : res_op0 = captures[4];
926 2 : tree res_op1;
927 2 : res_op1 = captures[5];
928 2 : tree _r;
929 2 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
930 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 214, __FILE__, __LINE__, true);
931 2 : return _r;
932 : }
933 : next_after_fail272:;
934 : }
935 : else
936 : {
937 384 : if (code1 == EQ_EXPR
938 384 : && code2 == GE_EXPR
939 : && one_before
940 0 : && allbits
941 384 : && ((VECTOR_BOOLEAN_TYPE_P (type)
942 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GE_EXPR))
943 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
944 : )
945 : {
946 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail273;
947 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail273;
948 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail273;
949 0 : {
950 0 : tree res_op0;
951 0 : res_op0 = captures[4];
952 0 : tree res_op1;
953 0 : {
954 0 : tree _o1[1], _r1;
955 0 : _o1[0] = captures[2];
956 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
957 : {
958 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
959 : }
960 : else
961 : _r1 = _o1[0];
962 0 : res_op1 = _r1;
963 : }
964 0 : tree _r;
965 0 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
966 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 215, __FILE__, __LINE__, true);
967 0 : return _r;
968 : }
969 : next_after_fail273:;
970 : }
971 : else
972 : {
973 384 : if (code1 == EQ_EXPR
974 384 : && code2 == LE_EXPR
975 : && one_after
976 0 : && allbits
977 384 : && ((VECTOR_BOOLEAN_TYPE_P (type)
978 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LE_EXPR))
979 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
980 : )
981 : {
982 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail274;
983 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail274;
984 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail274;
985 0 : {
986 0 : tree res_op0;
987 0 : res_op0 = captures[4];
988 0 : tree res_op1;
989 0 : {
990 0 : tree _o1[1], _r1;
991 0 : _o1[0] = captures[2];
992 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
993 : {
994 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
995 : }
996 : else
997 : _r1 = _o1[0];
998 0 : res_op1 = _r1;
999 : }
1000 0 : tree _r;
1001 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1002 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 216, __FILE__, __LINE__, true);
1003 0 : return _r;
1004 : }
1005 : next_after_fail274:;
1006 : }
1007 : }
1008 : }
1009 : }
1010 : }
1011 : }
1012 : }
1013 : }
1014 : }
1015 : return NULL_TREE;
1016 : }
1017 :
1018 : tree
1019 2 : generic_simplify_201 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1020 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1021 : const combined_fn ARG_UNUSED (POW))
1022 : {
1023 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1024 2 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1025 : )
1026 : {
1027 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail341;
1028 2 : {
1029 2 : tree res_op0;
1030 2 : {
1031 2 : tree _o1[2], _r1;
1032 2 : _o1[0] = captures[1];
1033 2 : _o1[1] = captures[4];
1034 2 : _r1 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1035 2 : res_op0 = _r1;
1036 : }
1037 2 : tree res_op1;
1038 2 : res_op1 = captures[2];
1039 2 : tree _r;
1040 2 : _r = maybe_build_call_expr_loc (loc, POW, type, 2, res_op0, res_op1);
1041 2 : if (!_r)
1042 0 : goto next_after_fail341;
1043 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 256, __FILE__, __LINE__, true);
1044 2 : return _r;
1045 : }
1046 : next_after_fail341:;
1047 : }
1048 : return NULL_TREE;
1049 : }
1050 :
1051 : tree
1052 0 : generic_simplify_210 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1053 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1054 : const enum tree_code ARG_UNUSED (neeq))
1055 : {
1056 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1057 0 : if (TREE_CODE (TREE_TYPE (captures[0])) == BOOLEAN_TYPE
1058 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
1059 0 : && TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1060 : )
1061 : {
1062 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail353;
1063 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail353;
1064 0 : {
1065 0 : tree res_op0;
1066 0 : res_op0 = captures[1];
1067 0 : tree res_op1;
1068 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[1]));
1069 0 : tree _r;
1070 0 : _r = fold_build2_loc (loc, neeq, type, res_op0, res_op1);
1071 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 267, __FILE__, __LINE__, true);
1072 0 : return _r;
1073 : }
1074 : next_after_fail353:;
1075 : }
1076 : return NULL_TREE;
1077 : }
1078 :
1079 : tree
1080 1750928 : generic_simplify_215 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1081 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1082 : const enum tree_code ARG_UNUSED (cmp))
1083 : {
1084 1750928 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1085 3501856 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1086 1750928 : && integer_nonzerop (captures[2])
1087 1749139 : && !TREE_OVERFLOW (captures[2])
1088 3500067 : && !TREE_OVERFLOW (captures[3])
1089 : )
1090 : {
1091 1749139 : {
1092 1749139 : tree lo, hi; bool neg_overflow;
1093 1749139 : enum tree_code code = fold_div_compare (cmp, captures[2], captures[3], &lo, &hi,
1094 : &neg_overflow);
1095 1749139 : if (code == LT_EXPR || code == GE_EXPR
1096 : )
1097 : {
1098 40732 : if (TREE_OVERFLOW (lo)
1099 : )
1100 : {
1101 8697 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail358;
1102 8697 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail358;
1103 8697 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail358;
1104 8697 : {
1105 8697 : tree _r;
1106 8697 : _r = build_int_cst (type, (code == LT_EXPR) ^ neg_overflow);
1107 8697 : if (TREE_SIDE_EFFECTS (captures[1]))
1108 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1109 8697 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 272, __FILE__, __LINE__, true);
1110 1749136 : return _r;
1111 : }
1112 3 : next_after_fail358:;
1113 : }
1114 : else
1115 : {
1116 32035 : if (code == LT_EXPR
1117 : )
1118 : {
1119 722 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail359;
1120 722 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail359;
1121 722 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail359;
1122 722 : {
1123 722 : tree res_op0;
1124 722 : res_op0 = captures[1];
1125 722 : tree res_op1;
1126 722 : res_op1 = lo;
1127 722 : tree _r;
1128 722 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
1129 722 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 273, __FILE__, __LINE__, true);
1130 722 : return _r;
1131 : }
1132 3 : next_after_fail359:;
1133 : }
1134 : else
1135 : {
1136 31313 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail360;
1137 31313 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail360;
1138 31313 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail360;
1139 31313 : {
1140 31313 : tree res_op0;
1141 31313 : res_op0 = captures[1];
1142 31313 : tree res_op1;
1143 31313 : res_op1 = lo;
1144 31313 : tree _r;
1145 31313 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
1146 31313 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 274, __FILE__, __LINE__, true);
1147 31313 : return _r;
1148 : }
1149 3 : next_after_fail360:;
1150 : }
1151 : }
1152 : }
1153 : else
1154 : {
1155 1708407 : if (code == LE_EXPR || code == GT_EXPR
1156 : )
1157 : {
1158 1705332 : if (TREE_OVERFLOW (hi)
1159 : )
1160 : {
1161 536260 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail361;
1162 536260 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail361;
1163 536260 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail361;
1164 536260 : {
1165 536260 : tree _r;
1166 536260 : _r = build_int_cst (type, (code == LE_EXPR) ^ neg_overflow);
1167 536260 : if (TREE_SIDE_EFFECTS (captures[1]))
1168 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1169 536260 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 275, __FILE__, __LINE__, true);
1170 536260 : return _r;
1171 : }
1172 3 : next_after_fail361:;
1173 : }
1174 : else
1175 : {
1176 1169072 : if (code == LE_EXPR
1177 : )
1178 : {
1179 682 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail362;
1180 682 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail362;
1181 682 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail362;
1182 682 : {
1183 682 : tree res_op0;
1184 682 : res_op0 = captures[1];
1185 682 : tree res_op1;
1186 682 : res_op1 = hi;
1187 682 : tree _r;
1188 682 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1189 682 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 276, __FILE__, __LINE__, true);
1190 682 : return _r;
1191 : }
1192 3 : next_after_fail362:;
1193 : }
1194 : else
1195 : {
1196 1168390 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail363;
1197 1168390 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail363;
1198 1168390 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail363;
1199 1168390 : {
1200 1168390 : tree res_op0;
1201 1168390 : res_op0 = captures[1];
1202 1168390 : tree res_op1;
1203 1168390 : res_op1 = hi;
1204 1168390 : tree _r;
1205 1168390 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
1206 1168390 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 277, __FILE__, __LINE__, true);
1207 1168390 : return _r;
1208 : }
1209 3 : next_after_fail363:;
1210 : }
1211 : }
1212 : }
1213 : else
1214 : {
1215 3075 : if (!lo && !hi
1216 : )
1217 : {
1218 40 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail364;
1219 40 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail364;
1220 40 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail364;
1221 40 : {
1222 40 : tree _r;
1223 40 : _r = build_int_cst (type, code == NE_EXPR);
1224 40 : if (TREE_SIDE_EFFECTS (captures[1]))
1225 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1226 40 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 278, __FILE__, __LINE__, true);
1227 40 : return _r;
1228 : }
1229 3 : next_after_fail364:;
1230 : }
1231 : else
1232 : {
1233 3035 : if (code == EQ_EXPR && !hi
1234 : )
1235 : {
1236 15 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail365;
1237 15 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail365;
1238 15 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail365;
1239 15 : {
1240 15 : tree res_op0;
1241 15 : res_op0 = captures[1];
1242 15 : tree res_op1;
1243 15 : res_op1 = lo;
1244 15 : tree _r;
1245 15 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
1246 15 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 279, __FILE__, __LINE__, true);
1247 15 : return _r;
1248 : }
1249 3 : next_after_fail365:;
1250 : }
1251 : else
1252 : {
1253 930 : if (code == EQ_EXPR && !lo
1254 : )
1255 : {
1256 11 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail366;
1257 11 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail366;
1258 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail366;
1259 11 : {
1260 11 : tree res_op0;
1261 11 : res_op0 = captures[1];
1262 11 : tree res_op1;
1263 11 : res_op1 = hi;
1264 11 : tree _r;
1265 11 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1266 11 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 280, __FILE__, __LINE__, true);
1267 11 : return _r;
1268 : }
1269 3 : next_after_fail366:;
1270 : }
1271 : else
1272 : {
1273 3009 : if (code == NE_EXPR && !hi
1274 : )
1275 : {
1276 4 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail367;
1277 4 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail367;
1278 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail367;
1279 4 : {
1280 4 : tree res_op0;
1281 4 : res_op0 = captures[1];
1282 4 : tree res_op1;
1283 4 : res_op1 = lo;
1284 4 : tree _r;
1285 4 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
1286 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 281, __FILE__, __LINE__, true);
1287 4 : return _r;
1288 : }
1289 3 : next_after_fail367:;
1290 : }
1291 : else
1292 : {
1293 2086 : if (code == NE_EXPR && !lo
1294 : )
1295 : {
1296 18 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail368;
1297 18 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail368;
1298 18 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail368;
1299 18 : {
1300 18 : tree res_op0;
1301 18 : res_op0 = captures[1];
1302 18 : tree res_op1;
1303 18 : res_op1 = hi;
1304 18 : tree _r;
1305 18 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
1306 18 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 282, __FILE__, __LINE__, true);
1307 18 : return _r;
1308 : }
1309 3 : next_after_fail368:;
1310 : }
1311 : else
1312 : {
1313 2987 : if (1
1314 : )
1315 : {
1316 2987 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail369;
1317 2984 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail369;
1318 2984 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail369;
1319 2984 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail369;
1320 2984 : {
1321 2984 : tree _r;
1322 2984 : _r = build_range_check (UNKNOWN_LOCATION, type, captures[1], code == EQ_EXPR,
1323 : lo, hi);
1324 2984 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 283, __FILE__, __LINE__, true);
1325 2984 : return _r;
1326 : }
1327 3 : next_after_fail369:;
1328 : }
1329 : else
1330 : {
1331 : {
1332 : tree etype = range_check_type (TREE_TYPE (captures[1]));
1333 : if (etype)
1334 : {
1335 : hi = fold_convert (etype, hi);
1336 : lo = fold_convert (etype, lo);
1337 : hi = const_binop (MINUS_EXPR, etype, hi, lo);
1338 : }
1339 : if (etype && hi && !TREE_OVERFLOW (hi)
1340 : )
1341 : {
1342 : if (code == EQ_EXPR
1343 : )
1344 : {
1345 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail370;
1346 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail370;
1347 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail370;
1348 : {
1349 : tree res_op0;
1350 : {
1351 : tree _o1[2], _r1;
1352 : {
1353 : tree _o2[1], _r2;
1354 : _o2[0] = captures[1];
1355 : if (TREE_TYPE (_o2[0]) != etype)
1356 : {
1357 : _r2 = fold_build1_loc (loc, NOP_EXPR, etype, _o2[0]);
1358 : }
1359 : else
1360 : _r2 = _o2[0];
1361 : _o1[0] = _r2;
1362 : }
1363 : _o1[1] = lo;
1364 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1365 : res_op0 = _r1;
1366 : }
1367 : tree res_op1;
1368 : res_op1 = hi;
1369 : tree _r;
1370 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1371 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 284, __FILE__, __LINE__, true);
1372 : return _r;
1373 : }
1374 : next_after_fail370:;
1375 : }
1376 : else
1377 : {
1378 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail371;
1379 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail371;
1380 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail371;
1381 : {
1382 : tree res_op0;
1383 : {
1384 : tree _o1[2], _r1;
1385 : {
1386 : tree _o2[1], _r2;
1387 : _o2[0] = captures[1];
1388 : if (TREE_TYPE (_o2[0]) != etype)
1389 : {
1390 : _r2 = fold_build1_loc (loc, NOP_EXPR, etype, _o2[0]);
1391 : }
1392 : else
1393 : _r2 = _o2[0];
1394 : _o1[0] = _r2;
1395 : }
1396 : _o1[1] = lo;
1397 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1398 : res_op0 = _r1;
1399 : }
1400 : tree res_op1;
1401 : res_op1 = hi;
1402 : tree _r;
1403 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
1404 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 285, __FILE__, __LINE__, true);
1405 : return _r;
1406 : }
1407 : next_after_fail371:;
1408 : }
1409 : }
1410 : }
1411 : }
1412 : }
1413 : }
1414 : }
1415 : }
1416 : }
1417 : }
1418 : }
1419 : }
1420 : }
1421 : return NULL_TREE;
1422 : }
1423 :
1424 : tree
1425 0 : generic_simplify_272 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1426 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1427 : const enum tree_code ARG_UNUSED (cmp))
1428 : {
1429 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1430 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
1431 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1432 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1433 0 : && TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (TREE_TYPE (captures[2]))
1434 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (TREE_TYPE (captures[1]))
1435 0 : && !wi::neg_p (wi::to_wide (captures[3]))
1436 : )
1437 : {
1438 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail502;
1439 0 : {
1440 0 : tree res_op0;
1441 0 : {
1442 0 : tree _o1[2], _r1;
1443 0 : _o1[0] = captures[2];
1444 0 : {
1445 0 : tree _o2[1], _r2;
1446 0 : {
1447 0 : tree _o3[1], _r3;
1448 0 : _o3[0] = captures[3];
1449 0 : _r3 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o3[0]), _o3[0]);
1450 0 : _o2[0] = _r3;
1451 : }
1452 0 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
1453 : {
1454 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
1455 : }
1456 : else
1457 : _r2 = _o2[0];
1458 0 : _o1[1] = _r2;
1459 : }
1460 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1461 0 : res_op0 = _r1;
1462 : }
1463 0 : tree res_op1;
1464 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[2]));
1465 0 : tree _r;
1466 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1467 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 406, __FILE__, __LINE__, true);
1468 0 : return _r;
1469 : }
1470 0 : next_after_fail502:;
1471 : }
1472 : return NULL_TREE;
1473 : }
1474 :
1475 : tree
1476 804203 : generic_simplify_279 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1477 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1478 : const enum tree_code ARG_UNUSED (cmp),
1479 : const enum tree_code ARG_UNUSED (ncmp))
1480 : {
1481 804203 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1482 1545137 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1483 804203 : && type_has_mode_precision_p (TREE_TYPE (captures[1]))
1484 802907 : && element_precision (captures[0]) >= element_precision (captures[1])
1485 1608406 : && wi::only_sign_bit_p (wi::to_wide (captures[2]), element_precision (captures[1]))
1486 : )
1487 : {
1488 12881 : {
1489 12881 : tree stype = signed_type_for (TREE_TYPE (captures[1]));
1490 12881 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail509;
1491 12881 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail509;
1492 12881 : {
1493 12881 : tree res_op0;
1494 12881 : {
1495 12881 : tree _o1[1], _r1;
1496 12881 : _o1[0] = captures[1];
1497 12881 : if (TREE_TYPE (_o1[0]) != stype)
1498 : {
1499 12668 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
1500 : }
1501 : else
1502 : _r1 = _o1[0];
1503 12881 : res_op0 = _r1;
1504 : }
1505 12881 : tree res_op1;
1506 12881 : res_op1 = build_zero_cst (stype);
1507 12881 : tree _r;
1508 12881 : _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
1509 12881 : if (TREE_SIDE_EFFECTS (captures[2]))
1510 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1511 12881 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 412, __FILE__, __LINE__, true);
1512 12881 : return _r;
1513 : }
1514 : next_after_fail509:;
1515 : }
1516 : }
1517 : return NULL_TREE;
1518 : }
1519 :
1520 : tree
1521 2 : generic_simplify_289 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1522 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1523 : const enum tree_code ARG_UNUSED (cmp))
1524 : {
1525 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1526 4 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
1527 2 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1528 2 : && TYPE_UNSIGNED (TREE_TYPE (captures[2]))
1529 2 : && (TYPE_PRECISION (TREE_TYPE (captures[1]))
1530 2 : >= 2 * TYPE_PRECISION (TREE_TYPE (captures[2])))
1531 2 : && tree_fits_uhwi_p (captures[4])
1532 2 : && tree_to_uhwi (captures[4]) == TYPE_PRECISION (TREE_TYPE (captures[2]))
1533 2 : && types_match (captures[2], captures[3])
1534 2 : && type_has_mode_precision_p (TREE_TYPE (captures[2]))
1535 6 : && (optab_handler (umulv4_optab, TYPE_MODE (TREE_TYPE (captures[2])))
1536 : != CODE_FOR_nothing)
1537 : )
1538 : {
1539 2 : {
1540 2 : tree t = TREE_TYPE (captures[2]), cpx = build_complex_type (t);
1541 2 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail537;
1542 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail537;
1543 2 : {
1544 2 : tree res_op0;
1545 2 : {
1546 2 : tree _o1[1], _r1;
1547 2 : {
1548 2 : tree _o2[2], _r2;
1549 2 : _o2[0] = captures[2];
1550 2 : _o2[1] = captures[3];
1551 2 : _r2 = maybe_build_call_expr_loc (loc, CFN_MUL_OVERFLOW, cpx, 2, _o2[0], _o2[1]);
1552 2 : if (!_r2)
1553 0 : goto next_after_fail537;
1554 2 : _o1[0] = _r2;
1555 : }
1556 2 : _r1 = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
1557 2 : res_op0 = _r1;
1558 : }
1559 2 : tree res_op1;
1560 2 : res_op1 = build_zero_cst (t);
1561 2 : tree _r;
1562 2 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1563 2 : if (TREE_SIDE_EFFECTS (captures[4]))
1564 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
1565 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 431, __FILE__, __LINE__, true);
1566 2 : return _r;
1567 : }
1568 : next_after_fail537:;
1569 : }
1570 : }
1571 : return NULL_TREE;
1572 : }
1573 :
1574 : tree
1575 366 : generic_simplify_292 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1576 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1577 : const enum tree_code ARG_UNUSED (op),
1578 : const enum tree_code ARG_UNUSED (cmp),
1579 : const combined_fn ARG_UNUSED (clz))
1580 : {
1581 366 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1582 366 : if (!sanitize_flags_p (SANITIZE_BUILTIN)
1583 366 : || (cfun && (cfun->curr_properties & PROP_ssa) != 0)
1584 : )
1585 : {
1586 302 : if (integer_zerop (captures[2]) && single_use (captures[0])
1587 : )
1588 : {
1589 59 : {
1590 59 : tree stype = signed_type_for (TREE_TYPE (captures[1]));
1591 59 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail549;
1592 59 : {
1593 59 : tree res_op0;
1594 59 : {
1595 59 : tree _o1[1], _r1;
1596 59 : _o1[0] = captures[1];
1597 59 : if (TREE_TYPE (_o1[0]) != stype)
1598 : {
1599 59 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
1600 : }
1601 : else
1602 : _r1 = _o1[0];
1603 59 : res_op0 = _r1;
1604 : }
1605 59 : tree res_op1;
1606 59 : res_op1 = build_zero_cst (stype);
1607 59 : tree _r;
1608 59 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1609 59 : if (TREE_SIDE_EFFECTS (captures[2]))
1610 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1611 59 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 443, __FILE__, __LINE__, true);
1612 59 : return _r;
1613 : }
1614 0 : next_after_fail549:;
1615 : }
1616 : }
1617 : else
1618 : {
1619 243 : if (wi::to_wide (captures[2]) == TYPE_PRECISION (TREE_TYPE (captures[1])) - 1
1620 : )
1621 : {
1622 79 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail550;
1623 79 : {
1624 79 : tree res_op0;
1625 79 : res_op0 = captures[1];
1626 79 : tree res_op1;
1627 79 : res_op1 = build_one_cst (TREE_TYPE (captures[1]));
1628 79 : tree _r;
1629 79 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1630 79 : if (TREE_SIDE_EFFECTS (captures[2]))
1631 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1632 79 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 444, __FILE__, __LINE__, true);
1633 79 : return _r;
1634 : }
1635 0 : next_after_fail550:;
1636 : }
1637 : }
1638 : }
1639 : return NULL_TREE;
1640 : }
1641 :
1642 : tree
1643 17 : generic_simplify_297 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1644 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1645 : const enum tree_code ARG_UNUSED (cmp),
1646 : const combined_fn ARG_UNUSED (ffs))
1647 : {
1648 17 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1649 17 : {
1650 17 : int prec = TYPE_PRECISION (TREE_TYPE (captures[1]));
1651 17 : if (integer_zerop (captures[2])
1652 : )
1653 : {
1654 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail558;
1655 9 : {
1656 9 : tree res_op0;
1657 9 : res_op0 = captures[1];
1658 9 : tree res_op1;
1659 9 : res_op1 = build_zero_cst (TREE_TYPE (captures[1]));
1660 9 : tree _r;
1661 9 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1662 9 : if (TREE_SIDE_EFFECTS (captures[2]))
1663 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1664 9 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 452, __FILE__, __LINE__, true);
1665 17 : return _r;
1666 : }
1667 0 : next_after_fail558:;
1668 : }
1669 : else
1670 : {
1671 8 : if (tree_int_cst_sgn (captures[2]) < 0 || wi::to_widest (captures[2]) > prec
1672 : )
1673 : {
1674 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail559;
1675 4 : {
1676 4 : tree _r;
1677 4 : _r = constant_boolean_node (cmp == NE_EXPR ? true : false, type);
1678 4 : if (TREE_SIDE_EFFECTS (captures[1]))
1679 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1680 4 : if (TREE_SIDE_EFFECTS (captures[2]))
1681 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1682 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 453, __FILE__, __LINE__, true);
1683 4 : return _r;
1684 : }
1685 0 : next_after_fail559:;
1686 : }
1687 : else
1688 : {
1689 4 : if (single_use (captures[0])
1690 : )
1691 : {
1692 4 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail560;
1693 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail560;
1694 4 : {
1695 4 : tree res_op0;
1696 4 : {
1697 4 : tree _o1[2], _r1;
1698 4 : _o1[0] = captures[1];
1699 4 : _o1[1] = wide_int_to_tree (TREE_TYPE (captures[1]),
1700 4 : wi::mask (tree_to_uhwi (captures[2]),
1701 : false, prec));
1702 4 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1703 4 : res_op0 = _r1;
1704 : }
1705 4 : tree res_op1;
1706 4 : res_op1 = wide_int_to_tree (TREE_TYPE (captures[1]),
1707 4 : wi::shifted_mask (tree_to_uhwi (captures[2]) - 1, 1,
1708 : false, prec));
1709 4 : tree _r;
1710 4 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1711 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 454, __FILE__, __LINE__, true);
1712 4 : return _r;
1713 : }
1714 0 : next_after_fail560:;
1715 : }
1716 : }
1717 : }
1718 : }
1719 0 : return NULL_TREE;
1720 : }
1721 :
1722 : tree
1723 1 : generic_simplify_315 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1724 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1725 : const enum tree_code ARG_UNUSED (div))
1726 : {
1727 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1728 0 : if ((INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
1729 1 : && TYPE_OVERFLOW_UNDEFINED (type)
1730 1 : && !integer_zerop (captures[0])
1731 2 : && (!flag_non_call_exceptions || tree_expr_nonzero_p (captures[0]))
1732 : )
1733 : {
1734 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail581;
1735 1 : {
1736 1 : tree _r;
1737 1 : _r = build_minus_one_cst (type);
1738 1 : if (TREE_SIDE_EFFECTS (captures[0]))
1739 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1740 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 473, __FILE__, __LINE__, true);
1741 1 : return _r;
1742 : }
1743 0 : next_after_fail581:;
1744 : }
1745 : return NULL_TREE;
1746 : }
1747 :
1748 : tree
1749 2274349 : generic_simplify_321 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1750 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1751 : const enum tree_code ARG_UNUSED (floor_divmod),
1752 : const enum tree_code ARG_UNUSED (trunc_divmod))
1753 : {
1754 2274349 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1755 0 : if ((INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
1756 2274349 : && TYPE_UNSIGNED (type)
1757 : )
1758 : {
1759 2265235 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail588;
1760 2265235 : {
1761 2265235 : tree res_op0;
1762 2265235 : res_op0 = captures[0];
1763 2265235 : tree res_op1;
1764 2265235 : res_op1 = captures[1];
1765 2265235 : tree _r;
1766 2265235 : _r = fold_build2_loc (loc, trunc_divmod, type, res_op0, res_op1);
1767 2265235 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 480, __FILE__, __LINE__, true);
1768 2265235 : return _r;
1769 : }
1770 0 : next_after_fail588:;
1771 : }
1772 : return NULL_TREE;
1773 : }
1774 :
1775 : tree
1776 227 : generic_simplify_325 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1777 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1778 : const enum tree_code ARG_UNUSED (mod))
1779 : {
1780 227 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1781 227 : if (!integer_zerop (captures[0])
1782 : )
1783 : {
1784 93 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail592;
1785 93 : {
1786 93 : tree _r;
1787 93 : _r = build_zero_cst (type);
1788 93 : if (TREE_SIDE_EFFECTS (captures[0]))
1789 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1790 93 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 484, __FILE__, __LINE__, true);
1791 93 : return _r;
1792 : }
1793 0 : next_after_fail592:;
1794 : }
1795 : return NULL_TREE;
1796 : }
1797 :
1798 : tree
1799 3 : generic_simplify_335 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1800 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1801 : const combined_fn ARG_UNUSED (TANH),
1802 : const combined_fn ARG_UNUSED (SINH),
1803 : const combined_fn ARG_UNUSED (COSH))
1804 : {
1805 3 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1806 3 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1807 : )
1808 : {
1809 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail604;
1810 3 : {
1811 3 : tree res_op0;
1812 3 : res_op0 = build_one_cst (type);
1813 3 : tree res_op1;
1814 3 : {
1815 3 : tree _o1[1], _r1;
1816 3 : _o1[0] = captures[1];
1817 3 : _r1 = maybe_build_call_expr_loc (loc, COSH, TREE_TYPE (_o1[0]), 1, _o1[0]);
1818 3 : if (!_r1)
1819 0 : goto next_after_fail604;
1820 3 : res_op1 = _r1;
1821 : }
1822 3 : tree _r;
1823 3 : _r = fold_build2_loc (loc, RDIV_EXPR, type, res_op0, res_op1);
1824 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 496, __FILE__, __LINE__, true);
1825 3 : return _r;
1826 : }
1827 : next_after_fail604:;
1828 : }
1829 : return NULL_TREE;
1830 : }
1831 :
1832 : tree
1833 7421 : generic_simplify_343 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1834 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1835 : const enum tree_code ARG_UNUSED (cmp),
1836 : const enum tree_code ARG_UNUSED (op))
1837 : {
1838 7421 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1839 7421 : {
1840 7421 : tree from_type = TREE_TYPE (captures[0]), to_type = TREE_TYPE (captures[1]);
1841 7421 : if (types_match (from_type, to_type)
1842 7421 : || (TYPE_UNSIGNED (from_type)
1843 37 : && !TYPE_UNSIGNED (to_type)
1844 37 : && TYPE_PRECISION (from_type) == TYPE_PRECISION (to_type)
1845 37 : && integer_zerop (captures[1])
1846 31 : && (cmp == LT_EXPR || cmp == GE_EXPR))
1847 : )
1848 : {
1849 7391 : {
1850 7391 : wi::overflow_type overflow = wi::OVF_NONE;
1851 7391 : enum tree_code code, cmp_code = cmp;
1852 7391 : wide_int real_c1;
1853 7391 : wide_int c1 = wi::to_wide (captures[1]);
1854 7391 : wide_int c2 = wi::to_wide (captures[2]);
1855 7391 : wide_int c3 = wi::to_wide (captures[3]);
1856 7391 : signop sgn = TYPE_SIGN (from_type);
1857 7391 : if (!types_match (from_type, to_type))
1858 : {
1859 7 : if (cmp_code == LT_EXPR)
1860 : cmp_code = GT_EXPR;
1861 0 : if (cmp_code == GE_EXPR)
1862 0 : cmp_code = LE_EXPR;
1863 7 : c1 = wi::max_value (to_type);
1864 : }
1865 7391 : if (op == PLUS_EXPR)
1866 7391 : real_c1 = wi::sub (c3, c2, sgn, &overflow);
1867 : else
1868 0 : real_c1 = wi::add (c3, c2, sgn, &overflow);
1869 7391 : code = cmp_code;
1870 7391 : if (!overflow || !TYPE_OVERFLOW_UNDEFINED (from_type))
1871 : {
1872 14782 : if (!wi::cmp (wi::sub (real_c1, 1, sgn, &overflow), c1, sgn)
1873 7391 : && !overflow)
1874 : {
1875 631 : if (cmp_code == LE_EXPR)
1876 : code = LT_EXPR;
1877 631 : if (cmp_code == GT_EXPR)
1878 7391 : code = GE_EXPR;
1879 : }
1880 14782 : if (!wi::cmp (wi::add (real_c1, 1, sgn, &overflow), c1, sgn)
1881 7391 : && !overflow)
1882 : {
1883 6327 : if (cmp_code == LT_EXPR)
1884 : code = LE_EXPR;
1885 6327 : if (cmp_code == GE_EXPR)
1886 : code = GT_EXPR;
1887 : }
1888 1081 : if (code != cmp_code || !wi::cmp (real_c1, c1, sgn))
1889 : {
1890 7168 : if (cmp_code == LT_EXPR || cmp_code == LE_EXPR)
1891 : code = MIN_EXPR;
1892 7168 : if (cmp_code == GT_EXPR || cmp_code == GE_EXPR)
1893 : code = MAX_EXPR;
1894 : }
1895 : }
1896 223 : if (code == MAX_EXPR
1897 : )
1898 : {
1899 7168 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail614;
1900 7168 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail614;
1901 7168 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail614;
1902 7168 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail614;
1903 7168 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail614;
1904 7168 : {
1905 7168 : tree res_op0;
1906 7168 : {
1907 7168 : tree _o1[2], _r1;
1908 7168 : _o1[0] = captures[0];
1909 7168 : _o1[1] = wide_int_to_tree (from_type, real_c1);
1910 7168 : _r1 = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1911 7168 : res_op0 = _r1;
1912 : }
1913 7168 : tree res_op1;
1914 7168 : res_op1 = wide_int_to_tree (from_type, c2);
1915 7168 : tree _r;
1916 7168 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1917 7168 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 506, __FILE__, __LINE__, true);
1918 7168 : return _r;
1919 : }
1920 223 : next_after_fail614:;
1921 : }
1922 : else
1923 : {
1924 223 : if (code == MIN_EXPR
1925 : )
1926 : {
1927 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail615;
1928 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail615;
1929 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail615;
1930 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail615;
1931 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail615;
1932 0 : {
1933 0 : tree res_op0;
1934 0 : {
1935 0 : tree _o1[2], _r1;
1936 0 : _o1[0] = captures[0];
1937 0 : _o1[1] = wide_int_to_tree (from_type, real_c1);
1938 0 : _r1 = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1939 0 : res_op0 = _r1;
1940 : }
1941 0 : tree res_op1;
1942 0 : res_op1 = wide_int_to_tree (from_type, c2);
1943 0 : tree _r;
1944 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1945 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 507, __FILE__, __LINE__, true);
1946 0 : return _r;
1947 : }
1948 223 : next_after_fail615:;
1949 : }
1950 : }
1951 7391 : }
1952 : }
1953 : }
1954 : return NULL_TREE;
1955 : }
1956 :
1957 : tree
1958 17 : generic_simplify_373 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1959 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1960 : const enum tree_code ARG_UNUSED (cmp))
1961 : {
1962 17 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1963 17 : if (INTEGRAL_TYPE_P (type)
1964 17 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1965 17 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1966 34 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == TYPE_PRECISION (type)
1967 : )
1968 : {
1969 17 : {
1970 17 : tree shifter = build_int_cst (integer_type_node, TYPE_PRECISION (type) - 1);
1971 17 : if (cmp == GE_EXPR
1972 : )
1973 : {
1974 9 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail650;
1975 9 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail650;
1976 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail650;
1977 9 : {
1978 9 : tree res_op0;
1979 9 : {
1980 9 : tree _o1[1], _r1;
1981 9 : {
1982 9 : tree _o2[2], _r2;
1983 9 : _o2[0] = captures[0];
1984 9 : _o2[1] = shifter;
1985 9 : _r2 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
1986 9 : _o1[0] = _r2;
1987 : }
1988 9 : if (TREE_TYPE (_o1[0]) != type)
1989 : {
1990 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
1991 : }
1992 : else
1993 : _r1 = _o1[0];
1994 9 : res_op0 = _r1;
1995 : }
1996 9 : tree res_op1;
1997 9 : res_op1 = captures[1];
1998 9 : tree _r;
1999 9 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
2000 9 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 540, __FILE__, __LINE__, true);
2001 9 : return _r;
2002 : }
2003 : next_after_fail650:;
2004 : }
2005 : else
2006 : {
2007 8 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail651;
2008 8 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail651;
2009 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail651;
2010 8 : {
2011 8 : tree res_op0;
2012 8 : {
2013 8 : tree _o1[2], _r1;
2014 8 : {
2015 8 : tree _o2[1], _r2;
2016 8 : {
2017 8 : tree _o3[2], _r3;
2018 8 : _o3[0] = captures[0];
2019 8 : _o3[1] = shifter;
2020 8 : _r3 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
2021 8 : _o2[0] = _r3;
2022 : }
2023 8 : if (TREE_TYPE (_o2[0]) != type)
2024 : {
2025 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, type, _o2[0]);
2026 : }
2027 : else
2028 : _r2 = _o2[0];
2029 8 : _o1[0] = _r2;
2030 : }
2031 8 : _o1[1] = captures[1];
2032 8 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2033 8 : res_op0 = _r1;
2034 : }
2035 8 : tree _r;
2036 8 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
2037 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 541, __FILE__, __LINE__, true);
2038 8 : return _r;
2039 : }
2040 : next_after_fail651:;
2041 : }
2042 : }
2043 : }
2044 : return NULL_TREE;
2045 : }
2046 :
2047 : tree
2048 21475508 : generic_simplify_393 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2049 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2050 : const enum tree_code ARG_UNUSED (cmp))
2051 : {
2052 21475508 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2053 42945017 : if ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2054 11093 : || POINTER_TYPE_P (TREE_TYPE (captures[2]))
2055 2632 : || VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[2])))
2056 42945017 : && tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
2057 : )
2058 : {
2059 21475508 : {
2060 21475508 : tree cst = uniform_integer_cst_p (captures[2]);
2061 21475508 : tree arg1_type = TREE_TYPE (cst);
2062 21475508 : unsigned int prec = TYPE_PRECISION (arg1_type);
2063 21475508 : wide_int max = wi::max_value (arg1_type);
2064 21475508 : wide_int signed_max = wi::max_value (prec, SIGNED);
2065 21475508 : wide_int min = wi::min_value (arg1_type);
2066 21475508 : if (wi::to_wide (cst) == max
2067 : )
2068 : {
2069 170300 : if (cmp == GT_EXPR
2070 : )
2071 : {
2072 116451 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail691;
2073 116451 : {
2074 116451 : tree _r;
2075 116451 : _r = constant_boolean_node (false, type);
2076 116451 : if (TREE_SIDE_EFFECTS (captures[0]))
2077 80 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2078 116451 : if (TREE_SIDE_EFFECTS (captures[2]))
2079 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2080 116451 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 565, __FILE__, __LINE__, true);
2081 116451 : return _r;
2082 : }
2083 0 : next_after_fail691:;
2084 : }
2085 : else
2086 : {
2087 53849 : if (cmp == GE_EXPR
2088 : )
2089 : {
2090 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail692;
2091 7 : {
2092 7 : tree res_op0;
2093 7 : res_op0 = captures[0];
2094 7 : tree res_op1;
2095 7 : res_op1 = captures[2];
2096 7 : tree _r;
2097 7 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
2098 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 566, __FILE__, __LINE__, true);
2099 7 : return _r;
2100 : }
2101 0 : next_after_fail692:;
2102 : }
2103 : else
2104 : {
2105 53842 : if (cmp == LE_EXPR
2106 : )
2107 : {
2108 53832 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail693;
2109 53832 : {
2110 53832 : tree _r;
2111 53832 : _r = constant_boolean_node (true, type);
2112 53832 : if (TREE_SIDE_EFFECTS (captures[0]))
2113 23 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2114 53832 : if (TREE_SIDE_EFFECTS (captures[2]))
2115 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2116 53832 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 567, __FILE__, __LINE__, true);
2117 53832 : return _r;
2118 : }
2119 0 : next_after_fail693:;
2120 : }
2121 : else
2122 : {
2123 10 : if (cmp == LT_EXPR
2124 : )
2125 : {
2126 10 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail694;
2127 10 : {
2128 10 : tree res_op0;
2129 10 : res_op0 = captures[0];
2130 10 : tree res_op1;
2131 10 : res_op1 = captures[2];
2132 10 : tree _r;
2133 10 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
2134 10 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 568, __FILE__, __LINE__, true);
2135 10 : return _r;
2136 : }
2137 0 : next_after_fail694:;
2138 : }
2139 : }
2140 : }
2141 : }
2142 : }
2143 : else
2144 : {
2145 21305208 : if (wi::to_wide (cst) == min
2146 : )
2147 : {
2148 1332501 : if (cmp == LT_EXPR
2149 : )
2150 : {
2151 432261 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail695;
2152 432261 : {
2153 432261 : tree _r;
2154 432261 : _r = constant_boolean_node (false, type);
2155 432261 : if (TREE_SIDE_EFFECTS (captures[0]))
2156 38 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2157 432261 : if (TREE_SIDE_EFFECTS (captures[2]))
2158 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2159 432261 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 569, __FILE__, __LINE__, true);
2160 432261 : return _r;
2161 : }
2162 0 : next_after_fail695:;
2163 : }
2164 : else
2165 : {
2166 900240 : if (cmp == LE_EXPR
2167 : )
2168 : {
2169 98726 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail696;
2170 98726 : {
2171 98726 : tree res_op0;
2172 98726 : res_op0 = captures[0];
2173 98726 : tree res_op1;
2174 98726 : res_op1 = captures[2];
2175 98726 : tree _r;
2176 98726 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
2177 98726 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 570, __FILE__, __LINE__, true);
2178 98726 : return _r;
2179 : }
2180 0 : next_after_fail696:;
2181 : }
2182 : else
2183 : {
2184 801514 : if (cmp == GE_EXPR
2185 : )
2186 : {
2187 239662 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail697;
2188 239662 : {
2189 239662 : tree _r;
2190 239662 : _r = constant_boolean_node (true, type);
2191 239662 : if (TREE_SIDE_EFFECTS (captures[0]))
2192 175 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2193 239662 : if (TREE_SIDE_EFFECTS (captures[2]))
2194 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2195 239662 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 571, __FILE__, __LINE__, true);
2196 239662 : return _r;
2197 : }
2198 0 : next_after_fail697:;
2199 : }
2200 : else
2201 : {
2202 561852 : if (cmp == GT_EXPR
2203 : )
2204 : {
2205 561852 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail698;
2206 561852 : {
2207 561852 : tree res_op0;
2208 561852 : res_op0 = captures[0];
2209 561852 : tree res_op1;
2210 561852 : res_op1 = captures[2];
2211 561852 : tree _r;
2212 561852 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
2213 561852 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 572, __FILE__, __LINE__, true);
2214 561852 : return _r;
2215 : }
2216 0 : next_after_fail698:;
2217 : }
2218 : }
2219 : }
2220 : }
2221 : }
2222 : else
2223 : {
2224 19972714 : if (wi::to_wide (cst) == max - 1
2225 : )
2226 : {
2227 388674 : if (cmp == GT_EXPR
2228 : )
2229 : {
2230 154212 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail699;
2231 154212 : {
2232 154212 : tree res_op0;
2233 154212 : res_op0 = captures[0];
2234 154212 : tree res_op1;
2235 154212 : res_op1 = build_uniform_cst (TREE_TYPE (captures[2]),
2236 154212 : wide_int_to_tree (TREE_TYPE (cst),
2237 154212 : wi::to_wide (cst)
2238 308424 : + 1));
2239 154212 : tree _r;
2240 154212 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
2241 154212 : if (TREE_SIDE_EFFECTS (captures[2]))
2242 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2243 154212 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 573, __FILE__, __LINE__, true);
2244 154212 : return _r;
2245 : }
2246 0 : next_after_fail699:;
2247 : }
2248 : else
2249 : {
2250 234462 : if (cmp == LE_EXPR
2251 : )
2252 : {
2253 234462 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail700;
2254 234462 : {
2255 234462 : tree res_op0;
2256 234462 : res_op0 = captures[0];
2257 234462 : tree res_op1;
2258 234462 : res_op1 = build_uniform_cst (TREE_TYPE (captures[2]),
2259 234462 : wide_int_to_tree (TREE_TYPE (cst),
2260 234462 : wi::to_wide (cst)
2261 468924 : + 1));
2262 234462 : tree _r;
2263 234462 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
2264 234462 : if (TREE_SIDE_EFFECTS (captures[2]))
2265 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2266 234462 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 574, __FILE__, __LINE__, true);
2267 234462 : return _r;
2268 : }
2269 0 : next_after_fail700:;
2270 : }
2271 : }
2272 : }
2273 : else
2274 : {
2275 19584038 : if (wi::to_wide (cst) == min + 1
2276 : )
2277 : {
2278 714457 : if (cmp == GE_EXPR
2279 : )
2280 : {
2281 59424 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail701;
2282 59424 : {
2283 59424 : tree res_op0;
2284 59424 : res_op0 = captures[0];
2285 59424 : tree res_op1;
2286 59424 : res_op1 = build_uniform_cst (TREE_TYPE (captures[2]),
2287 59424 : wide_int_to_tree (TREE_TYPE (cst),
2288 59424 : wi::to_wide (cst)
2289 118848 : - 1));
2290 59424 : tree _r;
2291 59424 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
2292 59424 : if (TREE_SIDE_EFFECTS (captures[2]))
2293 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2294 59424 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 575, __FILE__, __LINE__, true);
2295 59424 : return _r;
2296 : }
2297 0 : next_after_fail701:;
2298 : }
2299 : else
2300 : {
2301 655033 : if (cmp == LT_EXPR
2302 : )
2303 : {
2304 25643 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail702;
2305 25643 : {
2306 25643 : tree res_op0;
2307 25643 : res_op0 = captures[0];
2308 25643 : tree res_op1;
2309 25643 : res_op1 = build_uniform_cst (TREE_TYPE (captures[2]),
2310 25643 : wide_int_to_tree (TREE_TYPE (cst),
2311 25643 : wi::to_wide (cst)
2312 51286 : - 1));
2313 25643 : tree _r;
2314 25643 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
2315 25643 : if (TREE_SIDE_EFFECTS (captures[2]))
2316 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2317 25643 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 576, __FILE__, __LINE__, true);
2318 25643 : return _r;
2319 : }
2320 0 : next_after_fail702:;
2321 : }
2322 : }
2323 : }
2324 : else
2325 : {
2326 18869576 : if (wi::to_wide (cst) == signed_max
2327 67300 : && TYPE_UNSIGNED (arg1_type)
2328 67300 : && TYPE_MODE (arg1_type) != BLKmode
2329 18869583 : && prec == GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (arg1_type))
2330 18936303 : && INTEGRAL_TYPE_P (arg1_type)
2331 : )
2332 : {
2333 66720 : if (cmp == LE_EXPR || cmp == GT_EXPR
2334 : )
2335 : {
2336 66720 : {
2337 66720 : tree st = signed_type_for (TREE_TYPE (captures[2]));
2338 66720 : if (cst == captures[2] && cmp == LE_EXPR
2339 : )
2340 : {
2341 22665 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail703;
2342 22665 : {
2343 22665 : tree res_op0;
2344 22665 : {
2345 22665 : tree _o1[1], _r1;
2346 22665 : _o1[0] = captures[1];
2347 22665 : if (TREE_TYPE (_o1[0]) != st)
2348 : {
2349 22665 : _r1 = fold_build1_loc (loc, NOP_EXPR, st, _o1[0]);
2350 : }
2351 : else
2352 : _r1 = _o1[0];
2353 22665 : res_op0 = _r1;
2354 : }
2355 22665 : tree res_op1;
2356 22665 : res_op1 = build_zero_cst (st);
2357 22665 : tree _r;
2358 22665 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
2359 22665 : if (TREE_SIDE_EFFECTS (captures[2]))
2360 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2361 22665 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 577, __FILE__, __LINE__, true);
2362 22665 : return _r;
2363 : }
2364 0 : next_after_fail703:;
2365 0 : }
2366 : else
2367 : {
2368 44055 : if (cst == captures[2] && cmp == GT_EXPR
2369 : )
2370 : {
2371 43969 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail704;
2372 43969 : {
2373 43969 : tree res_op0;
2374 43969 : {
2375 43969 : tree _o1[1], _r1;
2376 43969 : _o1[0] = captures[1];
2377 43969 : if (TREE_TYPE (_o1[0]) != st)
2378 : {
2379 43969 : _r1 = fold_build1_loc (loc, NOP_EXPR, st, _o1[0]);
2380 : }
2381 : else
2382 : _r1 = _o1[0];
2383 43969 : res_op0 = _r1;
2384 : }
2385 43969 : tree res_op1;
2386 43969 : res_op1 = build_zero_cst (st);
2387 43969 : tree _r;
2388 43969 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
2389 43969 : if (TREE_SIDE_EFFECTS (captures[2]))
2390 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2391 43969 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 578, __FILE__, __LINE__, true);
2392 43969 : return _r;
2393 : }
2394 0 : next_after_fail704:;
2395 0 : }
2396 : else
2397 : {
2398 86 : if (cmp == LE_EXPR
2399 : )
2400 : {
2401 30 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail705;
2402 30 : {
2403 30 : tree res_op0;
2404 30 : {
2405 30 : tree _o1[1], _r1;
2406 30 : _o1[0] = captures[1];
2407 30 : if (TREE_TYPE (_o1[0]) != st)
2408 : {
2409 30 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, st, _o1[0]);
2410 : }
2411 : else
2412 : _r1 = _o1[0];
2413 30 : res_op0 = _r1;
2414 : }
2415 30 : tree res_op1;
2416 30 : res_op1 = build_zero_cst (st);
2417 30 : tree _r;
2418 30 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
2419 30 : if (TREE_SIDE_EFFECTS (captures[2]))
2420 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2421 30 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 579, __FILE__, __LINE__, true);
2422 30 : return _r;
2423 : }
2424 0 : next_after_fail705:;
2425 : }
2426 : else
2427 : {
2428 56 : if (cmp == GT_EXPR
2429 : )
2430 : {
2431 56 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail706;
2432 56 : {
2433 56 : tree res_op0;
2434 56 : {
2435 56 : tree _o1[1], _r1;
2436 56 : _o1[0] = captures[1];
2437 56 : if (TREE_TYPE (_o1[0]) != st)
2438 : {
2439 56 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, st, _o1[0]);
2440 : }
2441 : else
2442 : _r1 = _o1[0];
2443 56 : res_op0 = _r1;
2444 : }
2445 56 : tree res_op1;
2446 56 : res_op1 = build_zero_cst (st);
2447 56 : tree _r;
2448 56 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
2449 56 : if (TREE_SIDE_EFFECTS (captures[2]))
2450 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2451 56 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 580, __FILE__, __LINE__, true);
2452 56 : return _r;
2453 : }
2454 0 : next_after_fail706:;
2455 : }
2456 : }
2457 : }
2458 : }
2459 : }
2460 : }
2461 : }
2462 : }
2463 : }
2464 : }
2465 : }
2466 21475522 : }
2467 : }
2468 : return NULL_TREE;
2469 : }
2470 :
2471 : tree
2472 0 : generic_simplify_451 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2473 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2474 : {
2475 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2476 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail796;
2477 0 : {
2478 0 : tree res_op0;
2479 0 : res_op0 = captures[0];
2480 0 : tree res_op1;
2481 0 : res_op1 = captures[1];
2482 0 : tree _r;
2483 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2484 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 651, __FILE__, __LINE__, true);
2485 : return _r;
2486 : }
2487 0 : next_after_fail796:;
2488 0 : return NULL_TREE;
2489 : }
2490 :
2491 : tree
2492 362 : generic_simplify_457 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2493 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2494 : const enum tree_code ARG_UNUSED (bitop),
2495 : const enum tree_code ARG_UNUSED (op))
2496 : {
2497 362 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2498 362 : {
2499 362 : tree pmop[2];
2500 362 : tree utype = fold_bit_and_mask (TREE_TYPE (captures[1]), captures[5], op, captures[1], ERROR_MARK,
2501 : NULL_TREE, NULL_TREE, captures[2], bitop, captures[3],
2502 : captures[4], pmop);
2503 362 : if (utype
2504 : )
2505 : {
2506 361 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail802;
2507 361 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail802;
2508 361 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail802;
2509 361 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail802;
2510 361 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail802;
2511 361 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail802;
2512 361 : {
2513 361 : tree res_op0;
2514 361 : {
2515 361 : tree _o1[2], _r1;
2516 361 : {
2517 361 : tree _o2[2], _r2;
2518 361 : {
2519 361 : tree _o3[1], _r3;
2520 361 : _o3[0] = pmop[0];
2521 361 : if (TREE_TYPE (_o3[0]) != utype)
2522 : {
2523 14 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
2524 : }
2525 : else
2526 : _r3 = _o3[0];
2527 361 : _o2[0] = _r3;
2528 : }
2529 361 : {
2530 361 : tree _o3[1], _r3;
2531 361 : _o3[0] = pmop[1];
2532 361 : if (TREE_TYPE (_o3[0]) != utype)
2533 : {
2534 74 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
2535 : }
2536 : else
2537 : _r3 = _o3[0];
2538 361 : _o2[1] = _r3;
2539 : }
2540 361 : _r2 = fold_build2_loc (loc, op, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
2541 361 : _o1[0] = _r2;
2542 : }
2543 361 : {
2544 361 : tree _o2[1], _r2;
2545 361 : _o2[0] = captures[5];
2546 361 : if (TREE_TYPE (_o2[0]) != utype)
2547 : {
2548 14 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2549 : }
2550 : else
2551 : _r2 = _o2[0];
2552 361 : _o1[1] = _r2;
2553 : }
2554 361 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2555 361 : res_op0 = _r1;
2556 : }
2557 361 : tree _r;
2558 361 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2559 361 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 656, __FILE__, __LINE__, true);
2560 361 : return _r;
2561 : }
2562 1 : next_after_fail802:;
2563 : }
2564 : }
2565 1 : return NULL_TREE;
2566 : }
2567 :
2568 : tree
2569 111 : generic_simplify_473 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2570 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2571 : const enum tree_code ARG_UNUSED (code2),
2572 : const enum tree_code ARG_UNUSED (code1))
2573 : {
2574 111 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2575 111 : if ((TREE_CODE (captures[2]) == INTEGER_CST
2576 47 : && TREE_CODE (captures[4]) == INTEGER_CST)
2577 111 : || ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2578 14 : || (VECTOR_TYPE_P (TREE_TYPE (captures[2]))
2579 4 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, code2))
2580 10 : || POINTER_TYPE_P (TREE_TYPE (captures[2])))
2581 54 : && operand_equal_p (captures[2], captures[4]))
2582 : )
2583 : {
2584 51 : {
2585 51 : int cmp = 0;
2586 51 : if (TREE_CODE (captures[2]) == INTEGER_CST
2587 47 : && TREE_CODE (captures[4]) == INTEGER_CST)
2588 47 : cmp = tree_int_cst_compare (captures[2], captures[4]);
2589 51 : if ((code1 == LT_EXPR || code1 == LE_EXPR)
2590 4 : && (code2 == LT_EXPR || code2 == LE_EXPR)
2591 : )
2592 : {
2593 0 : if ((cmp < 0) || (cmp == 0 && code1 == LT_EXPR)
2594 : )
2595 : {
2596 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail832;
2597 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail832;
2598 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail832;
2599 0 : {
2600 0 : tree _r;
2601 0 : _r = captures[0];
2602 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 678, __FILE__, __LINE__, true);
2603 0 : return _r;
2604 : }
2605 : next_after_fail832:;
2606 : }
2607 : else
2608 : {
2609 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail833;
2610 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail833;
2611 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail833;
2612 0 : {
2613 0 : tree _r;
2614 0 : _r = captures[3];
2615 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 679, __FILE__, __LINE__, true);
2616 0 : return _r;
2617 : }
2618 : next_after_fail833:;
2619 : }
2620 : }
2621 : else
2622 : {
2623 51 : if ((code1 == GT_EXPR || code1 == GE_EXPR)
2624 47 : && (code2 == GT_EXPR || code2 == GE_EXPR)
2625 : )
2626 : {
2627 0 : if ((cmp > 0) || (cmp == 0 && code1 == GT_EXPR)
2628 : )
2629 : {
2630 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail834;
2631 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail834;
2632 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail834;
2633 0 : {
2634 0 : tree _r;
2635 0 : _r = captures[0];
2636 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 680, __FILE__, __LINE__, true);
2637 0 : return _r;
2638 : }
2639 : next_after_fail834:;
2640 : }
2641 : else
2642 : {
2643 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail835;
2644 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail835;
2645 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail835;
2646 0 : {
2647 0 : tree _r;
2648 0 : _r = captures[3];
2649 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 681, __FILE__, __LINE__, true);
2650 0 : return _r;
2651 : }
2652 : next_after_fail835:;
2653 : }
2654 : }
2655 : else
2656 : {
2657 51 : if (cmp == 0
2658 4 : && ((code1 == LE_EXPR && code2 == GE_EXPR)
2659 4 : || (code1 == GE_EXPR && code2 == LE_EXPR))
2660 : )
2661 : {
2662 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail836;
2663 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail836;
2664 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail836;
2665 0 : {
2666 0 : tree res_op0;
2667 0 : res_op0 = captures[1];
2668 0 : tree res_op1;
2669 0 : res_op1 = captures[2];
2670 0 : tree _r;
2671 0 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
2672 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 682, __FILE__, __LINE__, true);
2673 0 : return _r;
2674 : }
2675 : next_after_fail836:;
2676 : }
2677 : else
2678 : {
2679 51 : if (cmp <= 0
2680 50 : && (code1 == LT_EXPR || code1 == LE_EXPR)
2681 4 : && (code2 == GT_EXPR || code2 == GE_EXPR)
2682 : )
2683 : {
2684 4 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail837;
2685 4 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail837;
2686 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail837;
2687 4 : {
2688 4 : tree _r;
2689 4 : _r = constant_boolean_node (false, type);
2690 4 : if (TREE_SIDE_EFFECTS (captures[1]))
2691 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2692 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 683, __FILE__, __LINE__, true);
2693 4 : return _r;
2694 : }
2695 : next_after_fail837:;
2696 : }
2697 : else
2698 : {
2699 46 : if (cmp >= 0
2700 1 : && (code1 == GT_EXPR || code1 == GE_EXPR)
2701 1 : && (code2 == LT_EXPR || code2 == LE_EXPR)
2702 : )
2703 : {
2704 1 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail838;
2705 1 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail838;
2706 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail838;
2707 1 : {
2708 1 : tree _r;
2709 1 : _r = constant_boolean_node (false, type);
2710 1 : if (TREE_SIDE_EFFECTS (captures[1]))
2711 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2712 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 684, __FILE__, __LINE__, true);
2713 1 : return _r;
2714 : }
2715 : next_after_fail838:;
2716 : }
2717 : }
2718 : }
2719 : }
2720 : }
2721 : }
2722 : }
2723 : return NULL_TREE;
2724 : }
2725 :
2726 : tree
2727 34 : generic_simplify_490 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2728 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2729 : const combined_fn ARG_UNUSED (bswap))
2730 : {
2731 34 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2732 34 : if (BITS_PER_UNIT == 8
2733 34 : && tree_fits_uhwi_p (captures[2])
2734 34 : && tree_to_uhwi (captures[2]) < 256
2735 : )
2736 : {
2737 32 : {
2738 32 : unsigned HOST_WIDE_INT prec = TYPE_PRECISION (TREE_TYPE (captures[0]));
2739 32 : tree utype = unsigned_type_for (TREE_TYPE (captures[1]));
2740 32 : tree nst = build_int_cst (integer_type_node, prec - 8);
2741 32 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail878;
2742 32 : {
2743 32 : tree res_op0;
2744 32 : {
2745 32 : tree _o1[1], _r1;
2746 32 : {
2747 32 : tree _o2[2], _r2;
2748 32 : {
2749 32 : tree _o3[1], _r3;
2750 32 : _o3[0] = captures[1];
2751 32 : if (TREE_TYPE (_o3[0]) != utype)
2752 : {
2753 0 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
2754 : }
2755 : else
2756 : _r3 = _o3[0];
2757 32 : _o2[0] = _r3;
2758 : }
2759 32 : _o2[1] = nst;
2760 32 : _r2 = fold_build2_loc (loc, RSHIFT_EXPR, utype, _o2[0], _o2[1]);
2761 32 : _o1[0] = _r2;
2762 : }
2763 32 : if (TREE_TYPE (_o1[0]) != type)
2764 : {
2765 18 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2766 : }
2767 : else
2768 : _r1 = _o1[0];
2769 32 : res_op0 = _r1;
2770 : }
2771 32 : tree res_op1;
2772 32 : res_op1 = captures[2];
2773 32 : tree _r;
2774 32 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2775 32 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 694, __FILE__, __LINE__, true);
2776 32 : return _r;
2777 : }
2778 0 : next_after_fail878:;
2779 : }
2780 : }
2781 : return NULL_TREE;
2782 : }
2783 :
2784 : tree
2785 0 : generic_simplify_493 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2786 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2787 : {
2788 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2789 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail881;
2790 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail881;
2791 0 : {
2792 0 : tree _r;
2793 0 : _r = captures[1];
2794 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 696, __FILE__, __LINE__, true);
2795 : return _r;
2796 : }
2797 : next_after_fail881:;
2798 : return NULL_TREE;
2799 : }
2800 :
2801 : tree
2802 28 : generic_simplify_498 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2803 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2804 : {
2805 28 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2806 28 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[0]))
2807 28 : || !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
2808 : )
2809 : {
2810 28 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail887;
2811 28 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail887;
2812 28 : {
2813 28 : tree res_op0;
2814 28 : {
2815 28 : tree _o1[1], _r1;
2816 28 : _o1[0] = captures[0];
2817 28 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2818 28 : res_op0 = _r1;
2819 : }
2820 28 : tree _r;
2821 28 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2822 28 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 702, __FILE__, __LINE__, true);
2823 28 : return _r;
2824 : }
2825 : next_after_fail887:;
2826 : }
2827 : return NULL_TREE;
2828 : }
2829 :
2830 : tree
2831 0 : generic_simplify_506 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2832 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2833 : const enum tree_code ARG_UNUSED (rotate))
2834 : {
2835 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2836 0 : if ((element_precision (TREE_TYPE (captures[2]))
2837 0 : <= element_precision (TREE_TYPE (captures[3]))
2838 0 : || !TYPE_UNSIGNED (TREE_TYPE (captures[3])))
2839 0 : && (element_precision (type) <= element_precision (TREE_TYPE (captures[2]))
2840 0 : || !TYPE_UNSIGNED (TREE_TYPE (captures[2])))
2841 : )
2842 : {
2843 0 : {
2844 0 : tree rotate_type = TREE_TYPE (captures[2]);
2845 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail895;
2846 0 : {
2847 0 : tree res_op0;
2848 0 : {
2849 0 : tree _o1[2], _r1;
2850 0 : {
2851 0 : tree _o2[1], _r2;
2852 0 : _o2[0] = captures[3];
2853 0 : if (TREE_TYPE (_o2[0]) != rotate_type)
2854 : {
2855 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, rotate_type, _o2[0]);
2856 : }
2857 : else
2858 : _r2 = _o2[0];
2859 0 : _o1[0] = _r2;
2860 : }
2861 0 : _o1[1] = captures[4];
2862 0 : _r1 = fold_build2_loc (loc, rotate, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2863 0 : res_op0 = _r1;
2864 : }
2865 0 : tree _r;
2866 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2867 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 709, __FILE__, __LINE__, true);
2868 0 : return _r;
2869 : }
2870 0 : next_after_fail895:;
2871 : }
2872 : }
2873 : return NULL_TREE;
2874 : }
2875 :
2876 : tree
2877 0 : generic_simplify_517 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2878 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2879 : const enum tree_code ARG_UNUSED (minmax))
2880 : {
2881 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2882 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail908;
2883 0 : {
2884 0 : tree _r;
2885 0 : _r = captures[0];
2886 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 721, __FILE__, __LINE__, true);
2887 : return _r;
2888 : }
2889 0 : next_after_fail908:;
2890 0 : return NULL_TREE;
2891 : }
2892 :
2893 : tree
2894 0 : generic_simplify_524 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2895 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2896 : const enum tree_code ARG_UNUSED (minmax))
2897 : {
2898 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2899 0 : if (TYPE_UNSIGNED (type)
2900 0 : || (tree_int_cst_sgn (captures[2]) == tree_int_cst_sgn (captures[4]))
2901 : )
2902 : {
2903 0 : {
2904 0 : auto andvalue = wi::to_wide (captures[2]) & wi::to_wide (captures[4]);
2905 0 : if (andvalue == ((minmax == MIN_EXPR)
2906 0 : ? wi::to_wide (captures[2]) : wi::to_wide (captures[4]))
2907 : )
2908 : {
2909 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail915;
2910 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail915;
2911 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail915;
2912 0 : {
2913 0 : tree _r;
2914 0 : _r = captures[0];
2915 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 727, __FILE__, __LINE__, true);
2916 0 : return _r;
2917 : }
2918 0 : next_after_fail915:;
2919 : }
2920 : else
2921 : {
2922 0 : if (andvalue == ((minmax != MIN_EXPR)
2923 0 : ? wi::to_wide (captures[2]) : wi::to_wide (captures[4]))
2924 : )
2925 : {
2926 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail916;
2927 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail916;
2928 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail916;
2929 0 : {
2930 0 : tree _r;
2931 0 : _r = captures[3];
2932 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 728, __FILE__, __LINE__, true);
2933 0 : return _r;
2934 : }
2935 0 : next_after_fail916:;
2936 : }
2937 : }
2938 0 : }
2939 : }
2940 : return NULL_TREE;
2941 : }
2942 :
2943 : tree
2944 0 : generic_simplify_537 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2945 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2946 : const combined_fn ARG_UNUSED (FMAX_ALL))
2947 : {
2948 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2949 0 : if (flag_finite_math_only
2950 : )
2951 : {
2952 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail942;
2953 0 : {
2954 0 : tree res_op0;
2955 0 : res_op0 = captures[0];
2956 0 : tree res_op1;
2957 0 : res_op1 = captures[1];
2958 0 : tree _r;
2959 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
2960 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 742, __FILE__, __LINE__, true);
2961 0 : return _r;
2962 : }
2963 0 : next_after_fail942:;
2964 : }
2965 : return NULL_TREE;
2966 : }
2967 :
2968 : tree
2969 0 : generic_simplify_543 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2970 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
2971 : const combined_fn ARG_UNUSED (cond_op))
2972 : {
2973 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2974 0 : {
2975 0 : tree op_type = TREE_TYPE (captures[3]);
2976 0 : if (element_precision (type) == element_precision (op_type)
2977 : )
2978 : {
2979 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail948;
2980 0 : {
2981 0 : tree res_op0;
2982 0 : {
2983 0 : tree _o1[4], _r1;
2984 0 : _o1[0] = captures[0];
2985 0 : _o1[1] = captures[1];
2986 0 : _o1[2] = captures[2];
2987 0 : {
2988 0 : tree _o2[1], _r2;
2989 0 : _o2[0] = captures[4];
2990 0 : if (TREE_TYPE (_o2[0]) != op_type)
2991 : {
2992 0 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
2993 : }
2994 : else
2995 : _r2 = _o2[0];
2996 0 : _o1[3] = _r2;
2997 : }
2998 0 : _r1 = maybe_build_call_expr_loc (loc, cond_op, TREE_TYPE (_o1[1]), 4, _o1[0], _o1[1], _o1[2], _o1[3]);
2999 0 : if (!_r1)
3000 0 : goto next_after_fail948;
3001 0 : res_op0 = _r1;
3002 : }
3003 0 : tree _r;
3004 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3005 0 : if (TREE_SIDE_EFFECTS (captures[3]))
3006 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
3007 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 743, __FILE__, __LINE__, true);
3008 0 : return _r;
3009 : }
3010 : next_after_fail948:;
3011 : }
3012 : }
3013 : return NULL_TREE;
3014 : }
3015 :
3016 : tree
3017 0 : generic_simplify_553 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3018 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
3019 : const enum tree_code ARG_UNUSED (rotate))
3020 : {
3021 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3022 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail958;
3023 0 : {
3024 0 : tree _r;
3025 0 : _r = captures[0];
3026 0 : if (TREE_SIDE_EFFECTS (captures[1]))
3027 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3028 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 753, __FILE__, __LINE__, true);
3029 : return _r;
3030 : }
3031 0 : next_after_fail958:;
3032 0 : return NULL_TREE;
3033 : }
3034 :
3035 : tree
3036 60 : generic_simplify_562 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3037 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
3038 : const enum tree_code ARG_UNUSED (cmp))
3039 : {
3040 60 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3041 60 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail970;
3042 60 : {
3043 60 : tree _r;
3044 60 : _r = constant_boolean_node (true, type);
3045 60 : if (TREE_SIDE_EFFECTS (captures[0]))
3046 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3047 60 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 765, __FILE__, __LINE__, true);
3048 : return _r;
3049 : }
3050 0 : next_after_fail970:;
3051 0 : return NULL_TREE;
3052 : }
3053 :
3054 : tree
3055 0 : generic_simplify_569 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3056 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3057 : const combined_fn ARG_UNUSED (sins),
3058 : const combined_fn ARG_UNUSED (atans),
3059 : const combined_fn ARG_UNUSED (sqrts),
3060 : const combined_fn ARG_UNUSED (copysigns))
3061 : {
3062 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3063 0 : {
3064 0 : REAL_VALUE_TYPE r_cst;
3065 0 : build_sinatan_real (&r_cst, type);
3066 0 : tree t_cst = build_real (type, r_cst);
3067 0 : tree t_one = build_one_cst (type);
3068 0 : if (SCALAR_FLOAT_TYPE_P (type)
3069 : )
3070 : {
3071 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail977;
3072 0 : {
3073 0 : if (! tree_invariant_p (captures[1])) goto next_after_fail977;
3074 0 : tree res_op0;
3075 0 : {
3076 0 : tree _o1[2], _r1;
3077 0 : {
3078 0 : tree _o2[1], _r2;
3079 0 : _o2[0] = unshare_expr (captures[1]);
3080 0 : _r2 = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
3081 0 : _o1[0] = _r2;
3082 : }
3083 0 : _o1[1] = t_cst;
3084 0 : _r1 = fold_build2_loc (loc, LT_EXPR, boolean_type_node, _o1[0], _o1[1]);
3085 0 : res_op0 = _r1;
3086 : }
3087 0 : tree res_op1;
3088 0 : {
3089 0 : tree _o1[2], _r1;
3090 0 : _o1[0] = unshare_expr (captures[1]);
3091 0 : {
3092 0 : tree _o2[1], _r2;
3093 0 : {
3094 0 : tree _o3[2], _r3;
3095 0 : {
3096 0 : tree _o4[2], _r4;
3097 0 : _o4[0] = unshare_expr (captures[1]);
3098 0 : _o4[1] = unshare_expr (captures[1]);
3099 0 : _r4 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o4[0]), _o4[0], _o4[1]);
3100 0 : _o3[0] = _r4;
3101 : }
3102 0 : _o3[1] = t_one;
3103 0 : _r3 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
3104 0 : _o2[0] = _r3;
3105 : }
3106 0 : _r2 = maybe_build_call_expr_loc (loc, sqrts, TREE_TYPE (_o2[0]), 1, _o2[0]);
3107 0 : if (!_r2)
3108 0 : goto next_after_fail977;
3109 0 : _o1[1] = _r2;
3110 : }
3111 0 : _r1 = fold_build2_loc (loc, RDIV_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3112 0 : res_op1 = _r1;
3113 : }
3114 0 : tree res_op2;
3115 0 : {
3116 0 : tree _o1[2], _r1;
3117 0 : _o1[0] = t_one;
3118 0 : _o1[1] = captures[1];
3119 0 : _r1 = maybe_build_call_expr_loc (loc, copysigns, TREE_TYPE (_o1[0]), 2, _o1[0], _o1[1]);
3120 0 : if (!_r1)
3121 0 : goto next_after_fail977;
3122 0 : res_op2 = _r1;
3123 : }
3124 0 : tree _r;
3125 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
3126 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 772, __FILE__, __LINE__, true);
3127 0 : return _r;
3128 : }
3129 0 : next_after_fail977:;
3130 : }
3131 : }
3132 0 : 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 (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures))
3138 : {
3139 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3140 0 : if (canonicalize_math_after_vectorization_p ()
3141 : )
3142 : {
3143 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail999;
3144 : {
3145 : tree res_op0;
3146 : res_op0 = captures[0];
3147 : tree res_op1;
3148 : res_op1 = captures[1];
3149 : tree res_op2;
3150 : res_op2 = captures[2];
3151 : tree _r;
3152 : _r = maybe_build_call_expr_loc (loc, CFN_FNMA, type, 3, res_op0, res_op1, res_op2);
3153 : if (!_r)
3154 : goto next_after_fail999;
3155 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 794, __FILE__, __LINE__, true);
3156 : return _r;
3157 : }
3158 0 : next_after_fail999:;
3159 : }
3160 0 : return NULL_TREE;
3161 : }
3162 :
3163 : tree
3164 0 : generic_simplify_601 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3165 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree ARG_UNUSED (_p3), tree ARG_UNUSED (_p4), tree *ARG_UNUSED (captures))
3166 : {
3167 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3168 0 : if (canonicalize_math_after_vectorization_p ()
3169 : )
3170 : {
3171 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1009;
3172 : {
3173 : tree res_op0;
3174 : res_op0 = captures[0];
3175 : tree res_op1;
3176 : res_op1 = captures[1];
3177 : tree res_op2;
3178 : res_op2 = captures[2];
3179 : tree res_op3;
3180 : res_op3 = captures[3];
3181 : tree res_op4;
3182 : res_op4 = captures[4];
3183 : tree _r;
3184 : _r = maybe_build_call_expr_loc (loc, CFN_COND_FMS, type, 5, res_op0, res_op1, res_op2, res_op3, res_op4);
3185 : if (!_r)
3186 : goto next_after_fail1009;
3187 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 804, __FILE__, __LINE__, true);
3188 : return _r;
3189 : }
3190 0 : next_after_fail1009:;
3191 : }
3192 0 : return NULL_TREE;
3193 : }
3194 :
3195 : tree
3196 0 : generic_simplify_611 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3197 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3198 : const combined_fn ARG_UNUSED (bswap),
3199 : const combined_fn ARG_UNUSED (popcount))
3200 : {
3201 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3202 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3203 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
3204 : )
3205 : {
3206 0 : {
3207 0 : tree type0 = TREE_TYPE (captures[0]);
3208 0 : tree type1 = TREE_TYPE (captures[1]);
3209 0 : unsigned int prec0 = TYPE_PRECISION (type0);
3210 0 : unsigned int prec1 = TYPE_PRECISION (type1);
3211 0 : if (prec0 == prec1 || (prec0 > prec1 && TYPE_UNSIGNED (type1))
3212 : )
3213 : {
3214 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1019;
3215 0 : {
3216 0 : tree res_op0;
3217 0 : {
3218 0 : tree _o1[1], _r1;
3219 0 : {
3220 0 : tree _o2[1], _r2;
3221 0 : _o2[0] = captures[2];
3222 0 : if (TREE_TYPE (_o2[0]) != type1)
3223 : {
3224 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, type1, _o2[0]);
3225 : }
3226 : else
3227 : _r2 = _o2[0];
3228 0 : _o1[0] = _r2;
3229 : }
3230 0 : if (TREE_TYPE (_o1[0]) != type0)
3231 : {
3232 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type0, _o1[0]);
3233 : }
3234 : else
3235 : _r1 = _o1[0];
3236 0 : res_op0 = _r1;
3237 : }
3238 0 : tree _r;
3239 0 : _r = maybe_build_call_expr_loc (loc, popcount, type, 1, res_op0);
3240 0 : if (!_r)
3241 0 : goto next_after_fail1019;
3242 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 808, __FILE__, __LINE__, true);
3243 0 : return _r;
3244 : }
3245 : next_after_fail1019:;
3246 : }
3247 : }
3248 : }
3249 : return NULL_TREE;
3250 : }
3251 :
3252 : tree
3253 714242381 : generic_simplify_CONVERT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0)
3254 : {
3255 714242381 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3256 714242381 : switch (TREE_CODE (_p0))
3257 : {
3258 730642 : case NEGATE_EXPR:
3259 730642 : {
3260 730642 : tree _q20 = TREE_OPERAND (_p0, 0);
3261 730642 : switch (TREE_CODE (_q20))
3262 : {
3263 392006 : CASE_CONVERT:
3264 392006 : {
3265 392006 : tree _q30 = TREE_OPERAND (_q20, 0);
3266 392006 : {
3267 392006 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q30 };
3268 392006 : if (INTEGRAL_TYPE_P (type)
3269 391705 : && tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
3270 387965 : && (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (captures[2]))
3271 387114 : || TYPE_UNSIGNED (type))
3272 417220 : && TREE_CODE (type) != BOOLEAN_TYPE
3273 : )
3274 : {
3275 25214 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1038;
3276 25214 : {
3277 25214 : tree res_op0;
3278 25214 : {
3279 25214 : tree _o1[1], _r1;
3280 25214 : _o1[0] = captures[2];
3281 25214 : if (TREE_TYPE (_o1[0]) != type)
3282 : {
3283 25172 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3284 : }
3285 : else
3286 : _r1 = _o1[0];
3287 25214 : res_op0 = _r1;
3288 : }
3289 25214 : tree _r;
3290 25214 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
3291 25214 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 826, __FILE__, __LINE__, true);
3292 25214 : return _r;
3293 : }
3294 0 : next_after_fail1038:;
3295 : }
3296 : }
3297 366792 : break;
3298 : }
3299 : default:;
3300 : }
3301 : break;
3302 : }
3303 1181835 : case BIT_AND_EXPR:
3304 1181835 : {
3305 1181835 : tree _q20 = TREE_OPERAND (_p0, 0);
3306 1181835 : tree _q21 = TREE_OPERAND (_p0, 1);
3307 1181835 : {
3308 1181835 : tree _q20_pops[1];
3309 1181835 : if (tree_nop_convert (_q20, _q20_pops))
3310 : {
3311 597497 : tree _q30 = _q20_pops[0];
3312 597497 : {
3313 597497 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3314 597497 : tree res = generic_simplify_427 (loc, type, _p0, captures, BIT_AND_EXPR);
3315 597497 : if (res) return res;
3316 : }
3317 : }
3318 : }
3319 1181835 : {
3320 1181835 : tree _q21_pops[1];
3321 1181835 : if (tree_nop_convert (_q21, _q21_pops))
3322 : {
3323 509497 : tree _q40 = _q21_pops[0];
3324 509497 : {
3325 509497 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3326 509497 : tree res = generic_simplify_427 (loc, type, _p0, captures, BIT_AND_EXPR);
3327 509497 : if (res) return res;
3328 : }
3329 : }
3330 : }
3331 1181835 : switch (TREE_CODE (_q20))
3332 : {
3333 668474 : CASE_CONVERT:
3334 668474 : {
3335 668474 : tree _q30 = TREE_OPERAND (_q20, 0);
3336 668474 : {
3337 668474 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3338 668474 : tree res = generic_simplify_428 (loc, type, _p0, captures, BIT_AND_EXPR);
3339 668474 : if (res) return res;
3340 : }
3341 668474 : break;
3342 : }
3343 1181835 : default:;
3344 : }
3345 1181835 : switch (TREE_CODE (_q21))
3346 : {
3347 510276 : CASE_CONVERT:
3348 510276 : {
3349 510276 : tree _q40 = TREE_OPERAND (_q21, 0);
3350 510276 : {
3351 510276 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3352 510276 : tree res = generic_simplify_428 (loc, type, _p0, captures, BIT_AND_EXPR);
3353 510276 : if (res) return res;
3354 : }
3355 510276 : break;
3356 : }
3357 : default:;
3358 : }
3359 : break;
3360 : }
3361 1133956 : case BIT_IOR_EXPR:
3362 1133956 : {
3363 1133956 : tree _q20 = TREE_OPERAND (_p0, 0);
3364 1133956 : tree _q21 = TREE_OPERAND (_p0, 1);
3365 1133956 : {
3366 1133956 : tree _q20_pops[1];
3367 1133956 : if (tree_nop_convert (_q20, _q20_pops))
3368 : {
3369 415973 : tree _q30 = _q20_pops[0];
3370 415973 : {
3371 415973 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3372 415973 : tree res = generic_simplify_427 (loc, type, _p0, captures, BIT_IOR_EXPR);
3373 415973 : if (res) return res;
3374 : }
3375 : }
3376 : }
3377 1133956 : {
3378 1133956 : tree _q21_pops[1];
3379 1133956 : if (tree_nop_convert (_q21, _q21_pops))
3380 : {
3381 1063129 : tree _q40 = _q21_pops[0];
3382 1063129 : {
3383 1063129 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3384 1063129 : tree res = generic_simplify_427 (loc, type, _p0, captures, BIT_IOR_EXPR);
3385 1063129 : if (res) return res;
3386 : }
3387 : }
3388 : }
3389 1133956 : switch (TREE_CODE (_q20))
3390 : {
3391 432767 : CASE_CONVERT:
3392 432767 : {
3393 432767 : tree _q30 = TREE_OPERAND (_q20, 0);
3394 432767 : {
3395 432767 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3396 432767 : tree res = generic_simplify_428 (loc, type, _p0, captures, BIT_IOR_EXPR);
3397 432767 : if (res) return res;
3398 : }
3399 432767 : break;
3400 : }
3401 1133956 : default:;
3402 : }
3403 1133956 : switch (TREE_CODE (_q21))
3404 : {
3405 1070949 : CASE_CONVERT:
3406 1070949 : {
3407 1070949 : tree _q40 = TREE_OPERAND (_q21, 0);
3408 1070949 : {
3409 1070949 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3410 1070949 : tree res = generic_simplify_428 (loc, type, _p0, captures, BIT_IOR_EXPR);
3411 1070949 : if (res) return res;
3412 : }
3413 1070949 : break;
3414 : }
3415 : default:;
3416 : }
3417 : break;
3418 : }
3419 576627 : case BIT_XOR_EXPR:
3420 576627 : {
3421 576627 : tree _q20 = TREE_OPERAND (_p0, 0);
3422 576627 : tree _q21 = TREE_OPERAND (_p0, 1);
3423 576627 : {
3424 576627 : tree _q20_pops[1];
3425 576627 : if (tree_nop_convert (_q20, _q20_pops))
3426 : {
3427 330016 : tree _q30 = _q20_pops[0];
3428 330016 : {
3429 330016 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3430 330016 : tree res = generic_simplify_427 (loc, type, _p0, captures, BIT_XOR_EXPR);
3431 330016 : if (res) return res;
3432 : }
3433 : }
3434 : }
3435 576627 : {
3436 576627 : tree _q21_pops[1];
3437 576627 : if (tree_nop_convert (_q21, _q21_pops))
3438 : {
3439 464312 : tree _q40 = _q21_pops[0];
3440 464312 : {
3441 464312 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3442 464312 : tree res = generic_simplify_427 (loc, type, _p0, captures, BIT_XOR_EXPR);
3443 464312 : if (res) return res;
3444 : }
3445 : }
3446 : }
3447 576627 : switch (TREE_CODE (_q20))
3448 : {
3449 370442 : CASE_CONVERT:
3450 370442 : {
3451 370442 : tree _q30 = TREE_OPERAND (_q20, 0);
3452 370442 : {
3453 370442 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3454 370442 : tree res = generic_simplify_428 (loc, type, _p0, captures, BIT_XOR_EXPR);
3455 370442 : if (res) return res;
3456 : }
3457 370442 : break;
3458 : }
3459 576627 : default:;
3460 : }
3461 576627 : switch (TREE_CODE (_q21))
3462 : {
3463 503724 : CASE_CONVERT:
3464 503724 : {
3465 503724 : tree _q40 = TREE_OPERAND (_q21, 0);
3466 503724 : {
3467 503724 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3468 503724 : tree res = generic_simplify_428 (loc, type, _p0, captures, BIT_XOR_EXPR);
3469 503724 : if (res) return res;
3470 : }
3471 503724 : break;
3472 : }
3473 : default:;
3474 : }
3475 : break;
3476 : }
3477 9060653 : case MULT_EXPR:
3478 9060653 : {
3479 9060653 : tree _q20 = TREE_OPERAND (_p0, 0);
3480 9060653 : tree _q21 = TREE_OPERAND (_p0, 1);
3481 9060653 : if (tree_zero_one_valued_p (_q20))
3482 : {
3483 57498 : switch (TREE_CODE (_q21))
3484 : {
3485 52021 : case INTEGER_CST:
3486 52021 : {
3487 52021 : {
3488 52021 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
3489 52021 : if (INTEGRAL_TYPE_P (type)
3490 52021 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3491 52021 : && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (captures[0]))
3492 52027 : && (TYPE_UNSIGNED (type) || TYPE_PRECISION (type) > 1)
3493 : )
3494 : {
3495 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1039;
3496 6 : {
3497 6 : tree res_op0;
3498 6 : {
3499 6 : tree _o1[1], _r1;
3500 6 : _o1[0] = captures[1];
3501 6 : if (TREE_TYPE (_o1[0]) != type)
3502 : {
3503 6 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3504 : }
3505 : else
3506 : _r1 = _o1[0];
3507 6 : res_op0 = _r1;
3508 : }
3509 6 : tree res_op1;
3510 6 : {
3511 6 : tree _o1[1], _r1;
3512 6 : _o1[0] = captures[2];
3513 6 : if (TREE_TYPE (_o1[0]) != type)
3514 : {
3515 6 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3516 : }
3517 : else
3518 : _r1 = _o1[0];
3519 6 : res_op1 = _r1;
3520 : }
3521 6 : tree _r;
3522 6 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
3523 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 827, __FILE__, __LINE__, true);
3524 6 : return _r;
3525 : }
3526 0 : next_after_fail1039:;
3527 : }
3528 : }
3529 52015 : break;
3530 : }
3531 : default:;
3532 : }
3533 : }
3534 : break;
3535 : }
3536 1107785 : case POINTER_DIFF_EXPR:
3537 1107785 : {
3538 1107785 : tree _q20 = TREE_OPERAND (_p0, 0);
3539 1107785 : tree _q21 = TREE_OPERAND (_p0, 1);
3540 1107785 : switch (TREE_CODE (_q21))
3541 : {
3542 200 : case INTEGER_CST:
3543 200 : {
3544 200 : {
3545 200 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3546 200 : if (POINTER_TYPE_P (type)
3547 : )
3548 : {
3549 18 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1040;
3550 18 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1040;
3551 18 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1040;
3552 18 : {
3553 18 : tree _r;
3554 18 : _r = build_fold_addr_expr_with_type
3555 : (build2 (MEM_REF, char_type_node, captures[0],
3556 : wide_int_to_tree (ptr_type_node, wi::neg (wi::to_wide (captures[1])))),
3557 : type);
3558 18 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 828, __FILE__, __LINE__, true);
3559 18 : return _r;
3560 : }
3561 182 : next_after_fail1040:;
3562 : }
3563 : }
3564 182 : break;
3565 : }
3566 : default:;
3567 : }
3568 : break;
3569 : }
3570 203441 : case EQ_EXPR:
3571 203441 : {
3572 203441 : tree _q20 = TREE_OPERAND (_p0, 0);
3573 203441 : tree _q21 = TREE_OPERAND (_p0, 1);
3574 203441 : if (tree_zero_one_valued_p (_q20))
3575 : {
3576 1583 : switch (TREE_CODE (_q21))
3577 : {
3578 710 : case INTEGER_CST:
3579 710 : {
3580 710 : {
3581 710 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3582 710 : tree res = generic_simplify_429 (loc, type, _p0, captures, EQ_EXPR);
3583 710 : if (res) return res;
3584 : }
3585 663 : break;
3586 : }
3587 : default:;
3588 : }
3589 : }
3590 : break;
3591 : }
3592 254772 : case NE_EXPR:
3593 254772 : {
3594 254772 : tree _q20 = TREE_OPERAND (_p0, 0);
3595 254772 : tree _q21 = TREE_OPERAND (_p0, 1);
3596 254772 : if (tree_zero_one_valued_p (_q20))
3597 : {
3598 1851 : switch (TREE_CODE (_q21))
3599 : {
3600 1525 : case INTEGER_CST:
3601 1525 : {
3602 1525 : {
3603 1525 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3604 1525 : tree res = generic_simplify_429 (loc, type, _p0, captures, NE_EXPR);
3605 1525 : if (res) return res;
3606 : }
3607 1 : break;
3608 : }
3609 : default:;
3610 : }
3611 : }
3612 : break;
3613 : }
3614 1996 : case MIN_EXPR:
3615 1996 : {
3616 1996 : tree _q20 = TREE_OPERAND (_p0, 0);
3617 1996 : tree _q21 = TREE_OPERAND (_p0, 1);
3618 1996 : switch (TREE_CODE (_q20))
3619 : {
3620 731 : CASE_CONVERT:
3621 731 : {
3622 731 : tree _q30 = TREE_OPERAND (_q20, 0);
3623 731 : switch (TREE_CODE (_q21))
3624 : {
3625 659 : case INTEGER_CST:
3626 659 : {
3627 659 : {
3628 659 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q21 };
3629 659 : tree res = generic_simplify_430 (loc, type, _p0, captures, MIN_EXPR);
3630 659 : if (res) return res;
3631 : }
3632 659 : break;
3633 : }
3634 : default:;
3635 : }
3636 : break;
3637 : }
3638 : default:;
3639 : }
3640 : break;
3641 : }
3642 299460 : case MAX_EXPR:
3643 299460 : {
3644 299460 : tree _q20 = TREE_OPERAND (_p0, 0);
3645 299460 : tree _q21 = TREE_OPERAND (_p0, 1);
3646 299460 : switch (TREE_CODE (_q20))
3647 : {
3648 6573 : CASE_CONVERT:
3649 6573 : {
3650 6573 : tree _q30 = TREE_OPERAND (_q20, 0);
3651 6573 : switch (TREE_CODE (_q21))
3652 : {
3653 6537 : case INTEGER_CST:
3654 6537 : {
3655 6537 : {
3656 6537 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q21 };
3657 6537 : tree res = generic_simplify_430 (loc, type, _p0, captures, MAX_EXPR);
3658 6537 : if (res) return res;
3659 : }
3660 6537 : break;
3661 : }
3662 : default:;
3663 : }
3664 : break;
3665 : }
3666 : default:;
3667 : }
3668 : break;
3669 : }
3670 464319 : case LSHIFT_EXPR:
3671 464319 : {
3672 464319 : tree _q20 = TREE_OPERAND (_p0, 0);
3673 464319 : tree _q21 = TREE_OPERAND (_p0, 1);
3674 464319 : switch (TREE_CODE (_q21))
3675 : {
3676 141044 : case INTEGER_CST:
3677 141044 : {
3678 141044 : {
3679 141044 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
3680 141044 : if (INTEGRAL_TYPE_P (type)
3681 141017 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3682 141017 : && !integer_zerop (captures[2])
3683 281288 : && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (captures[0]))
3684 : )
3685 : {
3686 138961 : if (TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (captures[0]))
3687 138961 : || wi::ltu_p (wi::to_wide (captures[2]), TYPE_PRECISION (type))
3688 : )
3689 : {
3690 138653 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1041;
3691 138653 : {
3692 138653 : tree res_op0;
3693 138653 : {
3694 138653 : tree _o1[1], _r1;
3695 138653 : _o1[0] = captures[1];
3696 138653 : if (TREE_TYPE (_o1[0]) != type)
3697 : {
3698 129579 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3699 : }
3700 : else
3701 : _r1 = _o1[0];
3702 138653 : res_op0 = _r1;
3703 : }
3704 138653 : tree res_op1;
3705 138653 : res_op1 = captures[2];
3706 138653 : tree _r;
3707 138653 : _r = fold_build2_loc (loc, LSHIFT_EXPR, type, res_op0, res_op1);
3708 138653 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 829, __FILE__, __LINE__, true);
3709 138653 : return _r;
3710 : }
3711 0 : next_after_fail1041:;
3712 : }
3713 : else
3714 : {
3715 308 : if (wi::ltu_p (wi::to_wide (captures[2]), TYPE_PRECISION (TREE_TYPE (captures[0])))
3716 : )
3717 : {
3718 259 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1042;
3719 259 : {
3720 259 : tree _r;
3721 259 : _r = build_zero_cst (type);
3722 259 : if (TREE_SIDE_EFFECTS (captures[1]))
3723 14 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3724 259 : if (TREE_SIDE_EFFECTS (captures[2]))
3725 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
3726 259 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 830, __FILE__, __LINE__, true);
3727 259 : return _r;
3728 : }
3729 0 : next_after_fail1042:;
3730 : }
3731 : }
3732 : }
3733 : }
3734 2132 : break;
3735 : }
3736 : default:;
3737 : }
3738 : break;
3739 : }
3740 714076660 : default:;
3741 : }
3742 714076660 : {
3743 714076660 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3744 1428153320 : if ((
3745 :
3746 : && useless_type_conversion_p (type, TREE_TYPE (captures[0])))
3747 : || (
3748 : 1
3749 714076660 : && type == TREE_TYPE (captures[0]))
3750 : )
3751 : {
3752 47981421 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1043;
3753 47981421 : {
3754 47981421 : tree _r;
3755 47981421 : _r = captures[0];
3756 47981421 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 831, __FILE__, __LINE__, true);
3757 47981421 : return _r;
3758 : }
3759 0 : next_after_fail1043:;
3760 : }
3761 : }
3762 666095239 : switch (TREE_CODE (_p0))
3763 : {
3764 94712018 : CASE_CONVERT:
3765 94712018 : {
3766 94712018 : tree _q20 = TREE_OPERAND (_p0, 0);
3767 94712018 : {
3768 94712018 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3769 94712018 : {
3770 94712018 : tree inside_type = TREE_TYPE (captures[1]);
3771 94712018 : tree inter_type = TREE_TYPE (captures[0]);
3772 94712018 : int inside_int = INTEGRAL_TYPE_P (inside_type);
3773 94712018 : int inside_ptr = POINTER_TYPE_P (inside_type);
3774 94712018 : int inside_float = FLOAT_TYPE_P (inside_type);
3775 94712018 : int inside_vec = VECTOR_TYPE_P (inside_type);
3776 94712018 : unsigned int inside_prec = element_precision (inside_type);
3777 94712018 : int inside_unsignedp = TYPE_UNSIGNED (inside_type);
3778 94712018 : int inter_int = INTEGRAL_TYPE_P (inter_type);
3779 94712018 : int inter_ptr = POINTER_TYPE_P (inter_type);
3780 94712018 : int inter_float = FLOAT_TYPE_P (inter_type);
3781 94712018 : int inter_vec = VECTOR_TYPE_P (inter_type);
3782 94712018 : unsigned int inter_prec = element_precision (inter_type);
3783 94712018 : int inter_unsignedp = TYPE_UNSIGNED (inter_type);
3784 94712018 : int final_int = INTEGRAL_TYPE_P (type);
3785 94712018 : int final_ptr = POINTER_TYPE_P (type);
3786 94712018 : int final_float = FLOAT_TYPE_P (type);
3787 94712018 : int final_vec = VECTOR_TYPE_P (type);
3788 94712018 : unsigned int final_prec = element_precision (type);
3789 94712018 : int final_unsignedp = TYPE_UNSIGNED (type);
3790 94712018 : if (((
3791 :
3792 : && useless_type_conversion_p (type, inside_type))
3793 : || (
3794 : 1
3795 94712018 : && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
3796 22319949 : && (((inter_int || inter_ptr) && final_int)
3797 16754867 : || (inter_float && final_float))
3798 100356220 : && inter_prec >= final_prec
3799 : )
3800 : {
3801 5121752 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1044;
3802 5121752 : {
3803 5121752 : tree res_op0;
3804 5121752 : res_op0 = captures[1];
3805 5121752 : tree _r;
3806 5121752 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3807 5121752 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 832, __FILE__, __LINE__, true);
3808 5121752 : return _r;
3809 : }
3810 0 : next_after_fail1044:;
3811 : }
3812 : else
3813 : {
3814 89590266 : if (((inter_int && inside_int) || (inter_float && inside_float))
3815 12378539 : && (final_int || final_float)
3816 12248403 : && inter_prec >= inside_prec
3817 11007603 : && (inter_float || inter_unsignedp == inside_unsignedp)
3818 : )
3819 : {
3820 7612500 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1045;
3821 7612500 : {
3822 7612500 : tree res_op0;
3823 7612500 : res_op0 = captures[1];
3824 7612500 : tree _r;
3825 7612500 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3826 7612500 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 833, __FILE__, __LINE__, true);
3827 7612500 : return _r;
3828 : }
3829 0 : next_after_fail1045:;
3830 0 : }
3831 : else
3832 : {
3833 81977766 : if (inside_int && inter_int && final_int
3834 4629602 : && ((inside_prec < inter_prec && inter_prec < final_prec
3835 191150 : && inside_unsignedp && !inter_unsignedp)
3836 4465228 : || final_prec == inter_prec
3837 2318307 : || (inside_prec < inter_prec && inter_prec > final_prec
3838 154119 : && !inside_unsignedp && inter_unsignedp))
3839 : )
3840 : {
3841 2376870 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1046;
3842 2376870 : {
3843 2376870 : tree res_op0;
3844 2376870 : res_op0 = captures[1];
3845 2376870 : tree _r;
3846 2376870 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3847 2376870 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 834, __FILE__, __LINE__, true);
3848 2376870 : return _r;
3849 : }
3850 0 : next_after_fail1046:;
3851 0 : }
3852 : else
3853 : {
3854 79600896 : if (! inside_float && ! inter_float && ! final_float
3855 : && ! inside_vec && ! inter_vec && ! final_vec
3856 79594591 : && (inter_prec >= inside_prec || inter_prec >= final_prec)
3857 78865021 : && ! (inside_int && inter_int
3858 1653294 : && inter_unsignedp != inside_unsignedp
3859 1653294 : && inter_prec < final_prec)
3860 77511020 : && ((inter_unsignedp && inter_prec > inside_prec)
3861 77511020 : == (final_unsignedp && final_prec > inter_prec))
3862 77488530 : && ! (inside_ptr && inter_prec != final_prec)
3863 77013604 : && ! (final_ptr && inside_prec != inter_prec)
3864 : )
3865 : {
3866 76992830 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1047;
3867 76992830 : {
3868 76992830 : tree res_op0;
3869 76992830 : res_op0 = captures[1];
3870 76992830 : tree _r;
3871 76992830 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3872 76992830 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 835, __FILE__, __LINE__, true);
3873 76992830 : return _r;
3874 : }
3875 0 : next_after_fail1047:;
3876 0 : }
3877 : else
3878 : {
3879 2608066 : if (inside_int && inter_int && final_int
3880 2113059 : && final_prec <= inside_prec
3881 670384 : && inter_prec >= inside_prec
3882 : )
3883 : {
3884 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1048;
3885 0 : {
3886 0 : tree res_op0;
3887 0 : res_op0 = captures[1];
3888 0 : tree _r;
3889 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3890 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 836, __FILE__, __LINE__, true);
3891 0 : return _r;
3892 : }
3893 0 : next_after_fail1048:;
3894 0 : }
3895 : else
3896 : {
3897 : if (0
3898 : && final_int && inter_int && inside_int
3899 : && final_prec >= inside_prec
3900 : && inside_prec > inter_prec
3901 : && inter_unsignedp
3902 : )
3903 : {
3904 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1049;
3905 : {
3906 : tree res_op0;
3907 : {
3908 : tree _o1[2], _r1;
3909 : _o1[0] = captures[1];
3910 : _o1[1] = wide_int_to_tree
3911 : (inside_type,
3912 : wi::mask (inter_prec, false,
3913 : TYPE_PRECISION (inside_type)));
3914 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3915 : res_op0 = _r1;
3916 : }
3917 : tree _r;
3918 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3919 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 837, __FILE__, __LINE__, true);
3920 : return _r;
3921 : }
3922 : next_after_fail1049:;
3923 : }
3924 : else
3925 : {
3926 : if (0
3927 : && inside_int && inter_float && final_int &&
3928 : (unsigned) significand_size (TYPE_MODE (inter_type))
3929 : >= inside_prec - !inside_unsignedp
3930 : )
3931 : {
3932 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1050;
3933 : {
3934 : tree res_op0;
3935 : res_op0 = captures[1];
3936 : tree _r;
3937 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3938 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 838, __FILE__, __LINE__, true);
3939 : return _r;
3940 : }
3941 : next_after_fail1050:;
3942 : }
3943 : }
3944 : }
3945 : }
3946 : }
3947 : }
3948 : }
3949 : }
3950 : }
3951 2608066 : break;
3952 : }
3953 3065 : case FLOAT_EXPR:
3954 3065 : {
3955 3065 : tree _q20 = TREE_OPERAND (_p0, 0);
3956 3065 : {
3957 3065 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3958 3065 : {
3959 3065 : tree inside_type = TREE_TYPE (captures[1]);
3960 3065 : tree inter_type = TREE_TYPE (captures[0]);
3961 3065 : int inside_int = INTEGRAL_TYPE_P (inside_type);
3962 3065 : int inside_ptr = POINTER_TYPE_P (inside_type);
3963 3065 : int inside_float = FLOAT_TYPE_P (inside_type);
3964 3065 : int inside_vec = VECTOR_TYPE_P (inside_type);
3965 3065 : unsigned int inside_prec = element_precision (inside_type);
3966 3065 : int inside_unsignedp = TYPE_UNSIGNED (inside_type);
3967 3065 : int inter_int = INTEGRAL_TYPE_P (inter_type);
3968 3065 : int inter_ptr = POINTER_TYPE_P (inter_type);
3969 3065 : int inter_float = FLOAT_TYPE_P (inter_type);
3970 3065 : int inter_vec = VECTOR_TYPE_P (inter_type);
3971 3065 : unsigned int inter_prec = element_precision (inter_type);
3972 3065 : int inter_unsignedp = TYPE_UNSIGNED (inter_type);
3973 3065 : int final_int = INTEGRAL_TYPE_P (type);
3974 3065 : int final_ptr = POINTER_TYPE_P (type);
3975 3065 : int final_float = FLOAT_TYPE_P (type);
3976 3065 : int final_vec = VECTOR_TYPE_P (type);
3977 3065 : unsigned int final_prec = element_precision (type);
3978 3065 : int final_unsignedp = TYPE_UNSIGNED (type);
3979 3065 : if (((
3980 :
3981 : && useless_type_conversion_p (type, inside_type))
3982 : || (
3983 : 1
3984 3065 : && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
3985 0 : && (((inter_int || inter_ptr) && final_int)
3986 0 : || (inter_float && final_float))
3987 3065 : && inter_prec >= final_prec
3988 : )
3989 : {
3990 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1051;
3991 0 : {
3992 0 : tree res_op0;
3993 0 : res_op0 = captures[1];
3994 0 : tree _r;
3995 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3996 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 832, __FILE__, __LINE__, true);
3997 0 : return _r;
3998 : }
3999 0 : next_after_fail1051:;
4000 : }
4001 : else
4002 : {
4003 3065 : if (((inter_int && inside_int) || (inter_float && inside_float))
4004 0 : && (final_int || final_float)
4005 0 : && inter_prec >= inside_prec
4006 0 : && (inter_float || inter_unsignedp == inside_unsignedp)
4007 : )
4008 : {
4009 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1052;
4010 0 : {
4011 0 : tree res_op0;
4012 0 : res_op0 = captures[1];
4013 0 : tree _r;
4014 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4015 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 833, __FILE__, __LINE__, true);
4016 0 : return _r;
4017 : }
4018 0 : next_after_fail1052:;
4019 0 : }
4020 : else
4021 : {
4022 3065 : if (inside_int && inter_int && final_int
4023 0 : && ((inside_prec < inter_prec && inter_prec < final_prec
4024 0 : && inside_unsignedp && !inter_unsignedp)
4025 0 : || final_prec == inter_prec
4026 0 : || (inside_prec < inter_prec && inter_prec > final_prec
4027 0 : && !inside_unsignedp && inter_unsignedp))
4028 : )
4029 : {
4030 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1053;
4031 0 : {
4032 0 : tree res_op0;
4033 0 : res_op0 = captures[1];
4034 0 : tree _r;
4035 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4036 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 834, __FILE__, __LINE__, true);
4037 0 : return _r;
4038 : }
4039 0 : next_after_fail1053:;
4040 0 : }
4041 : else
4042 : {
4043 3065 : if (! inside_float && ! inter_float && ! final_float
4044 : && ! inside_vec && ! inter_vec && ! final_vec
4045 0 : && (inter_prec >= inside_prec || inter_prec >= final_prec)
4046 0 : && ! (inside_int && inter_int
4047 0 : && inter_unsignedp != inside_unsignedp
4048 0 : && inter_prec < final_prec)
4049 0 : && ((inter_unsignedp && inter_prec > inside_prec)
4050 0 : == (final_unsignedp && final_prec > inter_prec))
4051 0 : && ! (inside_ptr && inter_prec != final_prec)
4052 0 : && ! (final_ptr && inside_prec != inter_prec)
4053 : )
4054 : {
4055 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1054;
4056 0 : {
4057 0 : tree res_op0;
4058 0 : res_op0 = captures[1];
4059 0 : tree _r;
4060 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4061 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 835, __FILE__, __LINE__, true);
4062 0 : return _r;
4063 : }
4064 0 : next_after_fail1054:;
4065 0 : }
4066 : else
4067 : {
4068 3065 : if (inside_int && inter_int && final_int
4069 0 : && final_prec <= inside_prec
4070 0 : && inter_prec >= inside_prec
4071 : )
4072 : {
4073 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1055;
4074 0 : {
4075 0 : tree res_op0;
4076 0 : res_op0 = captures[1];
4077 0 : tree _r;
4078 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4079 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 836, __FILE__, __LINE__, true);
4080 0 : return _r;
4081 : }
4082 0 : next_after_fail1055:;
4083 0 : }
4084 : else
4085 : {
4086 : if (0
4087 : && final_int && inter_int && inside_int
4088 : && final_prec >= inside_prec
4089 : && inside_prec > inter_prec
4090 : && inter_unsignedp
4091 : )
4092 : {
4093 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1056;
4094 : {
4095 : tree res_op0;
4096 : {
4097 : tree _o1[2], _r1;
4098 : _o1[0] = captures[1];
4099 : _o1[1] = wide_int_to_tree
4100 : (inside_type,
4101 : wi::mask (inter_prec, false,
4102 : TYPE_PRECISION (inside_type)));
4103 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4104 : res_op0 = _r1;
4105 : }
4106 : tree _r;
4107 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4108 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 837, __FILE__, __LINE__, true);
4109 : return _r;
4110 : }
4111 : next_after_fail1056:;
4112 : }
4113 : else
4114 : {
4115 : if (0
4116 : && inside_int && inter_float && final_int &&
4117 : (unsigned) significand_size (TYPE_MODE (inter_type))
4118 : >= inside_prec - !inside_unsignedp
4119 : )
4120 : {
4121 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1057;
4122 : {
4123 : tree res_op0;
4124 : res_op0 = captures[1];
4125 : tree _r;
4126 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4127 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 838, __FILE__, __LINE__, true);
4128 : return _r;
4129 : }
4130 : next_after_fail1057:;
4131 : }
4132 : }
4133 : }
4134 : }
4135 : }
4136 : }
4137 : }
4138 : }
4139 : }
4140 3065 : break;
4141 : }
4142 830033 : case BIT_AND_EXPR:
4143 830033 : {
4144 830033 : tree _q20 = TREE_OPERAND (_p0, 0);
4145 830033 : tree _q21 = TREE_OPERAND (_p0, 1);
4146 830033 : switch (TREE_CODE (_q21))
4147 : {
4148 209144 : case INTEGER_CST:
4149 209144 : {
4150 209144 : {
4151 209144 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4152 209144 : if (INTEGRAL_TYPE_P (type)
4153 208636 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4154 208636 : && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (captures[0]))
4155 352748 : && operand_equal_p (captures[1], build_low_bits_mask (TREE_TYPE (captures[1]),
4156 143604 : TYPE_PRECISION (type)), 0)
4157 : )
4158 : {
4159 12316 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1058;
4160 12316 : {
4161 12316 : tree res_op0;
4162 12316 : res_op0 = captures[0];
4163 12316 : tree _r;
4164 12316 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4165 12316 : if (TREE_SIDE_EFFECTS (captures[1]))
4166 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4167 12316 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 839, __FILE__, __LINE__, true);
4168 12316 : return _r;
4169 : }
4170 0 : next_after_fail1058:;
4171 : }
4172 : }
4173 196828 : break;
4174 : }
4175 : default:;
4176 : }
4177 : break;
4178 : }
4179 5 : case VEC_COND_EXPR:
4180 5 : {
4181 5 : tree _q20 = TREE_OPERAND (_p0, 0);
4182 5 : tree _q21 = TREE_OPERAND (_p0, 1);
4183 5 : tree _q22 = TREE_OPERAND (_p0, 2);
4184 5 : {
4185 5 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
4186 5 : if (VECTOR_TYPE_P (type)
4187 0 : && types_match (TREE_TYPE (captures[1]), truth_type_for (type))
4188 5 : && (expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
4189 0 : || !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1])))
4190 : )
4191 : {
4192 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1059;
4193 0 : {
4194 0 : tree res_op0;
4195 0 : res_op0 = captures[1];
4196 0 : tree res_op1;
4197 0 : {
4198 0 : tree _o1[1], _r1;
4199 0 : _o1[0] = captures[2];
4200 0 : if (TREE_TYPE (_o1[0]) != type)
4201 : {
4202 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4203 0 : if (EXPR_P (_r1))
4204 0 : goto next_after_fail1059;
4205 : }
4206 : else
4207 : _r1 = _o1[0];
4208 0 : res_op1 = _r1;
4209 : }
4210 0 : tree res_op2;
4211 0 : {
4212 0 : tree _o1[1], _r1;
4213 0 : _o1[0] = captures[3];
4214 0 : if (TREE_TYPE (_o1[0]) != type)
4215 : {
4216 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4217 0 : if (EXPR_P (_r1))
4218 0 : goto next_after_fail1059;
4219 : }
4220 : else
4221 : _r1 = _o1[0];
4222 0 : res_op2 = _r1;
4223 : }
4224 0 : tree _r;
4225 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4226 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 840, __FILE__, __LINE__, true);
4227 0 : return _r;
4228 : }
4229 5 : next_after_fail1059:;
4230 : }
4231 : }
4232 5 : break;
4233 : }
4234 612089 : case COND_EXPR:
4235 612089 : {
4236 612089 : tree _q20 = TREE_OPERAND (_p0, 0);
4237 612089 : tree _q21 = TREE_OPERAND (_p0, 1);
4238 612089 : tree _q22 = TREE_OPERAND (_p0, 2);
4239 612089 : switch (TREE_CODE (_q21))
4240 : {
4241 175576 : case INTEGER_CST:
4242 175576 : {
4243 175576 : switch (TREE_CODE (_q22))
4244 : {
4245 110706 : case INTEGER_CST:
4246 110706 : {
4247 110706 : {
4248 110706 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
4249 110706 : if (INTEGRAL_TYPE_P (type)
4250 110706 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4251 : )
4252 : {
4253 110706 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1060;
4254 110706 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1060;
4255 110706 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1060;
4256 110706 : {
4257 110706 : tree res_op0;
4258 110706 : res_op0 = captures[1];
4259 110706 : tree res_op1;
4260 110706 : {
4261 110706 : tree _o1[1], _r1;
4262 110706 : _o1[0] = captures[2];
4263 110706 : if (TREE_TYPE (_o1[0]) != type)
4264 : {
4265 110706 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4266 : }
4267 : else
4268 : _r1 = _o1[0];
4269 110706 : res_op1 = _r1;
4270 : }
4271 110706 : tree res_op2;
4272 110706 : {
4273 110706 : tree _o1[1], _r1;
4274 110706 : _o1[0] = captures[3];
4275 110706 : if (TREE_TYPE (_o1[0]) != type)
4276 : {
4277 110706 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4278 : }
4279 : else
4280 : _r1 = _o1[0];
4281 110706 : res_op2 = _r1;
4282 : }
4283 110706 : tree _r;
4284 110706 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
4285 110706 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 841, __FILE__, __LINE__, true);
4286 110706 : return _r;
4287 : }
4288 0 : next_after_fail1060:;
4289 : }
4290 : }
4291 0 : break;
4292 : }
4293 : default:;
4294 : }
4295 : break;
4296 : }
4297 : default:;
4298 : }
4299 : break;
4300 : }
4301 11563014 : case PLUS_EXPR:
4302 11563014 : {
4303 11563014 : tree _q20 = TREE_OPERAND (_p0, 0);
4304 11563014 : tree _q21 = TREE_OPERAND (_p0, 1);
4305 11563014 : switch (TREE_CODE (_q20))
4306 : {
4307 4493745 : CASE_CONVERT:
4308 4493745 : {
4309 4493745 : tree _q30 = TREE_OPERAND (_q20, 0);
4310 4493745 : switch (TREE_CODE (_q21))
4311 : {
4312 343573 : CASE_CONVERT:
4313 343573 : {
4314 343573 : tree _q50 = TREE_OPERAND (_q21, 0);
4315 343573 : {
4316 343573 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4317 343573 : tree res = generic_simplify_431 (loc, type, _p0, captures, PLUS_EXPR);
4318 343573 : if (res) return res;
4319 : }
4320 343517 : break;
4321 : }
4322 4493689 : default:;
4323 : }
4324 4493689 : {
4325 4493689 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4326 4493689 : tree res = generic_simplify_432 (loc, type, _p0, captures, PLUS_EXPR);
4327 4493689 : if (res) return res;
4328 : }
4329 4480720 : break;
4330 : }
4331 11549989 : default:;
4332 : }
4333 11549989 : switch (TREE_CODE (_q21))
4334 : {
4335 1494893 : CASE_CONVERT:
4336 1494893 : {
4337 1494893 : tree _q40 = TREE_OPERAND (_q21, 0);
4338 1494893 : {
4339 1494893 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4340 1494893 : tree res = generic_simplify_433 (loc, type, _p0, captures, PLUS_EXPR);
4341 1494893 : if (res) return res;
4342 : }
4343 1494893 : break;
4344 : }
4345 11549989 : default:;
4346 : }
4347 11549989 : {
4348 11549989 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4349 11549989 : tree res = generic_simplify_434 (loc, type, _p0, captures, PLUS_EXPR);
4350 11549989 : if (res) return res;
4351 : }
4352 11549955 : break;
4353 : }
4354 916422 : case MINUS_EXPR:
4355 916422 : {
4356 916422 : tree _q20 = TREE_OPERAND (_p0, 0);
4357 916422 : tree _q21 = TREE_OPERAND (_p0, 1);
4358 916422 : switch (TREE_CODE (_q20))
4359 : {
4360 350147 : CASE_CONVERT:
4361 350147 : {
4362 350147 : tree _q30 = TREE_OPERAND (_q20, 0);
4363 350147 : switch (TREE_CODE (_q21))
4364 : {
4365 199251 : CASE_CONVERT:
4366 199251 : {
4367 199251 : tree _q50 = TREE_OPERAND (_q21, 0);
4368 199251 : {
4369 199251 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4370 199251 : tree res = generic_simplify_431 (loc, type, _p0, captures, MINUS_EXPR);
4371 199251 : if (res) return res;
4372 : }
4373 199222 : break;
4374 : }
4375 350118 : default:;
4376 : }
4377 350118 : {
4378 350118 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4379 350118 : tree res = generic_simplify_432 (loc, type, _p0, captures, MINUS_EXPR);
4380 350118 : if (res) return res;
4381 : }
4382 348998 : break;
4383 : }
4384 915273 : default:;
4385 : }
4386 915273 : switch (TREE_CODE (_q21))
4387 : {
4388 257593 : CASE_CONVERT:
4389 257593 : {
4390 257593 : tree _q40 = TREE_OPERAND (_q21, 0);
4391 257593 : {
4392 257593 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4393 257593 : tree res = generic_simplify_433 (loc, type, _p0, captures, MINUS_EXPR);
4394 257593 : if (res) return res;
4395 : }
4396 257583 : break;
4397 : }
4398 915263 : default:;
4399 : }
4400 915263 : {
4401 915263 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4402 915263 : tree res = generic_simplify_434 (loc, type, _p0, captures, MINUS_EXPR);
4403 915263 : if (res) return res;
4404 : }
4405 915231 : break;
4406 : }
4407 8843293 : case MULT_EXPR:
4408 8843293 : {
4409 8843293 : tree _q20 = TREE_OPERAND (_p0, 0);
4410 8843293 : tree _q21 = TREE_OPERAND (_p0, 1);
4411 8843293 : switch (TREE_CODE (_q20))
4412 : {
4413 4059520 : CASE_CONVERT:
4414 4059520 : {
4415 4059520 : tree _q30 = TREE_OPERAND (_q20, 0);
4416 4059520 : switch (TREE_CODE (_q21))
4417 : {
4418 318227 : CASE_CONVERT:
4419 318227 : {
4420 318227 : tree _q50 = TREE_OPERAND (_q21, 0);
4421 318227 : {
4422 318227 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4423 318227 : tree res = generic_simplify_431 (loc, type, _p0, captures, MULT_EXPR);
4424 318227 : if (res) return res;
4425 : }
4426 318227 : break;
4427 : }
4428 4059520 : default:;
4429 : }
4430 4059520 : {
4431 4059520 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4432 4059520 : tree res = generic_simplify_432 (loc, type, _p0, captures, MULT_EXPR);
4433 4059520 : if (res) return res;
4434 : }
4435 4059399 : break;
4436 : }
4437 8843172 : default:;
4438 : }
4439 8843172 : switch (TREE_CODE (_q21))
4440 : {
4441 684891 : CASE_CONVERT:
4442 684891 : {
4443 684891 : tree _q40 = TREE_OPERAND (_q21, 0);
4444 684891 : {
4445 684891 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4446 684891 : tree res = generic_simplify_433 (loc, type, _p0, captures, MULT_EXPR);
4447 684891 : if (res) return res;
4448 : }
4449 684891 : break;
4450 : }
4451 8843172 : default:;
4452 : }
4453 8843172 : {
4454 8843172 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4455 8843172 : tree res = generic_simplify_434 (loc, type, _p0, captures, MULT_EXPR);
4456 8843172 : if (res) return res;
4457 : }
4458 8843139 : break;
4459 : }
4460 3067 : case RDIV_EXPR:
4461 3067 : {
4462 3067 : tree _q20 = TREE_OPERAND (_p0, 0);
4463 3067 : tree _q21 = TREE_OPERAND (_p0, 1);
4464 3067 : switch (TREE_CODE (_q20))
4465 : {
4466 969 : CASE_CONVERT:
4467 969 : {
4468 969 : tree _q30 = TREE_OPERAND (_q20, 0);
4469 969 : switch (TREE_CODE (_q21))
4470 : {
4471 667 : CASE_CONVERT:
4472 667 : {
4473 667 : tree _q50 = TREE_OPERAND (_q21, 0);
4474 667 : {
4475 667 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4476 667 : tree res = generic_simplify_431 (loc, type, _p0, captures, RDIV_EXPR);
4477 667 : if (res) return res;
4478 : }
4479 666 : break;
4480 : }
4481 968 : default:;
4482 : }
4483 968 : {
4484 968 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4485 968 : tree res = generic_simplify_432 (loc, type, _p0, captures, RDIV_EXPR);
4486 968 : if (res) return res;
4487 : }
4488 966 : break;
4489 : }
4490 3064 : default:;
4491 : }
4492 3064 : switch (TREE_CODE (_q21))
4493 : {
4494 1656 : CASE_CONVERT:
4495 1656 : {
4496 1656 : tree _q40 = TREE_OPERAND (_q21, 0);
4497 1656 : {
4498 1656 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4499 1656 : tree res = generic_simplify_433 (loc, type, _p0, captures, RDIV_EXPR);
4500 1656 : if (res) return res;
4501 : }
4502 1011 : break;
4503 : }
4504 2419 : default:;
4505 : }
4506 2419 : {
4507 2419 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4508 2419 : tree res = generic_simplify_434 (loc, type, _p0, captures, RDIV_EXPR);
4509 2419 : if (res) return res;
4510 : }
4511 2377 : break;
4512 : }
4513 689924 : case NEGATE_EXPR:
4514 689924 : {
4515 689924 : tree _q20 = TREE_OPERAND (_p0, 0);
4516 689924 : {
4517 689924 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4518 689924 : tree res = generic_simplify_435 (loc, type, _p0, captures);
4519 689924 : if (res) return res;
4520 : }
4521 689902 : break;
4522 : }
4523 : default:;
4524 : }
4525 : return NULL_TREE;
4526 : }
4527 :
4528 : tree
4529 6962 : 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)
4530 : {
4531 6962 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4532 6962 : if (integer_onep (_p1))
4533 : {
4534 1755 : {
4535 1755 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4536 1755 : tree res = generic_simplify_180 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4537 1755 : if (res) return res;
4538 : }
4539 : }
4540 5207 : if (integer_zerop (_p0))
4541 : {
4542 0 : {
4543 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4544 0 : tree res = generic_simplify_310 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4545 0 : if (res) return res;
4546 : }
4547 : }
4548 5207 : switch (TREE_CODE (_p1))
4549 : {
4550 34 : case SSA_NAME:
4551 34 : {
4552 34 : {
4553 34 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4554 34 : tree res = generic_simplify_312 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4555 34 : if (res) return res;
4556 : }
4557 34 : break;
4558 : }
4559 5207 : default:;
4560 : }
4561 5207 : if (integer_minus_onep (_p1))
4562 : {
4563 0 : {
4564 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4565 0 : tree res = generic_simplify_311 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4566 0 : if (res) return res;
4567 : }
4568 : }
4569 5207 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
4570 : {
4571 0 : {
4572 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4573 0 : tree res = generic_simplify_313 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4574 0 : if (res) return res;
4575 : }
4576 : }
4577 5207 : switch (TREE_CODE (_p1))
4578 : {
4579 0 : case ABS_EXPR:
4580 0 : {
4581 0 : tree _q30 = TREE_OPERAND (_p1, 0);
4582 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
4583 : {
4584 0 : {
4585 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4586 0 : tree res = generic_simplify_314 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4587 0 : if (res) return res;
4588 : }
4589 : }
4590 : break;
4591 : }
4592 5207 : default:;
4593 : }
4594 5207 : switch (TREE_CODE (_p0))
4595 : {
4596 0 : case ABS_EXPR:
4597 0 : {
4598 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4599 0 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4600 : {
4601 0 : {
4602 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4603 0 : tree res = generic_simplify_314 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4604 0 : if (res) return res;
4605 : }
4606 : }
4607 : break;
4608 : }
4609 5207 : default:;
4610 : }
4611 5207 : switch (TREE_CODE (_p1))
4612 : {
4613 0 : case NEGATE_EXPR:
4614 0 : {
4615 0 : tree _q30 = TREE_OPERAND (_p1, 0);
4616 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
4617 : {
4618 0 : {
4619 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4620 0 : tree res = generic_simplify_315 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4621 0 : if (res) return res;
4622 : }
4623 : }
4624 : break;
4625 : }
4626 5207 : default:;
4627 : }
4628 5207 : switch (TREE_CODE (_p0))
4629 : {
4630 0 : case NEGATE_EXPR:
4631 0 : {
4632 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4633 0 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4634 : {
4635 0 : {
4636 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4637 0 : tree res = generic_simplify_315 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4638 0 : if (res) return res;
4639 : }
4640 : }
4641 : break;
4642 : }
4643 536 : CASE_CONVERT:
4644 536 : {
4645 536 : tree _q20 = TREE_OPERAND (_p0, 0);
4646 536 : switch (TREE_CODE (_q20))
4647 : {
4648 0 : case BIT_AND_EXPR:
4649 0 : {
4650 0 : tree _q30 = TREE_OPERAND (_q20, 0);
4651 0 : tree _q31 = TREE_OPERAND (_q20, 1);
4652 0 : switch (TREE_CODE (_q31))
4653 : {
4654 0 : case INTEGER_CST:
4655 0 : {
4656 0 : switch (TREE_CODE (_p1))
4657 : {
4658 0 : case INTEGER_CST:
4659 0 : {
4660 0 : {
4661 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
4662 0 : tree res = generic_simplify_317 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4663 0 : if (res) return res;
4664 : }
4665 0 : break;
4666 : }
4667 : default:;
4668 : }
4669 : break;
4670 : }
4671 : default:;
4672 : }
4673 : break;
4674 : }
4675 : default:;
4676 : }
4677 : break;
4678 : }
4679 0 : case BIT_AND_EXPR:
4680 0 : {
4681 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4682 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4683 0 : switch (TREE_CODE (_q21))
4684 : {
4685 0 : case INTEGER_CST:
4686 0 : {
4687 0 : switch (TREE_CODE (_p1))
4688 : {
4689 0 : case INTEGER_CST:
4690 0 : {
4691 0 : {
4692 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4693 0 : tree res = generic_simplify_317 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4694 0 : if (res) return res;
4695 : }
4696 0 : break;
4697 : }
4698 : default:;
4699 : }
4700 : break;
4701 : }
4702 : default:;
4703 : }
4704 : break;
4705 : }
4706 0 : case MULT_EXPR:
4707 0 : {
4708 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4709 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4710 0 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
4711 : {
4712 0 : {
4713 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
4714 0 : tree res = generic_simplify_319 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4715 0 : if (res) return res;
4716 : }
4717 : }
4718 0 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4719 : {
4720 0 : {
4721 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
4722 0 : tree res = generic_simplify_319 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4723 0 : if (res) return res;
4724 : }
4725 : }
4726 0 : switch (TREE_CODE (_q21))
4727 : {
4728 0 : case INTEGER_CST:
4729 0 : {
4730 0 : switch (TREE_CODE (_p1))
4731 : {
4732 0 : case MULT_EXPR:
4733 0 : {
4734 0 : tree _q50 = TREE_OPERAND (_p1, 0);
4735 0 : tree _q51 = TREE_OPERAND (_p1, 1);
4736 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4737 : {
4738 0 : switch (TREE_CODE (_q51))
4739 : {
4740 0 : case INTEGER_CST:
4741 0 : {
4742 0 : {
4743 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
4744 0 : tree res = generic_simplify_320 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4745 0 : if (res) return res;
4746 : }
4747 0 : break;
4748 : }
4749 : default:;
4750 : }
4751 : }
4752 : break;
4753 : }
4754 : default:;
4755 : }
4756 : break;
4757 : }
4758 : default:;
4759 : }
4760 : break;
4761 : }
4762 0 : case VEC_COND_EXPR:
4763 0 : {
4764 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4765 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4766 0 : tree _q22 = TREE_OPERAND (_p0, 2);
4767 0 : switch (TREE_CODE (_p1))
4768 : {
4769 0 : case VEC_COND_EXPR:
4770 0 : {
4771 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4772 0 : tree _q61 = TREE_OPERAND (_p1, 1);
4773 0 : tree _q62 = TREE_OPERAND (_p1, 2);
4774 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4775 : {
4776 0 : {
4777 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
4778 0 : if (VECTOR_TYPE_P (type)
4779 0 : && (TREE_CODE_CLASS (CEIL_DIV_EXPR) != tcc_comparison
4780 : || types_match (type, TREE_TYPE (captures[2]))
4781 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
4782 : || (optimize_vectors_before_lowering_p ()
4783 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
4784 : )
4785 : {
4786 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1574;
4787 0 : {
4788 0 : tree res_op0;
4789 0 : res_op0 = captures[1];
4790 0 : tree res_op1;
4791 0 : {
4792 0 : tree _o1[2], _r1;
4793 0 : _o1[0] = captures[2];
4794 0 : _o1[1] = captures[5];
4795 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4796 0 : if (EXPR_P (_r1))
4797 0 : goto next_after_fail1574;
4798 0 : res_op1 = _r1;
4799 : }
4800 0 : tree res_op2;
4801 0 : {
4802 0 : tree _o1[2], _r1;
4803 0 : _o1[0] = captures[3];
4804 0 : _o1[1] = captures[6];
4805 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4806 0 : if (EXPR_P (_r1))
4807 0 : goto next_after_fail1574;
4808 0 : res_op2 = _r1;
4809 : }
4810 0 : tree _r;
4811 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4812 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 890, __FILE__, __LINE__, true);
4813 0 : return _r;
4814 : }
4815 0 : next_after_fail1574:;
4816 : }
4817 : }
4818 : }
4819 : break;
4820 : }
4821 0 : default:;
4822 : }
4823 0 : {
4824 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
4825 0 : if (VECTOR_TYPE_P (type)
4826 0 : && (TREE_CODE_CLASS (CEIL_DIV_EXPR) != tcc_comparison
4827 : || types_match (type, TREE_TYPE (captures[2]))
4828 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
4829 : || (optimize_vectors_before_lowering_p ()
4830 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
4831 : )
4832 : {
4833 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1575;
4834 0 : {
4835 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1575;
4836 0 : tree res_op0;
4837 0 : res_op0 = captures[1];
4838 0 : tree res_op1;
4839 0 : {
4840 0 : tree _o1[2], _r1;
4841 0 : _o1[0] = captures[2];
4842 0 : _o1[1] = unshare_expr (captures[4]);
4843 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4844 0 : if (EXPR_P (_r1))
4845 0 : goto next_after_fail1575;
4846 0 : res_op1 = _r1;
4847 : }
4848 0 : tree res_op2;
4849 0 : {
4850 0 : tree _o1[2], _r1;
4851 0 : _o1[0] = captures[3];
4852 0 : _o1[1] = captures[4];
4853 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4854 0 : if (EXPR_P (_r1))
4855 0 : goto next_after_fail1575;
4856 0 : res_op2 = _r1;
4857 : }
4858 0 : tree _r;
4859 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4860 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
4861 0 : return _r;
4862 : }
4863 0 : next_after_fail1575:;
4864 : }
4865 : }
4866 0 : break;
4867 : }
4868 5207 : default:;
4869 : }
4870 5207 : switch (TREE_CODE (_p1))
4871 : {
4872 0 : case VEC_COND_EXPR:
4873 0 : {
4874 0 : tree _q30 = TREE_OPERAND (_p1, 0);
4875 0 : tree _q31 = TREE_OPERAND (_p1, 1);
4876 0 : tree _q32 = TREE_OPERAND (_p1, 2);
4877 0 : {
4878 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
4879 0 : if (VECTOR_TYPE_P (type)
4880 0 : && (TREE_CODE_CLASS (CEIL_DIV_EXPR) != tcc_comparison
4881 : || types_match (type, TREE_TYPE (captures[3]))
4882 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
4883 : || (optimize_vectors_before_lowering_p ()
4884 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
4885 : )
4886 : {
4887 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1576;
4888 0 : {
4889 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1576;
4890 0 : tree res_op0;
4891 0 : res_op0 = captures[2];
4892 0 : tree res_op1;
4893 0 : {
4894 0 : tree _o1[2], _r1;
4895 0 : _o1[0] = unshare_expr (captures[0]);
4896 0 : _o1[1] = captures[3];
4897 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4898 0 : if (EXPR_P (_r1))
4899 0 : goto next_after_fail1576;
4900 0 : res_op1 = _r1;
4901 : }
4902 0 : tree res_op2;
4903 0 : {
4904 0 : tree _o1[2], _r1;
4905 0 : _o1[0] = captures[0];
4906 0 : _o1[1] = captures[4];
4907 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4908 0 : if (EXPR_P (_r1))
4909 0 : goto next_after_fail1576;
4910 0 : res_op2 = _r1;
4911 : }
4912 0 : tree _r;
4913 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4914 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
4915 0 : return _r;
4916 : }
4917 0 : next_after_fail1576:;
4918 : }
4919 : }
4920 0 : break;
4921 : }
4922 : default:;
4923 : }
4924 : return NULL_TREE;
4925 : }
4926 :
4927 : tree
4928 3391389 : 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)
4929 : {
4930 3391389 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4931 3391389 : if (integer_onep (_p1))
4932 : {
4933 2014948 : {
4934 2014948 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4935 2014948 : tree res = generic_simplify_180 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
4936 2014948 : if (res) return res;
4937 : }
4938 : }
4939 1376441 : switch (TREE_CODE (_p0))
4940 : {
4941 8822 : CASE_CONVERT:
4942 8822 : {
4943 8822 : tree _q20 = TREE_OPERAND (_p0, 0);
4944 8822 : switch (TREE_CODE (_p1))
4945 : {
4946 0 : CASE_CONVERT:
4947 0 : {
4948 0 : tree _q40 = TREE_OPERAND (_p1, 0);
4949 0 : switch (TREE_CODE (_q40))
4950 : {
4951 0 : case LSHIFT_EXPR:
4952 0 : {
4953 0 : tree _q50 = TREE_OPERAND (_q40, 0);
4954 0 : tree _q51 = TREE_OPERAND (_q40, 1);
4955 0 : if (integer_onep (_q50))
4956 : {
4957 0 : {
4958 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q50, _q51 };
4959 0 : tree res = generic_simplify_308 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
4960 0 : if (res) return res;
4961 : }
4962 : }
4963 : break;
4964 : }
4965 : default:;
4966 : }
4967 : break;
4968 : }
4969 0 : case LSHIFT_EXPR:
4970 0 : {
4971 0 : tree _q40 = TREE_OPERAND (_p1, 0);
4972 0 : tree _q41 = TREE_OPERAND (_p1, 1);
4973 0 : if (integer_onep (_q40))
4974 : {
4975 0 : {
4976 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q41 };
4977 0 : tree res = generic_simplify_308 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
4978 0 : if (res) return res;
4979 : }
4980 : }
4981 : break;
4982 : }
4983 : default:;
4984 : }
4985 : break;
4986 : }
4987 1376441 : default:;
4988 : }
4989 1376441 : switch (TREE_CODE (_p1))
4990 : {
4991 2 : CASE_CONVERT:
4992 2 : {
4993 2 : tree _q30 = TREE_OPERAND (_p1, 0);
4994 2 : switch (TREE_CODE (_q30))
4995 : {
4996 0 : case LSHIFT_EXPR:
4997 0 : {
4998 0 : tree _q40 = TREE_OPERAND (_q30, 0);
4999 0 : tree _q41 = TREE_OPERAND (_q30, 1);
5000 0 : if (integer_onep (_q40))
5001 : {
5002 0 : {
5003 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q40, _q41 };
5004 0 : tree res = generic_simplify_309 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5005 0 : if (res) return res;
5006 : }
5007 : }
5008 : break;
5009 : }
5010 : default:;
5011 : }
5012 : break;
5013 : }
5014 0 : case LSHIFT_EXPR:
5015 0 : {
5016 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5017 0 : tree _q31 = TREE_OPERAND (_p1, 1);
5018 0 : if (integer_onep (_q30))
5019 : {
5020 0 : {
5021 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q30, _q31 };
5022 0 : tree res = generic_simplify_309 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5023 0 : if (res) return res;
5024 : }
5025 : }
5026 : break;
5027 : }
5028 1376441 : default:;
5029 : }
5030 1376441 : if (integer_zerop (_p0))
5031 : {
5032 0 : {
5033 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
5034 0 : tree res = generic_simplify_310 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5035 0 : if (res) return res;
5036 : }
5037 : }
5038 1376441 : switch (TREE_CODE (_p1))
5039 : {
5040 0 : case SSA_NAME:
5041 0 : {
5042 0 : {
5043 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
5044 0 : tree res = generic_simplify_312 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5045 0 : if (res) return res;
5046 : }
5047 0 : break;
5048 : }
5049 1376441 : default:;
5050 : }
5051 1376441 : if (integer_minus_onep (_p1))
5052 : {
5053 0 : {
5054 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
5055 0 : tree res = generic_simplify_311 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5056 0 : if (res) return res;
5057 : }
5058 : }
5059 1376441 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
5060 : {
5061 0 : {
5062 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
5063 0 : tree res = generic_simplify_313 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5064 0 : if (res) return res;
5065 : }
5066 : }
5067 1376441 : switch (TREE_CODE (_p1))
5068 : {
5069 0 : case ABS_EXPR:
5070 0 : {
5071 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5072 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5073 : {
5074 0 : {
5075 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
5076 0 : tree res = generic_simplify_314 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5077 0 : if (res) return res;
5078 : }
5079 : }
5080 : break;
5081 : }
5082 1376441 : default:;
5083 : }
5084 1376441 : switch (TREE_CODE (_p0))
5085 : {
5086 0 : case ABS_EXPR:
5087 0 : {
5088 0 : tree _q20 = TREE_OPERAND (_p0, 0);
5089 0 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5090 : {
5091 0 : {
5092 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
5093 0 : tree res = generic_simplify_314 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5094 0 : if (res) return res;
5095 : }
5096 : }
5097 : break;
5098 : }
5099 1376441 : default:;
5100 : }
5101 1376441 : switch (TREE_CODE (_p1))
5102 : {
5103 0 : case NEGATE_EXPR:
5104 0 : {
5105 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5106 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5107 : {
5108 0 : {
5109 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
5110 0 : tree res = generic_simplify_315 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5111 0 : if (res) return res;
5112 : }
5113 : }
5114 : break;
5115 : }
5116 1376441 : default:;
5117 : }
5118 1376441 : switch (TREE_CODE (_p0))
5119 : {
5120 1193 : case NEGATE_EXPR:
5121 1193 : {
5122 1193 : tree _q20 = TREE_OPERAND (_p0, 0);
5123 1193 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5124 : {
5125 0 : {
5126 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
5127 0 : tree res = generic_simplify_315 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5128 0 : if (res) return res;
5129 : }
5130 : }
5131 : break;
5132 : }
5133 0 : case EXACT_DIV_EXPR:
5134 0 : {
5135 0 : tree _q20 = TREE_OPERAND (_p0, 0);
5136 0 : tree _q21 = TREE_OPERAND (_p0, 1);
5137 0 : switch (TREE_CODE (_q21))
5138 : {
5139 0 : case INTEGER_CST:
5140 0 : {
5141 0 : switch (TREE_CODE (_p1))
5142 : {
5143 0 : case INTEGER_CST:
5144 0 : {
5145 0 : {
5146 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
5147 0 : tree res = generic_simplify_316 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5148 0 : if (res) return res;
5149 : }
5150 0 : break;
5151 : }
5152 : default:;
5153 : }
5154 : break;
5155 : }
5156 : default:;
5157 : }
5158 : break;
5159 : }
5160 8822 : CASE_CONVERT:
5161 8822 : {
5162 8822 : tree _q20 = TREE_OPERAND (_p0, 0);
5163 8822 : switch (TREE_CODE (_q20))
5164 : {
5165 0 : case BIT_AND_EXPR:
5166 0 : {
5167 0 : tree _q30 = TREE_OPERAND (_q20, 0);
5168 0 : tree _q31 = TREE_OPERAND (_q20, 1);
5169 0 : switch (TREE_CODE (_q31))
5170 : {
5171 0 : case INTEGER_CST:
5172 0 : {
5173 0 : switch (TREE_CODE (_p1))
5174 : {
5175 0 : case INTEGER_CST:
5176 0 : {
5177 0 : {
5178 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
5179 0 : tree res = generic_simplify_317 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5180 0 : if (res) return res;
5181 : }
5182 0 : break;
5183 : }
5184 : default:;
5185 : }
5186 : break;
5187 : }
5188 : default:;
5189 : }
5190 : break;
5191 : }
5192 : default:;
5193 : }
5194 : break;
5195 : }
5196 0 : case BIT_AND_EXPR:
5197 0 : {
5198 0 : tree _q20 = TREE_OPERAND (_p0, 0);
5199 0 : tree _q21 = TREE_OPERAND (_p0, 1);
5200 0 : switch (TREE_CODE (_q21))
5201 : {
5202 0 : case INTEGER_CST:
5203 0 : {
5204 0 : switch (TREE_CODE (_p1))
5205 : {
5206 0 : case INTEGER_CST:
5207 0 : {
5208 0 : {
5209 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5210 0 : tree res = generic_simplify_317 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5211 0 : if (res) return res;
5212 : }
5213 0 : break;
5214 : }
5215 : default:;
5216 : }
5217 : break;
5218 : }
5219 : default:;
5220 : }
5221 : break;
5222 : }
5223 18541 : case MULT_EXPR:
5224 18541 : {
5225 18541 : tree _q20 = TREE_OPERAND (_p0, 0);
5226 18541 : tree _q21 = TREE_OPERAND (_p0, 1);
5227 18541 : if (integer_pow2p (_q21))
5228 : {
5229 17432 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5230 : {
5231 17404 : {
5232 17404 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5233 17404 : tree res = generic_simplify_318 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5234 17404 : if (res) return res;
5235 : }
5236 : }
5237 : }
5238 1144 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5239 : {
5240 7 : {
5241 7 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
5242 7 : tree res = generic_simplify_319 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5243 7 : if (res) return res;
5244 : }
5245 : }
5246 1137 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5247 : {
5248 0 : {
5249 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
5250 0 : tree res = generic_simplify_319 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5251 0 : if (res) return res;
5252 : }
5253 : }
5254 1137 : switch (TREE_CODE (_q21))
5255 : {
5256 1137 : case INTEGER_CST:
5257 1137 : {
5258 1137 : switch (TREE_CODE (_p1))
5259 : {
5260 0 : case MULT_EXPR:
5261 0 : {
5262 0 : tree _q50 = TREE_OPERAND (_p1, 0);
5263 0 : tree _q51 = TREE_OPERAND (_p1, 1);
5264 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5265 : {
5266 0 : switch (TREE_CODE (_q51))
5267 : {
5268 0 : case INTEGER_CST:
5269 0 : {
5270 0 : {
5271 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
5272 0 : tree res = generic_simplify_320 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5273 0 : if (res) return res;
5274 : }
5275 0 : break;
5276 : }
5277 : default:;
5278 : }
5279 : }
5280 : break;
5281 : }
5282 : default:;
5283 : }
5284 : break;
5285 : }
5286 : default:;
5287 : }
5288 : break;
5289 : }
5290 0 : case VEC_COND_EXPR:
5291 0 : {
5292 0 : tree _q20 = TREE_OPERAND (_p0, 0);
5293 0 : tree _q21 = TREE_OPERAND (_p0, 1);
5294 0 : tree _q22 = TREE_OPERAND (_p0, 2);
5295 0 : switch (TREE_CODE (_p1))
5296 : {
5297 0 : case VEC_COND_EXPR:
5298 0 : {
5299 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5300 0 : tree _q61 = TREE_OPERAND (_p1, 1);
5301 0 : tree _q62 = TREE_OPERAND (_p1, 2);
5302 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
5303 : {
5304 0 : {
5305 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
5306 0 : if (VECTOR_TYPE_P (type)
5307 0 : && (TREE_CODE_CLASS (EXACT_DIV_EXPR) != tcc_comparison
5308 : || types_match (type, TREE_TYPE (captures[2]))
5309 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
5310 : || (optimize_vectors_before_lowering_p ()
5311 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
5312 : )
5313 : {
5314 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1583;
5315 0 : {
5316 0 : tree res_op0;
5317 0 : res_op0 = captures[1];
5318 0 : tree res_op1;
5319 0 : {
5320 0 : tree _o1[2], _r1;
5321 0 : _o1[0] = captures[2];
5322 0 : _o1[1] = captures[5];
5323 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5324 0 : if (EXPR_P (_r1))
5325 0 : goto next_after_fail1583;
5326 0 : res_op1 = _r1;
5327 : }
5328 0 : tree res_op2;
5329 0 : {
5330 0 : tree _o1[2], _r1;
5331 0 : _o1[0] = captures[3];
5332 0 : _o1[1] = captures[6];
5333 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5334 0 : if (EXPR_P (_r1))
5335 0 : goto next_after_fail1583;
5336 0 : res_op2 = _r1;
5337 : }
5338 0 : tree _r;
5339 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
5340 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 890, __FILE__, __LINE__, true);
5341 0 : return _r;
5342 : }
5343 0 : next_after_fail1583:;
5344 : }
5345 : }
5346 : }
5347 : break;
5348 : }
5349 0 : default:;
5350 : }
5351 0 : {
5352 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
5353 0 : if (VECTOR_TYPE_P (type)
5354 0 : && (TREE_CODE_CLASS (EXACT_DIV_EXPR) != tcc_comparison
5355 : || types_match (type, TREE_TYPE (captures[2]))
5356 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
5357 : || (optimize_vectors_before_lowering_p ()
5358 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
5359 : )
5360 : {
5361 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1584;
5362 0 : {
5363 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1584;
5364 0 : tree res_op0;
5365 0 : res_op0 = captures[1];
5366 0 : tree res_op1;
5367 0 : {
5368 0 : tree _o1[2], _r1;
5369 0 : _o1[0] = captures[2];
5370 0 : _o1[1] = unshare_expr (captures[4]);
5371 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5372 0 : if (EXPR_P (_r1))
5373 0 : goto next_after_fail1584;
5374 0 : res_op1 = _r1;
5375 : }
5376 0 : tree res_op2;
5377 0 : {
5378 0 : tree _o1[2], _r1;
5379 0 : _o1[0] = captures[3];
5380 0 : _o1[1] = captures[4];
5381 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5382 0 : if (EXPR_P (_r1))
5383 0 : goto next_after_fail1584;
5384 0 : res_op2 = _r1;
5385 : }
5386 0 : tree _r;
5387 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
5388 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
5389 0 : return _r;
5390 : }
5391 0 : next_after_fail1584:;
5392 : }
5393 : }
5394 0 : break;
5395 : }
5396 1359037 : default:;
5397 : }
5398 1359037 : switch (TREE_CODE (_p1))
5399 : {
5400 0 : case VEC_COND_EXPR:
5401 0 : {
5402 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5403 0 : tree _q31 = TREE_OPERAND (_p1, 1);
5404 0 : tree _q32 = TREE_OPERAND (_p1, 2);
5405 0 : {
5406 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
5407 0 : if (VECTOR_TYPE_P (type)
5408 0 : && (TREE_CODE_CLASS (EXACT_DIV_EXPR) != tcc_comparison
5409 : || types_match (type, TREE_TYPE (captures[3]))
5410 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
5411 : || (optimize_vectors_before_lowering_p ()
5412 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
5413 : )
5414 : {
5415 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1585;
5416 0 : {
5417 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1585;
5418 0 : tree res_op0;
5419 0 : res_op0 = captures[2];
5420 0 : tree res_op1;
5421 0 : {
5422 0 : tree _o1[2], _r1;
5423 0 : _o1[0] = unshare_expr (captures[0]);
5424 0 : _o1[1] = captures[3];
5425 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5426 0 : if (EXPR_P (_r1))
5427 0 : goto next_after_fail1585;
5428 0 : res_op1 = _r1;
5429 : }
5430 0 : tree res_op2;
5431 0 : {
5432 0 : tree _o1[2], _r1;
5433 0 : _o1[0] = captures[0];
5434 0 : _o1[1] = captures[4];
5435 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5436 0 : if (EXPR_P (_r1))
5437 0 : goto next_after_fail1585;
5438 0 : res_op2 = _r1;
5439 : }
5440 0 : tree _r;
5441 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
5442 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
5443 0 : return _r;
5444 : }
5445 0 : next_after_fail1585:;
5446 : }
5447 : }
5448 0 : break;
5449 : }
5450 : default:;
5451 : }
5452 : return NULL_TREE;
5453 : }
5454 :
5455 : tree
5456 9246556 : generic_simplify_LE_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
5457 : {
5458 9246556 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
5459 9246556 : switch (TREE_CODE (_p0))
5460 : {
5461 2318 : case RDIV_EXPR:
5462 2318 : {
5463 2318 : tree _q20 = TREE_OPERAND (_p0, 0);
5464 2318 : tree _q21 = TREE_OPERAND (_p0, 1);
5465 2318 : switch (TREE_CODE (_q20))
5466 : {
5467 548 : case REAL_CST:
5468 548 : {
5469 548 : if (real_zerop (_p1))
5470 : {
5471 2 : {
5472 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5473 2 : tree res = generic_simplify_374 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
5474 2 : if (res) return res;
5475 : }
5476 : }
5477 : break;
5478 : }
5479 : default:;
5480 : }
5481 : break;
5482 : }
5483 9246554 : default:;
5484 : }
5485 9246554 : switch (TREE_CODE (_p1))
5486 : {
5487 7 : case TRUNC_MOD_EXPR:
5488 7 : {
5489 7 : tree _q30 = TREE_OPERAND (_p1, 0);
5490 7 : tree _q31 = TREE_OPERAND (_p1, 1);
5491 7 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5492 : {
5493 0 : {
5494 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
5495 0 : tree res = generic_simplify_375 (loc, type, _p0, _p1, captures, GE_EXPR);
5496 0 : if (res) return res;
5497 : }
5498 : }
5499 : break;
5500 : }
5501 9246554 : default:;
5502 : }
5503 9246554 : switch (TREE_CODE (_p0))
5504 : {
5505 62112 : case MULT_EXPR:
5506 62112 : {
5507 62112 : tree _q20 = TREE_OPERAND (_p0, 0);
5508 62112 : tree _q21 = TREE_OPERAND (_p0, 1);
5509 62112 : switch (TREE_CODE (_p1))
5510 : {
5511 2714 : case MULT_EXPR:
5512 2714 : {
5513 2714 : tree _q50 = TREE_OPERAND (_p1, 0);
5514 2714 : tree _q51 = TREE_OPERAND (_p1, 1);
5515 2714 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5516 : {
5517 1863 : {
5518 1863 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5519 1863 : tree res = generic_simplify_376 (loc, type, _p0, _p1, captures, LE_EXPR);
5520 1863 : if (res) return res;
5521 : }
5522 : }
5523 1733 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5524 : {
5525 1 : {
5526 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5527 1 : tree res = generic_simplify_376 (loc, type, _p0, _p1, captures, LE_EXPR);
5528 1 : if (res) return res;
5529 : }
5530 : }
5531 1733 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5532 : {
5533 4 : {
5534 4 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
5535 4 : tree res = generic_simplify_376 (loc, type, _p0, _p1, captures, LE_EXPR);
5536 4 : if (res) return res;
5537 : }
5538 : }
5539 1733 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5540 : {
5541 315 : {
5542 315 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
5543 315 : tree res = generic_simplify_376 (loc, type, _p0, _p1, captures, LE_EXPR);
5544 315 : if (res) return res;
5545 : }
5546 : }
5547 : break;
5548 : }
5549 : default:;
5550 : }
5551 : break;
5552 : }
5553 1608431 : case PLUS_EXPR:
5554 1608431 : {
5555 1608431 : tree _q20 = TREE_OPERAND (_p0, 0);
5556 1608431 : tree _q21 = TREE_OPERAND (_p0, 1);
5557 1608431 : if (integer_minus_onep (_q21))
5558 : {
5559 534324 : switch (TREE_CODE (_p1))
5560 : {
5561 331179 : case INTEGER_CST:
5562 331179 : {
5563 331179 : {
5564 331179 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5565 331179 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR);
5566 331179 : if (res) return res;
5567 : }
5568 331177 : break;
5569 : }
5570 : default:;
5571 : }
5572 : }
5573 1608429 : switch (TREE_CODE (_p1))
5574 : {
5575 87583 : case PLUS_EXPR:
5576 87583 : {
5577 87583 : tree _q50 = TREE_OPERAND (_p1, 0);
5578 87583 : tree _q51 = TREE_OPERAND (_p1, 1);
5579 87583 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5580 : {
5581 7256 : {
5582 7256 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5583 7256 : tree res = generic_simplify_377 (loc, type, _p0, _p1, captures, LE_EXPR);
5584 7256 : if (res) return res;
5585 : }
5586 : }
5587 83420 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5588 : {
5589 13 : {
5590 13 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5591 13 : tree res = generic_simplify_377 (loc, type, _p0, _p1, captures, LE_EXPR);
5592 13 : if (res) return res;
5593 : }
5594 : }
5595 83420 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5596 : {
5597 209 : {
5598 209 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
5599 209 : tree res = generic_simplify_377 (loc, type, _p0, _p1, captures, LE_EXPR);
5600 209 : if (res) return res;
5601 : }
5602 : }
5603 83412 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5604 : {
5605 6998 : {
5606 6998 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
5607 6998 : tree res = generic_simplify_377 (loc, type, _p0, _p1, captures, LE_EXPR);
5608 6998 : if (res) return res;
5609 : }
5610 : }
5611 : break;
5612 : }
5613 1603736 : default:;
5614 : }
5615 1603736 : switch (TREE_CODE (_q21))
5616 : {
5617 1479759 : case INTEGER_CST:
5618 1479759 : {
5619 1479759 : switch (TREE_CODE (_p1))
5620 : {
5621 80840 : case PLUS_EXPR:
5622 80840 : {
5623 80840 : tree _q50 = TREE_OPERAND (_p1, 0);
5624 80840 : tree _q51 = TREE_OPERAND (_p1, 1);
5625 80840 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5626 : {
5627 3035 : {
5628 3035 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5629 3035 : tree res = generic_simplify_378 (loc, type, _p0, _p1, captures, LE_EXPR);
5630 3035 : if (res) return res;
5631 : }
5632 : }
5633 : break;
5634 : }
5635 : default:;
5636 : }
5637 : break;
5638 : }
5639 1603736 : default:;
5640 : }
5641 1603736 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5642 : {
5643 73152 : {
5644 73152 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
5645 73152 : tree res = generic_simplify_379 (loc, type, _p0, _p1, captures, LE_EXPR);
5646 73152 : if (res) return res;
5647 : }
5648 : }
5649 1561602 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5650 : {
5651 3117 : {
5652 3117 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
5653 3117 : tree res = generic_simplify_379 (loc, type, _p0, _p1, captures, LE_EXPR);
5654 3117 : if (res) return res;
5655 : }
5656 : }
5657 : break;
5658 : }
5659 1668234 : CASE_CONVERT:
5660 1668234 : {
5661 1668234 : tree _q20 = TREE_OPERAND (_p0, 0);
5662 1668234 : switch (TREE_CODE (_q20))
5663 : {
5664 0 : case EXACT_DIV_EXPR:
5665 0 : {
5666 0 : tree _q30 = TREE_OPERAND (_q20, 0);
5667 0 : tree _q31 = TREE_OPERAND (_q20, 1);
5668 0 : switch (TREE_CODE (_q31))
5669 : {
5670 0 : case INTEGER_CST:
5671 0 : {
5672 0 : switch (TREE_CODE (_p1))
5673 : {
5674 0 : CASE_CONVERT:
5675 0 : {
5676 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5677 0 : switch (TREE_CODE (_q60))
5678 : {
5679 0 : case EXACT_DIV_EXPR:
5680 0 : {
5681 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5682 0 : tree _q71 = TREE_OPERAND (_q60, 1);
5683 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
5684 : {
5685 0 : {
5686 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q70 };
5687 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, LE_EXPR);
5688 0 : if (res) return res;
5689 : }
5690 : }
5691 : break;
5692 : }
5693 : default:;
5694 : }
5695 : break;
5696 : }
5697 : default:;
5698 : }
5699 : break;
5700 : }
5701 : default:;
5702 : }
5703 : break;
5704 : }
5705 : default:;
5706 : }
5707 : break;
5708 : }
5709 413 : case EXACT_DIV_EXPR:
5710 413 : {
5711 413 : tree _q20 = TREE_OPERAND (_p0, 0);
5712 413 : tree _q21 = TREE_OPERAND (_p0, 1);
5713 413 : switch (TREE_CODE (_q21))
5714 : {
5715 413 : case INTEGER_CST:
5716 413 : {
5717 413 : switch (TREE_CODE (_p1))
5718 : {
5719 0 : case EXACT_DIV_EXPR:
5720 0 : {
5721 0 : tree _q50 = TREE_OPERAND (_p1, 0);
5722 0 : tree _q51 = TREE_OPERAND (_p1, 1);
5723 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5724 : {
5725 0 : {
5726 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
5727 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, LE_EXPR);
5728 0 : if (res) return res;
5729 : }
5730 : }
5731 : break;
5732 : }
5733 : default:;
5734 : }
5735 : break;
5736 : }
5737 : default:;
5738 : }
5739 : break;
5740 : }
5741 10848 : case TRUNC_DIV_EXPR:
5742 10848 : {
5743 10848 : tree _q20 = TREE_OPERAND (_p0, 0);
5744 10848 : tree _q21 = TREE_OPERAND (_p0, 1);
5745 10848 : switch (TREE_CODE (_q21))
5746 : {
5747 2812 : case INTEGER_CST:
5748 2812 : {
5749 2812 : switch (TREE_CODE (_p1))
5750 : {
5751 1387 : case INTEGER_CST:
5752 1387 : {
5753 1387 : {
5754 1387 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
5755 1387 : tree res = generic_simplify_215 (loc, type, _p0, _p1, captures, LE_EXPR);
5756 1387 : if (res) return res;
5757 : }
5758 679 : break;
5759 : }
5760 : default:;
5761 : }
5762 : break;
5763 : }
5764 : default:;
5765 : }
5766 : break;
5767 : }
5768 64787 : case MINUS_EXPR:
5769 64787 : {
5770 64787 : tree _q20 = TREE_OPERAND (_p0, 0);
5771 64787 : tree _q21 = TREE_OPERAND (_p0, 1);
5772 64787 : switch (TREE_CODE (_p1))
5773 : {
5774 489 : case MINUS_EXPR:
5775 489 : {
5776 489 : tree _q50 = TREE_OPERAND (_p1, 0);
5777 489 : tree _q51 = TREE_OPERAND (_p1, 1);
5778 489 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5779 : {
5780 54 : {
5781 54 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5782 54 : tree res = generic_simplify_380 (loc, type, _p0, _p1, captures, LE_EXPR);
5783 54 : if (res) return res;
5784 : }
5785 : }
5786 489 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5787 : {
5788 26 : {
5789 26 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5790 26 : tree res = generic_simplify_381 (loc, type, _p0, _p1, captures, LE_EXPR);
5791 26 : if (res) return res;
5792 : }
5793 : }
5794 : break;
5795 : }
5796 : default:;
5797 : }
5798 : break;
5799 : }
5800 5385 : case POINTER_DIFF_EXPR:
5801 5385 : {
5802 5385 : tree _q20 = TREE_OPERAND (_p0, 0);
5803 5385 : tree _q21 = TREE_OPERAND (_p0, 1);
5804 5385 : switch (TREE_CODE (_p1))
5805 : {
5806 219 : case POINTER_DIFF_EXPR:
5807 219 : {
5808 219 : tree _q50 = TREE_OPERAND (_p1, 0);
5809 219 : tree _q51 = TREE_OPERAND (_p1, 1);
5810 219 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5811 : {
5812 0 : {
5813 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
5814 0 : tree res = generic_simplify_219 (loc, type, _p0, _p1, captures, LE_EXPR);
5815 0 : if (res) return res;
5816 : }
5817 : }
5818 219 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5819 : {
5820 0 : {
5821 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
5822 0 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, LE_EXPR);
5823 0 : if (res) return res;
5824 : }
5825 : }
5826 : break;
5827 : }
5828 : default:;
5829 : }
5830 : break;
5831 : }
5832 9197727 : default:;
5833 : }
5834 9197727 : switch (TREE_CODE (_p1))
5835 : {
5836 118761 : case PLUS_EXPR:
5837 118761 : {
5838 118761 : tree _q30 = TREE_OPERAND (_p1, 0);
5839 118761 : tree _q31 = TREE_OPERAND (_p1, 1);
5840 118761 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5841 : {
5842 0 : {
5843 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
5844 0 : tree res = generic_simplify_379 (loc, type, _p0, _p1, captures, GE_EXPR);
5845 0 : if (res) return res;
5846 : }
5847 : }
5848 118761 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5849 : {
5850 57 : {
5851 57 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q31, _p0 };
5852 57 : tree res = generic_simplify_379 (loc, type, _p0, _p1, captures, GE_EXPR);
5853 57 : if (res) return res;
5854 : }
5855 : }
5856 : break;
5857 : }
5858 1208 : case MINUS_EXPR:
5859 1208 : {
5860 1208 : tree _q30 = TREE_OPERAND (_p1, 0);
5861 1208 : tree _q31 = TREE_OPERAND (_p1, 1);
5862 1208 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5863 : {
5864 0 : {
5865 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
5866 0 : tree res = generic_simplify_218 (loc, type, _p0, _p1, captures, LE_EXPR);
5867 0 : if (res) return res;
5868 : }
5869 : }
5870 : break;
5871 : }
5872 9197700 : default:;
5873 : }
5874 9197700 : switch (TREE_CODE (_p0))
5875 : {
5876 64787 : case MINUS_EXPR:
5877 64787 : {
5878 64787 : tree _q20 = TREE_OPERAND (_p0, 0);
5879 64787 : tree _q21 = TREE_OPERAND (_p0, 1);
5880 64787 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5881 : {
5882 2509 : {
5883 2509 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
5884 2509 : tree res = generic_simplify_218 (loc, type, _p0, _p1, captures, GE_EXPR);
5885 2509 : if (res) return res;
5886 : }
5887 : }
5888 : break;
5889 : }
5890 5249 : case BIT_AND_EXPR:
5891 5249 : {
5892 5249 : tree _q20 = TREE_OPERAND (_p0, 0);
5893 5249 : tree _q21 = TREE_OPERAND (_p0, 1);
5894 5249 : if (tree_expr_nonnegative_p (_q20))
5895 : {
5896 4445 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5897 : {
5898 0 : {
5899 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5900 0 : tree res = generic_simplify_382 (loc, type, _p0, _p1, captures, LE_EXPR, BIT_AND_EXPR);
5901 0 : if (res) return res;
5902 : }
5903 : }
5904 : }
5905 5249 : if (tree_expr_nonnegative_p (_q21))
5906 : {
5907 4855 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5908 : {
5909 0 : {
5910 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
5911 0 : tree res = generic_simplify_382 (loc, type, _p0, _p1, captures, LE_EXPR, BIT_AND_EXPR);
5912 0 : if (res) return res;
5913 : }
5914 : }
5915 : }
5916 : break;
5917 : }
5918 9197700 : default:;
5919 : }
5920 9197700 : switch (TREE_CODE (_p1))
5921 : {
5922 46 : case BIT_IOR_EXPR:
5923 46 : {
5924 46 : tree _q30 = TREE_OPERAND (_p1, 0);
5925 46 : tree _q31 = TREE_OPERAND (_p1, 1);
5926 46 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5927 : {
5928 0 : if (tree_expr_nonnegative_p (_q30))
5929 : {
5930 0 : {
5931 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
5932 0 : tree res = generic_simplify_382 (loc, type, _p0, _p1, captures, GE_EXPR, BIT_IOR_EXPR);
5933 0 : if (res) return res;
5934 : }
5935 : }
5936 : }
5937 46 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5938 : {
5939 0 : if (tree_expr_nonnegative_p (_q31))
5940 : {
5941 0 : {
5942 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
5943 0 : tree res = generic_simplify_382 (loc, type, _p0, _p1, captures, GE_EXPR, BIT_IOR_EXPR);
5944 0 : if (res) return res;
5945 : }
5946 : }
5947 : }
5948 : break;
5949 : }
5950 9197700 : default:;
5951 : }
5952 9197700 : switch (TREE_CODE (_p0))
5953 : {
5954 9967 : case MIN_EXPR:
5955 9967 : {
5956 9967 : tree _q20 = TREE_OPERAND (_p0, 0);
5957 9967 : tree _q21 = TREE_OPERAND (_p0, 1);
5958 9967 : switch (TREE_CODE (_p1))
5959 : {
5960 4 : case MAX_EXPR:
5961 4 : {
5962 4 : tree _q50 = TREE_OPERAND (_p1, 0);
5963 4 : tree _q51 = TREE_OPERAND (_p1, 1);
5964 4 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5965 : {
5966 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5967 : {
5968 0 : {
5969 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5970 0 : tree res = generic_simplify_383 (loc, type, _p0, _p1, captures, LE_EXPR);
5971 0 : if (res) return res;
5972 : }
5973 : }
5974 : }
5975 : break;
5976 : }
5977 : default:;
5978 : }
5979 : break;
5980 : }
5981 4351 : case MAX_EXPR:
5982 4351 : {
5983 4351 : tree _q20 = TREE_OPERAND (_p0, 0);
5984 4351 : tree _q21 = TREE_OPERAND (_p0, 1);
5985 4351 : switch (TREE_CODE (_p1))
5986 : {
5987 4 : case MIN_EXPR:
5988 4 : {
5989 4 : tree _q50 = TREE_OPERAND (_p1, 0);
5990 4 : tree _q51 = TREE_OPERAND (_p1, 1);
5991 4 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5992 : {
5993 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5994 : {
5995 0 : {
5996 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5997 0 : tree res = generic_simplify_384 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
5998 0 : if (res) return res;
5999 : }
6000 : }
6001 : }
6002 : break;
6003 : }
6004 4351 : default:;
6005 : }
6006 4351 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
6007 : {
6008 0 : {
6009 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6010 0 : tree res = generic_simplify_228 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR, GE_EXPR);
6011 0 : if (res) return res;
6012 : }
6013 : }
6014 4351 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
6015 : {
6016 1 : {
6017 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6018 1 : tree res = generic_simplify_228 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR, GE_EXPR);
6019 1 : if (res) return res;
6020 : }
6021 : }
6022 : break;
6023 : }
6024 9197699 : default:;
6025 : }
6026 9197699 : switch (TREE_CODE (_p1))
6027 : {
6028 304 : case MIN_EXPR:
6029 304 : {
6030 304 : tree _q30 = TREE_OPERAND (_p1, 0);
6031 304 : tree _q31 = TREE_OPERAND (_p1, 1);
6032 304 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
6033 : {
6034 0 : {
6035 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
6036 0 : tree res = generic_simplify_228 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR, LE_EXPR);
6037 0 : if (res) return res;
6038 : }
6039 : }
6040 304 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6041 : {
6042 0 : {
6043 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
6044 0 : tree res = generic_simplify_228 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR, LE_EXPR);
6045 0 : if (res) return res;
6046 : }
6047 : }
6048 : break;
6049 : }
6050 13 : case MAX_EXPR:
6051 13 : {
6052 13 : tree _q30 = TREE_OPERAND (_p1, 0);
6053 13 : tree _q31 = TREE_OPERAND (_p1, 1);
6054 13 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
6055 : {
6056 0 : {
6057 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
6058 0 : tree res = generic_simplify_385 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR);
6059 0 : if (res) return res;
6060 : }
6061 : }
6062 13 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6063 : {
6064 0 : {
6065 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
6066 0 : tree res = generic_simplify_385 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR);
6067 0 : if (res) return res;
6068 : }
6069 : }
6070 : break;
6071 : }
6072 9197699 : default:;
6073 : }
6074 9197699 : switch (TREE_CODE (_p0))
6075 : {
6076 9967 : case MIN_EXPR:
6077 9967 : {
6078 9967 : tree _q20 = TREE_OPERAND (_p0, 0);
6079 9967 : tree _q21 = TREE_OPERAND (_p0, 1);
6080 9967 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
6081 : {
6082 0 : {
6083 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6084 0 : tree res = generic_simplify_385 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR);
6085 0 : if (res) return res;
6086 : }
6087 : }
6088 9967 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
6089 : {
6090 0 : {
6091 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6092 0 : tree res = generic_simplify_385 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR);
6093 0 : if (res) return res;
6094 : }
6095 : }
6096 9967 : switch (TREE_CODE (_q21))
6097 : {
6098 919 : case INTEGER_CST:
6099 919 : {
6100 919 : switch (TREE_CODE (_p1))
6101 : {
6102 0 : case INTEGER_CST:
6103 0 : {
6104 0 : {
6105 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6106 0 : tree res = generic_simplify_386 (loc, type, _p0, _p1, captures, MIN_EXPR, LE_EXPR, BIT_IOR_EXPR);
6107 0 : if (res) return res;
6108 : }
6109 0 : break;
6110 : }
6111 : default:;
6112 : }
6113 : break;
6114 : }
6115 : default:;
6116 : }
6117 : break;
6118 : }
6119 4350 : case MAX_EXPR:
6120 4350 : {
6121 4350 : tree _q20 = TREE_OPERAND (_p0, 0);
6122 4350 : tree _q21 = TREE_OPERAND (_p0, 1);
6123 4350 : switch (TREE_CODE (_q21))
6124 : {
6125 4108 : case INTEGER_CST:
6126 4108 : {
6127 4108 : switch (TREE_CODE (_p1))
6128 : {
6129 0 : case INTEGER_CST:
6130 0 : {
6131 0 : {
6132 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6133 0 : tree res = generic_simplify_386 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR, BIT_AND_EXPR);
6134 0 : if (res) return res;
6135 : }
6136 0 : break;
6137 : }
6138 : default:;
6139 : }
6140 : break;
6141 : }
6142 : default:;
6143 : }
6144 : break;
6145 : }
6146 9 : case VEC_COND_EXPR:
6147 9 : {
6148 9 : tree _q20 = TREE_OPERAND (_p0, 0);
6149 9 : tree _q21 = TREE_OPERAND (_p0, 1);
6150 9 : tree _q22 = TREE_OPERAND (_p0, 2);
6151 9 : switch (TREE_CODE (_p1))
6152 : {
6153 2 : case VEC_COND_EXPR:
6154 2 : {
6155 2 : tree _q60 = TREE_OPERAND (_p1, 0);
6156 2 : tree _q61 = TREE_OPERAND (_p1, 1);
6157 2 : tree _q62 = TREE_OPERAND (_p1, 2);
6158 2 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6159 : {
6160 0 : {
6161 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
6162 0 : if (VECTOR_TYPE_P (type)
6163 0 : && (TREE_CODE_CLASS (LE_EXPR) != tcc_comparison
6164 0 : || types_match (type, TREE_TYPE (captures[2]))
6165 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
6166 : || (optimize_vectors_before_lowering_p ()
6167 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
6168 : )
6169 : {
6170 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1631;
6171 0 : {
6172 0 : tree res_op0;
6173 0 : res_op0 = captures[1];
6174 0 : tree res_op1;
6175 0 : {
6176 0 : tree _o1[2], _r1;
6177 0 : _o1[0] = captures[2];
6178 0 : _o1[1] = captures[5];
6179 0 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6180 0 : if (EXPR_P (_r1))
6181 0 : goto next_after_fail1631;
6182 0 : res_op1 = _r1;
6183 : }
6184 0 : tree res_op2;
6185 0 : {
6186 0 : tree _o1[2], _r1;
6187 0 : _o1[0] = captures[3];
6188 0 : _o1[1] = captures[6];
6189 0 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6190 0 : if (EXPR_P (_r1))
6191 0 : goto next_after_fail1631;
6192 0 : res_op2 = _r1;
6193 : }
6194 0 : tree _r;
6195 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
6196 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 890, __FILE__, __LINE__, true);
6197 0 : return _r;
6198 : }
6199 0 : next_after_fail1631:;
6200 : }
6201 : }
6202 : }
6203 : break;
6204 : }
6205 9 : default:;
6206 : }
6207 9 : {
6208 9 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
6209 9 : if (VECTOR_TYPE_P (type)
6210 9 : && (TREE_CODE_CLASS (LE_EXPR) != tcc_comparison
6211 9 : || types_match (type, TREE_TYPE (captures[2]))
6212 9 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
6213 : || (optimize_vectors_before_lowering_p ()
6214 1 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
6215 : )
6216 : {
6217 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1632;
6218 9 : {
6219 9 : if (! tree_invariant_p (captures[4])) goto next_after_fail1632;
6220 7 : tree res_op0;
6221 7 : res_op0 = captures[1];
6222 7 : tree res_op1;
6223 7 : {
6224 7 : tree _o1[2], _r1;
6225 7 : _o1[0] = captures[2];
6226 7 : _o1[1] = unshare_expr (captures[4]);
6227 7 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6228 7 : if (EXPR_P (_r1))
6229 0 : goto next_after_fail1632;
6230 7 : res_op1 = _r1;
6231 : }
6232 7 : tree res_op2;
6233 7 : {
6234 7 : tree _o1[2], _r1;
6235 7 : _o1[0] = captures[3];
6236 7 : _o1[1] = captures[4];
6237 7 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6238 7 : if (EXPR_P (_r1))
6239 0 : goto next_after_fail1632;
6240 7 : res_op2 = _r1;
6241 : }
6242 7 : tree _r;
6243 7 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
6244 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
6245 7 : return _r;
6246 : }
6247 2 : next_after_fail1632:;
6248 : }
6249 : }
6250 2 : break;
6251 : }
6252 9197692 : default:;
6253 : }
6254 9197692 : switch (TREE_CODE (_p1))
6255 : {
6256 2 : case VEC_COND_EXPR:
6257 2 : {
6258 2 : tree _q30 = TREE_OPERAND (_p1, 0);
6259 2 : tree _q31 = TREE_OPERAND (_p1, 1);
6260 2 : tree _q32 = TREE_OPERAND (_p1, 2);
6261 2 : {
6262 2 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
6263 2 : if (VECTOR_TYPE_P (type)
6264 2 : && (TREE_CODE_CLASS (LE_EXPR) != tcc_comparison
6265 2 : || types_match (type, TREE_TYPE (captures[3]))
6266 2 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
6267 : || (optimize_vectors_before_lowering_p ()
6268 1 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
6269 : )
6270 : {
6271 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1633;
6272 2 : {
6273 2 : if (! tree_invariant_p (captures[0])) goto next_after_fail1633;
6274 0 : tree res_op0;
6275 0 : res_op0 = captures[2];
6276 0 : tree res_op1;
6277 0 : {
6278 0 : tree _o1[2], _r1;
6279 0 : _o1[0] = unshare_expr (captures[0]);
6280 0 : _o1[1] = captures[3];
6281 0 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6282 0 : if (EXPR_P (_r1))
6283 0 : goto next_after_fail1633;
6284 0 : res_op1 = _r1;
6285 : }
6286 0 : tree res_op2;
6287 0 : {
6288 0 : tree _o1[2], _r1;
6289 0 : _o1[0] = captures[0];
6290 0 : _o1[1] = captures[4];
6291 0 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6292 0 : if (EXPR_P (_r1))
6293 0 : goto next_after_fail1633;
6294 0 : res_op2 = _r1;
6295 : }
6296 0 : tree _r;
6297 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
6298 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
6299 0 : return _r;
6300 : }
6301 2 : next_after_fail1633:;
6302 : }
6303 : }
6304 2 : break;
6305 : }
6306 9197692 : default:;
6307 : }
6308 9197692 : if (uniform_integer_cst_p (_p1))
6309 : {
6310 6735939 : {
6311 6735939 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
6312 6735939 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, LE_EXPR, LT_EXPR);
6313 6735939 : if (res) return res;
6314 : }
6315 : }
6316 9101353 : switch (TREE_CODE (_p0))
6317 : {
6318 60710 : case MULT_EXPR:
6319 60710 : {
6320 60710 : tree _q20 = TREE_OPERAND (_p0, 0);
6321 60710 : tree _q21 = TREE_OPERAND (_p0, 1);
6322 60710 : switch (TREE_CODE (_q21))
6323 : {
6324 53329 : case INTEGER_CST:
6325 53329 : {
6326 53329 : if (integer_zerop (_p1))
6327 : {
6328 987 : {
6329 987 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
6330 987 : tree res = generic_simplify_248 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6331 987 : if (res) return res;
6332 : }
6333 : }
6334 : break;
6335 : }
6336 : default:;
6337 : }
6338 : break;
6339 : }
6340 9100569 : default:;
6341 : }
6342 9100569 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
6343 : {
6344 4951 : {
6345 4951 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
6346 4951 : tree res = generic_simplify_250 (loc, type, _p0, _p1, captures, LE_EXPR);
6347 4951 : if (res) return res;
6348 : }
6349 : }
6350 9095660 : switch (TREE_CODE (_p0))
6351 : {
6352 2549 : case BIT_NOT_EXPR:
6353 2549 : {
6354 2549 : tree _q20 = TREE_OPERAND (_p0, 0);
6355 2549 : switch (TREE_CODE (_p1))
6356 : {
6357 0 : case BIT_NOT_EXPR:
6358 0 : {
6359 0 : tree _q40 = TREE_OPERAND (_p1, 0);
6360 0 : {
6361 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _p1, _q40 };
6362 0 : tree res = generic_simplify_254 (loc, type, _p0, _p1, captures, LE_EXPR);
6363 0 : if (res) return res;
6364 : }
6365 0 : break;
6366 : }
6367 2549 : default:;
6368 : }
6369 2549 : {
6370 2549 : tree _p1_pops[1];
6371 2549 : if (tree_nop_convert (_p1, _p1_pops))
6372 : {
6373 1 : tree _q40 = _p1_pops[0];
6374 1 : switch (TREE_CODE (_q40))
6375 : {
6376 0 : case BIT_NOT_EXPR:
6377 0 : {
6378 0 : tree _q50 = TREE_OPERAND (_q40, 0);
6379 0 : {
6380 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40, _q50 };
6381 0 : tree res = generic_simplify_254 (loc, type, _p0, _p1, captures, LE_EXPR);
6382 0 : if (res) return res;
6383 : }
6384 0 : break;
6385 : }
6386 : default:;
6387 : }
6388 : }
6389 : }
6390 2549 : if (CONSTANT_CLASS_P (_p1))
6391 : {
6392 2255 : {
6393 2255 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
6394 2255 : tree res = generic_simplify_253 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6395 2255 : if (res) return res;
6396 : }
6397 : }
6398 : break;
6399 : }
6400 9093405 : default:;
6401 : }
6402 9093405 : {
6403 9093405 : tree _p0_pops[1];
6404 9093405 : if (tree_nop_convert (_p0, _p0_pops))
6405 : {
6406 834482 : tree _q20 = _p0_pops[0];
6407 834482 : switch (TREE_CODE (_q20))
6408 : {
6409 0 : case BIT_NOT_EXPR:
6410 0 : {
6411 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6412 0 : switch (TREE_CODE (_p1))
6413 : {
6414 0 : case BIT_NOT_EXPR:
6415 0 : {
6416 0 : tree _q50 = TREE_OPERAND (_p1, 0);
6417 0 : {
6418 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _p1, _q50 };
6419 0 : tree res = generic_simplify_252 (loc, type, _p0, _p1, captures, LE_EXPR);
6420 0 : if (res) return res;
6421 : }
6422 0 : break;
6423 : }
6424 0 : default:;
6425 : }
6426 0 : {
6427 0 : tree _p1_pops[1];
6428 0 : if (tree_nop_convert (_p1, _p1_pops))
6429 : {
6430 0 : tree _q50 = _p1_pops[0];
6431 0 : switch (TREE_CODE (_q50))
6432 : {
6433 0 : case BIT_NOT_EXPR:
6434 0 : {
6435 0 : tree _q60 = TREE_OPERAND (_q50, 0);
6436 0 : {
6437 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50, _q60 };
6438 0 : tree res = generic_simplify_252 (loc, type, _p0, _p1, captures, LE_EXPR);
6439 0 : if (res) return res;
6440 : }
6441 0 : break;
6442 : }
6443 : default:;
6444 : }
6445 : }
6446 : }
6447 0 : if (CONSTANT_CLASS_P (_p1))
6448 : {
6449 0 : {
6450 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
6451 0 : tree res = generic_simplify_253 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6452 0 : if (res) return res;
6453 : }
6454 : }
6455 : break;
6456 : }
6457 : default:;
6458 : }
6459 : }
6460 : }
6461 9093405 : switch (TREE_CODE (_p1))
6462 : {
6463 187475 : case REAL_CST:
6464 187475 : {
6465 187475 : {
6466 187475 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
6467 187475 : tree res = generic_simplify_255 (loc, type, _p0, _p1, captures, LE_EXPR);
6468 187475 : if (res) return res;
6469 : }
6470 187412 : break;
6471 : }
6472 9093342 : default:;
6473 : }
6474 9093342 : switch (TREE_CODE (_p0))
6475 : {
6476 1559976 : case PLUS_EXPR:
6477 1559976 : {
6478 1559976 : tree _q20 = TREE_OPERAND (_p0, 0);
6479 1559976 : tree _q21 = TREE_OPERAND (_p0, 1);
6480 1559976 : switch (TREE_CODE (_q21))
6481 : {
6482 86 : case REAL_CST:
6483 86 : {
6484 86 : switch (TREE_CODE (_p1))
6485 : {
6486 81 : case REAL_CST:
6487 81 : {
6488 81 : {
6489 81 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6490 81 : tree res = generic_simplify_256 (loc, type, _p0, _p1, captures, PLUS_EXPR, LE_EXPR);
6491 81 : if (res) return res;
6492 : }
6493 81 : break;
6494 : }
6495 : default:;
6496 : }
6497 : break;
6498 : }
6499 1456762 : case INTEGER_CST:
6500 1456762 : {
6501 1456762 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
6502 : {
6503 1969 : {
6504 1969 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q20, _q21 };
6505 1969 : tree res = generic_simplify_389 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR);
6506 1969 : if (res) return res;
6507 : }
6508 : }
6509 : break;
6510 : }
6511 : default:;
6512 : }
6513 : break;
6514 : }
6515 59154 : case MINUS_EXPR:
6516 59154 : {
6517 59154 : tree _q20 = TREE_OPERAND (_p0, 0);
6518 59154 : tree _q21 = TREE_OPERAND (_p0, 1);
6519 59154 : switch (TREE_CODE (_q21))
6520 : {
6521 1225 : case REAL_CST:
6522 1225 : {
6523 1225 : switch (TREE_CODE (_p1))
6524 : {
6525 1202 : case REAL_CST:
6526 1202 : {
6527 1202 : {
6528 1202 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6529 1202 : tree res = generic_simplify_256 (loc, type, _p0, _p1, captures, MINUS_EXPR, LE_EXPR);
6530 1202 : if (res) return res;
6531 : }
6532 1202 : break;
6533 : }
6534 : default:;
6535 : }
6536 : break;
6537 : }
6538 59154 : default:;
6539 : }
6540 59154 : switch (TREE_CODE (_q20))
6541 : {
6542 2 : case REAL_CST:
6543 2 : {
6544 2 : switch (TREE_CODE (_p1))
6545 : {
6546 0 : case REAL_CST:
6547 0 : {
6548 0 : {
6549 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6550 0 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, LE_EXPR);
6551 0 : if (res) return res;
6552 : }
6553 0 : break;
6554 : }
6555 : default:;
6556 : }
6557 : break;
6558 : }
6559 : default:;
6560 : }
6561 : break;
6562 : }
6563 11786 : case FLOAT_EXPR:
6564 11786 : {
6565 11786 : tree _q20 = TREE_OPERAND (_p0, 0);
6566 11786 : switch (TREE_CODE (_p1))
6567 : {
6568 0 : case FLOAT_EXPR:
6569 0 : {
6570 0 : tree _q40 = TREE_OPERAND (_p1, 0);
6571 0 : {
6572 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
6573 0 : tree res = generic_simplify_260 (loc, type, _p0, _p1, captures, LE_EXPR, LE_EXPR);
6574 0 : if (res) return res;
6575 : }
6576 0 : break;
6577 : }
6578 235 : case REAL_CST:
6579 235 : {
6580 235 : {
6581 235 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6582 235 : tree res = generic_simplify_261 (loc, type, _p0, _p1, captures, LE_EXPR, LE_EXPR);
6583 235 : if (res) return res;
6584 : }
6585 156 : break;
6586 : }
6587 : default:;
6588 : }
6589 : break;
6590 : }
6591 413 : case EXACT_DIV_EXPR:
6592 413 : {
6593 413 : tree _q20 = TREE_OPERAND (_p0, 0);
6594 413 : tree _q21 = TREE_OPERAND (_p0, 1);
6595 413 : switch (TREE_CODE (_q21))
6596 : {
6597 413 : case INTEGER_CST:
6598 413 : {
6599 413 : switch (TREE_CODE (_p1))
6600 : {
6601 336 : case INTEGER_CST:
6602 336 : {
6603 336 : {
6604 336 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6605 336 : tree res = generic_simplify_390 (loc, type, _p0, _p1, captures, LE_EXPR);
6606 336 : if (res) return res;
6607 : }
6608 0 : break;
6609 : }
6610 : default:;
6611 : }
6612 : break;
6613 : }
6614 : default:;
6615 : }
6616 : break;
6617 : }
6618 1665007 : CASE_CONVERT:
6619 1665007 : {
6620 1665007 : tree _q20 = TREE_OPERAND (_p0, 0);
6621 1665007 : switch (TREE_CODE (_q20))
6622 : {
6623 0 : case EXACT_DIV_EXPR:
6624 0 : {
6625 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6626 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6627 0 : switch (TREE_CODE (_q31))
6628 : {
6629 0 : case INTEGER_CST:
6630 0 : {
6631 0 : switch (TREE_CODE (_p1))
6632 : {
6633 0 : case INTEGER_CST:
6634 0 : {
6635 0 : {
6636 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
6637 0 : tree res = generic_simplify_391 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6638 0 : if (res) return res;
6639 : }
6640 0 : break;
6641 : }
6642 : default:;
6643 : }
6644 : break;
6645 : }
6646 : default:;
6647 : }
6648 : break;
6649 : }
6650 1665007 : default:;
6651 : }
6652 1665007 : switch (TREE_CODE (_p1))
6653 : {
6654 77209 : CASE_CONVERT:
6655 77209 : {
6656 77209 : tree _q40 = TREE_OPERAND (_p1, 0);
6657 77209 : {
6658 77209 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
6659 77209 : tree res = generic_simplify_265 (loc, type, _p0, _p1, captures, LE_EXPR);
6660 77209 : if (res) return res;
6661 : }
6662 28823 : break;
6663 : }
6664 1616621 : default:;
6665 : }
6666 1616621 : {
6667 1616621 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
6668 1616621 : tree res = generic_simplify_266 (loc, type, _p0, _p1, captures, LE_EXPR);
6669 1616621 : if (res) return res;
6670 : }
6671 938352 : switch (TREE_CODE (_q20))
6672 : {
6673 5794 : case ADDR_EXPR:
6674 5794 : {
6675 5794 : switch (TREE_CODE (_p1))
6676 : {
6677 5485 : CASE_CONVERT:
6678 5485 : {
6679 5485 : tree _q40 = TREE_OPERAND (_p1, 0);
6680 5485 : switch (TREE_CODE (_q40))
6681 : {
6682 5485 : case ADDR_EXPR:
6683 5485 : {
6684 5485 : {
6685 5485 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
6686 5485 : tree res = generic_simplify_284 (loc, type, _p0, _p1, captures, LE_EXPR);
6687 5485 : if (res) return res;
6688 : }
6689 160 : break;
6690 : }
6691 : default:;
6692 : }
6693 : break;
6694 : }
6695 0 : case ADDR_EXPR:
6696 0 : {
6697 0 : {
6698 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
6699 0 : tree res = generic_simplify_284 (loc, type, _p0, _p1, captures, LE_EXPR);
6700 0 : if (res) return res;
6701 : }
6702 0 : break;
6703 : }
6704 : default:;
6705 : }
6706 : break;
6707 : }
6708 933027 : default:;
6709 : }
6710 933027 : if (uniform_integer_cst_p (_p1))
6711 : {
6712 484275 : {
6713 484275 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
6714 484275 : tree res = generic_simplify_392 (loc, type, _p0, _p1, captures, LE_EXPR);
6715 484275 : if (res) return res;
6716 : }
6717 : }
6718 : break;
6719 : }
6720 5249 : case BIT_AND_EXPR:
6721 5249 : {
6722 5249 : tree _q20 = TREE_OPERAND (_p0, 0);
6723 5249 : tree _q21 = TREE_OPERAND (_p0, 1);
6724 5249 : switch (TREE_CODE (_q21))
6725 : {
6726 4767 : case INTEGER_CST:
6727 4767 : {
6728 4767 : switch (TREE_CODE (_p1))
6729 : {
6730 2708 : case INTEGER_CST:
6731 2708 : {
6732 2708 : {
6733 2708 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
6734 2708 : tree res = generic_simplify_406 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR);
6735 2708 : if (res) return res;
6736 : }
6737 2661 : break;
6738 : }
6739 : default:;
6740 : }
6741 : break;
6742 : }
6743 : default:;
6744 : }
6745 : break;
6746 : }
6747 5496 : case NEGATE_EXPR:
6748 5496 : {
6749 5496 : tree _q20 = TREE_OPERAND (_p0, 0);
6750 5496 : switch (TREE_CODE (_p1))
6751 : {
6752 32 : case NEGATE_EXPR:
6753 32 : {
6754 32 : tree _q40 = TREE_OPERAND (_p1, 0);
6755 32 : {
6756 32 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6757 32 : tree res = generic_simplify_263 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6758 32 : if (res) return res;
6759 : }
6760 32 : break;
6761 : }
6762 5496 : default:;
6763 : }
6764 5496 : if (CONSTANT_CLASS_P (_p1))
6765 : {
6766 461 : {
6767 461 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6768 461 : tree res = generic_simplify_264 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6769 461 : if (res) return res;
6770 : }
6771 : }
6772 : break;
6773 : }
6774 1484 : case ADDR_EXPR:
6775 1484 : {
6776 1484 : switch (TREE_CODE (_p1))
6777 : {
6778 18 : CASE_CONVERT:
6779 18 : {
6780 18 : tree _q30 = TREE_OPERAND (_p1, 0);
6781 18 : switch (TREE_CODE (_q30))
6782 : {
6783 18 : case ADDR_EXPR:
6784 18 : {
6785 18 : {
6786 18 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q30 };
6787 18 : tree res = generic_simplify_285 (loc, type, _p0, _p1, captures, LE_EXPR);
6788 18 : if (res) return res;
6789 : }
6790 0 : break;
6791 : }
6792 : default:;
6793 : }
6794 : break;
6795 : }
6796 646 : case ADDR_EXPR:
6797 646 : {
6798 646 : {
6799 646 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
6800 646 : tree res = generic_simplify_285 (loc, type, _p0, _p1, captures, LE_EXPR);
6801 646 : if (res) return res;
6802 : }
6803 300 : break;
6804 : }
6805 : default:;
6806 : }
6807 : break;
6808 : }
6809 124456 : case CALL_EXPR:
6810 124456 : switch (get_call_combined_fn (_p0))
6811 : {
6812 2 : case CFN_BUILT_IN_SQRTF:
6813 2 : if (call_expr_nargs (_p0) == 1)
6814 : {
6815 2 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
6816 2 : switch (TREE_CODE (_p1))
6817 : {
6818 2 : case REAL_CST:
6819 2 : {
6820 2 : {
6821 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6822 2 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, LE_EXPR);
6823 2 : if (res) return res;
6824 : }
6825 0 : break;
6826 : }
6827 0 : case CALL_EXPR:
6828 0 : switch (get_call_combined_fn (_p1))
6829 : {
6830 0 : case CFN_BUILT_IN_SQRTF:
6831 0 : if (call_expr_nargs (_p1) == 1)
6832 : {
6833 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
6834 0 : {
6835 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6836 0 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, LE_EXPR);
6837 0 : if (res) return res;
6838 : }
6839 : }
6840 : break;
6841 : default:;
6842 : }
6843 : break;
6844 : default:;
6845 : }
6846 : }
6847 : break;
6848 0 : case CFN_BUILT_IN_SQRTL:
6849 0 : if (call_expr_nargs (_p0) == 1)
6850 : {
6851 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
6852 0 : switch (TREE_CODE (_p1))
6853 : {
6854 0 : case REAL_CST:
6855 0 : {
6856 0 : {
6857 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6858 0 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, LE_EXPR);
6859 0 : if (res) return res;
6860 : }
6861 0 : break;
6862 : }
6863 0 : case CALL_EXPR:
6864 0 : switch (get_call_combined_fn (_p1))
6865 : {
6866 0 : case CFN_BUILT_IN_SQRTL:
6867 0 : if (call_expr_nargs (_p1) == 1)
6868 : {
6869 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
6870 0 : {
6871 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6872 0 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, LE_EXPR);
6873 0 : if (res) return res;
6874 : }
6875 : }
6876 : break;
6877 : default:;
6878 : }
6879 : break;
6880 : default:;
6881 : }
6882 : }
6883 : break;
6884 2 : case CFN_BUILT_IN_SQRT:
6885 2 : if (call_expr_nargs (_p0) == 1)
6886 : {
6887 2 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
6888 2 : switch (TREE_CODE (_p1))
6889 : {
6890 2 : case REAL_CST:
6891 2 : {
6892 2 : {
6893 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6894 2 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, LE_EXPR);
6895 2 : if (res) return res;
6896 : }
6897 2 : break;
6898 : }
6899 0 : case CALL_EXPR:
6900 0 : switch (get_call_combined_fn (_p1))
6901 : {
6902 0 : case CFN_BUILT_IN_SQRT:
6903 0 : if (call_expr_nargs (_p1) == 1)
6904 : {
6905 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
6906 0 : {
6907 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6908 0 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, LE_EXPR);
6909 0 : if (res) return res;
6910 : }
6911 : }
6912 : break;
6913 : default:;
6914 : }
6915 : break;
6916 : default:;
6917 : }
6918 : }
6919 : break;
6920 0 : case CFN_SQRT:
6921 0 : if (call_expr_nargs (_p0) == 1)
6922 : {
6923 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
6924 0 : switch (TREE_CODE (_p1))
6925 : {
6926 0 : case REAL_CST:
6927 0 : {
6928 0 : {
6929 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6930 0 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, CFN_SQRT, LE_EXPR);
6931 0 : if (res) return res;
6932 : }
6933 0 : break;
6934 : }
6935 0 : case CALL_EXPR:
6936 0 : switch (get_call_combined_fn (_p1))
6937 : {
6938 0 : case CFN_SQRT:
6939 0 : if (call_expr_nargs (_p1) == 1)
6940 : {
6941 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
6942 0 : {
6943 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6944 0 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, CFN_SQRT, LE_EXPR);
6945 0 : if (res) return res;
6946 : }
6947 : }
6948 : break;
6949 : default:;
6950 : }
6951 : break;
6952 : default:;
6953 : }
6954 : }
6955 : break;
6956 : default:;
6957 : }
6958 : break;
6959 8336159 : default:;
6960 : }
6961 8336159 : if (uniform_integer_cst_p (_p1))
6962 : {
6963 5935609 : {
6964 5935609 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
6965 5935609 : tree res = generic_simplify_393 (loc, type, _p0, _p1, captures, LE_EXPR);
6966 5935609 : if (res) return res;
6967 : }
6968 : }
6969 7926444 : switch (TREE_CODE (_p0))
6970 : {
6971 895220 : CASE_CONVERT:
6972 895220 : {
6973 895220 : tree _q20 = TREE_OPERAND (_p0, 0);
6974 895220 : switch (TREE_CODE (_q20))
6975 : {
6976 96878 : case PLUS_EXPR:
6977 96878 : {
6978 96878 : tree _q30 = TREE_OPERAND (_q20, 0);
6979 96878 : tree _q31 = TREE_OPERAND (_q20, 1);
6980 96878 : switch (TREE_CODE (_q30))
6981 : {
6982 82064 : CASE_CONVERT:
6983 82064 : {
6984 82064 : tree _q40 = TREE_OPERAND (_q30, 0);
6985 82064 : switch (TREE_CODE (_q31))
6986 : {
6987 81481 : case INTEGER_CST:
6988 81481 : {
6989 81481 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
6990 : {
6991 4 : {
6992 4 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q40, _q31 };
6993 4 : tree res = generic_simplify_394 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR);
6994 4 : if (res) return res;
6995 : }
6996 : }
6997 : break;
6998 : }
6999 : default:;
7000 : }
7001 : break;
7002 : }
7003 : default:;
7004 : }
7005 : break;
7006 : }
7007 : default:;
7008 : }
7009 : break;
7010 : }
7011 7926440 : default:;
7012 : }
7013 7926440 : switch (TREE_CODE (_p1))
7014 : {
7015 190590 : CASE_CONVERT:
7016 190590 : {
7017 190590 : tree _q30 = TREE_OPERAND (_p1, 0);
7018 190590 : switch (TREE_CODE (_q30))
7019 : {
7020 1935 : case PLUS_EXPR:
7021 1935 : {
7022 1935 : tree _q40 = TREE_OPERAND (_q30, 0);
7023 1935 : tree _q41 = TREE_OPERAND (_q30, 1);
7024 1935 : switch (TREE_CODE (_q40))
7025 : {
7026 442 : CASE_CONVERT:
7027 442 : {
7028 442 : tree _q50 = TREE_OPERAND (_q40, 0);
7029 442 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
7030 : {
7031 0 : switch (TREE_CODE (_q41))
7032 : {
7033 0 : case INTEGER_CST:
7034 0 : {
7035 0 : {
7036 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0, _q41 };
7037 0 : tree res = generic_simplify_394 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR);
7038 0 : if (res) return res;
7039 : }
7040 0 : break;
7041 : }
7042 : default:;
7043 : }
7044 : }
7045 : break;
7046 : }
7047 : default:;
7048 : }
7049 : break;
7050 : }
7051 : default:;
7052 : }
7053 : break;
7054 : }
7055 118418 : case PLUS_EXPR:
7056 118418 : {
7057 118418 : tree _q30 = TREE_OPERAND (_p1, 0);
7058 118418 : tree _q31 = TREE_OPERAND (_p1, 1);
7059 118418 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
7060 : {
7061 30 : switch (TREE_CODE (_q31))
7062 : {
7063 30 : case INTEGER_CST:
7064 30 : {
7065 30 : {
7066 30 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0, _q31 };
7067 30 : tree res = generic_simplify_389 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR);
7068 30 : if (res) return res;
7069 : }
7070 0 : break;
7071 : }
7072 : default:;
7073 : }
7074 : }
7075 : break;
7076 : }
7077 7926410 : default:;
7078 : }
7079 7926410 : switch (TREE_CODE (_p0))
7080 : {
7081 57068 : case MINUS_EXPR:
7082 57068 : {
7083 57068 : tree _q20 = TREE_OPERAND (_p0, 0);
7084 57068 : tree _q21 = TREE_OPERAND (_p0, 1);
7085 57068 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
7086 : {
7087 2509 : {
7088 2509 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
7089 2509 : tree res = generic_simplify_395 (loc, type, _p0, _p1, captures, LE_EXPR);
7090 2509 : if (res) return res;
7091 : }
7092 : }
7093 : break;
7094 : }
7095 7926283 : default:;
7096 : }
7097 7926283 : switch (TREE_CODE (_p1))
7098 : {
7099 118388 : case PLUS_EXPR:
7100 118388 : {
7101 118388 : tree _q30 = TREE_OPERAND (_p1, 0);
7102 118388 : tree _q31 = TREE_OPERAND (_p1, 1);
7103 118388 : switch (TREE_CODE (_q30))
7104 : {
7105 4 : case MINUS_EXPR:
7106 4 : {
7107 4 : tree _q40 = TREE_OPERAND (_q30, 0);
7108 4 : tree _q41 = TREE_OPERAND (_q30, 1);
7109 4 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
7110 : {
7111 0 : if (integer_minus_onep (_q31))
7112 : {
7113 0 : {
7114 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
7115 0 : tree res = generic_simplify_407 (loc, type, _p0, _p1, captures, GE_EXPR);
7116 0 : if (res) return res;
7117 : }
7118 : }
7119 : }
7120 : break;
7121 : }
7122 : default:;
7123 : }
7124 : break;
7125 : }
7126 7926283 : default:;
7127 : }
7128 7926283 : switch (TREE_CODE (_p0))
7129 : {
7130 12 : case REALPART_EXPR:
7131 12 : {
7132 12 : tree _q20 = TREE_OPERAND (_p0, 0);
7133 12 : switch (TREE_CODE (_q20))
7134 : {
7135 0 : case CALL_EXPR:
7136 0 : switch (get_call_combined_fn (_q20))
7137 : {
7138 0 : case CFN_SUB_OVERFLOW:
7139 0 : if (call_expr_nargs (_q20) == 2)
7140 : {
7141 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
7142 0 : tree _q31 = CALL_EXPR_ARG (_q20, 1);
7143 0 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
7144 : {
7145 0 : {
7146 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7147 0 : tree res = generic_simplify_408 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR);
7148 0 : if (res) return res;
7149 : }
7150 : }
7151 : }
7152 : break;
7153 : default:;
7154 : }
7155 : break;
7156 : default:;
7157 : }
7158 : break;
7159 : }
7160 7926283 : default:;
7161 : }
7162 7926283 : switch (TREE_CODE (_p1))
7163 : {
7164 0 : case REALPART_EXPR:
7165 0 : {
7166 0 : tree _q30 = TREE_OPERAND (_p1, 0);
7167 0 : switch (TREE_CODE (_q30))
7168 : {
7169 0 : case CALL_EXPR:
7170 0 : switch (get_call_combined_fn (_q30))
7171 : {
7172 0 : case CFN_ADD_OVERFLOW:
7173 0 : if (call_expr_nargs (_q30) == 2)
7174 : {
7175 0 : tree _q40 = CALL_EXPR_ARG (_q30, 0);
7176 0 : tree _q41 = CALL_EXPR_ARG (_q30, 1);
7177 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
7178 : {
7179 0 : {
7180 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p0, _q41 };
7181 0 : tree res = generic_simplify_409 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
7182 0 : if (res) return res;
7183 : }
7184 : }
7185 0 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
7186 : {
7187 0 : {
7188 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p0, _q40 };
7189 0 : tree res = generic_simplify_409 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
7190 0 : if (res) return res;
7191 : }
7192 : }
7193 : }
7194 : break;
7195 : default:;
7196 : }
7197 : break;
7198 : default:;
7199 : }
7200 : break;
7201 : }
7202 336 : case TRUNC_DIV_EXPR:
7203 336 : {
7204 336 : tree _q30 = TREE_OPERAND (_p1, 0);
7205 336 : tree _q31 = TREE_OPERAND (_p1, 1);
7206 336 : if (integer_all_onesp (_q30))
7207 : {
7208 0 : {
7209 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q31, _p0 };
7210 0 : tree res = generic_simplify_410 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
7211 0 : if (res) return res;
7212 : }
7213 : }
7214 : break;
7215 : }
7216 7926283 : default:;
7217 : }
7218 7926283 : switch (TREE_CODE (_p0))
7219 : {
7220 57625 : case MULT_EXPR:
7221 57625 : {
7222 57625 : tree _q20 = TREE_OPERAND (_p0, 0);
7223 57625 : tree _q21 = TREE_OPERAND (_p0, 1);
7224 57625 : switch (TREE_CODE (_q21))
7225 : {
7226 812 : case REAL_CST:
7227 812 : {
7228 812 : switch (TREE_CODE (_p1))
7229 : {
7230 544 : case REAL_CST:
7231 544 : {
7232 544 : {
7233 544 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7234 544 : tree res = generic_simplify_400 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
7235 544 : if (res) return res;
7236 : }
7237 542 : break;
7238 : }
7239 : default:;
7240 : }
7241 : break;
7242 : }
7243 : default:;
7244 : }
7245 : break;
7246 : }
7247 22 : case REAL_CST:
7248 22 : {
7249 22 : switch (TREE_CODE (_p1))
7250 : {
7251 0 : case CALL_EXPR:
7252 0 : switch (get_call_combined_fn (_p1))
7253 : {
7254 0 : case CFN_BUILT_IN_EXP:
7255 0 : if (call_expr_nargs (_p1) == 1)
7256 : {
7257 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7258 0 : {
7259 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7260 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, GE_EXPR);
7261 0 : if (res) return res;
7262 : }
7263 : }
7264 : break;
7265 0 : case CFN_BUILT_IN_LOG:
7266 0 : if (call_expr_nargs (_p1) == 1)
7267 : {
7268 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7269 0 : {
7270 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7271 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, GE_EXPR);
7272 0 : if (res) return res;
7273 : }
7274 : }
7275 : break;
7276 0 : case CFN_BUILT_IN_EXP10F:
7277 0 : if (call_expr_nargs (_p1) == 1)
7278 : {
7279 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7280 0 : {
7281 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7282 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, GE_EXPR);
7283 0 : if (res) return res;
7284 : }
7285 : }
7286 : break;
7287 0 : case CFN_BUILT_IN_EXP10L:
7288 0 : if (call_expr_nargs (_p1) == 1)
7289 : {
7290 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7291 0 : {
7292 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7293 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, GE_EXPR);
7294 0 : if (res) return res;
7295 : }
7296 : }
7297 : break;
7298 0 : case CFN_BUILT_IN_EXP2:
7299 0 : if (call_expr_nargs (_p1) == 1)
7300 : {
7301 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7302 0 : {
7303 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7304 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, GE_EXPR);
7305 0 : if (res) return res;
7306 : }
7307 : }
7308 : break;
7309 0 : case CFN_BUILT_IN_EXPF:
7310 0 : if (call_expr_nargs (_p1) == 1)
7311 : {
7312 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7313 0 : {
7314 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7315 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, GE_EXPR);
7316 0 : if (res) return res;
7317 : }
7318 : }
7319 : break;
7320 0 : case CFN_BUILT_IN_EXPL:
7321 0 : if (call_expr_nargs (_p1) == 1)
7322 : {
7323 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7324 0 : {
7325 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7326 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, GE_EXPR);
7327 0 : if (res) return res;
7328 : }
7329 : }
7330 : break;
7331 0 : case CFN_BUILT_IN_LOG2:
7332 0 : if (call_expr_nargs (_p1) == 1)
7333 : {
7334 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7335 0 : {
7336 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7337 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, GE_EXPR);
7338 0 : if (res) return res;
7339 : }
7340 : }
7341 : break;
7342 0 : case CFN_BUILT_IN_LOGF:
7343 0 : if (call_expr_nargs (_p1) == 1)
7344 : {
7345 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7346 0 : {
7347 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7348 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, GE_EXPR);
7349 0 : if (res) return res;
7350 : }
7351 : }
7352 : break;
7353 0 : case CFN_BUILT_IN_LOGL:
7354 0 : if (call_expr_nargs (_p1) == 1)
7355 : {
7356 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7357 0 : {
7358 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7359 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, GE_EXPR);
7360 0 : if (res) return res;
7361 : }
7362 : }
7363 : break;
7364 0 : case CFN_BUILT_IN_LOG10F:
7365 0 : if (call_expr_nargs (_p1) == 1)
7366 : {
7367 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7368 0 : {
7369 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7370 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, GE_EXPR);
7371 0 : if (res) return res;
7372 : }
7373 : }
7374 : break;
7375 0 : case CFN_BUILT_IN_LOG10L:
7376 0 : if (call_expr_nargs (_p1) == 1)
7377 : {
7378 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7379 0 : {
7380 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7381 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, GE_EXPR);
7382 0 : if (res) return res;
7383 : }
7384 : }
7385 : break;
7386 0 : case CFN_EXP:
7387 0 : if (call_expr_nargs (_p1) == 1)
7388 : {
7389 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7390 0 : {
7391 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7392 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, GE_EXPR);
7393 0 : if (res) return res;
7394 : }
7395 : }
7396 : break;
7397 0 : case CFN_LOG:
7398 0 : if (call_expr_nargs (_p1) == 1)
7399 : {
7400 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7401 0 : {
7402 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7403 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, GE_EXPR);
7404 0 : if (res) return res;
7405 : }
7406 : }
7407 : break;
7408 0 : case CFN_EXP2:
7409 0 : if (call_expr_nargs (_p1) == 1)
7410 : {
7411 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7412 0 : {
7413 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7414 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, GE_EXPR);
7415 0 : if (res) return res;
7416 : }
7417 : }
7418 : break;
7419 0 : case CFN_LOG2:
7420 0 : if (call_expr_nargs (_p1) == 1)
7421 : {
7422 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7423 0 : {
7424 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7425 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, GE_EXPR);
7426 0 : if (res) return res;
7427 : }
7428 : }
7429 : break;
7430 0 : case CFN_EXP10:
7431 0 : if (call_expr_nargs (_p1) == 1)
7432 : {
7433 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7434 0 : {
7435 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7436 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, GE_EXPR);
7437 0 : if (res) return res;
7438 : }
7439 : }
7440 : break;
7441 0 : case CFN_LOG10:
7442 0 : if (call_expr_nargs (_p1) == 1)
7443 : {
7444 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7445 0 : {
7446 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7447 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, GE_EXPR);
7448 0 : if (res) return res;
7449 : }
7450 : }
7451 : break;
7452 0 : case CFN_BUILT_IN_EXP10:
7453 0 : if (call_expr_nargs (_p1) == 1)
7454 : {
7455 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7456 0 : {
7457 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7458 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, GE_EXPR);
7459 0 : if (res) return res;
7460 : }
7461 : }
7462 : break;
7463 0 : case CFN_BUILT_IN_EXP2F:
7464 0 : if (call_expr_nargs (_p1) == 1)
7465 : {
7466 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7467 0 : {
7468 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7469 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, GE_EXPR);
7470 0 : if (res) return res;
7471 : }
7472 : }
7473 : break;
7474 0 : case CFN_BUILT_IN_EXP2L:
7475 0 : if (call_expr_nargs (_p1) == 1)
7476 : {
7477 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7478 0 : {
7479 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7480 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, GE_EXPR);
7481 0 : if (res) return res;
7482 : }
7483 : }
7484 : break;
7485 0 : case CFN_BUILT_IN_LOG10:
7486 0 : if (call_expr_nargs (_p1) == 1)
7487 : {
7488 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7489 0 : {
7490 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7491 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, GE_EXPR);
7492 0 : if (res) return res;
7493 : }
7494 : }
7495 : break;
7496 0 : case CFN_BUILT_IN_LOG2F:
7497 0 : if (call_expr_nargs (_p1) == 1)
7498 : {
7499 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7500 0 : {
7501 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7502 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, GE_EXPR);
7503 0 : if (res) return res;
7504 : }
7505 : }
7506 : break;
7507 0 : case CFN_BUILT_IN_LOG2L:
7508 0 : if (call_expr_nargs (_p1) == 1)
7509 : {
7510 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7511 0 : {
7512 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7513 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, GE_EXPR);
7514 0 : if (res) return res;
7515 : }
7516 : }
7517 : break;
7518 : default:;
7519 : }
7520 : break;
7521 : default:;
7522 : }
7523 : break;
7524 : }
7525 1470967 : case PLUS_EXPR:
7526 1470967 : {
7527 1470967 : tree _q20 = TREE_OPERAND (_p0, 0);
7528 1470967 : tree _q21 = TREE_OPERAND (_p0, 1);
7529 1470967 : switch (TREE_CODE (_q21))
7530 : {
7531 1370251 : case INTEGER_CST:
7532 1370251 : {
7533 1370251 : switch (TREE_CODE (_p1))
7534 : {
7535 853486 : case INTEGER_CST:
7536 853486 : {
7537 853486 : {
7538 853486 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
7539 853486 : tree res = generic_simplify_401 (loc, type, _p0, _p1, captures, PLUS_EXPR, MINUS_EXPR, LE_EXPR, GE_EXPR);
7540 853486 : if (res) return res;
7541 : }
7542 671245 : break;
7543 : }
7544 : default:;
7545 : }
7546 : break;
7547 : }
7548 : default:;
7549 : }
7550 : break;
7551 : }
7552 56941 : case MINUS_EXPR:
7553 56941 : {
7554 56941 : tree _q20 = TREE_OPERAND (_p0, 0);
7555 56941 : tree _q21 = TREE_OPERAND (_p0, 1);
7556 56941 : switch (TREE_CODE (_q21))
7557 : {
7558 2208 : case INTEGER_CST:
7559 2208 : {
7560 2208 : switch (TREE_CODE (_p1))
7561 : {
7562 2208 : case INTEGER_CST:
7563 2208 : {
7564 2208 : {
7565 2208 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
7566 2208 : tree res = generic_simplify_401 (loc, type, _p0, _p1, captures, MINUS_EXPR, PLUS_EXPR, LE_EXPR, GE_EXPR);
7567 2208 : if (res) return res;
7568 : }
7569 2207 : break;
7570 : }
7571 : default:;
7572 : }
7573 : break;
7574 : }
7575 56940 : default:;
7576 : }
7577 56940 : switch (TREE_CODE (_q20))
7578 : {
7579 2050 : case INTEGER_CST:
7580 2050 : {
7581 2050 : switch (TREE_CODE (_p1))
7582 : {
7583 1076 : case INTEGER_CST:
7584 1076 : {
7585 1076 : {
7586 1076 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7587 1076 : tree res = generic_simplify_291 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
7588 1076 : if (res) return res;
7589 : }
7590 0 : break;
7591 : }
7592 : default:;
7593 : }
7594 : break;
7595 : }
7596 : default:;
7597 : }
7598 : break;
7599 : }
7600 124042 : case CALL_EXPR:
7601 124042 : switch (get_call_combined_fn (_p0))
7602 : {
7603 18 : case CFN_BUILT_IN_CTZ:
7604 18 : if (call_expr_nargs (_p0) == 1)
7605 : {
7606 18 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7607 18 : switch (TREE_CODE (_p1))
7608 : {
7609 18 : case INTEGER_CST:
7610 18 : {
7611 18 : {
7612 18 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7613 18 : tree res = generic_simplify_402 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_BUILT_IN_CTZ);
7614 18 : if (res) return res;
7615 : }
7616 16 : break;
7617 : }
7618 : default:;
7619 : }
7620 : }
7621 : break;
7622 0 : case CFN_BUILT_IN_EXP:
7623 0 : if (call_expr_nargs (_p0) == 1)
7624 : {
7625 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7626 0 : switch (TREE_CODE (_p1))
7627 : {
7628 0 : case REAL_CST:
7629 0 : {
7630 0 : {
7631 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7632 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, LE_EXPR);
7633 0 : if (res) return res;
7634 : }
7635 0 : break;
7636 : }
7637 : default:;
7638 : }
7639 : }
7640 : break;
7641 8 : case CFN_BUILT_IN_FFS:
7642 8 : if (call_expr_nargs (_p0) == 1)
7643 : {
7644 8 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7645 8 : switch (TREE_CODE (_p1))
7646 : {
7647 8 : case INTEGER_CST:
7648 8 : {
7649 8 : {
7650 8 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7651 8 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_FFS);
7652 8 : if (res) return res;
7653 : }
7654 2 : break;
7655 : }
7656 : default:;
7657 : }
7658 : }
7659 : break;
7660 0 : case CFN_BUILT_IN_LOG:
7661 0 : if (call_expr_nargs (_p0) == 1)
7662 : {
7663 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7664 0 : switch (TREE_CODE (_p1))
7665 : {
7666 0 : case REAL_CST:
7667 0 : {
7668 0 : {
7669 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7670 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, LE_EXPR);
7671 0 : if (res) return res;
7672 : }
7673 0 : break;
7674 : }
7675 : default:;
7676 : }
7677 : }
7678 : break;
7679 0 : case CFN_BUILT_IN_FFSIMAX:
7680 0 : if (call_expr_nargs (_p0) == 1)
7681 : {
7682 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7683 0 : switch (TREE_CODE (_p1))
7684 : {
7685 0 : case INTEGER_CST:
7686 0 : {
7687 0 : {
7688 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7689 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_FFSIMAX);
7690 0 : if (res) return res;
7691 : }
7692 0 : break;
7693 : }
7694 : default:;
7695 : }
7696 : }
7697 : break;
7698 0 : case CFN_BUILT_IN_EXP10F:
7699 0 : if (call_expr_nargs (_p0) == 1)
7700 : {
7701 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7702 0 : switch (TREE_CODE (_p1))
7703 : {
7704 0 : case REAL_CST:
7705 0 : {
7706 0 : {
7707 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7708 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, LE_EXPR);
7709 0 : if (res) return res;
7710 : }
7711 0 : break;
7712 : }
7713 : default:;
7714 : }
7715 : }
7716 : break;
7717 0 : case CFN_BUILT_IN_EXP10L:
7718 0 : if (call_expr_nargs (_p0) == 1)
7719 : {
7720 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7721 0 : switch (TREE_CODE (_p1))
7722 : {
7723 0 : case REAL_CST:
7724 0 : {
7725 0 : {
7726 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7727 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, LE_EXPR);
7728 0 : if (res) return res;
7729 : }
7730 0 : break;
7731 : }
7732 : default:;
7733 : }
7734 : }
7735 : break;
7736 37 : case CFN_BUILT_IN_POPCOUNT:
7737 37 : if (call_expr_nargs (_p0) == 1)
7738 : {
7739 37 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7740 37 : if (integer_zerop (_p1))
7741 : {
7742 1 : {
7743 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
7744 1 : tree res = generic_simplify_296 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNT);
7745 1 : if (res) return res;
7746 : }
7747 : }
7748 : }
7749 : break;
7750 0 : case CFN_BUILT_IN_CTZL:
7751 0 : if (call_expr_nargs (_p0) == 1)
7752 : {
7753 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7754 0 : switch (TREE_CODE (_p1))
7755 : {
7756 0 : case INTEGER_CST:
7757 0 : {
7758 0 : {
7759 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7760 0 : tree res = generic_simplify_402 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_BUILT_IN_CTZL);
7761 0 : if (res) return res;
7762 : }
7763 0 : break;
7764 : }
7765 : default:;
7766 : }
7767 : }
7768 : break;
7769 0 : case CFN_BUILT_IN_EXP2:
7770 0 : if (call_expr_nargs (_p0) == 1)
7771 : {
7772 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7773 0 : switch (TREE_CODE (_p1))
7774 : {
7775 0 : case REAL_CST:
7776 0 : {
7777 0 : {
7778 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7779 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, LE_EXPR);
7780 0 : if (res) return res;
7781 : }
7782 0 : break;
7783 : }
7784 : default:;
7785 : }
7786 : }
7787 : break;
7788 0 : case CFN_BUILT_IN_EXPF:
7789 0 : if (call_expr_nargs (_p0) == 1)
7790 : {
7791 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7792 0 : switch (TREE_CODE (_p1))
7793 : {
7794 0 : case REAL_CST:
7795 0 : {
7796 0 : {
7797 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7798 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, LE_EXPR);
7799 0 : if (res) return res;
7800 : }
7801 0 : break;
7802 : }
7803 : default:;
7804 : }
7805 : }
7806 : break;
7807 0 : case CFN_BUILT_IN_EXPL:
7808 0 : if (call_expr_nargs (_p0) == 1)
7809 : {
7810 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7811 0 : switch (TREE_CODE (_p1))
7812 : {
7813 0 : case REAL_CST:
7814 0 : {
7815 0 : {
7816 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7817 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, LE_EXPR);
7818 0 : if (res) return res;
7819 : }
7820 0 : break;
7821 : }
7822 : default:;
7823 : }
7824 : }
7825 : break;
7826 3 : case CFN_BUILT_IN_FFSL:
7827 3 : if (call_expr_nargs (_p0) == 1)
7828 : {
7829 3 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7830 3 : switch (TREE_CODE (_p1))
7831 : {
7832 3 : case INTEGER_CST:
7833 3 : {
7834 3 : {
7835 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7836 3 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_FFSL);
7837 3 : if (res) return res;
7838 : }
7839 0 : break;
7840 : }
7841 : default:;
7842 : }
7843 : }
7844 : break;
7845 0 : case CFN_BUILT_IN_LOG2:
7846 0 : if (call_expr_nargs (_p0) == 1)
7847 : {
7848 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7849 0 : switch (TREE_CODE (_p1))
7850 : {
7851 0 : case REAL_CST:
7852 0 : {
7853 0 : {
7854 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7855 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, LE_EXPR);
7856 0 : if (res) return res;
7857 : }
7858 0 : break;
7859 : }
7860 : default:;
7861 : }
7862 : }
7863 : break;
7864 0 : case CFN_BUILT_IN_LOGF:
7865 0 : if (call_expr_nargs (_p0) == 1)
7866 : {
7867 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7868 0 : switch (TREE_CODE (_p1))
7869 : {
7870 0 : case REAL_CST:
7871 0 : {
7872 0 : {
7873 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7874 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, LE_EXPR);
7875 0 : if (res) return res;
7876 : }
7877 0 : break;
7878 : }
7879 : default:;
7880 : }
7881 : }
7882 : break;
7883 0 : case CFN_BUILT_IN_LOGL:
7884 0 : if (call_expr_nargs (_p0) == 1)
7885 : {
7886 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7887 0 : switch (TREE_CODE (_p1))
7888 : {
7889 0 : case REAL_CST:
7890 0 : {
7891 0 : {
7892 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7893 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, LE_EXPR);
7894 0 : if (res) return res;
7895 : }
7896 0 : break;
7897 : }
7898 : default:;
7899 : }
7900 : }
7901 : break;
7902 1 : case CFN_BUILT_IN_POPCOUNTLL:
7903 1 : if (call_expr_nargs (_p0) == 1)
7904 : {
7905 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7906 1 : if (integer_zerop (_p1))
7907 : {
7908 1 : {
7909 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
7910 1 : tree res = generic_simplify_296 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNTLL);
7911 1 : if (res) return res;
7912 : }
7913 : }
7914 : }
7915 : break;
7916 0 : case CFN_BUILT_IN_LOG10F:
7917 0 : if (call_expr_nargs (_p0) == 1)
7918 : {
7919 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7920 0 : switch (TREE_CODE (_p1))
7921 : {
7922 0 : case REAL_CST:
7923 0 : {
7924 0 : {
7925 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7926 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, LE_EXPR);
7927 0 : if (res) return res;
7928 : }
7929 0 : break;
7930 : }
7931 : default:;
7932 : }
7933 : }
7934 : break;
7935 0 : case CFN_BUILT_IN_LOG10L:
7936 0 : if (call_expr_nargs (_p0) == 1)
7937 : {
7938 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7939 0 : switch (TREE_CODE (_p1))
7940 : {
7941 0 : case REAL_CST:
7942 0 : {
7943 0 : {
7944 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7945 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, LE_EXPR);
7946 0 : if (res) return res;
7947 : }
7948 0 : break;
7949 : }
7950 : default:;
7951 : }
7952 : }
7953 : break;
7954 0 : case CFN_BUILT_IN_CTZIMAX:
7955 0 : if (call_expr_nargs (_p0) == 1)
7956 : {
7957 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7958 0 : switch (TREE_CODE (_p1))
7959 : {
7960 0 : case INTEGER_CST:
7961 0 : {
7962 0 : {
7963 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7964 0 : tree res = generic_simplify_402 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_BUILT_IN_CTZIMAX);
7965 0 : if (res) return res;
7966 : }
7967 0 : break;
7968 : }
7969 : default:;
7970 : }
7971 : }
7972 : break;
7973 0 : case CFN_POPCOUNT:
7974 0 : if (call_expr_nargs (_p0) == 1)
7975 : {
7976 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7977 0 : if (integer_zerop (_p1))
7978 : {
7979 0 : {
7980 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
7981 0 : tree res = generic_simplify_296 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_POPCOUNT);
7982 0 : if (res) return res;
7983 : }
7984 : }
7985 : }
7986 : break;
7987 0 : case CFN_CTZ:
7988 0 : if (call_expr_nargs (_p0) == 2)
7989 : {
7990 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7991 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
7992 0 : switch (TREE_CODE (_p1))
7993 : {
7994 0 : case INTEGER_CST:
7995 0 : {
7996 0 : {
7997 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
7998 0 : tree res = generic_simplify_403 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR);
7999 0 : if (res) return res;
8000 : }
8001 0 : break;
8002 : }
8003 : default:;
8004 : }
8005 : }
8006 0 : if (call_expr_nargs (_p0) == 1)
8007 : {
8008 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8009 0 : switch (TREE_CODE (_p1))
8010 : {
8011 0 : case INTEGER_CST:
8012 0 : {
8013 0 : {
8014 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8015 0 : tree res = generic_simplify_402 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_CTZ);
8016 0 : if (res) return res;
8017 : }
8018 0 : break;
8019 : }
8020 : default:;
8021 : }
8022 : }
8023 : break;
8024 0 : case CFN_EXP:
8025 0 : if (call_expr_nargs (_p0) == 1)
8026 : {
8027 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8028 0 : switch (TREE_CODE (_p1))
8029 : {
8030 0 : case REAL_CST:
8031 0 : {
8032 0 : {
8033 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8034 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, LE_EXPR);
8035 0 : if (res) return res;
8036 : }
8037 0 : break;
8038 : }
8039 : default:;
8040 : }
8041 : }
8042 : break;
8043 0 : case CFN_FFS:
8044 0 : if (call_expr_nargs (_p0) == 1)
8045 : {
8046 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8047 0 : switch (TREE_CODE (_p1))
8048 : {
8049 0 : case INTEGER_CST:
8050 0 : {
8051 0 : {
8052 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8053 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_FFS);
8054 0 : if (res) return res;
8055 : }
8056 0 : break;
8057 : }
8058 : default:;
8059 : }
8060 : }
8061 : break;
8062 0 : case CFN_LOG:
8063 0 : if (call_expr_nargs (_p0) == 1)
8064 : {
8065 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8066 0 : switch (TREE_CODE (_p1))
8067 : {
8068 0 : case REAL_CST:
8069 0 : {
8070 0 : {
8071 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8072 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, LE_EXPR);
8073 0 : if (res) return res;
8074 : }
8075 0 : break;
8076 : }
8077 : default:;
8078 : }
8079 : }
8080 : break;
8081 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
8082 0 : if (call_expr_nargs (_p0) == 1)
8083 : {
8084 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8085 0 : if (integer_zerop (_p1))
8086 : {
8087 0 : {
8088 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8089 0 : tree res = generic_simplify_296 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
8090 0 : if (res) return res;
8091 : }
8092 : }
8093 : }
8094 : break;
8095 0 : case CFN_EXP2:
8096 0 : if (call_expr_nargs (_p0) == 1)
8097 : {
8098 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8099 0 : switch (TREE_CODE (_p1))
8100 : {
8101 0 : case REAL_CST:
8102 0 : {
8103 0 : {
8104 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8105 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, LE_EXPR);
8106 0 : if (res) return res;
8107 : }
8108 0 : break;
8109 : }
8110 : default:;
8111 : }
8112 : }
8113 : break;
8114 0 : case CFN_LOG2:
8115 0 : if (call_expr_nargs (_p0) == 1)
8116 : {
8117 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8118 0 : switch (TREE_CODE (_p1))
8119 : {
8120 0 : case REAL_CST:
8121 0 : {
8122 0 : {
8123 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8124 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, LE_EXPR);
8125 0 : if (res) return res;
8126 : }
8127 0 : break;
8128 : }
8129 : default:;
8130 : }
8131 : }
8132 : break;
8133 0 : case CFN_EXP10:
8134 0 : if (call_expr_nargs (_p0) == 1)
8135 : {
8136 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8137 0 : switch (TREE_CODE (_p1))
8138 : {
8139 0 : case REAL_CST:
8140 0 : {
8141 0 : {
8142 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8143 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, LE_EXPR);
8144 0 : if (res) return res;
8145 : }
8146 0 : break;
8147 : }
8148 : default:;
8149 : }
8150 : }
8151 : break;
8152 1 : case CFN_BUILT_IN_POPCOUNTL:
8153 1 : if (call_expr_nargs (_p0) == 1)
8154 : {
8155 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8156 1 : if (integer_zerop (_p1))
8157 : {
8158 1 : {
8159 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8160 1 : tree res = generic_simplify_296 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNTL);
8161 1 : if (res) return res;
8162 : }
8163 : }
8164 : }
8165 : break;
8166 0 : case CFN_BUILT_IN_CTZLL:
8167 0 : if (call_expr_nargs (_p0) == 1)
8168 : {
8169 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8170 0 : switch (TREE_CODE (_p1))
8171 : {
8172 0 : case INTEGER_CST:
8173 0 : {
8174 0 : {
8175 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8176 0 : tree res = generic_simplify_402 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_BUILT_IN_CTZLL);
8177 0 : if (res) return res;
8178 : }
8179 0 : break;
8180 : }
8181 : default:;
8182 : }
8183 : }
8184 : break;
8185 0 : case CFN_LOG10:
8186 0 : if (call_expr_nargs (_p0) == 1)
8187 : {
8188 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8189 0 : switch (TREE_CODE (_p1))
8190 : {
8191 0 : case REAL_CST:
8192 0 : {
8193 0 : {
8194 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8195 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, LE_EXPR);
8196 0 : if (res) return res;
8197 : }
8198 0 : break;
8199 : }
8200 : default:;
8201 : }
8202 : }
8203 : break;
8204 0 : case CFN_BUILT_IN_EXP10:
8205 0 : if (call_expr_nargs (_p0) == 1)
8206 : {
8207 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8208 0 : switch (TREE_CODE (_p1))
8209 : {
8210 0 : case REAL_CST:
8211 0 : {
8212 0 : {
8213 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8214 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, LE_EXPR);
8215 0 : if (res) return res;
8216 : }
8217 0 : break;
8218 : }
8219 : default:;
8220 : }
8221 : }
8222 : break;
8223 0 : case CFN_BUILT_IN_EXP2F:
8224 0 : if (call_expr_nargs (_p0) == 1)
8225 : {
8226 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8227 0 : switch (TREE_CODE (_p1))
8228 : {
8229 0 : case REAL_CST:
8230 0 : {
8231 0 : {
8232 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8233 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, LE_EXPR);
8234 0 : if (res) return res;
8235 : }
8236 0 : break;
8237 : }
8238 : default:;
8239 : }
8240 : }
8241 : break;
8242 0 : case CFN_BUILT_IN_EXP2L:
8243 0 : if (call_expr_nargs (_p0) == 1)
8244 : {
8245 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8246 0 : switch (TREE_CODE (_p1))
8247 : {
8248 0 : case REAL_CST:
8249 0 : {
8250 0 : {
8251 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8252 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, LE_EXPR);
8253 0 : if (res) return res;
8254 : }
8255 0 : break;
8256 : }
8257 : default:;
8258 : }
8259 : }
8260 : break;
8261 3 : case CFN_BUILT_IN_FFSLL:
8262 3 : if (call_expr_nargs (_p0) == 1)
8263 : {
8264 3 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8265 3 : switch (TREE_CODE (_p1))
8266 : {
8267 3 : case INTEGER_CST:
8268 3 : {
8269 3 : {
8270 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8271 3 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_FFSLL);
8272 3 : if (res) return res;
8273 : }
8274 0 : break;
8275 : }
8276 : default:;
8277 : }
8278 : }
8279 : break;
8280 0 : case CFN_BUILT_IN_LOG10:
8281 0 : if (call_expr_nargs (_p0) == 1)
8282 : {
8283 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8284 0 : switch (TREE_CODE (_p1))
8285 : {
8286 0 : case REAL_CST:
8287 0 : {
8288 0 : {
8289 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8290 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, LE_EXPR);
8291 0 : if (res) return res;
8292 : }
8293 0 : break;
8294 : }
8295 : default:;
8296 : }
8297 : }
8298 : break;
8299 0 : case CFN_BUILT_IN_LOG2F:
8300 0 : if (call_expr_nargs (_p0) == 1)
8301 : {
8302 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8303 0 : switch (TREE_CODE (_p1))
8304 : {
8305 0 : case REAL_CST:
8306 0 : {
8307 0 : {
8308 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8309 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, LE_EXPR);
8310 0 : if (res) return res;
8311 : }
8312 0 : break;
8313 : }
8314 : default:;
8315 : }
8316 : }
8317 : break;
8318 0 : case CFN_BUILT_IN_LOG2L:
8319 0 : if (call_expr_nargs (_p0) == 1)
8320 : {
8321 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8322 0 : switch (TREE_CODE (_p1))
8323 : {
8324 0 : case REAL_CST:
8325 0 : {
8326 0 : {
8327 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8328 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, LE_EXPR);
8329 0 : if (res) return res;
8330 : }
8331 0 : break;
8332 : }
8333 : default:;
8334 : }
8335 : }
8336 : break;
8337 : default:;
8338 : }
8339 : break;
8340 : default:;
8341 : }
8342 : return NULL_TREE;
8343 : }
8344 :
8345 : tree
8346 4104 : 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)
8347 : {
8348 4104 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8349 4104 : if (integer_zerop (_p0))
8350 : {
8351 0 : {
8352 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8353 0 : tree res = generic_simplify_322 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8354 0 : if (res) return res;
8355 : }
8356 : }
8357 4104 : if (integer_onep (_p1))
8358 : {
8359 0 : {
8360 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8361 0 : tree res = generic_simplify_323 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8362 0 : if (res) return res;
8363 : }
8364 : }
8365 4104 : if (integer_minus_onep (_p1))
8366 : {
8367 0 : {
8368 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8369 0 : tree res = generic_simplify_324 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8370 0 : if (res) return res;
8371 : }
8372 : }
8373 4104 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
8374 : {
8375 0 : {
8376 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8377 0 : tree res = generic_simplify_325 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8378 0 : if (res) return res;
8379 : }
8380 : }
8381 4104 : switch (TREE_CODE (_p0))
8382 : {
8383 0 : case CEIL_MOD_EXPR:
8384 0 : {
8385 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8386 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8387 0 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8388 : {
8389 0 : {
8390 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8391 0 : tree res = generic_simplify_326 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8392 0 : if (res) return res;
8393 : }
8394 : }
8395 : break;
8396 : }
8397 0 : case MULT_EXPR:
8398 0 : {
8399 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8400 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8401 0 : switch (TREE_CODE (_q21))
8402 : {
8403 0 : case INTEGER_CST:
8404 0 : {
8405 0 : switch (TREE_CODE (_p1))
8406 : {
8407 0 : case INTEGER_CST:
8408 0 : {
8409 0 : {
8410 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8411 0 : tree res = generic_simplify_327 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8412 0 : if (res) return res;
8413 : }
8414 0 : break;
8415 : }
8416 : default:;
8417 : }
8418 : break;
8419 : }
8420 : default:;
8421 : }
8422 : break;
8423 : }
8424 0 : case VEC_COND_EXPR:
8425 0 : {
8426 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8427 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8428 0 : tree _q22 = TREE_OPERAND (_p0, 2);
8429 0 : switch (TREE_CODE (_p1))
8430 : {
8431 0 : case VEC_COND_EXPR:
8432 0 : {
8433 0 : tree _q60 = TREE_OPERAND (_p1, 0);
8434 0 : tree _q61 = TREE_OPERAND (_p1, 1);
8435 0 : tree _q62 = TREE_OPERAND (_p1, 2);
8436 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
8437 : {
8438 0 : {
8439 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
8440 0 : if (VECTOR_TYPE_P (type)
8441 0 : && (TREE_CODE_CLASS (CEIL_MOD_EXPR) != tcc_comparison
8442 : || types_match (type, TREE_TYPE (captures[2]))
8443 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8444 : || (optimize_vectors_before_lowering_p ()
8445 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8446 : )
8447 : {
8448 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1641;
8449 0 : {
8450 0 : tree res_op0;
8451 0 : res_op0 = captures[1];
8452 0 : tree res_op1;
8453 0 : {
8454 0 : tree _o1[2], _r1;
8455 0 : _o1[0] = captures[2];
8456 0 : _o1[1] = captures[5];
8457 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8458 0 : if (EXPR_P (_r1))
8459 0 : goto next_after_fail1641;
8460 0 : res_op1 = _r1;
8461 : }
8462 0 : tree res_op2;
8463 0 : {
8464 0 : tree _o1[2], _r1;
8465 0 : _o1[0] = captures[3];
8466 0 : _o1[1] = captures[6];
8467 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8468 0 : if (EXPR_P (_r1))
8469 0 : goto next_after_fail1641;
8470 0 : res_op2 = _r1;
8471 : }
8472 0 : tree _r;
8473 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8474 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 890, __FILE__, __LINE__, true);
8475 0 : return _r;
8476 : }
8477 0 : next_after_fail1641:;
8478 : }
8479 : }
8480 : }
8481 : break;
8482 : }
8483 0 : default:;
8484 : }
8485 0 : {
8486 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
8487 0 : if (VECTOR_TYPE_P (type)
8488 0 : && (TREE_CODE_CLASS (CEIL_MOD_EXPR) != tcc_comparison
8489 : || types_match (type, TREE_TYPE (captures[2]))
8490 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8491 : || (optimize_vectors_before_lowering_p ()
8492 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8493 : )
8494 : {
8495 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1642;
8496 0 : {
8497 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1642;
8498 0 : tree res_op0;
8499 0 : res_op0 = captures[1];
8500 0 : tree res_op1;
8501 0 : {
8502 0 : tree _o1[2], _r1;
8503 0 : _o1[0] = captures[2];
8504 0 : _o1[1] = unshare_expr (captures[4]);
8505 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8506 0 : if (EXPR_P (_r1))
8507 0 : goto next_after_fail1642;
8508 0 : res_op1 = _r1;
8509 : }
8510 0 : tree res_op2;
8511 0 : {
8512 0 : tree _o1[2], _r1;
8513 0 : _o1[0] = captures[3];
8514 0 : _o1[1] = captures[4];
8515 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8516 0 : if (EXPR_P (_r1))
8517 0 : goto next_after_fail1642;
8518 0 : res_op2 = _r1;
8519 : }
8520 0 : tree _r;
8521 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8522 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
8523 0 : return _r;
8524 : }
8525 0 : next_after_fail1642:;
8526 : }
8527 : }
8528 0 : break;
8529 : }
8530 4104 : default:;
8531 : }
8532 4104 : switch (TREE_CODE (_p1))
8533 : {
8534 0 : case VEC_COND_EXPR:
8535 0 : {
8536 0 : tree _q30 = TREE_OPERAND (_p1, 0);
8537 0 : tree _q31 = TREE_OPERAND (_p1, 1);
8538 0 : tree _q32 = TREE_OPERAND (_p1, 2);
8539 0 : {
8540 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
8541 0 : if (VECTOR_TYPE_P (type)
8542 0 : && (TREE_CODE_CLASS (CEIL_MOD_EXPR) != tcc_comparison
8543 : || types_match (type, TREE_TYPE (captures[3]))
8544 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
8545 : || (optimize_vectors_before_lowering_p ()
8546 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
8547 : )
8548 : {
8549 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1643;
8550 0 : {
8551 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1643;
8552 0 : tree res_op0;
8553 0 : res_op0 = captures[2];
8554 0 : tree res_op1;
8555 0 : {
8556 0 : tree _o1[2], _r1;
8557 0 : _o1[0] = unshare_expr (captures[0]);
8558 0 : _o1[1] = captures[3];
8559 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8560 0 : if (EXPR_P (_r1))
8561 0 : goto next_after_fail1643;
8562 0 : res_op1 = _r1;
8563 : }
8564 0 : tree res_op2;
8565 0 : {
8566 0 : tree _o1[2], _r1;
8567 0 : _o1[0] = captures[0];
8568 0 : _o1[1] = captures[4];
8569 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8570 0 : if (EXPR_P (_r1))
8571 0 : goto next_after_fail1643;
8572 0 : res_op2 = _r1;
8573 : }
8574 0 : tree _r;
8575 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8576 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
8577 0 : return _r;
8578 : }
8579 0 : next_after_fail1643:;
8580 : }
8581 : }
8582 0 : break;
8583 : }
8584 : default:;
8585 : }
8586 : return NULL_TREE;
8587 : }
8588 :
8589 : tree
8590 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)
8591 : {
8592 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8593 0 : if (integer_zerop (_p0))
8594 : {
8595 0 : {
8596 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8597 0 : tree res = generic_simplify_322 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8598 0 : if (res) return res;
8599 : }
8600 : }
8601 0 : if (integer_onep (_p1))
8602 : {
8603 0 : {
8604 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8605 0 : tree res = generic_simplify_323 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8606 0 : if (res) return res;
8607 : }
8608 : }
8609 0 : if (integer_minus_onep (_p1))
8610 : {
8611 0 : {
8612 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8613 0 : tree res = generic_simplify_324 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8614 0 : if (res) return res;
8615 : }
8616 : }
8617 0 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
8618 : {
8619 0 : {
8620 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8621 0 : tree res = generic_simplify_325 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8622 0 : if (res) return res;
8623 : }
8624 : }
8625 0 : switch (TREE_CODE (_p0))
8626 : {
8627 0 : case ROUND_MOD_EXPR:
8628 0 : {
8629 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8630 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8631 0 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8632 : {
8633 0 : {
8634 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8635 0 : tree res = generic_simplify_326 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8636 0 : if (res) return res;
8637 : }
8638 : }
8639 : break;
8640 : }
8641 0 : case MULT_EXPR:
8642 0 : {
8643 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8644 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8645 0 : switch (TREE_CODE (_q21))
8646 : {
8647 0 : case INTEGER_CST:
8648 0 : {
8649 0 : switch (TREE_CODE (_p1))
8650 : {
8651 0 : case INTEGER_CST:
8652 0 : {
8653 0 : {
8654 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8655 0 : tree res = generic_simplify_327 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8656 0 : if (res) return res;
8657 : }
8658 0 : break;
8659 : }
8660 : default:;
8661 : }
8662 : break;
8663 : }
8664 : default:;
8665 : }
8666 : break;
8667 : }
8668 0 : case VEC_COND_EXPR:
8669 0 : {
8670 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8671 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8672 0 : tree _q22 = TREE_OPERAND (_p0, 2);
8673 0 : switch (TREE_CODE (_p1))
8674 : {
8675 0 : case VEC_COND_EXPR:
8676 0 : {
8677 0 : tree _q60 = TREE_OPERAND (_p1, 0);
8678 0 : tree _q61 = TREE_OPERAND (_p1, 1);
8679 0 : tree _q62 = TREE_OPERAND (_p1, 2);
8680 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
8681 : {
8682 0 : {
8683 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
8684 0 : if (VECTOR_TYPE_P (type)
8685 0 : && (TREE_CODE_CLASS (ROUND_MOD_EXPR) != tcc_comparison
8686 : || types_match (type, TREE_TYPE (captures[2]))
8687 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8688 : || (optimize_vectors_before_lowering_p ()
8689 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8690 : )
8691 : {
8692 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1644;
8693 0 : {
8694 0 : tree res_op0;
8695 0 : res_op0 = captures[1];
8696 0 : tree res_op1;
8697 0 : {
8698 0 : tree _o1[2], _r1;
8699 0 : _o1[0] = captures[2];
8700 0 : _o1[1] = captures[5];
8701 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8702 0 : if (EXPR_P (_r1))
8703 0 : goto next_after_fail1644;
8704 0 : res_op1 = _r1;
8705 : }
8706 0 : tree res_op2;
8707 0 : {
8708 0 : tree _o1[2], _r1;
8709 0 : _o1[0] = captures[3];
8710 0 : _o1[1] = captures[6];
8711 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8712 0 : if (EXPR_P (_r1))
8713 0 : goto next_after_fail1644;
8714 0 : res_op2 = _r1;
8715 : }
8716 0 : tree _r;
8717 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8718 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 890, __FILE__, __LINE__, true);
8719 0 : return _r;
8720 : }
8721 0 : next_after_fail1644:;
8722 : }
8723 : }
8724 : }
8725 : break;
8726 : }
8727 0 : default:;
8728 : }
8729 0 : {
8730 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
8731 0 : if (VECTOR_TYPE_P (type)
8732 0 : && (TREE_CODE_CLASS (ROUND_MOD_EXPR) != tcc_comparison
8733 : || types_match (type, TREE_TYPE (captures[2]))
8734 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8735 : || (optimize_vectors_before_lowering_p ()
8736 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8737 : )
8738 : {
8739 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1645;
8740 0 : {
8741 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1645;
8742 0 : tree res_op0;
8743 0 : res_op0 = captures[1];
8744 0 : tree res_op1;
8745 0 : {
8746 0 : tree _o1[2], _r1;
8747 0 : _o1[0] = captures[2];
8748 0 : _o1[1] = unshare_expr (captures[4]);
8749 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8750 0 : if (EXPR_P (_r1))
8751 0 : goto next_after_fail1645;
8752 0 : res_op1 = _r1;
8753 : }
8754 0 : tree res_op2;
8755 0 : {
8756 0 : tree _o1[2], _r1;
8757 0 : _o1[0] = captures[3];
8758 0 : _o1[1] = captures[4];
8759 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8760 0 : if (EXPR_P (_r1))
8761 0 : goto next_after_fail1645;
8762 0 : res_op2 = _r1;
8763 : }
8764 0 : tree _r;
8765 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8766 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
8767 0 : return _r;
8768 : }
8769 0 : next_after_fail1645:;
8770 : }
8771 : }
8772 0 : break;
8773 : }
8774 0 : default:;
8775 : }
8776 0 : switch (TREE_CODE (_p1))
8777 : {
8778 0 : case VEC_COND_EXPR:
8779 0 : {
8780 0 : tree _q30 = TREE_OPERAND (_p1, 0);
8781 0 : tree _q31 = TREE_OPERAND (_p1, 1);
8782 0 : tree _q32 = TREE_OPERAND (_p1, 2);
8783 0 : {
8784 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
8785 0 : if (VECTOR_TYPE_P (type)
8786 0 : && (TREE_CODE_CLASS (ROUND_MOD_EXPR) != tcc_comparison
8787 : || types_match (type, TREE_TYPE (captures[3]))
8788 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
8789 : || (optimize_vectors_before_lowering_p ()
8790 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
8791 : )
8792 : {
8793 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1646;
8794 0 : {
8795 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1646;
8796 0 : tree res_op0;
8797 0 : res_op0 = captures[2];
8798 0 : tree res_op1;
8799 0 : {
8800 0 : tree _o1[2], _r1;
8801 0 : _o1[0] = unshare_expr (captures[0]);
8802 0 : _o1[1] = captures[3];
8803 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8804 0 : if (EXPR_P (_r1))
8805 0 : goto next_after_fail1646;
8806 0 : res_op1 = _r1;
8807 : }
8808 0 : tree res_op2;
8809 0 : {
8810 0 : tree _o1[2], _r1;
8811 0 : _o1[0] = captures[0];
8812 0 : _o1[1] = captures[4];
8813 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8814 0 : if (EXPR_P (_r1))
8815 0 : goto next_after_fail1646;
8816 0 : res_op2 = _r1;
8817 : }
8818 0 : tree _r;
8819 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8820 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
8821 0 : return _r;
8822 : }
8823 0 : next_after_fail1646:;
8824 : }
8825 : }
8826 0 : break;
8827 : }
8828 : default:;
8829 : }
8830 : return NULL_TREE;
8831 : }
8832 :
8833 : tree
8834 2049550 : 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)
8835 : {
8836 2049550 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8837 2049550 : if (integer_zerop (_p0))
8838 : {
8839 919 : {
8840 919 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8841 919 : tree res = generic_simplify_322 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8842 919 : if (res) return res;
8843 : }
8844 : }
8845 2048765 : if (integer_onep (_p1))
8846 : {
8847 212775 : {
8848 212775 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8849 212775 : tree res = generic_simplify_323 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8850 212775 : if (res) return res;
8851 : }
8852 : }
8853 1835990 : if (integer_minus_onep (_p1))
8854 : {
8855 529 : {
8856 529 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8857 529 : tree res = generic_simplify_324 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8858 529 : if (res) return res;
8859 : }
8860 : }
8861 1835970 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
8862 : {
8863 227 : {
8864 227 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8865 227 : tree res = generic_simplify_325 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8866 227 : if (res) return res;
8867 : }
8868 : }
8869 1835877 : switch (TREE_CODE (_p0))
8870 : {
8871 107 : case TRUNC_MOD_EXPR:
8872 107 : {
8873 107 : tree _q20 = TREE_OPERAND (_p0, 0);
8874 107 : tree _q21 = TREE_OPERAND (_p0, 1);
8875 107 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8876 : {
8877 52 : {
8878 52 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8879 52 : tree res = generic_simplify_326 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8880 52 : if (res) return res;
8881 : }
8882 : }
8883 : break;
8884 : }
8885 7299 : case MULT_EXPR:
8886 7299 : {
8887 7299 : tree _q20 = TREE_OPERAND (_p0, 0);
8888 7299 : tree _q21 = TREE_OPERAND (_p0, 1);
8889 7299 : switch (TREE_CODE (_q21))
8890 : {
8891 7206 : case INTEGER_CST:
8892 7206 : {
8893 7206 : switch (TREE_CODE (_p1))
8894 : {
8895 7184 : case INTEGER_CST:
8896 7184 : {
8897 7184 : {
8898 7184 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8899 7184 : tree res = generic_simplify_327 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8900 7184 : if (res) return res;
8901 : }
8902 7184 : break;
8903 : }
8904 : default:;
8905 : }
8906 : break;
8907 : }
8908 : default:;
8909 : }
8910 : break;
8911 : }
8912 1835825 : default:;
8913 : }
8914 1835825 : switch (TREE_CODE (_p1))
8915 : {
8916 1566462 : case INTEGER_CST:
8917 1566462 : {
8918 1566462 : {
8919 1566462 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8920 1566462 : if (TYPE_SIGN (type) == SIGNED
8921 278271 : && !TREE_OVERFLOW (captures[1])
8922 1566466 : && wi::neg_p (wi::to_wide (captures[1]))
8923 313 : && !TYPE_OVERFLOW_TRAPS (type)
8924 1566775 : && !sign_bit_p (captures[1], captures[1])
8925 : )
8926 : {
8927 309 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1647;
8928 309 : {
8929 309 : tree res_op0;
8930 309 : res_op0 = captures[0];
8931 309 : tree res_op1;
8932 309 : {
8933 309 : tree _o1[1], _r1;
8934 309 : _o1[0] = captures[1];
8935 309 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
8936 309 : res_op1 = _r1;
8937 : }
8938 309 : tree _r;
8939 309 : _r = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, res_op0, res_op1);
8940 309 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1000, __FILE__, __LINE__, true);
8941 309 : return _r;
8942 : }
8943 0 : next_after_fail1647:;
8944 : }
8945 : }
8946 1566153 : break;
8947 : }
8948 54914 : CASE_CONVERT:
8949 54914 : {
8950 54914 : tree _q30 = TREE_OPERAND (_p1, 0);
8951 54914 : switch (TREE_CODE (_q30))
8952 : {
8953 0 : case NEGATE_EXPR:
8954 0 : {
8955 0 : tree _q40 = TREE_OPERAND (_q30, 0);
8956 0 : {
8957 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q40 };
8958 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures);
8959 0 : if (res) return res;
8960 : }
8961 0 : break;
8962 : }
8963 54914 : default:;
8964 : }
8965 54914 : {
8966 54914 : tree _q30_pops[1];
8967 54914 : if (tree_power_of_two_cand (_q30, _q30_pops))
8968 : {
8969 7 : tree _q40 = _q30_pops[0];
8970 7 : {
8971 7 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q40 };
8972 7 : tree res = generic_simplify_328 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8973 7 : if (res) return res;
8974 : }
8975 : }
8976 : }
8977 54907 : break;
8978 : }
8979 94 : case NEGATE_EXPR:
8980 94 : {
8981 94 : tree _q30 = TREE_OPERAND (_p1, 0);
8982 94 : {
8983 94 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q30 };
8984 94 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures);
8985 94 : if (res) return res;
8986 : }
8987 94 : break;
8988 : }
8989 1835509 : default:;
8990 : }
8991 1835509 : {
8992 1835509 : tree _p1_pops[1];
8993 1835509 : if (tree_power_of_two_cand (_p1, _p1_pops))
8994 : {
8995 1566162 : tree _q30 = _p1_pops[0];
8996 1566162 : {
8997 1566162 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q30 };
8998 1566162 : tree res = generic_simplify_328 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8999 1566162 : if (res) return res;
9000 : }
9001 : }
9002 : }
9003 887035 : switch (TREE_CODE (_p0))
9004 : {
9005 0 : case VEC_COND_EXPR:
9006 0 : {
9007 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9008 0 : tree _q21 = TREE_OPERAND (_p0, 1);
9009 0 : tree _q22 = TREE_OPERAND (_p0, 2);
9010 0 : switch (TREE_CODE (_p1))
9011 : {
9012 0 : case VEC_COND_EXPR:
9013 0 : {
9014 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9015 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9016 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9017 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9018 : {
9019 0 : {
9020 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
9021 0 : if (VECTOR_TYPE_P (type)
9022 0 : && (TREE_CODE_CLASS (TRUNC_MOD_EXPR) != tcc_comparison
9023 : || types_match (type, TREE_TYPE (captures[2]))
9024 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9025 : || (optimize_vectors_before_lowering_p ()
9026 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9027 : )
9028 : {
9029 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1648;
9030 0 : {
9031 0 : tree res_op0;
9032 0 : res_op0 = captures[1];
9033 0 : tree res_op1;
9034 0 : {
9035 0 : tree _o1[2], _r1;
9036 0 : _o1[0] = captures[2];
9037 0 : _o1[1] = captures[5];
9038 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9039 0 : if (EXPR_P (_r1))
9040 0 : goto next_after_fail1648;
9041 0 : res_op1 = _r1;
9042 : }
9043 0 : tree res_op2;
9044 0 : {
9045 0 : tree _o1[2], _r1;
9046 0 : _o1[0] = captures[3];
9047 0 : _o1[1] = captures[6];
9048 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9049 0 : if (EXPR_P (_r1))
9050 0 : goto next_after_fail1648;
9051 0 : res_op2 = _r1;
9052 : }
9053 0 : tree _r;
9054 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9055 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 890, __FILE__, __LINE__, true);
9056 0 : return _r;
9057 : }
9058 0 : next_after_fail1648:;
9059 : }
9060 : }
9061 : }
9062 : break;
9063 : }
9064 0 : default:;
9065 : }
9066 0 : {
9067 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
9068 0 : if (VECTOR_TYPE_P (type)
9069 0 : && (TREE_CODE_CLASS (TRUNC_MOD_EXPR) != tcc_comparison
9070 : || types_match (type, TREE_TYPE (captures[2]))
9071 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9072 : || (optimize_vectors_before_lowering_p ()
9073 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9074 : )
9075 : {
9076 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1649;
9077 0 : {
9078 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1649;
9079 0 : tree res_op0;
9080 0 : res_op0 = captures[1];
9081 0 : tree res_op1;
9082 0 : {
9083 0 : tree _o1[2], _r1;
9084 0 : _o1[0] = captures[2];
9085 0 : _o1[1] = unshare_expr (captures[4]);
9086 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9087 0 : if (EXPR_P (_r1))
9088 0 : goto next_after_fail1649;
9089 0 : res_op1 = _r1;
9090 : }
9091 0 : tree res_op2;
9092 0 : {
9093 0 : tree _o1[2], _r1;
9094 0 : _o1[0] = captures[3];
9095 0 : _o1[1] = captures[4];
9096 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9097 0 : if (EXPR_P (_r1))
9098 0 : goto next_after_fail1649;
9099 0 : res_op2 = _r1;
9100 : }
9101 0 : tree _r;
9102 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9103 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
9104 0 : return _r;
9105 : }
9106 0 : next_after_fail1649:;
9107 : }
9108 : }
9109 0 : break;
9110 : }
9111 887035 : default:;
9112 : }
9113 887035 : switch (TREE_CODE (_p1))
9114 : {
9115 7 : case VEC_COND_EXPR:
9116 7 : {
9117 7 : tree _q30 = TREE_OPERAND (_p1, 0);
9118 7 : tree _q31 = TREE_OPERAND (_p1, 1);
9119 7 : tree _q32 = TREE_OPERAND (_p1, 2);
9120 7 : {
9121 7 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
9122 7 : if (VECTOR_TYPE_P (type)
9123 7 : && (TREE_CODE_CLASS (TRUNC_MOD_EXPR) != tcc_comparison
9124 : || types_match (type, TREE_TYPE (captures[3]))
9125 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
9126 : || (optimize_vectors_before_lowering_p ()
9127 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
9128 : )
9129 : {
9130 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1650;
9131 7 : {
9132 7 : if (! tree_invariant_p (captures[0])) goto next_after_fail1650;
9133 0 : tree res_op0;
9134 0 : res_op0 = captures[2];
9135 0 : tree res_op1;
9136 0 : {
9137 0 : tree _o1[2], _r1;
9138 0 : _o1[0] = unshare_expr (captures[0]);
9139 0 : _o1[1] = captures[3];
9140 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9141 0 : if (EXPR_P (_r1))
9142 0 : goto next_after_fail1650;
9143 0 : res_op1 = _r1;
9144 : }
9145 0 : tree res_op2;
9146 0 : {
9147 0 : tree _o1[2], _r1;
9148 0 : _o1[0] = captures[0];
9149 0 : _o1[1] = captures[4];
9150 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9151 0 : if (EXPR_P (_r1))
9152 0 : goto next_after_fail1650;
9153 0 : res_op2 = _r1;
9154 : }
9155 0 : tree _r;
9156 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9157 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
9158 0 : return _r;
9159 : }
9160 7 : next_after_fail1650:;
9161 : }
9162 : }
9163 7 : break;
9164 : }
9165 : default:;
9166 : }
9167 : return NULL_TREE;
9168 : }
9169 :
9170 : tree
9171 950674 : generic_simplify_RSHIFT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
9172 : {
9173 950674 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
9174 950674 : switch (TREE_CODE (_p1))
9175 : {
9176 119 : case TRUNC_MOD_EXPR:
9177 119 : {
9178 119 : tree _q30 = TREE_OPERAND (_p1, 0);
9179 119 : tree _q31 = TREE_OPERAND (_p1, 1);
9180 119 : {
9181 119 : tree _q31_pops[1];
9182 119 : if (tree_power_of_two_cand (_q31, _q31_pops))
9183 : {
9184 111 : tree _q50 = _q31_pops[0];
9185 111 : {
9186 111 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q50 };
9187 111 : tree res = generic_simplify_415 (loc, type, _p0, _p1, captures, RSHIFT_EXPR, TRUNC_MOD_EXPR);
9188 111 : if (res) return res;
9189 : }
9190 : }
9191 : }
9192 14 : break;
9193 : }
9194 0 : case FLOOR_MOD_EXPR:
9195 0 : {
9196 0 : tree _q30 = TREE_OPERAND (_p1, 0);
9197 0 : tree _q31 = TREE_OPERAND (_p1, 1);
9198 0 : {
9199 0 : tree _q31_pops[1];
9200 0 : if (tree_power_of_two_cand (_q31, _q31_pops))
9201 : {
9202 0 : tree _q50 = _q31_pops[0];
9203 0 : {
9204 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q50 };
9205 0 : tree res = generic_simplify_415 (loc, type, _p0, _p1, captures, RSHIFT_EXPR, FLOOR_MOD_EXPR);
9206 0 : if (res) return res;
9207 : }
9208 : }
9209 : }
9210 0 : break;
9211 : }
9212 950569 : default:;
9213 : }
9214 950569 : if (uniform_integer_cst_p (_p1))
9215 : {
9216 754777 : {
9217 754777 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9218 754777 : tree res = generic_simplify_416 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9219 754777 : if (res) return res;
9220 : }
9221 : }
9222 949812 : switch (TREE_CODE (_p0))
9223 : {
9224 58 : case NEGATE_EXPR:
9225 58 : {
9226 58 : tree _q20 = TREE_OPERAND (_p0, 0);
9227 58 : switch (TREE_CODE (_p1))
9228 : {
9229 57 : case INTEGER_CST:
9230 57 : {
9231 57 : {
9232 57 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9233 57 : if (!TYPE_UNSIGNED (type)
9234 57 : && TYPE_OVERFLOW_UNDEFINED (type)
9235 : )
9236 : {
9237 32 : {
9238 32 : tree stype = TREE_TYPE (captures[2]);
9239 32 : tree bt = truth_type_for (type);
9240 32 : tree zeros = build_zero_cst (type);
9241 32 : tree INTEGER_CST = NULL_TREE;
9242 32 : if (INTEGRAL_TYPE_P (type)
9243 : && canonicalize_math_after_vectorization_p ()
9244 : && wi::eq_p (wi::to_wide (captures[2]), TYPE_PRECISION (type) - 1)
9245 : )
9246 : {
9247 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1659;
9248 : {
9249 : tree res_op0;
9250 : {
9251 : tree _o1[1], _r1;
9252 : {
9253 : tree _o2[2], _r2;
9254 : _o2[0] = captures[1];
9255 : _o2[1] = zeros;
9256 : _r2 = fold_build2_loc (loc, GT_EXPR, boolean_type_node, _o2[0], _o2[1]);
9257 : _o1[0] = _r2;
9258 : }
9259 : if (TREE_TYPE (_o1[0]) != type)
9260 : {
9261 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
9262 : }
9263 : else
9264 : _r1 = _o1[0];
9265 : res_op0 = _r1;
9266 : }
9267 : tree _r;
9268 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
9269 : if (TREE_SIDE_EFFECTS (captures[2]))
9270 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
9271 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1005, __FILE__, __LINE__, true);
9272 : return _r;
9273 : }
9274 : next_after_fail1659:;
9275 : }
9276 : else
9277 : {
9278 0 : if (VECTOR_INTEGER_TYPE_P (type)
9279 0 : && TYPE_MODE (bt) == TYPE_MODE (type)
9280 0 : && expand_vec_cmp_expr_p (type, bt, GT_EXPR)
9281 0 : && (INTEGER_CST = uniform_integer_cst_p (captures[2])) != NULL
9282 32 : && wi::eq_p (wi::to_wide (INTEGER_CST), element_precision (type) - 1)
9283 : )
9284 : {
9285 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1660;
9286 0 : {
9287 0 : tree res_op0;
9288 0 : {
9289 0 : tree _o1[2], _r1;
9290 0 : _o1[0] = captures[1];
9291 0 : _o1[1] = zeros;
9292 0 : _r1 = fold_build2_loc (loc, GT_EXPR, bt, _o1[0], _o1[1]);
9293 0 : res_op0 = _r1;
9294 : }
9295 0 : tree _r;
9296 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
9297 0 : if (TREE_SIDE_EFFECTS (captures[2]))
9298 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
9299 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1006, __FILE__, __LINE__, true);
9300 0 : return _r;
9301 : }
9302 0 : next_after_fail1660:;
9303 : }
9304 : }
9305 : }
9306 : }
9307 : }
9308 57 : break;
9309 : }
9310 0 : case VECTOR_CST:
9311 0 : {
9312 0 : {
9313 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9314 0 : if (!TYPE_UNSIGNED (type)
9315 0 : && TYPE_OVERFLOW_UNDEFINED (type)
9316 : )
9317 : {
9318 0 : {
9319 0 : tree stype = TREE_TYPE (captures[2]);
9320 0 : tree bt = truth_type_for (type);
9321 0 : tree zeros = build_zero_cst (type);
9322 0 : tree VECTOR_CST = NULL_TREE;
9323 0 : if (INTEGRAL_TYPE_P (type)
9324 : && canonicalize_math_after_vectorization_p ()
9325 : && wi::eq_p (wi::to_wide (captures[2]), TYPE_PRECISION (type) - 1)
9326 : )
9327 : {
9328 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1661;
9329 : {
9330 : tree res_op0;
9331 : {
9332 : tree _o1[1], _r1;
9333 : {
9334 : tree _o2[2], _r2;
9335 : _o2[0] = captures[1];
9336 : _o2[1] = zeros;
9337 : _r2 = fold_build2_loc (loc, GT_EXPR, boolean_type_node, _o2[0], _o2[1]);
9338 : _o1[0] = _r2;
9339 : }
9340 : if (TREE_TYPE (_o1[0]) != type)
9341 : {
9342 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
9343 : }
9344 : else
9345 : _r1 = _o1[0];
9346 : res_op0 = _r1;
9347 : }
9348 : tree _r;
9349 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
9350 : if (TREE_SIDE_EFFECTS (captures[2]))
9351 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
9352 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1005, __FILE__, __LINE__, true);
9353 : return _r;
9354 : }
9355 : next_after_fail1661:;
9356 : }
9357 : else
9358 : {
9359 0 : if (VECTOR_INTEGER_TYPE_P (type)
9360 0 : && TYPE_MODE (bt) == TYPE_MODE (type)
9361 0 : && expand_vec_cmp_expr_p (type, bt, GT_EXPR)
9362 0 : && (VECTOR_CST = uniform_integer_cst_p (captures[2])) != NULL
9363 0 : && wi::eq_p (wi::to_wide (VECTOR_CST), element_precision (type) - 1)
9364 : )
9365 : {
9366 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1662;
9367 0 : {
9368 0 : tree res_op0;
9369 0 : {
9370 0 : tree _o1[2], _r1;
9371 0 : _o1[0] = captures[1];
9372 0 : _o1[1] = zeros;
9373 0 : _r1 = fold_build2_loc (loc, GT_EXPR, bt, _o1[0], _o1[1]);
9374 0 : res_op0 = _r1;
9375 : }
9376 0 : tree _r;
9377 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
9378 0 : if (TREE_SIDE_EFFECTS (captures[2]))
9379 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
9380 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1006, __FILE__, __LINE__, true);
9381 0 : return _r;
9382 : }
9383 0 : next_after_fail1662:;
9384 : }
9385 : }
9386 : }
9387 : }
9388 : }
9389 0 : break;
9390 : }
9391 : default:;
9392 : }
9393 : break;
9394 : }
9395 437 : case LSHIFT_EXPR:
9396 437 : {
9397 437 : tree _q20 = TREE_OPERAND (_p0, 0);
9398 437 : tree _q21 = TREE_OPERAND (_p0, 1);
9399 437 : switch (TREE_CODE (_q21))
9400 : {
9401 358 : case INTEGER_CST:
9402 358 : {
9403 358 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q21, 0))
9404 : {
9405 67 : {
9406 67 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p1, _q21 };
9407 67 : tree res = generic_simplify_425 (loc, type, _p0, _p1, captures);
9408 67 : if (res) return res;
9409 : }
9410 : }
9411 : break;
9412 : }
9413 : default:;
9414 : }
9415 : break;
9416 : }
9417 949785 : default:;
9418 : }
9419 949785 : {
9420 949785 : tree _p0_pops[1];
9421 949785 : if (tree_nop_convert (_p0, _p0_pops))
9422 : {
9423 138346 : tree _q20 = _p0_pops[0];
9424 138346 : switch (TREE_CODE (_q20))
9425 : {
9426 20 : case LSHIFT_EXPR:
9427 20 : {
9428 20 : tree _q30 = TREE_OPERAND (_q20, 0);
9429 20 : tree _q31 = TREE_OPERAND (_q20, 1);
9430 20 : switch (TREE_CODE (_q31))
9431 : {
9432 0 : case INTEGER_CST:
9433 0 : {
9434 0 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q31, 0))
9435 : {
9436 0 : {
9437 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p1, _q31 };
9438 0 : tree res = generic_simplify_425 (loc, type, _p0, _p1, captures);
9439 0 : if (res) return res;
9440 : }
9441 : }
9442 : break;
9443 : }
9444 : default:;
9445 : }
9446 : break;
9447 : }
9448 : default:;
9449 : }
9450 : }
9451 : }
9452 949785 : if (integer_all_onesp (_p0))
9453 : {
9454 10932 : {
9455 10932 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9456 10932 : if (!TYPE_UNSIGNED (type)
9457 : )
9458 : {
9459 119 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1663;
9460 119 : {
9461 119 : tree _r;
9462 119 : _r = captures[0];
9463 119 : if (TREE_SIDE_EFFECTS (captures[1]))
9464 1 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
9465 119 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1007, __FILE__, __LINE__, true);
9466 119 : return _r;
9467 : }
9468 0 : next_after_fail1663:;
9469 : }
9470 : }
9471 : }
9472 949666 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
9473 : {
9474 25 : {
9475 25 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
9476 25 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1664;
9477 25 : {
9478 25 : tree _r;
9479 25 : _r = build_zero_cst (type);
9480 25 : if (TREE_SIDE_EFFECTS (captures[0]))
9481 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
9482 25 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1008, __FILE__, __LINE__, true);
9483 25 : return _r;
9484 : }
9485 0 : next_after_fail1664:;
9486 : }
9487 : }
9488 949641 : if (integer_zerop (_p1))
9489 : {
9490 1280 : {
9491 1280 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
9492 1280 : tree res = generic_simplify_418 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9493 1280 : if (res) return res;
9494 : }
9495 : }
9496 948361 : if (integer_zerop (_p0))
9497 : {
9498 152 : {
9499 152 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9500 152 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9501 152 : if (res) return res;
9502 : }
9503 : }
9504 948209 : switch (TREE_CODE (_p1))
9505 : {
9506 0 : case VECTOR_CST:
9507 0 : {
9508 0 : {
9509 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9510 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9511 0 : if (res) return res;
9512 : }
9513 0 : break;
9514 : }
9515 0 : case CONSTRUCTOR:
9516 0 : {
9517 0 : {
9518 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9519 0 : tree res = generic_simplify_421 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9520 0 : if (res) return res;
9521 : }
9522 0 : break;
9523 : }
9524 948209 : default:;
9525 : }
9526 948209 : switch (TREE_CODE (_p0))
9527 : {
9528 118 : case RSHIFT_EXPR:
9529 118 : {
9530 118 : tree _q20 = TREE_OPERAND (_p0, 0);
9531 118 : tree _q21 = TREE_OPERAND (_p0, 1);
9532 118 : switch (TREE_CODE (_q21))
9533 : {
9534 73 : case INTEGER_CST:
9535 73 : {
9536 73 : switch (TREE_CODE (_p1))
9537 : {
9538 47 : case INTEGER_CST:
9539 47 : {
9540 47 : {
9541 47 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
9542 47 : tree res = generic_simplify_422 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9543 47 : if (res) return res;
9544 : }
9545 0 : break;
9546 : }
9547 : default:;
9548 : }
9549 : break;
9550 : }
9551 : default:;
9552 : }
9553 : break;
9554 : }
9555 162496 : CASE_CONVERT:
9556 162496 : {
9557 162496 : tree _q20 = TREE_OPERAND (_p0, 0);
9558 162496 : switch (TREE_CODE (_q20))
9559 : {
9560 6 : case BIT_AND_EXPR:
9561 6 : {
9562 6 : tree _q30 = TREE_OPERAND (_q20, 0);
9563 6 : tree _q31 = TREE_OPERAND (_q20, 1);
9564 6 : switch (TREE_CODE (_q31))
9565 : {
9566 0 : case INTEGER_CST:
9567 0 : {
9568 0 : switch (TREE_CODE (_p1))
9569 : {
9570 0 : case INTEGER_CST:
9571 0 : {
9572 0 : {
9573 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
9574 0 : tree res = generic_simplify_423 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, RSHIFT_EXPR);
9575 0 : if (res) return res;
9576 : }
9577 0 : break;
9578 : }
9579 : default:;
9580 : }
9581 : break;
9582 : }
9583 : default:;
9584 : }
9585 : break;
9586 : }
9587 14 : case BIT_XOR_EXPR:
9588 14 : {
9589 14 : tree _q30 = TREE_OPERAND (_q20, 0);
9590 14 : tree _q31 = TREE_OPERAND (_q20, 1);
9591 14 : switch (TREE_CODE (_q31))
9592 : {
9593 0 : case INTEGER_CST:
9594 0 : {
9595 0 : switch (TREE_CODE (_p1))
9596 : {
9597 0 : case INTEGER_CST:
9598 0 : {
9599 0 : {
9600 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
9601 0 : tree res = generic_simplify_423 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, RSHIFT_EXPR);
9602 0 : if (res) return res;
9603 : }
9604 0 : break;
9605 : }
9606 : default:;
9607 : }
9608 : break;
9609 : }
9610 : default:;
9611 : }
9612 : break;
9613 : }
9614 43 : case BIT_IOR_EXPR:
9615 43 : {
9616 43 : tree _q30 = TREE_OPERAND (_q20, 0);
9617 43 : tree _q31 = TREE_OPERAND (_q20, 1);
9618 43 : switch (TREE_CODE (_q31))
9619 : {
9620 24 : case INTEGER_CST:
9621 24 : {
9622 24 : switch (TREE_CODE (_p1))
9623 : {
9624 7 : case INTEGER_CST:
9625 7 : {
9626 7 : {
9627 7 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
9628 7 : tree res = generic_simplify_423 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, RSHIFT_EXPR);
9629 7 : if (res) return res;
9630 : }
9631 0 : break;
9632 : }
9633 : default:;
9634 : }
9635 : break;
9636 : }
9637 : default:;
9638 : }
9639 : break;
9640 : }
9641 131 : case CALL_EXPR:
9642 131 : switch (get_call_combined_fn (_q20))
9643 : {
9644 0 : case CFN_BUILT_IN_BSWAP128:
9645 0 : if (call_expr_nargs (_q20) == 1)
9646 : {
9647 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
9648 0 : switch (TREE_CODE (_p1))
9649 : {
9650 0 : case INTEGER_CST:
9651 0 : {
9652 0 : {
9653 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9654 0 : tree res = generic_simplify_426 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP128);
9655 0 : if (res) return res;
9656 : }
9657 0 : break;
9658 : }
9659 : default:;
9660 : }
9661 : }
9662 : break;
9663 8 : case CFN_BUILT_IN_BSWAP16:
9664 8 : if (call_expr_nargs (_q20) == 1)
9665 : {
9666 8 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
9667 8 : switch (TREE_CODE (_p1))
9668 : {
9669 7 : case INTEGER_CST:
9670 7 : {
9671 7 : {
9672 7 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9673 7 : tree res = generic_simplify_426 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP16);
9674 7 : if (res) return res;
9675 : }
9676 2 : break;
9677 : }
9678 : default:;
9679 : }
9680 : }
9681 : break;
9682 13 : case CFN_BUILT_IN_BSWAP32:
9683 13 : if (call_expr_nargs (_q20) == 1)
9684 : {
9685 13 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
9686 13 : switch (TREE_CODE (_p1))
9687 : {
9688 13 : case INTEGER_CST:
9689 13 : {
9690 13 : {
9691 13 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9692 13 : tree res = generic_simplify_426 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP32);
9693 13 : if (res) return res;
9694 : }
9695 9 : break;
9696 : }
9697 : default:;
9698 : }
9699 : }
9700 : break;
9701 18 : case CFN_BUILT_IN_BSWAP64:
9702 18 : if (call_expr_nargs (_q20) == 1)
9703 : {
9704 18 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
9705 18 : switch (TREE_CODE (_p1))
9706 : {
9707 18 : case INTEGER_CST:
9708 18 : {
9709 18 : {
9710 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9711 18 : tree res = generic_simplify_426 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP64);
9712 18 : if (res) return res;
9713 : }
9714 12 : break;
9715 : }
9716 : default:;
9717 : }
9718 : }
9719 : break;
9720 : default:;
9721 : }
9722 : break;
9723 : default:;
9724 : }
9725 : break;
9726 : }
9727 13903 : case BIT_AND_EXPR:
9728 13903 : {
9729 13903 : tree _q20 = TREE_OPERAND (_p0, 0);
9730 13903 : tree _q21 = TREE_OPERAND (_p0, 1);
9731 13903 : switch (TREE_CODE (_q21))
9732 : {
9733 13853 : case INTEGER_CST:
9734 13853 : {
9735 13853 : switch (TREE_CODE (_p1))
9736 : {
9737 13830 : case INTEGER_CST:
9738 13830 : {
9739 13830 : {
9740 13830 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
9741 13830 : tree res = generic_simplify_424 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, RSHIFT_EXPR);
9742 13830 : if (res) return res;
9743 : }
9744 0 : break;
9745 : }
9746 : default:;
9747 : }
9748 : break;
9749 : }
9750 : default:;
9751 : }
9752 : break;
9753 : }
9754 240 : case BIT_XOR_EXPR:
9755 240 : {
9756 240 : tree _q20 = TREE_OPERAND (_p0, 0);
9757 240 : tree _q21 = TREE_OPERAND (_p0, 1);
9758 240 : switch (TREE_CODE (_q21))
9759 : {
9760 97 : case INTEGER_CST:
9761 97 : {
9762 97 : switch (TREE_CODE (_p1))
9763 : {
9764 97 : case INTEGER_CST:
9765 97 : {
9766 97 : {
9767 97 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
9768 97 : tree res = generic_simplify_424 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, RSHIFT_EXPR);
9769 97 : if (res) return res;
9770 : }
9771 0 : break;
9772 : }
9773 : default:;
9774 : }
9775 : break;
9776 : }
9777 : default:;
9778 : }
9779 : break;
9780 : }
9781 55 : case BIT_IOR_EXPR:
9782 55 : {
9783 55 : tree _q20 = TREE_OPERAND (_p0, 0);
9784 55 : tree _q21 = TREE_OPERAND (_p0, 1);
9785 55 : switch (TREE_CODE (_q21))
9786 : {
9787 10 : case INTEGER_CST:
9788 10 : {
9789 10 : switch (TREE_CODE (_p1))
9790 : {
9791 8 : case INTEGER_CST:
9792 8 : {
9793 8 : {
9794 8 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
9795 8 : tree res = generic_simplify_424 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, RSHIFT_EXPR);
9796 8 : if (res) return res;
9797 : }
9798 0 : break;
9799 : }
9800 : default:;
9801 : }
9802 : break;
9803 : }
9804 : default:;
9805 : }
9806 : break;
9807 : }
9808 0 : case VEC_COND_EXPR:
9809 0 : {
9810 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9811 0 : tree _q21 = TREE_OPERAND (_p0, 1);
9812 0 : tree _q22 = TREE_OPERAND (_p0, 2);
9813 0 : switch (TREE_CODE (_p1))
9814 : {
9815 0 : case VEC_COND_EXPR:
9816 0 : {
9817 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9818 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9819 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9820 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9821 : {
9822 0 : {
9823 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
9824 0 : if (VECTOR_TYPE_P (type)
9825 0 : && (TREE_CODE_CLASS (RSHIFT_EXPR) != tcc_comparison
9826 : || types_match (type, TREE_TYPE (captures[2]))
9827 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9828 : || (optimize_vectors_before_lowering_p ()
9829 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9830 : )
9831 : {
9832 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1665;
9833 0 : {
9834 0 : tree res_op0;
9835 0 : res_op0 = captures[1];
9836 0 : tree res_op1;
9837 0 : {
9838 0 : tree _o1[2], _r1;
9839 0 : _o1[0] = captures[2];
9840 0 : _o1[1] = captures[5];
9841 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
9842 0 : if (EXPR_P (_r1))
9843 0 : goto next_after_fail1665;
9844 0 : res_op1 = _r1;
9845 : }
9846 0 : tree res_op2;
9847 0 : {
9848 0 : tree _o1[2], _r1;
9849 0 : _o1[0] = captures[3];
9850 0 : _o1[1] = captures[6];
9851 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
9852 0 : if (EXPR_P (_r1))
9853 0 : goto next_after_fail1665;
9854 0 : res_op2 = _r1;
9855 : }
9856 0 : tree _r;
9857 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9858 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 890, __FILE__, __LINE__, true);
9859 0 : return _r;
9860 : }
9861 0 : next_after_fail1665:;
9862 : }
9863 : }
9864 : }
9865 : break;
9866 : }
9867 0 : default:;
9868 : }
9869 0 : {
9870 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
9871 0 : if (VECTOR_TYPE_P (type)
9872 0 : && (TREE_CODE_CLASS (RSHIFT_EXPR) != tcc_comparison
9873 : || types_match (type, TREE_TYPE (captures[2]))
9874 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9875 : || (optimize_vectors_before_lowering_p ()
9876 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9877 : )
9878 : {
9879 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1666;
9880 0 : {
9881 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1666;
9882 0 : tree res_op0;
9883 0 : res_op0 = captures[1];
9884 0 : tree res_op1;
9885 0 : {
9886 0 : tree _o1[2], _r1;
9887 0 : _o1[0] = captures[2];
9888 0 : _o1[1] = unshare_expr (captures[4]);
9889 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
9890 0 : if (EXPR_P (_r1))
9891 0 : goto next_after_fail1666;
9892 0 : res_op1 = _r1;
9893 : }
9894 0 : tree res_op2;
9895 0 : {
9896 0 : tree _o1[2], _r1;
9897 0 : _o1[0] = captures[3];
9898 0 : _o1[1] = captures[4];
9899 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
9900 0 : if (EXPR_P (_r1))
9901 0 : goto next_after_fail1666;
9902 0 : res_op2 = _r1;
9903 : }
9904 0 : tree _r;
9905 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9906 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
9907 0 : return _r;
9908 : }
9909 0 : next_after_fail1666:;
9910 : }
9911 : }
9912 0 : break;
9913 : }
9914 566 : case CALL_EXPR:
9915 566 : switch (get_call_combined_fn (_p0))
9916 : {
9917 0 : case CFN_BUILT_IN_BSWAP128:
9918 0 : if (call_expr_nargs (_p0) == 1)
9919 : {
9920 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9921 0 : switch (TREE_CODE (_p1))
9922 : {
9923 0 : case INTEGER_CST:
9924 0 : {
9925 0 : {
9926 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9927 0 : tree res = generic_simplify_426 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP128);
9928 0 : if (res) return res;
9929 : }
9930 0 : break;
9931 : }
9932 : default:;
9933 : }
9934 : }
9935 : break;
9936 32 : case CFN_BUILT_IN_BSWAP16:
9937 32 : if (call_expr_nargs (_p0) == 1)
9938 : {
9939 32 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9940 32 : switch (TREE_CODE (_p1))
9941 : {
9942 32 : case INTEGER_CST:
9943 32 : {
9944 32 : {
9945 32 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9946 32 : tree res = generic_simplify_426 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP16);
9947 32 : if (res) return res;
9948 : }
9949 9 : break;
9950 : }
9951 : default:;
9952 : }
9953 : }
9954 : break;
9955 99 : case CFN_BUILT_IN_BSWAP32:
9956 99 : if (call_expr_nargs (_p0) == 1)
9957 : {
9958 99 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9959 99 : switch (TREE_CODE (_p1))
9960 : {
9961 98 : case INTEGER_CST:
9962 98 : {
9963 98 : {
9964 98 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9965 98 : tree res = generic_simplify_426 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP32);
9966 98 : if (res) return res;
9967 : }
9968 59 : break;
9969 : }
9970 : default:;
9971 : }
9972 : }
9973 : break;
9974 100 : case CFN_BUILT_IN_BSWAP64:
9975 100 : if (call_expr_nargs (_p0) == 1)
9976 : {
9977 100 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9978 100 : switch (TREE_CODE (_p1))
9979 : {
9980 99 : case INTEGER_CST:
9981 99 : {
9982 99 : {
9983 99 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9984 99 : tree res = generic_simplify_426 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP64);
9985 99 : if (res) return res;
9986 : }
9987 73 : break;
9988 : }
9989 : default:;
9990 : }
9991 : }
9992 : break;
9993 : default:;
9994 : }
9995 : break;
9996 934117 : default:;
9997 : }
9998 934117 : if (integer_onep (_p0))
9999 : {
10000 524 : {
10001 524 : tree captures[1] ATTRIBUTE_UNUSED = { _p1 };
10002 524 : if (INTEGRAL_TYPE_P (type)
10003 : )
10004 : {
10005 524 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1667;
10006 524 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1667;
10007 524 : {
10008 524 : tree res_op0;
10009 524 : {
10010 524 : tree _o1[2], _r1;
10011 524 : _o1[0] = captures[0];
10012 524 : _o1[1] = build_zero_cst (TREE_TYPE (captures[0]));
10013 524 : _r1 = fold_build2_loc (loc, EQ_EXPR, boolean_type_node, _o1[0], _o1[1]);
10014 524 : res_op0 = _r1;
10015 : }
10016 524 : tree _r;
10017 524 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
10018 524 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1009, __FILE__, __LINE__, true);
10019 524 : return _r;
10020 : }
10021 : next_after_fail1667:;
10022 : }
10023 : }
10024 : }
10025 933593 : switch (TREE_CODE (_p1))
10026 : {
10027 11 : case VEC_COND_EXPR:
10028 11 : {
10029 11 : tree _q30 = TREE_OPERAND (_p1, 0);
10030 11 : tree _q31 = TREE_OPERAND (_p1, 1);
10031 11 : tree _q32 = TREE_OPERAND (_p1, 2);
10032 11 : {
10033 11 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
10034 11 : if (VECTOR_TYPE_P (type)
10035 11 : && (TREE_CODE_CLASS (RSHIFT_EXPR) != tcc_comparison
10036 : || types_match (type, TREE_TYPE (captures[3]))
10037 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
10038 : || (optimize_vectors_before_lowering_p ()
10039 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
10040 : )
10041 : {
10042 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1668;
10043 11 : {
10044 11 : if (! tree_invariant_p (captures[0])) goto next_after_fail1668;
10045 0 : tree res_op0;
10046 0 : res_op0 = captures[2];
10047 0 : tree res_op1;
10048 0 : {
10049 0 : tree _o1[2], _r1;
10050 0 : _o1[0] = unshare_expr (captures[0]);
10051 0 : _o1[1] = captures[3];
10052 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
10053 0 : if (EXPR_P (_r1))
10054 0 : goto next_after_fail1668;
10055 0 : res_op1 = _r1;
10056 : }
10057 0 : tree res_op2;
10058 0 : {
10059 0 : tree _o1[2], _r1;
10060 0 : _o1[0] = captures[0];
10061 0 : _o1[1] = captures[4];
10062 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
10063 0 : if (EXPR_P (_r1))
10064 0 : goto next_after_fail1668;
10065 0 : res_op2 = _r1;
10066 : }
10067 0 : tree _r;
10068 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10069 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
10070 0 : return _r;
10071 : }
10072 11 : next_after_fail1668:;
10073 : }
10074 : }
10075 11 : break;
10076 : }
10077 933593 : default:;
10078 : }
10079 933593 : switch (TREE_CODE (_p0))
10080 : {
10081 0 : case VEC_PERM_EXPR:
10082 0 : {
10083 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10084 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10085 0 : tree _q22 = TREE_OPERAND (_p0, 2);
10086 0 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
10087 : {
10088 0 : switch (TREE_CODE (_p1))
10089 : {
10090 0 : case VEC_PERM_EXPR:
10091 0 : {
10092 0 : tree _q60 = TREE_OPERAND (_p1, 0);
10093 0 : tree _q61 = TREE_OPERAND (_p1, 1);
10094 0 : tree _q62 = TREE_OPERAND (_p1, 2);
10095 0 : if ((_q61 == _q60 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q60, 0) && types_match (_q61, _q60)))
10096 : {
10097 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
10098 : {
10099 0 : {
10100 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q22, _q60 };
10101 0 : if (VECTOR_INTEGER_TYPE_P (type)
10102 : )
10103 : {
10104 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1669;
10105 0 : {
10106 0 : tree res_op0;
10107 0 : {
10108 0 : tree _o1[2], _r1;
10109 0 : _o1[0] = captures[0];
10110 0 : _o1[1] = captures[2];
10111 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10112 0 : captures[3] = _r1;
10113 : }
10114 0 : res_op0 = unshare_expr (captures[3]);
10115 0 : tree res_op1;
10116 0 : res_op1 = captures[3];
10117 0 : tree res_op2;
10118 0 : res_op2 = captures[1];
10119 0 : tree _r;
10120 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
10121 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
10122 0 : return _r;
10123 : }
10124 0 : next_after_fail1669:;
10125 : }
10126 : }
10127 : }
10128 : }
10129 : break;
10130 : }
10131 : default:;
10132 : }
10133 : }
10134 : break;
10135 : }
10136 : default:;
10137 : }
10138 : return NULL_TREE;
10139 : }
10140 :
10141 : tree
10142 379764 : generic_simplify_MAX_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
10143 : {
10144 379764 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10145 379764 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
10146 : {
10147 0 : {
10148 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10149 0 : tree res = generic_simplify_517 (loc, type, _p0, _p1, captures, MAX_EXPR);
10150 0 : if (res) return res;
10151 : }
10152 : }
10153 379764 : switch (TREE_CODE (_p0))
10154 : {
10155 111 : case MAX_EXPR:
10156 111 : {
10157 111 : tree _q20 = TREE_OPERAND (_p0, 0);
10158 111 : tree _q21 = TREE_OPERAND (_p0, 1);
10159 111 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
10160 : {
10161 0 : {
10162 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
10163 0 : tree res = generic_simplify_518 (loc, type, _p0, _p1, captures, MAX_EXPR);
10164 0 : if (res) return res;
10165 : }
10166 : }
10167 111 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
10168 : {
10169 0 : {
10170 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
10171 0 : tree res = generic_simplify_518 (loc, type, _p0, _p1, captures, MAX_EXPR);
10172 0 : if (res) return res;
10173 : }
10174 : }
10175 : break;
10176 : }
10177 379764 : default:;
10178 : }
10179 379764 : switch (TREE_CODE (_p1))
10180 : {
10181 0 : case MAX_EXPR:
10182 0 : {
10183 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10184 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10185 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10186 : {
10187 0 : {
10188 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q31 };
10189 0 : tree res = generic_simplify_519 (loc, type, _p0, _p1, captures, MAX_EXPR);
10190 0 : if (res) return res;
10191 : }
10192 : }
10193 0 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
10194 : {
10195 0 : {
10196 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q30 };
10197 0 : tree res = generic_simplify_519 (loc, type, _p0, _p1, captures, MAX_EXPR);
10198 0 : if (res) return res;
10199 : }
10200 : }
10201 : break;
10202 : }
10203 379764 : default:;
10204 : }
10205 379764 : switch (TREE_CODE (_p0))
10206 : {
10207 3340 : case MIN_EXPR:
10208 3340 : {
10209 3340 : tree _q20 = TREE_OPERAND (_p0, 0);
10210 3340 : tree _q21 = TREE_OPERAND (_p0, 1);
10211 3340 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
10212 : {
10213 1 : {
10214 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10215 1 : tree res = generic_simplify_532 (loc, type, _p0, _p1, captures);
10216 1 : if (res) return res;
10217 : }
10218 : }
10219 3339 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
10220 : {
10221 1 : {
10222 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10223 1 : tree res = generic_simplify_532 (loc, type, _p0, _p1, captures);
10224 1 : if (res) return res;
10225 : }
10226 : }
10227 : break;
10228 : }
10229 379762 : default:;
10230 : }
10231 379762 : switch (TREE_CODE (_p1))
10232 : {
10233 0 : case MIN_EXPR:
10234 0 : {
10235 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10236 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10237 0 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
10238 : {
10239 0 : {
10240 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
10241 0 : tree res = generic_simplify_532 (loc, type, _p0, _p1, captures);
10242 0 : if (res) return res;
10243 : }
10244 : }
10245 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10246 : {
10247 0 : {
10248 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _p0 };
10249 0 : tree res = generic_simplify_532 (loc, type, _p0, _p1, captures);
10250 0 : if (res) return res;
10251 : }
10252 : }
10253 : break;
10254 : }
10255 0 : case NEGATE_EXPR:
10256 0 : {
10257 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10258 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10259 : {
10260 0 : {
10261 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10262 0 : tree res = generic_simplify_533 (loc, type, _p0, _p1, captures);
10263 0 : if (res) return res;
10264 : }
10265 : }
10266 : break;
10267 : }
10268 379762 : default:;
10269 : }
10270 379762 : switch (TREE_CODE (_p0))
10271 : {
10272 76 : case NEGATE_EXPR:
10273 76 : {
10274 76 : tree _q20 = TREE_OPERAND (_p0, 0);
10275 76 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
10276 : {
10277 2 : {
10278 2 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10279 2 : tree res = generic_simplify_533 (loc, type, _p0, _p1, captures);
10280 2 : if (res) return res;
10281 : }
10282 : }
10283 : break;
10284 : }
10285 379760 : default:;
10286 : }
10287 379760 : {
10288 379760 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
10289 379760 : if (INTEGRAL_TYPE_P (type)
10290 377824 : && TYPE_MAX_VALUE (type)
10291 757584 : && operand_equal_p (captures[1], TYPE_MAX_VALUE (type), OEP_ONLY_CONST)
10292 : )
10293 : {
10294 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1736;
10295 0 : {
10296 0 : tree _r;
10297 0 : _r = captures[1];
10298 0 : if (TREE_SIDE_EFFECTS (captures[0]))
10299 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
10300 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1024, __FILE__, __LINE__, true);
10301 0 : return _r;
10302 : }
10303 0 : next_after_fail1736:;
10304 : }
10305 : else
10306 : {
10307 379760 : if (INTEGRAL_TYPE_P (type)
10308 377824 : && TYPE_MIN_VALUE (type)
10309 757584 : && operand_equal_p (captures[1], TYPE_MIN_VALUE (type), OEP_ONLY_CONST)
10310 : )
10311 : {
10312 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1737;
10313 11 : {
10314 11 : tree _r;
10315 11 : _r = captures[0];
10316 11 : if (TREE_SIDE_EFFECTS (captures[1]))
10317 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
10318 11 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1025, __FILE__, __LINE__, true);
10319 11 : return _r;
10320 : }
10321 0 : next_after_fail1737:;
10322 : }
10323 : }
10324 : }
10325 379749 : switch (TREE_CODE (_p0))
10326 : {
10327 23099 : case PLUS_EXPR:
10328 23099 : {
10329 23099 : tree _q20 = TREE_OPERAND (_p0, 0);
10330 23099 : tree _q21 = TREE_OPERAND (_p0, 1);
10331 23099 : switch (TREE_CODE (_p1))
10332 : {
10333 14 : case PLUS_EXPR:
10334 14 : {
10335 14 : tree _q50 = TREE_OPERAND (_p1, 0);
10336 14 : tree _q51 = TREE_OPERAND (_p1, 1);
10337 14 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10338 : {
10339 0 : {
10340 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
10341 0 : tree res = generic_simplify_522 (loc, type, _p0, _p1, captures, MAX_EXPR);
10342 0 : if (res) return res;
10343 : }
10344 0 : {
10345 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q50, _q21, _p0, _q20 };
10346 0 : tree res = generic_simplify_522 (loc, type, _p0, _p1, captures, MAX_EXPR);
10347 0 : if (res) return res;
10348 : }
10349 : }
10350 14 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10351 : {
10352 0 : {
10353 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q50 };
10354 0 : tree res = generic_simplify_522 (loc, type, _p0, _p1, captures, MAX_EXPR);
10355 0 : if (res) return res;
10356 : }
10357 : }
10358 14 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10359 : {
10360 0 : {
10361 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q51, _q21, _p0, _q20 };
10362 0 : tree res = generic_simplify_522 (loc, type, _p0, _p1, captures, MAX_EXPR);
10363 0 : if (res) return res;
10364 : }
10365 : }
10366 : break;
10367 : }
10368 23099 : default:;
10369 : }
10370 23099 : switch (TREE_CODE (_q21))
10371 : {
10372 23061 : case INTEGER_CST:
10373 23061 : {
10374 23061 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
10375 : {
10376 11 : {
10377 11 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
10378 11 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
10379 : )
10380 : {
10381 0 : if (tree_int_cst_sgn (captures[2]) > 0
10382 : )
10383 : {
10384 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1738;
10385 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1738;
10386 0 : {
10387 0 : tree _r;
10388 0 : _r = captures[1];
10389 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1026, __FILE__, __LINE__, true);
10390 0 : return _r;
10391 : }
10392 11 : next_after_fail1738:;
10393 : }
10394 : else
10395 : {
10396 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1739;
10397 0 : {
10398 0 : tree _r;
10399 0 : _r = captures[0];
10400 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10401 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10402 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1027, __FILE__, __LINE__, true);
10403 0 : return _r;
10404 : }
10405 0 : next_after_fail1739:;
10406 : }
10407 : }
10408 : }
10409 : }
10410 : break;
10411 : }
10412 : default:;
10413 : }
10414 : break;
10415 : }
10416 8162 : case MINUS_EXPR:
10417 8162 : {
10418 8162 : tree _q20 = TREE_OPERAND (_p0, 0);
10419 8162 : tree _q21 = TREE_OPERAND (_p0, 1);
10420 8162 : switch (TREE_CODE (_p1))
10421 : {
10422 0 : case MINUS_EXPR:
10423 0 : {
10424 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10425 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10426 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10427 : {
10428 0 : {
10429 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
10430 0 : tree res = generic_simplify_523 (loc, type, _p0, _p1, captures, MAX_EXPR);
10431 0 : if (res) return res;
10432 : }
10433 0 : {
10434 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q50, _q21, _p0, _q20 };
10435 0 : tree res = generic_simplify_523 (loc, type, _p0, _p1, captures, MAX_EXPR);
10436 0 : if (res) return res;
10437 : }
10438 : }
10439 : break;
10440 : }
10441 : default:;
10442 : }
10443 : break;
10444 : }
10445 379749 : default:;
10446 : }
10447 379749 : switch (TREE_CODE (_p1))
10448 : {
10449 110 : case PLUS_EXPR:
10450 110 : {
10451 110 : tree _q30 = TREE_OPERAND (_p1, 0);
10452 110 : tree _q31 = TREE_OPERAND (_p1, 1);
10453 110 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10454 : {
10455 0 : switch (TREE_CODE (_q31))
10456 : {
10457 0 : case INTEGER_CST:
10458 0 : {
10459 0 : {
10460 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
10461 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
10462 : )
10463 : {
10464 0 : if (tree_int_cst_sgn (captures[2]) > 0
10465 : )
10466 : {
10467 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1740;
10468 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1740;
10469 0 : {
10470 0 : tree _r;
10471 0 : _r = captures[1];
10472 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1026, __FILE__, __LINE__, true);
10473 0 : return _r;
10474 : }
10475 0 : next_after_fail1740:;
10476 : }
10477 : else
10478 : {
10479 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1741;
10480 0 : {
10481 0 : tree _r;
10482 0 : _r = captures[0];
10483 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10484 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10485 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1027, __FILE__, __LINE__, true);
10486 0 : return _r;
10487 : }
10488 0 : next_after_fail1741:;
10489 : }
10490 : }
10491 : }
10492 0 : break;
10493 : }
10494 : default:;
10495 : }
10496 : }
10497 : break;
10498 : }
10499 379749 : default:;
10500 : }
10501 379749 : switch (TREE_CODE (_p0))
10502 : {
10503 3338 : case MIN_EXPR:
10504 3338 : {
10505 3338 : tree _q20 = TREE_OPERAND (_p0, 0);
10506 3338 : tree _q21 = TREE_OPERAND (_p0, 1);
10507 3338 : switch (TREE_CODE (_p1))
10508 : {
10509 0 : case MAX_EXPR:
10510 0 : {
10511 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10512 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10513 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10514 : {
10515 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10516 : {
10517 0 : {
10518 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10519 0 : if (!HONOR_NANS (captures[0])
10520 : )
10521 : {
10522 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1742;
10523 0 : {
10524 0 : tree res_op0;
10525 0 : res_op0 = captures[0];
10526 0 : tree res_op1;
10527 0 : res_op1 = captures[1];
10528 0 : tree _r;
10529 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
10530 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 889, __FILE__, __LINE__, true);
10531 0 : return _r;
10532 : }
10533 0 : next_after_fail1742:;
10534 : }
10535 : }
10536 : }
10537 : }
10538 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10539 : {
10540 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10541 : {
10542 0 : {
10543 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10544 0 : if (!HONOR_NANS (captures[0])
10545 : )
10546 : {
10547 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1743;
10548 0 : {
10549 0 : tree res_op0;
10550 0 : res_op0 = captures[0];
10551 0 : tree res_op1;
10552 0 : res_op1 = captures[1];
10553 0 : tree _r;
10554 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
10555 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 889, __FILE__, __LINE__, true);
10556 0 : return _r;
10557 : }
10558 0 : next_after_fail1743:;
10559 : }
10560 : }
10561 : }
10562 : }
10563 : break;
10564 : }
10565 : default:;
10566 : }
10567 : break;
10568 : }
10569 111 : case MAX_EXPR:
10570 111 : {
10571 111 : tree _q20 = TREE_OPERAND (_p0, 0);
10572 111 : tree _q21 = TREE_OPERAND (_p0, 1);
10573 111 : switch (TREE_CODE (_p1))
10574 : {
10575 0 : case MIN_EXPR:
10576 0 : {
10577 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10578 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10579 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10580 : {
10581 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10582 : {
10583 0 : {
10584 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10585 0 : if (!HONOR_NANS (captures[0])
10586 : )
10587 : {
10588 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1744;
10589 0 : {
10590 0 : tree res_op0;
10591 0 : res_op0 = captures[0];
10592 0 : tree res_op1;
10593 0 : res_op1 = captures[1];
10594 0 : tree _r;
10595 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
10596 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 889, __FILE__, __LINE__, true);
10597 0 : return _r;
10598 : }
10599 0 : next_after_fail1744:;
10600 : }
10601 : }
10602 : }
10603 : }
10604 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10605 : {
10606 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10607 : {
10608 0 : {
10609 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10610 0 : if (!HONOR_NANS (captures[0])
10611 : )
10612 : {
10613 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1745;
10614 0 : {
10615 0 : tree res_op0;
10616 0 : res_op0 = captures[0];
10617 0 : tree res_op1;
10618 0 : res_op1 = captures[1];
10619 0 : tree _r;
10620 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
10621 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 889, __FILE__, __LINE__, true);
10622 0 : return _r;
10623 : }
10624 0 : next_after_fail1745:;
10625 : }
10626 : }
10627 : }
10628 : }
10629 : break;
10630 : }
10631 : default:;
10632 : }
10633 : break;
10634 : }
10635 0 : case BIT_AND_EXPR:
10636 0 : {
10637 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10638 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10639 0 : switch (TREE_CODE (_q21))
10640 : {
10641 0 : case INTEGER_CST:
10642 0 : {
10643 0 : switch (TREE_CODE (_p1))
10644 : {
10645 0 : case BIT_AND_EXPR:
10646 0 : {
10647 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10648 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10649 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10650 : {
10651 0 : switch (TREE_CODE (_q51))
10652 : {
10653 0 : case INTEGER_CST:
10654 0 : {
10655 0 : {
10656 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
10657 0 : tree res = generic_simplify_524 (loc, type, _p0, _p1, captures, MAX_EXPR);
10658 0 : if (res) return res;
10659 : }
10660 0 : break;
10661 : }
10662 : default:;
10663 : }
10664 : }
10665 : break;
10666 : }
10667 : default:;
10668 : }
10669 : break;
10670 : }
10671 : default:;
10672 : }
10673 : break;
10674 : }
10675 379749 : default:;
10676 : }
10677 379749 : switch (TREE_CODE (_p1))
10678 : {
10679 0 : case BIT_AND_EXPR:
10680 0 : {
10681 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10682 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10683 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10684 : {
10685 0 : switch (TREE_CODE (_q31))
10686 : {
10687 0 : case INTEGER_CST:
10688 0 : {
10689 0 : {
10690 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
10691 0 : tree res = generic_simplify_525 (loc, type, _p0, _p1, captures, MAX_EXPR);
10692 0 : if (res) return res;
10693 : }
10694 0 : break;
10695 : }
10696 : default:;
10697 : }
10698 : }
10699 : break;
10700 : }
10701 379749 : default:;
10702 : }
10703 379749 : switch (TREE_CODE (_p0))
10704 : {
10705 32680 : CASE_CONVERT:
10706 32680 : {
10707 32680 : tree _q20 = TREE_OPERAND (_p0, 0);
10708 32680 : switch (TREE_CODE (_q20))
10709 : {
10710 0 : case ADDR_EXPR:
10711 0 : {
10712 0 : switch (TREE_CODE (_p1))
10713 : {
10714 0 : CASE_CONVERT:
10715 0 : {
10716 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10717 0 : switch (TREE_CODE (_q40))
10718 : {
10719 0 : case ADDR_EXPR:
10720 0 : {
10721 0 : {
10722 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10723 0 : tree res = generic_simplify_526 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR);
10724 0 : if (res) return res;
10725 : }
10726 0 : break;
10727 : }
10728 : default:;
10729 : }
10730 : break;
10731 : }
10732 0 : case ADDR_EXPR:
10733 0 : {
10734 0 : {
10735 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
10736 0 : tree res = generic_simplify_527 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR);
10737 0 : if (res) return res;
10738 : }
10739 0 : break;
10740 : }
10741 : default:;
10742 : }
10743 : break;
10744 : }
10745 : default:;
10746 : }
10747 : break;
10748 : }
10749 10 : case ADDR_EXPR:
10750 10 : {
10751 10 : switch (TREE_CODE (_p1))
10752 : {
10753 0 : CASE_CONVERT:
10754 0 : {
10755 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10756 0 : switch (TREE_CODE (_q30))
10757 : {
10758 0 : case ADDR_EXPR:
10759 0 : {
10760 0 : {
10761 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _p1, _q30 };
10762 0 : tree res = generic_simplify_528 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR);
10763 0 : if (res) return res;
10764 : }
10765 0 : break;
10766 : }
10767 : default:;
10768 : }
10769 : break;
10770 : }
10771 10 : case ADDR_EXPR:
10772 10 : {
10773 10 : {
10774 10 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _p1, _p1 };
10775 10 : tree res = generic_simplify_529 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR);
10776 10 : if (res) return res;
10777 : }
10778 10 : break;
10779 : }
10780 : default:;
10781 : }
10782 : break;
10783 : }
10784 74 : case NEGATE_EXPR:
10785 74 : {
10786 74 : tree _q20 = TREE_OPERAND (_p0, 0);
10787 74 : switch (TREE_CODE (_p1))
10788 : {
10789 0 : case NEGATE_EXPR:
10790 0 : {
10791 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10792 0 : {
10793 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10794 0 : if (FLOAT_TYPE_P (TREE_TYPE (captures[1]))
10795 0 : || (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
10796 0 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1])))
10797 : )
10798 : {
10799 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1746;
10800 0 : {
10801 0 : tree res_op0;
10802 0 : {
10803 0 : tree _o1[2], _r1;
10804 0 : _o1[0] = captures[1];
10805 0 : _o1[1] = captures[3];
10806 0 : _r1 = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10807 0 : res_op0 = _r1;
10808 : }
10809 0 : tree _r;
10810 0 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
10811 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1023, __FILE__, __LINE__, true);
10812 0 : return _r;
10813 : }
10814 0 : next_after_fail1746:;
10815 : }
10816 : }
10817 0 : break;
10818 : }
10819 : default:;
10820 : }
10821 : break;
10822 : }
10823 0 : case BIT_NOT_EXPR:
10824 0 : {
10825 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10826 0 : switch (TREE_CODE (_p1))
10827 : {
10828 0 : case BIT_NOT_EXPR:
10829 0 : {
10830 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10831 0 : {
10832 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10833 0 : tree res = generic_simplify_530 (loc, type, _p0, _p1, captures, MAX_EXPR, MIN_EXPR);
10834 0 : if (res) return res;
10835 : }
10836 0 : break;
10837 : }
10838 : default:;
10839 : }
10840 : break;
10841 : }
10842 0 : case VEC_COND_EXPR:
10843 0 : {
10844 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10845 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10846 0 : tree _q22 = TREE_OPERAND (_p0, 2);
10847 0 : switch (TREE_CODE (_p1))
10848 : {
10849 0 : case VEC_COND_EXPR:
10850 0 : {
10851 0 : tree _q60 = TREE_OPERAND (_p1, 0);
10852 0 : tree _q61 = TREE_OPERAND (_p1, 1);
10853 0 : tree _q62 = TREE_OPERAND (_p1, 2);
10854 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
10855 : {
10856 0 : {
10857 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
10858 0 : if (VECTOR_TYPE_P (type)
10859 0 : && (TREE_CODE_CLASS (MAX_EXPR) != tcc_comparison
10860 : || types_match (type, TREE_TYPE (captures[2]))
10861 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10862 : || (optimize_vectors_before_lowering_p ()
10863 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10864 : )
10865 : {
10866 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1747;
10867 0 : {
10868 0 : tree res_op0;
10869 0 : res_op0 = captures[1];
10870 0 : tree res_op1;
10871 0 : {
10872 0 : tree _o1[2], _r1;
10873 0 : _o1[0] = captures[2];
10874 0 : _o1[1] = captures[5];
10875 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
10876 0 : if (EXPR_P (_r1))
10877 0 : goto next_after_fail1747;
10878 0 : res_op1 = _r1;
10879 : }
10880 0 : tree res_op2;
10881 0 : {
10882 0 : tree _o1[2], _r1;
10883 0 : _o1[0] = captures[3];
10884 0 : _o1[1] = captures[6];
10885 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
10886 0 : if (EXPR_P (_r1))
10887 0 : goto next_after_fail1747;
10888 0 : res_op2 = _r1;
10889 : }
10890 0 : tree _r;
10891 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10892 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 890, __FILE__, __LINE__, true);
10893 0 : return _r;
10894 : }
10895 0 : next_after_fail1747:;
10896 : }
10897 : }
10898 : }
10899 : break;
10900 : }
10901 0 : default:;
10902 : }
10903 0 : {
10904 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
10905 0 : if (VECTOR_TYPE_P (type)
10906 0 : && (TREE_CODE_CLASS (MAX_EXPR) != tcc_comparison
10907 : || types_match (type, TREE_TYPE (captures[2]))
10908 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10909 : || (optimize_vectors_before_lowering_p ()
10910 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10911 : )
10912 : {
10913 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1748;
10914 0 : {
10915 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1748;
10916 0 : tree res_op0;
10917 0 : res_op0 = captures[1];
10918 0 : tree res_op1;
10919 0 : {
10920 0 : tree _o1[2], _r1;
10921 0 : _o1[0] = captures[2];
10922 0 : _o1[1] = unshare_expr (captures[4]);
10923 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
10924 0 : if (EXPR_P (_r1))
10925 0 : goto next_after_fail1748;
10926 0 : res_op1 = _r1;
10927 : }
10928 0 : tree res_op2;
10929 0 : {
10930 0 : tree _o1[2], _r1;
10931 0 : _o1[0] = captures[3];
10932 0 : _o1[1] = captures[4];
10933 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
10934 0 : if (EXPR_P (_r1))
10935 0 : goto next_after_fail1748;
10936 0 : res_op2 = _r1;
10937 : }
10938 0 : tree _r;
10939 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10940 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
10941 0 : return _r;
10942 : }
10943 0 : next_after_fail1748:;
10944 : }
10945 : }
10946 0 : break;
10947 : }
10948 379749 : default:;
10949 : }
10950 379749 : switch (TREE_CODE (_p1))
10951 : {
10952 0 : case VEC_COND_EXPR:
10953 0 : {
10954 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10955 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10956 0 : tree _q32 = TREE_OPERAND (_p1, 2);
10957 0 : {
10958 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
10959 0 : if (VECTOR_TYPE_P (type)
10960 0 : && (TREE_CODE_CLASS (MAX_EXPR) != tcc_comparison
10961 : || types_match (type, TREE_TYPE (captures[3]))
10962 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
10963 : || (optimize_vectors_before_lowering_p ()
10964 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
10965 : )
10966 : {
10967 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1749;
10968 0 : {
10969 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1749;
10970 0 : tree res_op0;
10971 0 : res_op0 = captures[2];
10972 0 : tree res_op1;
10973 0 : {
10974 0 : tree _o1[2], _r1;
10975 0 : _o1[0] = unshare_expr (captures[0]);
10976 0 : _o1[1] = captures[3];
10977 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
10978 0 : if (EXPR_P (_r1))
10979 0 : goto next_after_fail1749;
10980 0 : res_op1 = _r1;
10981 : }
10982 0 : tree res_op2;
10983 0 : {
10984 0 : tree _o1[2], _r1;
10985 0 : _o1[0] = captures[0];
10986 0 : _o1[1] = captures[4];
10987 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
10988 0 : if (EXPR_P (_r1))
10989 0 : goto next_after_fail1749;
10990 0 : res_op2 = _r1;
10991 : }
10992 0 : tree _r;
10993 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10994 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
10995 0 : return _r;
10996 : }
10997 0 : next_after_fail1749:;
10998 : }
10999 : }
11000 0 : break;
11001 : }
11002 379749 : default:;
11003 : }
11004 379749 : if (tree_zero_one_valued_p (_p0))
11005 : {
11006 10 : if (tree_zero_one_valued_p (_p1))
11007 : {
11008 0 : {
11009 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
11010 0 : tree res = generic_simplify_531 (loc, type, _p0, _p1, captures, MAX_EXPR, BIT_IOR_EXPR);
11011 0 : if (res) return res;
11012 : }
11013 : }
11014 : }
11015 : return NULL_TREE;
11016 : }
11017 :
11018 : tree
11019 407215 : generic_simplify_UNGE_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
11020 : {
11021 407215 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
11022 407215 : switch (TREE_CODE (_p0))
11023 : {
11024 0 : case VEC_COND_EXPR:
11025 0 : {
11026 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11027 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11028 0 : tree _q22 = TREE_OPERAND (_p0, 2);
11029 0 : switch (TREE_CODE (_p1))
11030 : {
11031 0 : case VEC_COND_EXPR:
11032 0 : {
11033 0 : tree _q60 = TREE_OPERAND (_p1, 0);
11034 0 : tree _q61 = TREE_OPERAND (_p1, 1);
11035 0 : tree _q62 = TREE_OPERAND (_p1, 2);
11036 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
11037 : {
11038 0 : {
11039 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
11040 0 : if (VECTOR_TYPE_P (type)
11041 0 : && (TREE_CODE_CLASS (UNGE_EXPR) != tcc_comparison
11042 0 : || types_match (type, TREE_TYPE (captures[2]))
11043 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
11044 : || (optimize_vectors_before_lowering_p ()
11045 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
11046 : )
11047 : {
11048 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1771;
11049 0 : {
11050 0 : tree res_op0;
11051 0 : res_op0 = captures[1];
11052 0 : tree res_op1;
11053 0 : {
11054 0 : tree _o1[2], _r1;
11055 0 : _o1[0] = captures[2];
11056 0 : _o1[1] = captures[5];
11057 0 : _r1 = fold_build2_loc (loc, UNGE_EXPR, type, _o1[0], _o1[1]);
11058 0 : if (EXPR_P (_r1))
11059 0 : goto next_after_fail1771;
11060 0 : res_op1 = _r1;
11061 : }
11062 0 : tree res_op2;
11063 0 : {
11064 0 : tree _o1[2], _r1;
11065 0 : _o1[0] = captures[3];
11066 0 : _o1[1] = captures[6];
11067 0 : _r1 = fold_build2_loc (loc, UNGE_EXPR, type, _o1[0], _o1[1]);
11068 0 : if (EXPR_P (_r1))
11069 0 : goto next_after_fail1771;
11070 0 : res_op2 = _r1;
11071 : }
11072 0 : tree _r;
11073 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11074 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 890, __FILE__, __LINE__, true);
11075 0 : return _r;
11076 : }
11077 0 : next_after_fail1771:;
11078 : }
11079 : }
11080 : }
11081 : break;
11082 : }
11083 0 : default:;
11084 : }
11085 0 : {
11086 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
11087 0 : if (VECTOR_TYPE_P (type)
11088 0 : && (TREE_CODE_CLASS (UNGE_EXPR) != tcc_comparison
11089 0 : || types_match (type, TREE_TYPE (captures[2]))
11090 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
11091 : || (optimize_vectors_before_lowering_p ()
11092 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
11093 : )
11094 : {
11095 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1772;
11096 0 : {
11097 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1772;
11098 0 : tree res_op0;
11099 0 : res_op0 = captures[1];
11100 0 : tree res_op1;
11101 0 : {
11102 0 : tree _o1[2], _r1;
11103 0 : _o1[0] = captures[2];
11104 0 : _o1[1] = unshare_expr (captures[4]);
11105 0 : _r1 = fold_build2_loc (loc, UNGE_EXPR, type, _o1[0], _o1[1]);
11106 0 : if (EXPR_P (_r1))
11107 0 : goto next_after_fail1772;
11108 0 : res_op1 = _r1;
11109 : }
11110 0 : tree res_op2;
11111 0 : {
11112 0 : tree _o1[2], _r1;
11113 0 : _o1[0] = captures[3];
11114 0 : _o1[1] = captures[4];
11115 0 : _r1 = fold_build2_loc (loc, UNGE_EXPR, type, _o1[0], _o1[1]);
11116 0 : if (EXPR_P (_r1))
11117 0 : goto next_after_fail1772;
11118 0 : res_op2 = _r1;
11119 : }
11120 0 : tree _r;
11121 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11122 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
11123 0 : return _r;
11124 : }
11125 0 : next_after_fail1772:;
11126 : }
11127 : }
11128 0 : break;
11129 : }
11130 407215 : default:;
11131 : }
11132 407215 : switch (TREE_CODE (_p1))
11133 : {
11134 0 : case VEC_COND_EXPR:
11135 0 : {
11136 0 : tree _q30 = TREE_OPERAND (_p1, 0);
11137 0 : tree _q31 = TREE_OPERAND (_p1, 1);
11138 0 : tree _q32 = TREE_OPERAND (_p1, 2);
11139 0 : {
11140 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
11141 0 : if (VECTOR_TYPE_P (type)
11142 0 : && (TREE_CODE_CLASS (UNGE_EXPR) != tcc_comparison
11143 0 : || types_match (type, TREE_TYPE (captures[3]))
11144 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
11145 : || (optimize_vectors_before_lowering_p ()
11146 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
11147 : )
11148 : {
11149 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1773;
11150 0 : {
11151 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1773;
11152 0 : tree res_op0;
11153 0 : res_op0 = captures[2];
11154 0 : tree res_op1;
11155 0 : {
11156 0 : tree _o1[2], _r1;
11157 0 : _o1[0] = unshare_expr (captures[0]);
11158 0 : _o1[1] = captures[3];
11159 0 : _r1 = fold_build2_loc (loc, UNGE_EXPR, type, _o1[0], _o1[1]);
11160 0 : if (EXPR_P (_r1))
11161 0 : goto next_after_fail1773;
11162 0 : res_op1 = _r1;
11163 : }
11164 0 : tree res_op2;
11165 0 : {
11166 0 : tree _o1[2], _r1;
11167 0 : _o1[0] = captures[0];
11168 0 : _o1[1] = captures[4];
11169 0 : _r1 = fold_build2_loc (loc, UNGE_EXPR, type, _o1[0], _o1[1]);
11170 0 : if (EXPR_P (_r1))
11171 0 : goto next_after_fail1773;
11172 0 : res_op2 = _r1;
11173 : }
11174 0 : tree _r;
11175 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11176 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
11177 0 : return _r;
11178 : }
11179 0 : next_after_fail1773:;
11180 : }
11181 : }
11182 0 : break;
11183 : }
11184 407215 : default:;
11185 : }
11186 407215 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
11187 : {
11188 30 : {
11189 30 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
11190 30 : tree res = generic_simplify_562 (loc, type, _p0, _p1, captures, UNGE_EXPR);
11191 30 : if (res) return res;
11192 : }
11193 : }
11194 407185 : switch (TREE_CODE (_p0))
11195 : {
11196 299 : case FLOAT_EXPR:
11197 299 : {
11198 299 : tree _q20 = TREE_OPERAND (_p0, 0);
11199 299 : switch (TREE_CODE (_p1))
11200 : {
11201 0 : case FLOAT_EXPR:
11202 0 : {
11203 0 : tree _q40 = TREE_OPERAND (_p1, 0);
11204 0 : {
11205 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
11206 0 : tree res = generic_simplify_260 (loc, type, _p0, _p1, captures, UNGE_EXPR, GE_EXPR);
11207 0 : if (res) return res;
11208 : }
11209 0 : break;
11210 : }
11211 : default:;
11212 : }
11213 : break;
11214 : }
11215 112 : case NEGATE_EXPR:
11216 112 : {
11217 112 : tree _q20 = TREE_OPERAND (_p0, 0);
11218 112 : switch (TREE_CODE (_p1))
11219 : {
11220 0 : case NEGATE_EXPR:
11221 0 : {
11222 0 : tree _q40 = TREE_OPERAND (_p1, 0);
11223 0 : {
11224 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
11225 0 : tree res = generic_simplify_263 (loc, type, _p0, _p1, captures, UNGE_EXPR, UNLE_EXPR);
11226 0 : if (res) return res;
11227 : }
11228 0 : break;
11229 : }
11230 112 : default:;
11231 : }
11232 112 : if (CONSTANT_CLASS_P (_p1))
11233 : {
11234 112 : {
11235 112 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
11236 112 : tree res = generic_simplify_264 (loc, type, _p0, _p1, captures, UNGE_EXPR, UNLE_EXPR);
11237 112 : if (res) return res;
11238 : }
11239 : }
11240 : break;
11241 : }
11242 407073 : default:;
11243 : }
11244 407073 : switch (TREE_CODE (_p1))
11245 : {
11246 53837 : case REAL_CST:
11247 53837 : {
11248 53837 : {
11249 53837 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
11250 53837 : tree res = generic_simplify_560 (loc, type, _p0, _p1, captures, UNGE_EXPR);
11251 53837 : if (res) return res;
11252 : }
11253 53835 : break;
11254 : }
11255 : default:;
11256 : }
11257 : return NULL_TREE;
11258 : }
11259 :
11260 : tree
11261 593374222 : generic_simplify (location_t loc, enum tree_code code, const tree type ATTRIBUTE_UNUSED, tree _p0, tree _p1)
11262 : {
11263 593374222 : switch (code)
11264 : {
11265 987939 : case BIT_XOR_EXPR:
11266 987939 : return generic_simplify_BIT_XOR_EXPR (loc, code, type, _p0, _p1);
11267 95738625 : case PLUS_EXPR:
11268 95738625 : return generic_simplify_PLUS_EXPR (loc, code, type, _p0, _p1);
11269 49336237 : case POINTER_PLUS_EXPR:
11270 49336237 : return generic_simplify_POINTER_PLUS_EXPR (loc, code, type, _p0, _p1);
11271 32388294 : case MINUS_EXPR:
11272 32388294 : return generic_simplify_MINUS_EXPR (loc, code, type, _p0, _p1);
11273 1843764 : case BIT_IOR_EXPR:
11274 1843764 : return generic_simplify_BIT_IOR_EXPR (loc, code, type, _p0, _p1);
11275 2868250 : case POINTER_DIFF_EXPR:
11276 2868250 : return generic_simplify_POINTER_DIFF_EXPR (loc, code, type, _p0, _p1);
11277 70109507 : case MULT_EXPR:
11278 70109507 : return generic_simplify_MULT_EXPR (loc, code, type, _p0, _p1);
11279 26531486 : case EQ_EXPR:
11280 26531486 : return generic_simplify_EQ_EXPR (loc, code, type, _p0, _p1);
11281 35979698 : case NE_EXPR:
11282 35979698 : return generic_simplify_NE_EXPR (loc, code, type, _p0, _p1);
11283 2202070 : case TRUNC_DIV_EXPR:
11284 2202070 : return generic_simplify_TRUNC_DIV_EXPR (loc, code, type, _p0, _p1);
11285 6962 : case CEIL_DIV_EXPR:
11286 6962 : return generic_simplify_CEIL_DIV_EXPR (loc, code, type, _p0, _p1);
11287 2190885 : case FLOOR_DIV_EXPR:
11288 2190885 : return generic_simplify_FLOOR_DIV_EXPR (loc, code, type, _p0, _p1);
11289 0 : case ROUND_DIV_EXPR:
11290 0 : return generic_simplify_ROUND_DIV_EXPR (loc, code, type, _p0, _p1);
11291 3391389 : case EXACT_DIV_EXPR:
11292 3391389 : return generic_simplify_EXACT_DIV_EXPR (loc, code, type, _p0, _p1);
11293 852973 : case FLOOR_MOD_EXPR:
11294 852973 : return generic_simplify_FLOOR_MOD_EXPR (loc, code, type, _p0, _p1);
11295 6192347 : case RDIV_EXPR:
11296 6192347 : return generic_simplify_RDIV_EXPR (loc, code, type, _p0, _p1);
11297 17653954 : case LT_EXPR:
11298 17653954 : return generic_simplify_LT_EXPR (loc, code, type, _p0, _p1);
11299 9246556 : case LE_EXPR:
11300 9246556 : return generic_simplify_LE_EXPR (loc, code, type, _p0, _p1);
11301 20215451 : case GT_EXPR:
11302 20215451 : return generic_simplify_GT_EXPR (loc, code, type, _p0, _p1);
11303 6569041 : case GE_EXPR:
11304 6569041 : return generic_simplify_GE_EXPR (loc, code, type, _p0, _p1);
11305 4104 : case CEIL_MOD_EXPR:
11306 4104 : return generic_simplify_CEIL_MOD_EXPR (loc, code, type, _p0, _p1);
11307 0 : case ROUND_MOD_EXPR:
11308 0 : return generic_simplify_ROUND_MOD_EXPR (loc, code, type, _p0, _p1);
11309 2049550 : case TRUNC_MOD_EXPR:
11310 2049550 : return generic_simplify_TRUNC_MOD_EXPR (loc, code, type, _p0, _p1);
11311 1246591 : case LSHIFT_EXPR:
11312 1246591 : return generic_simplify_LSHIFT_EXPR (loc, code, type, _p0, _p1);
11313 950674 : case RSHIFT_EXPR:
11314 950674 : return generic_simplify_RSHIFT_EXPR (loc, code, type, _p0, _p1);
11315 6743155 : case BIT_AND_EXPR:
11316 6743155 : return generic_simplify_BIT_AND_EXPR (loc, code, type, _p0, _p1);
11317 80513 : case MIN_EXPR:
11318 80513 : return generic_simplify_MIN_EXPR (loc, code, type, _p0, _p1);
11319 379764 : case MAX_EXPR:
11320 379764 : return generic_simplify_MAX_EXPR (loc, code, type, _p0, _p1);
11321 1908 : case LROTATE_EXPR:
11322 1908 : return generic_simplify_LROTATE_EXPR (loc, code, type, _p0, _p1);
11323 2784 : case RROTATE_EXPR:
11324 2784 : return generic_simplify_RROTATE_EXPR (loc, code, type, _p0, _p1);
11325 569150 : case COMPLEX_EXPR:
11326 569150 : return generic_simplify_COMPLEX_EXPR (loc, code, type, _p0, _p1);
11327 737730 : case UNORDERED_EXPR:
11328 737730 : return generic_simplify_UNORDERED_EXPR (loc, code, type, _p0, _p1);
11329 192441 : case ORDERED_EXPR:
11330 192441 : return generic_simplify_ORDERED_EXPR (loc, code, type, _p0, _p1);
11331 702480 : case UNLT_EXPR:
11332 702480 : return generic_simplify_UNLT_EXPR (loc, code, type, _p0, _p1);
11333 847128 : case UNLE_EXPR:
11334 847128 : return generic_simplify_UNLE_EXPR (loc, code, type, _p0, _p1);
11335 1251190 : case UNGT_EXPR:
11336 1251190 : return generic_simplify_UNGT_EXPR (loc, code, type, _p0, _p1);
11337 407215 : case UNGE_EXPR:
11338 407215 : return generic_simplify_UNGE_EXPR (loc, code, type, _p0, _p1);
11339 349656 : case UNEQ_EXPR:
11340 349656 : return generic_simplify_UNEQ_EXPR (loc, code, type, _p0, _p1);
11341 79 : case LTGT_EXPR:
11342 79 : return generic_simplify_LTGT_EXPR (loc, code, type, _p0, _p1);
11343 3231600 : case TRUTH_ORIF_EXPR:
11344 3231600 : return generic_simplify_TRUTH_ORIF_EXPR (loc, code, type, _p0, _p1);
11345 9301019 : case TRUTH_OR_EXPR:
11346 9301019 : return generic_simplify_TRUTH_OR_EXPR (loc, code, type, _p0, _p1);
11347 : default:;
11348 : }
11349 : return NULL_TREE;
11350 : }
11351 :
11352 : tree
11353 14829 : generic_simplify_BIT_INSERT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1, tree _p2)
11354 : {
11355 14829 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
11356 14829 : switch (TREE_CODE (_p1))
11357 : {
11358 0 : case BIT_FIELD_REF:
11359 0 : {
11360 0 : tree _q30 = TREE_OPERAND (_p1, 0);
11361 0 : tree _q31 = TREE_OPERAND (_p1, 1);
11362 0 : tree _q32 = TREE_OPERAND (_p1, 2);
11363 0 : {
11364 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32, _p2 };
11365 0 : if (VECTOR_TYPE_P (type)
11366 0 : && (VECTOR_MODE_P (TYPE_MODE (type))
11367 : || optimize_vectors_before_lowering_p ())
11368 0 : && operand_equal_p (TYPE_SIZE (TREE_TYPE (captures[0])),
11369 0 : TYPE_SIZE (TREE_TYPE (captures[2])), 0)
11370 0 : && types_match (TREE_TYPE (TREE_TYPE (captures[0])), TREE_TYPE (captures[1]))
11371 0 : && TYPE_VECTOR_SUBPARTS (type).is_constant ()
11372 0 : && multiple_p (wi::to_poly_offset (captures[4]),
11373 0 : wi::to_poly_offset (TYPE_SIZE (TREE_TYPE (type))))
11374 : )
11375 : {
11376 0 : {
11377 0 : unsigned HOST_WIDE_INT elsz
11378 0 : = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0]))));
11379 0 : poly_uint64 relt = exact_div (tree_to_poly_uint64 (captures[4]), elsz);
11380 0 : poly_uint64 ielt = exact_div (tree_to_poly_uint64 (captures[5]), elsz);
11381 0 : unsigned nunits = TYPE_VECTOR_SUBPARTS (type).to_constant ();
11382 0 : vec_perm_builder builder;
11383 0 : builder.new_vector (nunits, nunits, 1);
11384 0 : for (unsigned i = 0; i < nunits; ++i)
11385 0 : builder.quick_push (known_eq (ielt, i) ? nunits + relt : i);
11386 0 : vec_perm_indices sel (builder, 2, nunits);
11387 0 : if (!VECTOR_MODE_P (TYPE_MODE (type))
11388 0 : || can_vec_perm_const_p (TYPE_MODE (type),
11389 0 : TYPE_MODE (type), sel, false)
11390 : )
11391 : {
11392 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1965;
11393 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1965;
11394 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1965;
11395 0 : {
11396 0 : tree res_op0;
11397 0 : res_op0 = captures[0];
11398 0 : tree res_op1;
11399 0 : {
11400 0 : tree _o1[1], _r1;
11401 0 : _o1[0] = captures[2];
11402 0 : if (TREE_TYPE (_o1[0]) != type)
11403 : {
11404 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
11405 : }
11406 : else
11407 : _r1 = _o1[0];
11408 0 : res_op1 = _r1;
11409 : }
11410 0 : tree res_op2;
11411 0 : res_op2 = vec_perm_indices_to_tree (build_vector_type (ssizetype, nunits),
11412 : sel);
11413 0 : tree _r;
11414 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
11415 0 : if (TREE_SIDE_EFFECTS (captures[3]))
11416 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
11417 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1095, __FILE__, __LINE__, true);
11418 0 : return _r;
11419 : }
11420 0 : next_after_fail1965:;
11421 : }
11422 0 : }
11423 : }
11424 : }
11425 0 : break;
11426 : }
11427 : default:;
11428 : }
11429 : return NULL_TREE;
11430 : }
11431 :
11432 : tree
11433 773029 : generic_simplify_VEC_PERM_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1, tree _p2)
11434 : {
11435 773029 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
11436 773029 : switch (TREE_CODE (_p0))
11437 : {
11438 0 : case PLUS_EXPR:
11439 0 : {
11440 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11441 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11442 0 : switch (TREE_CODE (_p1))
11443 : {
11444 0 : case MINUS_EXPR:
11445 0 : {
11446 0 : tree _q50 = TREE_OPERAND (_p1, 0);
11447 0 : tree _q51 = TREE_OPERAND (_p1, 1);
11448 0 : switch (TREE_CODE (_p2))
11449 : {
11450 0 : case VECTOR_CST:
11451 0 : {
11452 0 : {
11453 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51, _p2 };
11454 0 : tree res = generic_simplify_621 (loc, type, _p0, _p1, _p2, captures, PLUS_EXPR, MINUS_EXPR);
11455 0 : if (res) return res;
11456 : }
11457 0 : break;
11458 : }
11459 : default:;
11460 : }
11461 : break;
11462 : }
11463 : default:;
11464 : }
11465 : break;
11466 : }
11467 0 : case MINUS_EXPR:
11468 0 : {
11469 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11470 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11471 0 : switch (TREE_CODE (_p1))
11472 : {
11473 0 : case PLUS_EXPR:
11474 0 : {
11475 0 : tree _q50 = TREE_OPERAND (_p1, 0);
11476 0 : tree _q51 = TREE_OPERAND (_p1, 1);
11477 0 : switch (TREE_CODE (_p2))
11478 : {
11479 0 : case VECTOR_CST:
11480 0 : {
11481 0 : {
11482 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51, _p2 };
11483 0 : tree res = generic_simplify_621 (loc, type, _p0, _p1, _p2, captures, MINUS_EXPR, PLUS_EXPR);
11484 0 : if (res) return res;
11485 : }
11486 0 : break;
11487 : }
11488 : default:;
11489 : }
11490 : break;
11491 : }
11492 : default:;
11493 : }
11494 : break;
11495 : }
11496 773029 : default:;
11497 : }
11498 773029 : switch (TREE_CODE (_p2))
11499 : {
11500 761697 : case VECTOR_CST:
11501 761697 : {
11502 761697 : {
11503 761697 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _p2 };
11504 761697 : {
11505 761697 : tree op0 = captures[0], op1 = captures[1], op2 = captures[2];
11506 761697 : machine_mode result_mode = TYPE_MODE (type);
11507 761697 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (op0));
11508 761697 : vec_perm_builder builder;
11509 761697 : if (tree_to_vec_perm_builder (&builder, op2)
11510 : )
11511 : {
11512 761685 : {
11513 761685 : poly_uint64 nelts = TYPE_VECTOR_SUBPARTS (type);
11514 761685 : poly_uint64 nelts_in = TYPE_VECTOR_SUBPARTS (TREE_TYPE (op0));
11515 761685 : bool single_arg = (op0 == op1);
11516 1327834 : vec_perm_indices sel (builder, single_arg ? 1 : 2, nelts_in);
11517 761685 : if (known_eq (nelts, nelts_in) && sel.series_p (0, 1, 0, 1)
11518 : )
11519 : {
11520 8426 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1966;
11521 8426 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1966;
11522 8426 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1966;
11523 8426 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1966;
11524 8426 : {
11525 8426 : tree res_op0;
11526 8426 : res_op0 = captures[0];
11527 8426 : tree _r;
11528 8426 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11529 8426 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1096, __FILE__, __LINE__, true);
11530 8426 : return _r;
11531 : }
11532 735793 : next_after_fail1966:;
11533 : }
11534 : else
11535 : {
11536 753259 : if (known_eq (nelts, nelts_in) && sel.series_p (0, 1, nelts_in, 1)
11537 : )
11538 : {
11539 13 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1967;
11540 13 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1967;
11541 13 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1967;
11542 13 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1967;
11543 13 : {
11544 13 : tree res_op0;
11545 13 : res_op0 = captures[1];
11546 13 : tree _r;
11547 13 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11548 13 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1097, __FILE__, __LINE__, true);
11549 13 : return _r;
11550 : }
11551 735793 : next_after_fail1967:;
11552 : }
11553 : else
11554 : {
11555 753246 : {
11556 753246 : if (!single_arg)
11557 : {
11558 558386 : if (sel.all_from_input_p (0))
11559 : op1 = op0;
11560 551363 : else if (sel.all_from_input_p (1))
11561 : {
11562 32 : op0 = op1;
11563 32 : sel.rotate_inputs (1);
11564 : }
11565 551331 : else if (known_ge (poly_uint64 (sel[0]), nelts_in))
11566 : {
11567 153 : std::swap (op0, op1);
11568 153 : sel.rotate_inputs (1);
11569 : }
11570 : }
11571 753246 : gassign *def;
11572 753246 : tree cop0 = op0, cop1 = op1;
11573 753246 : if (TREE_CODE (op0) == SSA_NAME
11574 720249 : && (def = dyn_cast <gassign *> (SSA_NAME_DEF_STMT (op0)))
11575 1439175 : && gimple_assign_rhs_code (def) == CONSTRUCTOR)
11576 6861 : cop0 = gimple_assign_rhs1 (def);
11577 753246 : if (TREE_CODE (op1) == SSA_NAME
11578 706731 : && (def = dyn_cast <gassign *> (SSA_NAME_DEF_STMT (op1)))
11579 1426886 : && gimple_assign_rhs_code (def) == CONSTRUCTOR)
11580 13483 : cop1 = gimple_assign_rhs1 (def);
11581 753246 : tree t;
11582 753246 : if ((TREE_CODE (cop0) == VECTOR_CST
11583 723739 : || TREE_CODE (cop0) == CONSTRUCTOR)
11584 37215 : && (TREE_CODE (cop1) == VECTOR_CST
11585 18418 : || TREE_CODE (cop1) == CONSTRUCTOR)
11586 778055 : && (t = fold_vec_perm (type, cop0, cop1, sel))
11587 : )
11588 : {
11589 15021 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1968;
11590 15021 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1968;
11591 15021 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1968;
11592 15021 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1968;
11593 15021 : {
11594 15021 : tree _r;
11595 15021 : _r = t;
11596 15021 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1098, __FILE__, __LINE__, true);
11597 15021 : return _r;
11598 : }
11599 735793 : next_after_fail1968:;
11600 : }
11601 : else
11602 : {
11603 738225 : {
11604 738225 : bool changed = (op0 == op1 && !single_arg);
11605 738225 : tree ins = NULL_TREE;
11606 738225 : unsigned at = 0;
11607 738225 : if (op_mode != BLKmode
11608 729220 : && known_eq (nelts, nelts_in)
11609 1467292 : && (TREE_CODE (cop0) == VECTOR_CST
11610 713658 : || TREE_CODE (cop0) == CONSTRUCTOR
11611 709217 : || TREE_CODE (cop1) == VECTOR_CST
11612 684917 : || TREE_CODE (cop1) == CONSTRUCTOR))
11613 : {
11614 51881 : bool insert_first_p = sel.series_p (1, 1, nelts + 1, 1);
11615 51881 : if (insert_first_p)
11616 : {
11617 778 : at = 0;
11618 778 : if ((ins = fold_read_from_vector (cop0, sel[0])))
11619 115 : op0 = op1;
11620 : }
11621 778 : if (!insert_first_p || (!ins && maybe_eq (nelts, 2u)))
11622 : {
11623 51567 : unsigned int encoded_nelts = sel.encoding ().encoded_nelts ();
11624 105705 : for (at = 0; at < encoded_nelts; ++at)
11625 105579 : if (maybe_ne (sel[at], at))
11626 : break;
11627 51567 : if (at < encoded_nelts
11628 51567 : && (known_eq (at + 1, nelts)
11629 50361 : || sel.series_p (at + 1, 1, at + 1, 1)))
11630 : {
11631 1787 : if (known_lt (poly_uint64 (sel[at]), nelts))
11632 0 : ins = fold_read_from_vector (cop0, sel[at]);
11633 : else
11634 1787 : ins = fold_read_from_vector (cop1, sel[at] - nelts);
11635 : }
11636 : }
11637 : }
11638 738225 : if (!ins && sel.encoding () != builder)
11639 : {
11640 1128 : tree oldop2 = op2;
11641 1128 : if (sel.ninputs () == 2
11642 1128 : || can_vec_perm_const_p (result_mode, op_mode, sel, false))
11643 689 : op2 = vec_perm_indices_to_tree (TREE_TYPE (op2), sel);
11644 : else
11645 : {
11646 439 : vec_perm_indices sel2 (builder, 2, nelts);
11647 439 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false))
11648 164 : op2 = vec_perm_indices_to_tree (TREE_TYPE (op2), sel2);
11649 : else
11650 275 : op2 = vec_perm_indices_to_tree (TREE_TYPE (op2), sel);
11651 439 : }
11652 1128 : if (!operand_equal_p (op2, oldop2, 0))
11653 964 : changed = true;
11654 : }
11655 738225 : if (ins
11656 : )
11657 : {
11658 1467 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1969;
11659 1467 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1969;
11660 1467 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1969;
11661 1467 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1969;
11662 1467 : {
11663 1467 : tree res_op0;
11664 1467 : res_op0 = op0;
11665 1467 : tree res_op1;
11666 1467 : res_op1 = ins;
11667 1467 : tree res_op2;
11668 1467 : res_op2 = bitsize_int (at * vector_element_bits (type));
11669 1467 : tree _r;
11670 1467 : _r = fold_build3_loc (loc, BIT_INSERT_EXPR, type, res_op0, res_op1, res_op2);
11671 1467 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1099, __FILE__, __LINE__, true);
11672 25892 : return _r;
11673 : }
11674 : next_after_fail1969:;
11675 : }
11676 : else
11677 : {
11678 736758 : if (changed
11679 : )
11680 : {
11681 965 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1970;
11682 965 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1970;
11683 965 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1970;
11684 965 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1970;
11685 965 : {
11686 965 : tree res_op0;
11687 965 : res_op0 = op0;
11688 965 : tree res_op1;
11689 965 : res_op1 = op1;
11690 965 : tree res_op2;
11691 965 : res_op2 = op2;
11692 965 : tree _r;
11693 965 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
11694 965 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1100, __FILE__, __LINE__, true);
11695 965 : return _r;
11696 : }
11697 : next_after_fail1970:;
11698 : }
11699 : }
11700 : }
11701 : }
11702 : }
11703 : }
11704 : }
11705 761685 : }
11706 : }
11707 25892 : }
11708 : }
11709 735805 : break;
11710 : }
11711 747137 : default:;
11712 : }
11713 747137 : switch (TREE_CODE (_p0))
11714 : {
11715 0 : case VIEW_CONVERT_EXPR:
11716 0 : {
11717 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11718 0 : switch (TREE_CODE (_q20))
11719 : {
11720 0 : case VEC_PERM_EXPR:
11721 0 : {
11722 0 : tree _q30 = TREE_OPERAND (_q20, 0);
11723 0 : tree _q31 = TREE_OPERAND (_q20, 1);
11724 0 : tree _q32 = TREE_OPERAND (_q20, 2);
11725 0 : switch (TREE_CODE (_q32))
11726 : {
11727 0 : case VECTOR_CST:
11728 0 : {
11729 0 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
11730 : {
11731 0 : switch (TREE_CODE (_p2))
11732 : {
11733 0 : case VECTOR_CST:
11734 0 : {
11735 0 : {
11736 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q32, _p2 };
11737 0 : if (TYPE_VECTOR_SUBPARTS (type).is_constant ()
11738 : )
11739 : {
11740 0 : {
11741 0 : machine_mode result_mode = TYPE_MODE (type);
11742 0 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (captures[2]));
11743 0 : int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
11744 0 : vec_perm_builder builder0;
11745 0 : vec_perm_builder builder1;
11746 0 : vec_perm_builder builder2 (nelts, nelts, 1);
11747 0 : if (tree_to_vec_perm_builder (&builder0, captures[4])
11748 0 : && tree_to_vec_perm_builder (&builder1, captures[5])
11749 0 : && TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0])))
11750 0 : == TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[1])))
11751 : )
11752 : {
11753 0 : {
11754 0 : vec_perm_indices sel0 (builder0, 2, nelts);
11755 0 : vec_perm_indices sel1 (builder1, 2, nelts);
11756 0 : for (int i = 0; i < nelts; i++)
11757 0 : builder2.quick_push (sel0[sel1[i].to_constant ()]);
11758 0 : vec_perm_indices sel2 (builder2, 2, nelts);
11759 0 : tree op0 = NULL_TREE;
11760 0 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false)
11761 0 : || (single_use (captures[0])
11762 0 : ? (!can_vec_perm_const_p (result_mode, op_mode, sel0, false)
11763 0 : || !can_vec_perm_const_p (result_mode, op_mode, sel1, false))
11764 : : !can_vec_perm_const_p (result_mode, op_mode, sel1, false)))
11765 0 : op0 = vec_perm_indices_to_tree (TREE_TYPE (captures[5]), sel2);
11766 0 : if (op0
11767 : )
11768 : {
11769 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1971;
11770 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1971;
11771 0 : {
11772 0 : tree res_op0;
11773 0 : {
11774 0 : tree _o1[3], _r1;
11775 0 : _o1[0] = captures[2];
11776 0 : _o1[1] = captures[3];
11777 0 : _o1[2] = op0;
11778 0 : _r1 = fold_build3_loc (loc, VEC_PERM_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1], _o1[2]);
11779 0 : res_op0 = _r1;
11780 : }
11781 0 : tree _r;
11782 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11783 0 : if (TREE_SIDE_EFFECTS (captures[4]))
11784 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
11785 0 : if (TREE_SIDE_EFFECTS (captures[5]))
11786 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
11787 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1101, __FILE__, __LINE__, true);
11788 0 : return _r;
11789 : }
11790 0 : next_after_fail1971:;
11791 : }
11792 0 : }
11793 : }
11794 0 : }
11795 : }
11796 : }
11797 0 : break;
11798 : }
11799 : default:;
11800 : }
11801 : }
11802 : break;
11803 : }
11804 : default:;
11805 : }
11806 : break;
11807 : }
11808 : default:;
11809 : }
11810 : break;
11811 : }
11812 0 : case VEC_PERM_EXPR:
11813 0 : {
11814 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11815 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11816 0 : tree _q22 = TREE_OPERAND (_p0, 2);
11817 0 : switch (TREE_CODE (_q22))
11818 : {
11819 0 : case VECTOR_CST:
11820 0 : {
11821 0 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
11822 : {
11823 0 : switch (TREE_CODE (_p2))
11824 : {
11825 0 : case VECTOR_CST:
11826 0 : {
11827 0 : {
11828 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _q22, _p2 };
11829 0 : if (TYPE_VECTOR_SUBPARTS (type).is_constant ()
11830 : )
11831 : {
11832 0 : {
11833 0 : machine_mode result_mode = TYPE_MODE (type);
11834 0 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (captures[2]));
11835 0 : int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
11836 0 : vec_perm_builder builder0;
11837 0 : vec_perm_builder builder1;
11838 0 : vec_perm_builder builder2 (nelts, nelts, 1);
11839 0 : if (tree_to_vec_perm_builder (&builder0, captures[4])
11840 0 : && tree_to_vec_perm_builder (&builder1, captures[5])
11841 0 : && TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0])))
11842 0 : == TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[1])))
11843 : )
11844 : {
11845 0 : {
11846 0 : vec_perm_indices sel0 (builder0, 2, nelts);
11847 0 : vec_perm_indices sel1 (builder1, 2, nelts);
11848 0 : for (int i = 0; i < nelts; i++)
11849 0 : builder2.quick_push (sel0[sel1[i].to_constant ()]);
11850 0 : vec_perm_indices sel2 (builder2, 2, nelts);
11851 0 : tree op0 = NULL_TREE;
11852 0 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false)
11853 0 : || (single_use (captures[0])
11854 0 : ? (!can_vec_perm_const_p (result_mode, op_mode, sel0, false)
11855 0 : || !can_vec_perm_const_p (result_mode, op_mode, sel1, false))
11856 : : !can_vec_perm_const_p (result_mode, op_mode, sel1, false)))
11857 0 : op0 = vec_perm_indices_to_tree (TREE_TYPE (captures[5]), sel2);
11858 0 : if (op0
11859 : )
11860 : {
11861 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1972;
11862 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1972;
11863 0 : {
11864 0 : tree res_op0;
11865 0 : {
11866 0 : tree _o1[3], _r1;
11867 0 : _o1[0] = captures[2];
11868 0 : _o1[1] = captures[3];
11869 0 : _o1[2] = op0;
11870 0 : _r1 = fold_build3_loc (loc, VEC_PERM_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1], _o1[2]);
11871 0 : res_op0 = _r1;
11872 : }
11873 0 : tree _r;
11874 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11875 0 : if (TREE_SIDE_EFFECTS (captures[4]))
11876 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
11877 0 : if (TREE_SIDE_EFFECTS (captures[5]))
11878 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
11879 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1101, __FILE__, __LINE__, true);
11880 0 : return _r;
11881 : }
11882 0 : next_after_fail1972:;
11883 : }
11884 0 : }
11885 : }
11886 0 : }
11887 : }
11888 : }
11889 0 : break;
11890 : }
11891 : default:;
11892 : }
11893 : }
11894 : break;
11895 : }
11896 : default:;
11897 : }
11898 : break;
11899 : }
11900 747137 : default:;
11901 : }
11902 747137 : if (tree_vec_same_elem_p (_p0))
11903 : {
11904 13913 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
11905 : {
11906 0 : {
11907 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p2 };
11908 0 : if (types_match (type, TREE_TYPE (captures[0]))
11909 : )
11910 : {
11911 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1973;
11912 0 : {
11913 0 : tree _r;
11914 0 : _r = captures[0];
11915 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11916 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11917 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1102, __FILE__, __LINE__, true);
11918 0 : return _r;
11919 : }
11920 0 : next_after_fail1973:;
11921 : }
11922 : else
11923 : {
11924 0 : {
11925 0 : tree elem = uniform_vector_p (captures[0]);
11926 0 : if (elem
11927 : )
11928 : {
11929 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1974;
11930 0 : {
11931 0 : tree _r;
11932 0 : _r = build_vector_from_val (type, elem);
11933 0 : if (TREE_SIDE_EFFECTS (captures[0]))
11934 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
11935 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11936 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11937 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1103, __FILE__, __LINE__, true);
11938 0 : return _r;
11939 : }
11940 0 : next_after_fail1974:;
11941 : }
11942 : }
11943 : }
11944 : }
11945 : }
11946 : }
11947 747137 : switch (TREE_CODE (_p1))
11948 : {
11949 0 : case VEC_PERM_EXPR:
11950 0 : {
11951 0 : tree _q30 = TREE_OPERAND (_p1, 0);
11952 0 : tree _q31 = TREE_OPERAND (_p1, 1);
11953 0 : tree _q32 = TREE_OPERAND (_p1, 2);
11954 0 : switch (TREE_CODE (_q32))
11955 : {
11956 0 : case VECTOR_CST:
11957 0 : {
11958 0 : switch (TREE_CODE (_p2))
11959 : {
11960 0 : case VECTOR_CST:
11961 0 : {
11962 0 : {
11963 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32, _p2 };
11964 0 : if (TYPE_VECTOR_SUBPARTS (type).is_constant ()
11965 : )
11966 : {
11967 0 : {
11968 0 : machine_mode result_mode = TYPE_MODE (type);
11969 0 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (captures[2]));
11970 0 : int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
11971 0 : vec_perm_builder builder0;
11972 0 : vec_perm_builder builder1;
11973 0 : vec_perm_builder builder2 (nelts, nelts, 2);
11974 0 : if (tree_to_vec_perm_builder (&builder0, captures[4])
11975 0 : && tree_to_vec_perm_builder (&builder1, captures[5])
11976 : )
11977 : {
11978 0 : {
11979 0 : vec_perm_indices sel0 (builder0, 2, nelts);
11980 0 : vec_perm_indices sel1 (builder1, 2, nelts);
11981 0 : bool use_1 = false, use_2 = false;
11982 0 : for (int i = 0; i < nelts; i++)
11983 : {
11984 0 : if (known_lt ((poly_uint64)sel1[i], sel1.nelts_per_input ()))
11985 0 : builder2.quick_push (sel1[i]);
11986 : else
11987 : {
11988 0 : poly_uint64 j = sel0[(sel1[i] - sel1.nelts_per_input ())
11989 0 : .to_constant ()];
11990 0 : if (known_lt (j, sel0.nelts_per_input ()))
11991 : use_1 = true;
11992 : else
11993 : {
11994 0 : use_2 = true;
11995 0 : j -= sel0.nelts_per_input ();
11996 : }
11997 0 : builder2.quick_push (j + sel1.nelts_per_input ());
11998 : }
11999 : }
12000 0 : if (use_1 ^ use_2
12001 : )
12002 : {
12003 0 : {
12004 0 : vec_perm_indices sel2 (builder2, 2, nelts);
12005 0 : tree op0 = NULL_TREE;
12006 0 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false)
12007 0 : || (single_use (captures[1])
12008 0 : ? (!can_vec_perm_const_p (result_mode, op_mode, sel0, false)
12009 0 : || !can_vec_perm_const_p (result_mode, op_mode, sel1, false))
12010 : : !can_vec_perm_const_p (result_mode, op_mode, sel1, false)))
12011 0 : op0 = vec_perm_indices_to_tree (TREE_TYPE (captures[5]), sel2);
12012 0 : if (op0
12013 : )
12014 : {
12015 0 : if (use_1
12016 : )
12017 : {
12018 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1975;
12019 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1975;
12020 0 : {
12021 0 : tree res_op0;
12022 0 : res_op0 = captures[0];
12023 0 : tree res_op1;
12024 0 : res_op1 = captures[2];
12025 0 : tree res_op2;
12026 0 : res_op2 = op0;
12027 0 : tree _r;
12028 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
12029 0 : if (TREE_SIDE_EFFECTS (captures[3]))
12030 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
12031 0 : if (TREE_SIDE_EFFECTS (captures[4]))
12032 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
12033 0 : if (TREE_SIDE_EFFECTS (captures[5]))
12034 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
12035 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1104, __FILE__, __LINE__, true);
12036 0 : return _r;
12037 : }
12038 0 : next_after_fail1975:;
12039 : }
12040 : else
12041 : {
12042 0 : if (use_2
12043 : )
12044 : {
12045 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1976;
12046 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1976;
12047 0 : {
12048 0 : tree res_op0;
12049 0 : res_op0 = captures[0];
12050 0 : tree res_op1;
12051 0 : res_op1 = captures[3];
12052 0 : tree res_op2;
12053 0 : res_op2 = op0;
12054 0 : tree _r;
12055 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
12056 0 : if (TREE_SIDE_EFFECTS (captures[2]))
12057 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
12058 0 : if (TREE_SIDE_EFFECTS (captures[4]))
12059 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
12060 0 : if (TREE_SIDE_EFFECTS (captures[5]))
12061 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
12062 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1105, __FILE__, __LINE__, true);
12063 0 : return _r;
12064 : }
12065 0 : next_after_fail1976:;
12066 : }
12067 : }
12068 : }
12069 0 : }
12070 : }
12071 0 : }
12072 : }
12073 0 : }
12074 : }
12075 : }
12076 0 : break;
12077 : }
12078 : default:;
12079 : }
12080 : break;
12081 : }
12082 : default:;
12083 : }
12084 : break;
12085 : }
12086 747137 : default:;
12087 : }
12088 747137 : switch (TREE_CODE (_p0))
12089 : {
12090 0 : case VEC_PERM_EXPR:
12091 0 : {
12092 0 : tree _q20 = TREE_OPERAND (_p0, 0);
12093 0 : tree _q21 = TREE_OPERAND (_p0, 1);
12094 0 : tree _q22 = TREE_OPERAND (_p0, 2);
12095 0 : switch (TREE_CODE (_q22))
12096 : {
12097 0 : case VECTOR_CST:
12098 0 : {
12099 0 : switch (TREE_CODE (_p2))
12100 : {
12101 0 : case VECTOR_CST:
12102 0 : {
12103 0 : {
12104 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _p2 };
12105 0 : if (TYPE_VECTOR_SUBPARTS (type).is_constant ()
12106 : )
12107 : {
12108 0 : {
12109 0 : machine_mode result_mode = TYPE_MODE (type);
12110 0 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (captures[1]));
12111 0 : int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
12112 0 : vec_perm_builder builder0;
12113 0 : vec_perm_builder builder1;
12114 0 : vec_perm_builder builder2 (nelts, nelts, 2);
12115 0 : if (tree_to_vec_perm_builder (&builder0, captures[3])
12116 0 : && tree_to_vec_perm_builder (&builder1, captures[5])
12117 : )
12118 : {
12119 0 : {
12120 0 : vec_perm_indices sel0 (builder0, 2, nelts);
12121 0 : vec_perm_indices sel1 (builder1, 2, nelts);
12122 0 : bool use_1 = false, use_2 = false;
12123 0 : for (int i = 0; i < nelts; i++)
12124 : {
12125 0 : if (known_ge ((poly_uint64)sel1[i], sel1.nelts_per_input ()))
12126 0 : builder2.quick_push (sel1[i]);
12127 : else
12128 : {
12129 0 : poly_uint64 j = sel0[sel1[i].to_constant ()];
12130 0 : if (known_lt (j, sel0.nelts_per_input ()))
12131 : use_1 = true;
12132 : else
12133 : {
12134 0 : use_2 = true;
12135 0 : j -= sel0.nelts_per_input ();
12136 : }
12137 0 : builder2.quick_push (j);
12138 : }
12139 : }
12140 0 : if (use_1 ^ use_2
12141 : )
12142 : {
12143 0 : {
12144 0 : vec_perm_indices sel2 (builder2, 2, nelts);
12145 0 : tree op0 = NULL_TREE;
12146 0 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false)
12147 0 : || (single_use (captures[0])
12148 0 : ? (!can_vec_perm_const_p (result_mode, op_mode, sel0, false)
12149 0 : || !can_vec_perm_const_p (result_mode, op_mode, sel1, false))
12150 : : !can_vec_perm_const_p (result_mode, op_mode, sel1, false)))
12151 0 : op0 = vec_perm_indices_to_tree (TREE_TYPE (captures[5]), sel2);
12152 0 : if (op0
12153 : )
12154 : {
12155 0 : if (use_1
12156 : )
12157 : {
12158 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1977;
12159 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1977;
12160 0 : {
12161 0 : tree res_op0;
12162 0 : res_op0 = captures[1];
12163 0 : tree res_op1;
12164 0 : res_op1 = captures[4];
12165 0 : tree res_op2;
12166 0 : res_op2 = op0;
12167 0 : tree _r;
12168 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
12169 0 : if (TREE_SIDE_EFFECTS (captures[2]))
12170 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
12171 0 : if (TREE_SIDE_EFFECTS (captures[3]))
12172 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
12173 0 : if (TREE_SIDE_EFFECTS (captures[5]))
12174 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
12175 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1106, __FILE__, __LINE__, true);
12176 0 : return _r;
12177 : }
12178 0 : next_after_fail1977:;
12179 : }
12180 : else
12181 : {
12182 0 : if (use_2
12183 : )
12184 : {
12185 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1978;
12186 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1978;
12187 0 : {
12188 0 : tree res_op0;
12189 0 : res_op0 = captures[2];
12190 0 : tree res_op1;
12191 0 : res_op1 = captures[4];
12192 0 : tree res_op2;
12193 0 : res_op2 = op0;
12194 0 : tree _r;
12195 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
12196 0 : if (TREE_SIDE_EFFECTS (captures[1]))
12197 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
12198 0 : if (TREE_SIDE_EFFECTS (captures[3]))
12199 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
12200 0 : if (TREE_SIDE_EFFECTS (captures[5]))
12201 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
12202 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1107, __FILE__, __LINE__, true);
12203 0 : return _r;
12204 : }
12205 0 : next_after_fail1978:;
12206 : }
12207 : }
12208 : }
12209 0 : }
12210 : }
12211 0 : }
12212 : }
12213 0 : }
12214 : }
12215 : }
12216 0 : break;
12217 : }
12218 0 : default:;
12219 : }
12220 0 : switch (TREE_CODE (_p1))
12221 : {
12222 0 : case VEC_PERM_EXPR:
12223 0 : {
12224 0 : tree _q60 = TREE_OPERAND (_p1, 0);
12225 0 : tree _q61 = TREE_OPERAND (_p1, 1);
12226 0 : tree _q62 = TREE_OPERAND (_p1, 2);
12227 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
12228 : {
12229 0 : switch (TREE_CODE (_q62))
12230 : {
12231 0 : case VECTOR_CST:
12232 0 : {
12233 0 : switch (TREE_CODE (_p2))
12234 : {
12235 0 : case VECTOR_CST:
12236 0 : {
12237 0 : {
12238 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60, _q61, _p2 };
12239 0 : tree res = generic_simplify_622 (loc, type, _p0, _p1, _p2, captures);
12240 0 : if (res) return res;
12241 : }
12242 0 : break;
12243 : }
12244 : default:;
12245 : }
12246 : break;
12247 : }
12248 : default:;
12249 : }
12250 : }
12251 : break;
12252 : }
12253 : default:;
12254 : }
12255 : break;
12256 : }
12257 : default:;
12258 : }
12259 : break;
12260 : }
12261 0 : case VIEW_CONVERT_EXPR:
12262 0 : {
12263 0 : tree _q20 = TREE_OPERAND (_p0, 0);
12264 0 : switch (TREE_CODE (_q20))
12265 : {
12266 0 : case VEC_PERM_EXPR:
12267 0 : {
12268 0 : tree _q30 = TREE_OPERAND (_q20, 0);
12269 0 : tree _q31 = TREE_OPERAND (_q20, 1);
12270 0 : tree _q32 = TREE_OPERAND (_q20, 2);
12271 0 : switch (TREE_CODE (_q32))
12272 : {
12273 0 : case VECTOR_CST:
12274 0 : {
12275 0 : switch (TREE_CODE (_p1))
12276 : {
12277 0 : case VIEW_CONVERT_EXPR:
12278 0 : {
12279 0 : tree _q70 = TREE_OPERAND (_p1, 0);
12280 0 : switch (TREE_CODE (_q70))
12281 : {
12282 0 : case VEC_PERM_EXPR:
12283 0 : {
12284 0 : tree _q80 = TREE_OPERAND (_q70, 0);
12285 0 : tree _q81 = TREE_OPERAND (_q70, 1);
12286 0 : tree _q82 = TREE_OPERAND (_q70, 2);
12287 0 : if ((_q82 == _q32 && ! TREE_SIDE_EFFECTS (_q82)) || (operand_equal_p (_q82, _q32, 0) && types_match (_q82, _q32)))
12288 : {
12289 0 : switch (TREE_CODE (_q82))
12290 : {
12291 0 : case VECTOR_CST:
12292 0 : {
12293 0 : switch (TREE_CODE (_p2))
12294 : {
12295 0 : case VECTOR_CST:
12296 0 : {
12297 0 : {
12298 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q30, _q31, _q32, _q80, _q81, _p2 };
12299 0 : tree res = generic_simplify_622 (loc, type, _p0, _p1, _p2, captures);
12300 0 : if (res) return res;
12301 : }
12302 0 : break;
12303 : }
12304 : default:;
12305 : }
12306 : break;
12307 : }
12308 : default:;
12309 : }
12310 : }
12311 : break;
12312 : }
12313 : default:;
12314 : }
12315 : break;
12316 : }
12317 : default:;
12318 : }
12319 : break;
12320 : }
12321 : default:;
12322 : }
12323 : break;
12324 : }
12325 : default:;
12326 : }
12327 : break;
12328 : }
12329 : default:;
12330 : }
12331 : return NULL_TREE;
12332 : }
12333 : #pragma GCC diagnostic pop
|
