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 160175258 : tree_truth_valued_p (tree t)
11 : {
12 160175258 : const tree type = TREE_TYPE (t);
13 160175258 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 160175258 : if (TREE_SIDE_EFFECTS (t)) return false;
15 155134503 : {
16 155134503 : tree captures[1] ATTRIBUTE_UNUSED = { t };
17 155134503 : if (INTEGRAL_TYPE_P (type) && TYPE_PRECISION (type) == 1
18 : )
19 : {
20 5719943 : {
21 5719943 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 20, __FILE__, __LINE__, false);
22 5719943 : return true;
23 : }
24 : }
25 : }
26 149414560 : switch (TREE_CODE (t))
27 : {
28 817 : case LT_EXPR:
29 817 : {
30 817 : tree _p0 = TREE_OPERAND (t, 0);
31 817 : tree _p1 = TREE_OPERAND (t, 1);
32 817 : {
33 817 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
34 817 : {
35 817 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
36 817 : return true;
37 : }
38 : }
39 700 : break;
40 : }
41 700 : case LE_EXPR:
42 700 : {
43 700 : tree _p0 = TREE_OPERAND (t, 0);
44 700 : tree _p1 = TREE_OPERAND (t, 1);
45 700 : {
46 700 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
47 700 : {
48 700 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
49 700 : return true;
50 : }
51 : }
52 11673 : break;
53 : }
54 11673 : case EQ_EXPR:
55 11673 : {
56 11673 : tree _p0 = TREE_OPERAND (t, 0);
57 11673 : tree _p1 = TREE_OPERAND (t, 1);
58 11673 : {
59 11673 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
60 11673 : {
61 11673 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
62 11673 : return true;
63 : }
64 : }
65 4445 : break;
66 : }
67 4445 : case NE_EXPR:
68 4445 : {
69 4445 : tree _p0 = TREE_OPERAND (t, 0);
70 4445 : tree _p1 = TREE_OPERAND (t, 1);
71 4445 : {
72 4445 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
73 4445 : {
74 4445 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
75 4445 : return true;
76 : }
77 : }
78 377 : break;
79 : }
80 377 : case GE_EXPR:
81 377 : {
82 377 : tree _p0 = TREE_OPERAND (t, 0);
83 377 : tree _p1 = TREE_OPERAND (t, 1);
84 377 : {
85 377 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
86 377 : {
87 377 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
88 377 : return true;
89 : }
90 : }
91 222399 : break;
92 : }
93 222399 : case GT_EXPR:
94 222399 : {
95 222399 : tree _p0 = TREE_OPERAND (t, 0);
96 222399 : tree _p1 = TREE_OPERAND (t, 1);
97 222399 : {
98 222399 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
99 222399 : {
100 222399 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
101 222399 : return true;
102 : }
103 : }
104 127719 : break;
105 : }
106 127719 : case UNORDERED_EXPR:
107 127719 : {
108 127719 : tree _p0 = TREE_OPERAND (t, 0);
109 127719 : tree _p1 = TREE_OPERAND (t, 1);
110 127719 : {
111 127719 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
112 127719 : {
113 127719 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
114 127719 : return true;
115 : }
116 : }
117 16 : break;
118 : }
119 16 : case ORDERED_EXPR:
120 16 : {
121 16 : tree _p0 = TREE_OPERAND (t, 0);
122 16 : tree _p1 = TREE_OPERAND (t, 1);
123 16 : {
124 16 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
125 16 : {
126 16 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
127 16 : return true;
128 : }
129 : }
130 70 : break;
131 : }
132 70 : case UNLT_EXPR:
133 70 : {
134 70 : tree _p0 = TREE_OPERAND (t, 0);
135 70 : tree _p1 = TREE_OPERAND (t, 1);
136 70 : {
137 70 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
138 70 : {
139 70 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
140 70 : return true;
141 : }
142 : }
143 1157 : break;
144 : }
145 1157 : case UNLE_EXPR:
146 1157 : {
147 1157 : tree _p0 = TREE_OPERAND (t, 0);
148 1157 : tree _p1 = TREE_OPERAND (t, 1);
149 1157 : {
150 1157 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
151 1157 : {
152 1157 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
153 1157 : return true;
154 : }
155 : }
156 70 : break;
157 : }
158 70 : case UNGT_EXPR:
159 70 : {
160 70 : tree _p0 = TREE_OPERAND (t, 0);
161 70 : tree _p1 = TREE_OPERAND (t, 1);
162 70 : {
163 70 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
164 70 : {
165 70 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
166 70 : return true;
167 : }
168 : }
169 70 : break;
170 : }
171 70 : case UNGE_EXPR:
172 70 : {
173 70 : tree _p0 = TREE_OPERAND (t, 0);
174 70 : tree _p1 = TREE_OPERAND (t, 1);
175 70 : {
176 70 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
177 70 : {
178 70 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
179 70 : return true;
180 : }
181 : }
182 84 : break;
183 : }
184 84 : case UNEQ_EXPR:
185 84 : {
186 84 : tree _p0 = TREE_OPERAND (t, 0);
187 84 : tree _p1 = TREE_OPERAND (t, 1);
188 84 : {
189 84 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
190 84 : {
191 84 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
192 84 : return true;
193 : }
194 : }
195 24 : break;
196 : }
197 24 : case LTGT_EXPR:
198 24 : {
199 24 : tree _p0 = TREE_OPERAND (t, 0);
200 24 : tree _p1 = TREE_OPERAND (t, 1);
201 24 : {
202 24 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
203 24 : {
204 24 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
205 24 : return true;
206 : }
207 : }
208 96 : break;
209 : }
210 96 : case TRUTH_AND_EXPR:
211 96 : {
212 96 : tree _p0 = TREE_OPERAND (t, 0);
213 96 : tree _p1 = TREE_OPERAND (t, 1);
214 96 : {
215 96 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
216 96 : {
217 96 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
218 96 : return true;
219 : }
220 : }
221 512 : break;
222 : }
223 512 : case TRUTH_ANDIF_EXPR:
224 512 : {
225 512 : tree _p0 = TREE_OPERAND (t, 0);
226 512 : tree _p1 = TREE_OPERAND (t, 1);
227 512 : {
228 512 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
229 512 : {
230 512 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
231 512 : return true;
232 : }
233 : }
234 43 : break;
235 : }
236 43 : case TRUTH_OR_EXPR:
237 43 : {
238 43 : tree _p0 = TREE_OPERAND (t, 0);
239 43 : tree _p1 = TREE_OPERAND (t, 1);
240 43 : {
241 43 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
242 43 : {
243 43 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
244 43 : return true;
245 : }
246 : }
247 1401 : break;
248 : }
249 1401 : case TRUTH_ORIF_EXPR:
250 1401 : {
251 1401 : tree _p0 = TREE_OPERAND (t, 0);
252 1401 : tree _p1 = TREE_OPERAND (t, 1);
253 1401 : {
254 1401 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
255 1401 : {
256 1401 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
257 1401 : return true;
258 : }
259 : }
260 0 : break;
261 : }
262 0 : case TRUTH_XOR_EXPR:
263 0 : {
264 0 : tree _p0 = TREE_OPERAND (t, 0);
265 0 : tree _p1 = TREE_OPERAND (t, 1);
266 0 : {
267 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
268 0 : {
269 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
270 0 : return true;
271 : }
272 : }
273 474505 : break;
274 : }
275 474505 : case TRUTH_NOT_EXPR:
276 474505 : {
277 474505 : tree _p0 = TREE_OPERAND (t, 0);
278 474505 : {
279 474505 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
280 474505 : {
281 474505 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
282 474505 : return true;
283 : }
284 : }
285 : break;
286 : }
287 : default:;
288 : }
289 : return false;
290 : }
291 :
292 : tree
293 0 : generic_simplify_41 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
294 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
295 : const enum tree_code ARG_UNUSED (op))
296 : {
297 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
298 0 : if (INTEGRAL_TYPE_P (type)
299 0 : && tree_int_cst_sgn (captures[5]) > 0
300 0 : && (tree_nonzero_bits (captures[0]) & tree_nonzero_bits (captures[4])) == 0
301 : )
302 : {
303 0 : {
304 0 : tree t = type;
305 0 : if (!TYPE_OVERFLOW_WRAPS (t))
306 0 : t = unsigned_type_for (t);
307 0 : wide_int wone = wi::one (TYPE_PRECISION (type));
308 0 : wide_int c = wi::add (wi::to_wide (captures[3]),
309 0 : wi::lshift (wone, wi::to_wide (captures[5])));
310 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail118;
311 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail118;
312 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail118;
313 0 : {
314 0 : tree res_op0;
315 0 : {
316 0 : tree _o1[2], _r1;
317 0 : {
318 0 : tree _o2[1], _r2;
319 0 : _o2[0] = captures[2];
320 0 : if (TREE_TYPE (_o2[0]) != t)
321 : {
322 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, t, _o2[0]);
323 : }
324 : else
325 : _r2 = _o2[0];
326 0 : _o1[0] = _r2;
327 : }
328 0 : _o1[1] = wide_int_to_tree (t, c);
329 0 : _r1 = fold_build2_loc (loc, MULT_EXPR, t, _o1[0], _o1[1]);
330 0 : res_op0 = _r1;
331 : }
332 0 : tree _r;
333 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
334 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 89, __FILE__, __LINE__, true);
335 0 : return _r;
336 : }
337 0 : next_after_fail118:;
338 0 : }
339 : }
340 : return NULL_TREE;
341 : }
342 :
343 : tree
344 11 : generic_simplify_53 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
345 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
346 : const combined_fn ARG_UNUSED (PARITY))
347 : {
348 11 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
349 11 : if (types_match (TREE_TYPE (captures[1]), TREE_TYPE (captures[3]))
350 : )
351 : {
352 10 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail132;
353 10 : {
354 10 : tree res_op0;
355 10 : {
356 10 : tree _o1[2], _r1;
357 10 : _o1[0] = captures[1];
358 10 : _o1[1] = captures[3];
359 10 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
360 10 : res_op0 = _r1;
361 : }
362 10 : tree _r;
363 10 : _r = maybe_build_call_expr_loc (loc, PARITY, type, 1, res_op0);
364 10 : if (!_r)
365 0 : goto next_after_fail132;
366 10 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 100, __FILE__, __LINE__, true);
367 10 : return _r;
368 : }
369 : next_after_fail132:;
370 : }
371 : else
372 : {
373 2 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
374 2 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[3]))
375 : )
376 : {
377 1 : {
378 1 : tree utype = TREE_TYPE (captures[1]);
379 1 : if (TYPE_PRECISION (utype) < TYPE_PRECISION (TREE_TYPE (captures[3])))
380 1 : utype = TREE_TYPE (captures[3]);
381 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail133;
382 1 : {
383 1 : tree res_op0;
384 1 : {
385 1 : tree _o1[2], _r1;
386 1 : {
387 1 : tree _o2[1], _r2;
388 1 : _o2[0] = captures[1];
389 1 : if (TREE_TYPE (_o2[0]) != utype)
390 : {
391 1 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
392 : }
393 : else
394 : _r2 = _o2[0];
395 1 : _o1[0] = _r2;
396 : }
397 1 : {
398 1 : tree _o2[1], _r2;
399 1 : _o2[0] = captures[3];
400 1 : if (TREE_TYPE (_o2[0]) != utype)
401 : {
402 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
403 : }
404 : else
405 : _r2 = _o2[0];
406 1 : _o1[1] = _r2;
407 : }
408 1 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
409 1 : res_op0 = _r1;
410 : }
411 1 : tree _r;
412 1 : _r = maybe_build_call_expr_loc (loc, PARITY, type, 1, res_op0);
413 1 : if (!_r)
414 1 : goto next_after_fail133;
415 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 101, __FILE__, __LINE__, true);
416 0 : return _r;
417 : }
418 : next_after_fail133:;
419 : }
420 : }
421 : }
422 : return NULL_TREE;
423 : }
424 :
425 : tree
426 113467 : generic_simplify_70 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
427 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
428 : {
429 113467 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
430 113467 : if (!TYPE_SATURATING (type)
431 : )
432 : {
433 113467 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
434 226934 : && !FIXED_POINT_TYPE_P (type)
435 : )
436 : {
437 113467 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
438 : )
439 : {
440 112607 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail159;
441 112607 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail159;
442 112607 : {
443 112607 : tree res_op0;
444 112607 : {
445 112607 : tree _o1[1], _r1;
446 112607 : _o1[0] = captures[0];
447 112607 : if (TREE_TYPE (_o1[0]) != type)
448 : {
449 109948 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
450 : }
451 : else
452 : _r1 = _o1[0];
453 112607 : res_op0 = _r1;
454 : }
455 112607 : tree _r;
456 112607 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
457 112607 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 127, __FILE__, __LINE__, true);
458 112607 : return _r;
459 : }
460 : next_after_fail159:;
461 : }
462 : }
463 : }
464 : return NULL_TREE;
465 : }
466 :
467 : tree
468 0 : generic_simplify_77 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
469 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
470 : {
471 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
472 0 : if (VECTOR_TYPE_P (type)
473 0 : && known_eq (TYPE_VECTOR_SUBPARTS (type),
474 : TYPE_VECTOR_SUBPARTS (TREE_TYPE (captures[3])))
475 0 : && (TYPE_MODE (TREE_TYPE (type))
476 0 : == TYPE_MODE (TREE_TYPE (TREE_TYPE (captures[3]))))
477 : )
478 : {
479 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail167;
480 0 : {
481 0 : tree res_op0;
482 0 : res_op0 = captures[0];
483 0 : tree res_op1;
484 0 : {
485 0 : tree _o1[1], _r1;
486 0 : {
487 0 : tree _o2[3], _r2;
488 0 : _o2[0] = captures[2];
489 0 : {
490 0 : tree _o3[1], _r3;
491 0 : _o3[0] = captures[3];
492 0 : _r3 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o3[0]), _o3[0]);
493 0 : _o2[1] = _r3;
494 : }
495 0 : _o2[2] = captures[4];
496 0 : _r2 = fold_build3_loc (loc, VEC_COND_EXPR, TREE_TYPE (_o2[1]), _o2[0], _o2[1], _o2[2]);
497 0 : _o1[0] = _r2;
498 : }
499 0 : if (TREE_TYPE (_o1[0]) != type)
500 : {
501 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
502 : }
503 : else
504 : _r1 = _o1[0];
505 0 : res_op1 = _r1;
506 : }
507 0 : tree _r;
508 0 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
509 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 135, __FILE__, __LINE__, true);
510 0 : return _r;
511 : }
512 0 : next_after_fail167:;
513 : }
514 : return NULL_TREE;
515 : }
516 :
517 : tree
518 85 : generic_simplify_86 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
519 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
520 : {
521 85 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
522 85 : if (INTEGRAL_TYPE_P (type)
523 85 : || (VECTOR_INTEGER_TYPE_P (type)
524 : && ((optimize_vectors_before_lowering_p ()
525 1 : && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
526 0 : || target_supports_op_p (type, TRUNC_MOD_EXPR,
527 : optab_vector)))
528 : )
529 : {
530 85 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail177;
531 85 : {
532 85 : tree res_op0;
533 85 : {
534 85 : tree _o1[2], _r1;
535 85 : _o1[0] = captures[0];
536 85 : _o1[1] = captures[1];
537 85 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
538 85 : res_op0 = _r1;
539 : }
540 85 : tree _r;
541 85 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
542 85 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 145, __FILE__, __LINE__, true);
543 85 : return _r;
544 : }
545 0 : next_after_fail177:;
546 : }
547 : return NULL_TREE;
548 : }
549 :
550 : tree
551 1 : generic_simplify_93 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
552 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
553 : {
554 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
555 1 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
556 1 : && tree_nop_conversion_p (type, TREE_TYPE (captures[3]))
557 : )
558 : {
559 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail184;
560 1 : {
561 1 : tree res_op0;
562 1 : {
563 1 : tree _o1[2], _r1;
564 1 : {
565 1 : tree _o2[1], _r2;
566 1 : _o2[0] = captures[3];
567 1 : _r2 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
568 1 : _o1[0] = _r2;
569 : }
570 1 : _o1[1] = captures[0];
571 1 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
572 1 : res_op0 = _r1;
573 : }
574 1 : tree _r;
575 1 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
576 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 152, __FILE__, __LINE__, true);
577 1 : return _r;
578 : }
579 0 : next_after_fail184:;
580 : }
581 : return NULL_TREE;
582 : }
583 :
584 : tree
585 668 : generic_simplify_101 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
586 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
587 : {
588 668 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
589 668 : if (!TYPE_SATURATING (type)
590 : )
591 : {
592 668 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
593 1336 : && !FIXED_POINT_TYPE_P (type)
594 : )
595 : {
596 668 : if (!ANY_INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_WRAPS (type)
597 : )
598 : {
599 28 : if (!CONSTANT_CLASS_P (captures[2])
600 : )
601 : {
602 28 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail194;
603 28 : {
604 28 : tree res_op0;
605 28 : {
606 28 : tree _o1[1], _r1;
607 28 : _o1[0] = captures[2];
608 28 : if (TREE_TYPE (_o1[0]) != type)
609 : {
610 28 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
611 : }
612 : else
613 : _r1 = _o1[0];
614 28 : res_op0 = _r1;
615 : }
616 28 : tree res_op1;
617 28 : {
618 28 : tree _o1[2], _r1;
619 28 : _o1[0] = captures[0];
620 28 : {
621 28 : tree _o2[1], _r2;
622 28 : _o2[0] = captures[1];
623 28 : if (TREE_TYPE (_o2[0]) != type)
624 : {
625 28 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o2[0]);
626 : }
627 : else
628 : _r2 = _o2[0];
629 28 : _o1[1] = _r2;
630 : }
631 28 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
632 28 : if (EXPR_P (_r1))
633 0 : goto next_after_fail194;
634 28 : res_op1 = _r1;
635 : }
636 28 : tree _r;
637 28 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
638 28 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 161, __FILE__, __LINE__, true);
639 28 : return _r;
640 : }
641 : next_after_fail194:;
642 : }
643 : }
644 : else
645 : {
646 1280 : if (!ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
647 1280 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))
648 : )
649 : {
650 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail195;
651 1 : {
652 1 : tree res_op0;
653 1 : {
654 1 : tree _o1[2], _r1;
655 1 : _o1[0] = captures[2];
656 1 : {
657 1 : tree _o2[2], _r2;
658 1 : {
659 1 : tree _o3[1], _r3;
660 1 : _o3[0] = captures[0];
661 1 : if (TREE_TYPE (_o3[0]) != TREE_TYPE (_o1[0]))
662 : {
663 1 : _r3 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (_o1[0]), _o3[0]);
664 : }
665 : else
666 : _r3 = _o3[0];
667 1 : _o2[0] = _r3;
668 : }
669 1 : _o2[1] = captures[1];
670 1 : _r2 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
671 1 : if (EXPR_P (_r2))
672 0 : goto next_after_fail195;
673 1 : _o1[1] = _r2;
674 : }
675 1 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
676 1 : res_op0 = _r1;
677 : }
678 1 : tree _r;
679 1 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
680 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 162, __FILE__, __LINE__, true);
681 1 : return _r;
682 : }
683 : next_after_fail195:;
684 : }
685 : else
686 : {
687 639 : if (types_match (type, captures[2]) && !TYPE_OVERFLOW_SANITIZED (type)
688 : )
689 : {
690 630 : {
691 630 : tree cst = const_binop (MINUS_EXPR, type, captures[0], captures[1]);
692 630 : if (cst && !TREE_OVERFLOW (cst)
693 : )
694 : {
695 630 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail196;
696 630 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail196;
697 630 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail196;
698 630 : {
699 630 : tree res_op0;
700 630 : res_op0 = cst;
701 630 : tree res_op1;
702 630 : res_op1 = captures[2];
703 630 : tree _r;
704 630 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
705 630 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 163, __FILE__, __LINE__, true);
706 630 : return _r;
707 : }
708 : next_after_fail196:;
709 : }
710 : }
711 : }
712 : }
713 : }
714 : }
715 : }
716 : return NULL_TREE;
717 : }
718 :
719 : tree
720 1 : generic_simplify_130 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
721 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
722 : {
723 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
724 1 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail227;
725 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail227;
726 1 : {
727 1 : tree _r;
728 1 : _r = captures[0];
729 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 189, __FILE__, __LINE__, true);
730 : return _r;
731 : }
732 : next_after_fail227:;
733 : return NULL_TREE;
734 : }
735 :
736 : tree
737 0 : generic_simplify_139 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
738 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
739 : const enum tree_code ARG_UNUSED (op))
740 : {
741 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
742 0 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[3]))
743 0 : && tree_nop_conversion_p (type, TREE_TYPE (captures[6]))
744 : )
745 : {
746 0 : if (single_use (captures[4]) && single_use (captures[5])
747 : )
748 : {
749 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail238;
750 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail238;
751 0 : {
752 0 : tree res_op0;
753 0 : res_op0 = captures[0];
754 0 : tree res_op1;
755 0 : {
756 0 : tree _o1[1], _r1;
757 0 : _o1[0] = captures[6];
758 0 : if (TREE_TYPE (_o1[0]) != type)
759 : {
760 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
761 : }
762 : else
763 : _r1 = _o1[0];
764 0 : res_op1 = _r1;
765 : }
766 0 : tree _r;
767 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
768 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 194, __FILE__, __LINE__, true);
769 0 : return _r;
770 : }
771 : next_after_fail238:;
772 : }
773 : else
774 : {
775 : if (single_use (captures[0]) && single_use (captures[1])
776 : )
777 : {
778 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail239;
779 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail239;
780 : {
781 : tree res_op0;
782 : {
783 : tree _o1[1], _r1;
784 : _o1[0] = captures[3];
785 : if (TREE_TYPE (_o1[0]) != type)
786 : {
787 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
788 : }
789 : else
790 : _r1 = _o1[0];
791 : res_op0 = _r1;
792 : }
793 : tree res_op1;
794 : res_op1 = captures[4];
795 : tree _r;
796 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
797 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 195, __FILE__, __LINE__, true);
798 : return _r;
799 : }
800 : next_after_fail239:;
801 : }
802 : }
803 : }
804 : return NULL_TREE;
805 : }
806 :
807 : tree
808 4 : generic_simplify_154 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
809 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
810 : {
811 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
812 4 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail259;
813 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail259;
814 4 : {
815 4 : tree _r;
816 4 : _r = captures[2];
817 4 : if (TREE_SIDE_EFFECTS (captures[1]))
818 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
819 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 208, __FILE__, __LINE__, true);
820 : return _r;
821 : }
822 : next_after_fail259:;
823 : return NULL_TREE;
824 : }
825 :
826 : tree
827 3 : generic_simplify_157 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
828 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
829 : const enum tree_code ARG_UNUSED (code2),
830 : const enum tree_code ARG_UNUSED (code1))
831 : {
832 3 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
833 3 : if ((TREE_CODE (captures[2]) == INTEGER_CST
834 0 : && TREE_CODE (captures[5]) == INTEGER_CST)
835 3 : || ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
836 3 : || (VECTOR_TYPE_P (TREE_TYPE (captures[2])))
837 0 : || POINTER_TYPE_P (TREE_TYPE (captures[2])))
838 3 : && bitwise_equal_p (captures[2], captures[5]))
839 : )
840 : {
841 3 : {
842 3 : bool one_before = false;
843 3 : bool one_after = false;
844 3 : int cmp = 0;
845 3 : bool allbits = true;
846 3 : if (TREE_CODE (captures[2]) == INTEGER_CST
847 0 : && TREE_CODE (captures[5]) == INTEGER_CST)
848 : {
849 0 : allbits = TYPE_PRECISION (TREE_TYPE (captures[2])) <= TYPE_PRECISION (TREE_TYPE (captures[5]));
850 0 : auto t1 = wi::to_wide (fold_convert (TREE_TYPE (captures[5]), captures[2]));
851 0 : auto t2 = wi::to_wide (captures[5]);
852 0 : cmp = wi::cmp (t1, t2, TYPE_SIGN (TREE_TYPE (captures[5])));
853 0 : if (cmp < 0
854 0 : && t1 == t2 - 1)
855 : one_before = true;
856 0 : if (cmp > 0
857 0 : && t1 == t2 + 1)
858 : one_after = true;
859 : }
860 3 : bool val;
861 3 : switch (code2)
862 : {
863 0 : case EQ_EXPR: val = (cmp == 0); break;
864 0 : case NE_EXPR: val = (cmp != 0); break;
865 0 : case LT_EXPR: val = (cmp < 0); break;
866 3 : case GT_EXPR: val = (cmp > 0); break;
867 0 : case LE_EXPR: val = (cmp <= 0); break;
868 0 : case GE_EXPR: val = (cmp >= 0); break;
869 0 : default: gcc_unreachable ();
870 : }
871 3 : if (code1 == EQ_EXPR && val
872 : )
873 : {
874 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail262;
875 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail262;
876 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail262;
877 0 : {
878 0 : tree _r;
879 0 : _r = captures[3];
880 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 211, __FILE__, __LINE__, true);
881 0 : return _r;
882 : }
883 : next_after_fail262:;
884 : }
885 : else
886 : {
887 3 : if (code1 == NE_EXPR && val && allbits
888 : )
889 : {
890 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail263;
891 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail263;
892 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail263;
893 0 : {
894 0 : tree _r;
895 0 : _r = constant_boolean_node (true, type);
896 0 : if (TREE_SIDE_EFFECTS (captures[1]))
897 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
898 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 212, __FILE__, __LINE__, true);
899 0 : return _r;
900 : }
901 : next_after_fail263:;
902 : }
903 : else
904 : {
905 3 : if (code1 == NE_EXPR && !val && allbits
906 : )
907 : {
908 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail264;
909 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail264;
910 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail264;
911 0 : {
912 0 : tree _r;
913 0 : _r = captures[0];
914 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 213, __FILE__, __LINE__, true);
915 0 : return _r;
916 : }
917 : next_after_fail264:;
918 : }
919 : else
920 : {
921 3 : if (code1 == EQ_EXPR
922 3 : && code2 == GT_EXPR
923 3 : && cmp == 0
924 3 : && allbits
925 6 : && ((VECTOR_BOOLEAN_TYPE_P (type)
926 3 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GE_EXPR))
927 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
928 : )
929 : {
930 3 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail265;
931 3 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail265;
932 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail265;
933 3 : {
934 3 : tree res_op0;
935 3 : res_op0 = captures[4];
936 3 : tree res_op1;
937 3 : res_op1 = captures[5];
938 3 : tree _r;
939 3 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
940 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 214, __FILE__, __LINE__, true);
941 3 : return _r;
942 : }
943 : next_after_fail265:;
944 : }
945 : else
946 : {
947 0 : if (code1 == EQ_EXPR
948 0 : && code2 == LT_EXPR
949 0 : && cmp == 0
950 0 : && allbits
951 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
952 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LE_EXPR))
953 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
954 : )
955 : {
956 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail266;
957 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail266;
958 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail266;
959 0 : {
960 0 : tree res_op0;
961 0 : res_op0 = captures[4];
962 0 : tree res_op1;
963 0 : res_op1 = captures[5];
964 0 : tree _r;
965 0 : _r = fold_build2_loc (loc, LE_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_fail266:;
970 : }
971 : else
972 : {
973 0 : if (code1 == EQ_EXPR
974 0 : && code2 == GE_EXPR
975 : && one_before
976 0 : && allbits
977 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
978 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GE_EXPR))
979 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
980 : )
981 : {
982 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail267;
983 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail267;
984 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail267;
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, GE_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_fail267:;
1006 : }
1007 : else
1008 : {
1009 0 : if (code1 == EQ_EXPR
1010 0 : && code2 == LE_EXPR
1011 : && one_after
1012 0 : && allbits
1013 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
1014 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LE_EXPR))
1015 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
1016 : )
1017 : {
1018 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail268;
1019 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail268;
1020 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail268;
1021 0 : {
1022 0 : tree res_op0;
1023 0 : res_op0 = captures[4];
1024 0 : tree res_op1;
1025 0 : {
1026 0 : tree _o1[1], _r1;
1027 0 : _o1[0] = captures[2];
1028 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
1029 : {
1030 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
1031 : }
1032 : else
1033 : _r1 = _o1[0];
1034 0 : res_op1 = _r1;
1035 : }
1036 0 : tree _r;
1037 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1038 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 217, __FILE__, __LINE__, true);
1039 0 : return _r;
1040 : }
1041 : next_after_fail268:;
1042 : }
1043 : }
1044 : }
1045 : }
1046 : }
1047 : }
1048 : }
1049 : }
1050 : }
1051 : return NULL_TREE;
1052 : }
1053 :
1054 : tree
1055 12 : generic_simplify_200 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1056 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1057 : const combined_fn ARG_UNUSED (TAN),
1058 : const combined_fn ARG_UNUSED (COS),
1059 : const combined_fn ARG_UNUSED (SIN))
1060 : {
1061 12 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1062 12 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1063 : )
1064 : {
1065 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail340;
1066 12 : {
1067 12 : tree res_op0;
1068 12 : res_op0 = captures[1];
1069 12 : tree _r;
1070 12 : _r = maybe_build_call_expr_loc (loc, SIN, type, 1, res_op0);
1071 12 : if (!_r)
1072 0 : goto next_after_fail340;
1073 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 255, __FILE__, __LINE__, true);
1074 12 : return _r;
1075 : }
1076 : next_after_fail340:;
1077 : }
1078 : return NULL_TREE;
1079 : }
1080 :
1081 : tree
1082 64 : generic_simplify_205 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1083 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1084 : const enum tree_code ARG_UNUSED (cmp))
1085 : {
1086 64 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1087 120 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1088 120 : && tree_expr_nonzero_p (captures[0])
1089 : )
1090 : {
1091 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail345;
1092 12 : {
1093 12 : tree _r;
1094 12 : _r = constant_boolean_node (cmp != EQ_EXPR, type);
1095 12 : if (TREE_SIDE_EFFECTS (captures[0]))
1096 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1097 12 : if (TREE_SIDE_EFFECTS (captures[1]))
1098 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1099 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 260, __FILE__, __LINE__, true);
1100 12 : return _r;
1101 : }
1102 0 : next_after_fail345:;
1103 : }
1104 : return NULL_TREE;
1105 : }
1106 :
1107 : tree
1108 9135 : generic_simplify_213 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1109 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1110 : const enum tree_code ARG_UNUSED (neeq),
1111 : const enum tree_code ARG_UNUSED (ltge))
1112 : {
1113 9135 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1114 9135 : {
1115 9135 : tree itype = signed_type_for (TREE_TYPE (captures[1]));
1116 18057 : if (wi::to_wide (captures[2]) == element_precision (itype) - 1
1117 9135 : && (!VECTOR_TYPE_P (itype)
1118 13 : || (cfun
1119 13 : && cfun->after_inlining
1120 5 : && VECTOR_BOOLEAN_TYPE_P (type)
1121 2 : && (expand_vec_cmp_expr_p (itype, type, ltge)
1122 2 : || !expand_vec_cmp_expr_p (TREE_TYPE (captures[0]),
1123 : type, neeq))))
1124 : )
1125 : {
1126 213 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail356;
1127 213 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail356;
1128 213 : {
1129 213 : tree res_op0;
1130 213 : {
1131 213 : tree _o1[1], _r1;
1132 213 : _o1[0] = captures[1];
1133 213 : if (TREE_TYPE (_o1[0]) != itype)
1134 : {
1135 161 : _r1 = fold_build1_loc (loc, NOP_EXPR, itype, _o1[0]);
1136 : }
1137 : else
1138 : _r1 = _o1[0];
1139 213 : res_op0 = _r1;
1140 : }
1141 213 : tree res_op1;
1142 213 : res_op1 = build_zero_cst (itype);
1143 213 : tree _r;
1144 213 : _r = fold_build2_loc (loc, ltge, type, res_op0, res_op1);
1145 213 : if (TREE_SIDE_EFFECTS (captures[2]))
1146 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1147 213 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 270, __FILE__, __LINE__, true);
1148 213 : return _r;
1149 : }
1150 : next_after_fail356:;
1151 : }
1152 : }
1153 : return NULL_TREE;
1154 : }
1155 :
1156 : tree
1157 21 : generic_simplify_226 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1158 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1159 : const enum tree_code ARG_UNUSED (cmp))
1160 : {
1161 21 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1162 21 : if (TREE_INT_CST_LOW (captures[1]) & 1
1163 : )
1164 : {
1165 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail382;
1166 2 : {
1167 2 : tree _r;
1168 2 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1169 2 : if (TREE_SIDE_EFFECTS (captures[0]))
1170 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1171 2 : if (TREE_SIDE_EFFECTS (captures[1]))
1172 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1173 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 295, __FILE__, __LINE__, true);
1174 2 : return _r;
1175 : }
1176 0 : next_after_fail382:;
1177 : }
1178 : return NULL_TREE;
1179 : }
1180 :
1181 : tree
1182 45 : generic_simplify_232 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1183 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1184 : const enum tree_code ARG_UNUSED (cmp))
1185 : {
1186 45 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1187 45 : if (TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1188 : )
1189 : {
1190 0 : {
1191 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[0]));
1192 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail390;
1193 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail390;
1194 0 : {
1195 0 : tree res_op0;
1196 0 : {
1197 0 : tree _o1[2], _r1;
1198 0 : {
1199 0 : tree _o2[1], _r2;
1200 0 : _o2[0] = captures[0];
1201 0 : if (TREE_TYPE (_o2[0]) != utype)
1202 : {
1203 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
1204 : }
1205 : else
1206 : _r2 = _o2[0];
1207 0 : _o1[0] = _r2;
1208 : }
1209 0 : {
1210 0 : tree _o2[1], _r2;
1211 0 : _o2[0] = captures[1];
1212 0 : if (TREE_TYPE (_o2[0]) != utype)
1213 : {
1214 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
1215 : }
1216 : else
1217 : _r2 = _o2[0];
1218 0 : _o1[1] = _r2;
1219 : }
1220 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1221 0 : res_op0 = _r1;
1222 : }
1223 0 : tree res_op1;
1224 0 : res_op1 = build_zero_cst (utype);
1225 0 : tree _r;
1226 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1227 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 303, __FILE__, __LINE__, true);
1228 0 : return _r;
1229 : }
1230 : next_after_fail390:;
1231 : }
1232 : }
1233 : return NULL_TREE;
1234 : }
1235 :
1236 : tree
1237 124 : generic_simplify_240 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1238 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1239 : const enum tree_code ARG_UNUSED (rotate),
1240 : const enum tree_code ARG_UNUSED (invrot),
1241 : const enum tree_code ARG_UNUSED (cmp))
1242 : {
1243 124 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1244 124 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail408;
1245 124 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail408;
1246 124 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail408;
1247 124 : {
1248 124 : tree res_op0;
1249 124 : res_op0 = captures[0];
1250 124 : tree res_op1;
1251 124 : res_op1 = const_binop (invrot, TREE_TYPE (captures[0]), captures[2], captures[1]);
1252 124 : tree _r;
1253 124 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1254 124 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 321, __FILE__, __LINE__, true);
1255 : return _r;
1256 : }
1257 : next_after_fail408:;
1258 : return NULL_TREE;
1259 : }
1260 :
1261 : tree
1262 25547 : generic_simplify_246 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1263 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1264 : const enum tree_code ARG_UNUSED (cmp),
1265 : const enum tree_code ARG_UNUSED (icmp),
1266 : const enum tree_code ARG_UNUSED (ncmp))
1267 : {
1268 25547 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1269 25547 : if (types_match (type, TREE_TYPE (captures[0]))
1270 : )
1271 : {
1272 24882 : {
1273 24882 : enum tree_code ic = invert_tree_comparison
1274 24882 : (cmp, HONOR_NANS (captures[1]));
1275 24882 : if (ic == icmp
1276 : )
1277 : {
1278 24643 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail414;
1279 24643 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail414;
1280 24643 : {
1281 24643 : tree res_op0;
1282 24643 : res_op0 = captures[1];
1283 24643 : tree res_op1;
1284 24643 : res_op1 = captures[2];
1285 24643 : tree _r;
1286 24643 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
1287 24643 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 327, __FILE__, __LINE__, true);
1288 24643 : return _r;
1289 : }
1290 : next_after_fail414:;
1291 : }
1292 : else
1293 : {
1294 239 : if (ic == ncmp
1295 : )
1296 : {
1297 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail415;
1298 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail415;
1299 0 : {
1300 0 : tree res_op0;
1301 0 : res_op0 = captures[1];
1302 0 : tree res_op1;
1303 0 : res_op1 = captures[2];
1304 0 : tree _r;
1305 0 : _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
1306 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 328, __FILE__, __LINE__, true);
1307 0 : return _r;
1308 : }
1309 : next_after_fail415:;
1310 : }
1311 : }
1312 : }
1313 : }
1314 : return NULL_TREE;
1315 : }
1316 :
1317 : tree
1318 6218298 : generic_simplify_256 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1319 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1320 : const enum tree_code ARG_UNUSED (cmp))
1321 : {
1322 6218298 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1323 6218298 : if (REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (captures[1]))
1324 : )
1325 : {
1326 1708 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail430;
1327 1708 : {
1328 1708 : tree res_op0;
1329 1708 : res_op0 = captures[0];
1330 1708 : tree res_op1;
1331 1708 : res_op1 = build_real (TREE_TYPE (captures[1]), dconst0);
1332 1708 : tree _r;
1333 1708 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1334 1708 : if (TREE_SIDE_EFFECTS (captures[1]))
1335 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1336 1708 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 341, __FILE__, __LINE__, true);
1337 1708 : return _r;
1338 : }
1339 0 : next_after_fail430:;
1340 : }
1341 : else
1342 : {
1343 6216590 : if (TREE_CODE (captures[0]) == REAL_CST
1344 6216590 : && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (captures[0]))
1345 : )
1346 : {
1347 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail431;
1348 0 : {
1349 0 : tree res_op0;
1350 0 : res_op0 = build_real (TREE_TYPE (captures[0]), dconst0);
1351 0 : tree res_op1;
1352 0 : res_op1 = captures[1];
1353 0 : tree _r;
1354 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1355 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1356 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1357 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 342, __FILE__, __LINE__, true);
1358 0 : return _r;
1359 : }
1360 0 : next_after_fail431:;
1361 : }
1362 : else
1363 : {
1364 6216590 : if (REAL_VALUE_ISNAN (TREE_REAL_CST (captures[1]))
1365 834 : && (cmp == EQ_EXPR || cmp == NE_EXPR || !flag_trapping_math)
1366 258 : && !tree_expr_signaling_nan_p (captures[1])
1367 6216818 : && !tree_expr_maybe_signaling_nan_p (captures[0])
1368 : )
1369 : {
1370 228 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail432;
1371 228 : {
1372 228 : tree _r;
1373 228 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1374 228 : if (TREE_SIDE_EFFECTS (captures[0]))
1375 6 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1376 228 : if (TREE_SIDE_EFFECTS (captures[1]))
1377 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1378 228 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 343, __FILE__, __LINE__, true);
1379 228 : return _r;
1380 : }
1381 0 : next_after_fail432:;
1382 : }
1383 : else
1384 : {
1385 6216362 : if (TREE_CODE (captures[0]) == REAL_CST
1386 2011 : && REAL_VALUE_ISNAN (TREE_REAL_CST (captures[0]))
1387 1817 : && (cmp == EQ_EXPR || cmp == NE_EXPR || !flag_trapping_math)
1388 0 : && !tree_expr_signaling_nan_p (captures[0])
1389 6216362 : && !tree_expr_signaling_nan_p (captures[1])
1390 : )
1391 : {
1392 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail433;
1393 0 : {
1394 0 : tree _r;
1395 0 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1396 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1397 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1398 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1399 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1400 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 344, __FILE__, __LINE__, true);
1401 0 : return _r;
1402 : }
1403 0 : next_after_fail433:;
1404 : }
1405 : else
1406 : {
1407 6216362 : if (REAL_VALUE_ISINF (TREE_REAL_CST (captures[1]))
1408 6924315 : && MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (captures[1])))
1409 : )
1410 : {
1411 236012 : {
1412 236012 : REAL_VALUE_TYPE max;
1413 236012 : enum tree_code code = cmp;
1414 236012 : bool neg = REAL_VALUE_NEGATIVE (TREE_REAL_CST (captures[1]));
1415 236012 : if (neg)
1416 33326 : code = swap_tree_comparison (code);
1417 236012 : if (code == GT_EXPR
1418 236012 : && !(HONOR_NANS (captures[0]) && flag_trapping_math)
1419 : )
1420 : {
1421 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail434;
1422 7 : {
1423 7 : tree _r;
1424 7 : _r = constant_boolean_node (false, type);
1425 7 : if (TREE_SIDE_EFFECTS (captures[0]))
1426 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1427 7 : if (TREE_SIDE_EFFECTS (captures[1]))
1428 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1429 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 345, __FILE__, __LINE__, true);
1430 67426 : return _r;
1431 : }
1432 0 : next_after_fail434:;
1433 : }
1434 : else
1435 : {
1436 236005 : if (code == LE_EXPR
1437 : )
1438 : {
1439 32122 : if (! HONOR_NANS (captures[0])
1440 : )
1441 : {
1442 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail435;
1443 0 : {
1444 0 : tree _r;
1445 0 : _r = constant_boolean_node (true, type);
1446 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1447 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1448 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1449 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1450 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 346, __FILE__, __LINE__, true);
1451 0 : return _r;
1452 : }
1453 0 : next_after_fail435:;
1454 : }
1455 : else
1456 : {
1457 32122 : if (!flag_trapping_math
1458 : )
1459 : {
1460 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail436;
1461 2 : {
1462 2 : if (! tree_invariant_p (captures[0])) goto next_after_fail436;
1463 0 : tree res_op0;
1464 0 : res_op0 = unshare_expr (captures[0]);
1465 0 : tree res_op1;
1466 0 : res_op1 = captures[0];
1467 0 : tree _r;
1468 0 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
1469 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1470 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1471 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 347, __FILE__, __LINE__, true);
1472 0 : return _r;
1473 : }
1474 168586 : next_after_fail436:;
1475 : }
1476 : }
1477 : }
1478 : else
1479 : {
1480 136263 : if ((code == EQ_EXPR && !(HONOR_NANS (captures[0]) && flag_trapping_math))
1481 340110 : || code == GE_EXPR
1482 : )
1483 : {
1484 140 : {
1485 140 : real_maxval (&max, neg, TYPE_MODE (TREE_TYPE (captures[0])));
1486 140 : if (neg
1487 : )
1488 : {
1489 55 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail437;
1490 55 : {
1491 55 : tree res_op0;
1492 55 : res_op0 = captures[0];
1493 55 : tree res_op1;
1494 55 : res_op1 = build_real (TREE_TYPE (captures[0]), max);
1495 55 : tree _r;
1496 55 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
1497 55 : if (TREE_SIDE_EFFECTS (captures[1]))
1498 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1499 55 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 348, __FILE__, __LINE__, true);
1500 55 : return _r;
1501 : }
1502 0 : next_after_fail437:;
1503 : }
1504 : else
1505 : {
1506 85 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail438;
1507 85 : {
1508 85 : tree res_op0;
1509 85 : res_op0 = captures[0];
1510 85 : tree res_op1;
1511 85 : res_op1 = build_real (TREE_TYPE (captures[0]), max);
1512 85 : tree _r;
1513 85 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
1514 85 : if (TREE_SIDE_EFFECTS (captures[1]))
1515 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1516 85 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 349, __FILE__, __LINE__, true);
1517 85 : return _r;
1518 : }
1519 0 : next_after_fail438:;
1520 : }
1521 : }
1522 : }
1523 : else
1524 : {
1525 203743 : if (code == LT_EXPR
1526 : )
1527 : {
1528 90 : {
1529 90 : real_maxval (&max, neg, TYPE_MODE (TREE_TYPE (captures[0])));
1530 90 : if (neg
1531 : )
1532 : {
1533 26 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail439;
1534 26 : {
1535 26 : tree res_op0;
1536 26 : res_op0 = captures[0];
1537 26 : tree res_op1;
1538 26 : res_op1 = build_real (TREE_TYPE (captures[0]), max);
1539 26 : tree _r;
1540 26 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
1541 26 : if (TREE_SIDE_EFFECTS (captures[1]))
1542 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1543 26 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 350, __FILE__, __LINE__, true);
1544 26 : return _r;
1545 : }
1546 0 : next_after_fail439:;
1547 : }
1548 : else
1549 : {
1550 64 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail440;
1551 64 : {
1552 64 : tree res_op0;
1553 64 : res_op0 = captures[0];
1554 64 : tree res_op1;
1555 64 : res_op1 = build_real (TREE_TYPE (captures[0]), max);
1556 64 : tree _r;
1557 64 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1558 64 : if (TREE_SIDE_EFFECTS (captures[1]))
1559 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1560 64 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 351, __FILE__, __LINE__, true);
1561 64 : return _r;
1562 : }
1563 0 : next_after_fail440:;
1564 : }
1565 : }
1566 : }
1567 : else
1568 : {
1569 203653 : if (code == NE_EXPR
1570 : )
1571 : {
1572 67189 : {
1573 67189 : real_maxval (&max, neg, TYPE_MODE (TREE_TYPE (captures[0])));
1574 67189 : if (! HONOR_NANS (captures[0])
1575 : )
1576 : {
1577 0 : if (neg
1578 : )
1579 : {
1580 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail441;
1581 0 : {
1582 0 : tree res_op0;
1583 0 : res_op0 = captures[0];
1584 0 : tree res_op1;
1585 0 : res_op1 = build_real (TREE_TYPE (captures[0]), max);
1586 0 : tree _r;
1587 0 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
1588 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1589 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1590 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 352, __FILE__, __LINE__, true);
1591 0 : return _r;
1592 : }
1593 0 : next_after_fail441:;
1594 : }
1595 : else
1596 : {
1597 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail442;
1598 0 : {
1599 0 : tree res_op0;
1600 0 : res_op0 = captures[0];
1601 0 : tree res_op1;
1602 0 : res_op1 = build_real (TREE_TYPE (captures[0]), max);
1603 0 : tree _r;
1604 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1605 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1606 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1607 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 353, __FILE__, __LINE__, true);
1608 0 : return _r;
1609 : }
1610 0 : next_after_fail442:;
1611 : }
1612 : }
1613 : else
1614 : {
1615 67189 : if (neg
1616 : )
1617 : {
1618 560 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail443;
1619 560 : {
1620 560 : tree res_op0;
1621 560 : res_op0 = captures[0];
1622 560 : tree res_op1;
1623 560 : res_op1 = build_real (TREE_TYPE (captures[0]), max);
1624 560 : tree _r;
1625 560 : _r = fold_build2_loc (loc, UNGE_EXPR, type, res_op0, res_op1);
1626 560 : if (TREE_SIDE_EFFECTS (captures[1]))
1627 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1628 560 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 354, __FILE__, __LINE__, true);
1629 560 : return _r;
1630 : }
1631 0 : next_after_fail443:;
1632 : }
1633 : else
1634 : {
1635 66629 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail444;
1636 66629 : {
1637 66629 : tree res_op0;
1638 66629 : res_op0 = captures[0];
1639 66629 : tree res_op1;
1640 66629 : res_op1 = build_real (TREE_TYPE (captures[0]), max);
1641 66629 : tree _r;
1642 66629 : _r = fold_build2_loc (loc, UNLE_EXPR, type, res_op0, res_op1);
1643 66629 : if (TREE_SIDE_EFFECTS (captures[1]))
1644 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1645 66629 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 355, __FILE__, __LINE__, true);
1646 66629 : return _r;
1647 : }
1648 0 : next_after_fail444:;
1649 : }
1650 : }
1651 : }
1652 : }
1653 : }
1654 : }
1655 : }
1656 : }
1657 : }
1658 : }
1659 : }
1660 : }
1661 : }
1662 : }
1663 : return NULL_TREE;
1664 : }
1665 :
1666 : tree
1667 45 : generic_simplify_297 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1668 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1669 : const enum tree_code ARG_UNUSED (cmp),
1670 : const enum tree_code ARG_UNUSED (rep),
1671 : const combined_fn ARG_UNUSED (popcount))
1672 : {
1673 45 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1674 45 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail560;
1675 45 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail560;
1676 45 : {
1677 45 : tree res_op0;
1678 45 : res_op0 = captures[0];
1679 45 : tree res_op1;
1680 45 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
1681 45 : tree _r;
1682 45 : _r = fold_build2_loc (loc, rep, type, res_op0, res_op1);
1683 45 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 453, __FILE__, __LINE__, true);
1684 : return _r;
1685 : }
1686 : next_after_fail560:;
1687 : return NULL_TREE;
1688 : }
1689 :
1690 : tree
1691 111841 : generic_simplify_302 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1692 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1693 : const enum tree_code ARG_UNUSED (cmp))
1694 : {
1695 111841 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1696 111841 : if (cmp != NE_EXPR
1697 106675 : || ! FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1698 124368 : || ! tree_expr_maybe_nan_p (captures[0])
1699 : )
1700 : {
1701 105128 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail568;
1702 105128 : {
1703 105128 : tree _r;
1704 105128 : _r = constant_boolean_node (false, type);
1705 105128 : if (TREE_SIDE_EFFECTS (captures[0]))
1706 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1707 105128 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 461, __FILE__, __LINE__, true);
1708 105128 : return _r;
1709 : }
1710 0 : next_after_fail568:;
1711 : }
1712 : return NULL_TREE;
1713 : }
1714 :
1715 : tree
1716 0 : generic_simplify_306 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1717 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1718 : const combined_fn ARG_UNUSED (COPYSIGN_ALL))
1719 : {
1720 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1721 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail572;
1722 0 : {
1723 0 : tree _r;
1724 0 : _r = captures[0];
1725 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 465, __FILE__, __LINE__, true);
1726 : return _r;
1727 : }
1728 0 : next_after_fail572:;
1729 0 : return NULL_TREE;
1730 : }
1731 :
1732 : tree
1733 14398 : generic_simplify_313 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1734 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1735 : const enum tree_code ARG_UNUSED (div))
1736 : {
1737 14398 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1738 14398 : if (INTEGRAL_TYPE_P (type)
1739 14370 : && ssa_name_has_boolean_range (captures[1])
1740 14398 : && !flag_non_call_exceptions
1741 : )
1742 : {
1743 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail581;
1744 0 : {
1745 0 : tree _r;
1746 0 : _r = captures[0];
1747 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1748 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1749 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 472, __FILE__, __LINE__, true);
1750 0 : return _r;
1751 : }
1752 0 : next_after_fail581:;
1753 : }
1754 : return NULL_TREE;
1755 : }
1756 :
1757 : tree
1758 23130 : generic_simplify_319 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1759 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1760 : const enum tree_code ARG_UNUSED (div))
1761 : {
1762 23130 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1763 23130 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) && TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1764 : )
1765 : {
1766 22982 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail588;
1767 22982 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail588;
1768 22982 : {
1769 22982 : tree res_op0;
1770 22982 : res_op0 = captures[0];
1771 22982 : tree res_op1;
1772 22982 : res_op1 = wide_int_to_tree
1773 45964 : (type, wi::mask (TYPE_PRECISION (type)
1774 22982 : - wi::exact_log2 (wi::to_wide (captures[1])),
1775 22982 : false, TYPE_PRECISION (type)));
1776 22982 : tree _r;
1777 22982 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
1778 22982 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 479, __FILE__, __LINE__, true);
1779 22982 : return _r;
1780 : }
1781 : next_after_fail588:;
1782 : }
1783 : return NULL_TREE;
1784 : }
1785 :
1786 : tree
1787 919 : generic_simplify_323 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1788 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1789 : const enum tree_code ARG_UNUSED (mod))
1790 : {
1791 919 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1792 919 : if (!integer_zerop (captures[1])
1793 : )
1794 : {
1795 785 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail592;
1796 785 : {
1797 785 : tree _r;
1798 785 : _r = captures[0];
1799 785 : if (TREE_SIDE_EFFECTS (captures[1]))
1800 74 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1801 785 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 483, __FILE__, __LINE__, true);
1802 785 : return _r;
1803 : }
1804 0 : next_after_fail592:;
1805 : }
1806 : return NULL_TREE;
1807 : }
1808 :
1809 : tree
1810 6 : generic_simplify_333 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1811 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1812 : const combined_fn ARG_UNUSED (SIN),
1813 : const combined_fn ARG_UNUSED (COS),
1814 : const combined_fn ARG_UNUSED (TAN))
1815 : {
1816 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1817 6 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1818 : )
1819 : {
1820 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail604;
1821 6 : {
1822 6 : tree res_op0;
1823 6 : res_op0 = captures[1];
1824 6 : tree _r;
1825 6 : _r = maybe_build_call_expr_loc (loc, TAN, type, 1, res_op0);
1826 6 : if (!_r)
1827 0 : goto next_after_fail604;
1828 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 495, __FILE__, __LINE__, true);
1829 6 : return _r;
1830 : }
1831 : next_after_fail604:;
1832 : }
1833 : return NULL_TREE;
1834 : }
1835 :
1836 : tree
1837 24 : generic_simplify_340 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1838 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1839 : const combined_fn ARG_UNUSED (POW))
1840 : {
1841 24 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1842 24 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1843 : )
1844 : {
1845 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail611;
1846 6 : {
1847 6 : tree res_op0;
1848 6 : res_op0 = captures[0];
1849 6 : tree res_op1;
1850 6 : {
1851 6 : tree _o1[2], _r1;
1852 6 : _o1[0] = captures[2];
1853 6 : {
1854 6 : tree _o2[1], _r2;
1855 6 : _o2[0] = captures[3];
1856 6 : _r2 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
1857 6 : _o1[1] = _r2;
1858 : }
1859 6 : _r1 = maybe_build_call_expr_loc (loc, POW, TREE_TYPE (_o1[0]), 2, _o1[0], _o1[1]);
1860 6 : if (!_r1)
1861 0 : goto next_after_fail611;
1862 6 : res_op1 = _r1;
1863 : }
1864 6 : tree _r;
1865 6 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
1866 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 502, __FILE__, __LINE__, true);
1867 6 : return _r;
1868 : }
1869 : next_after_fail611:;
1870 : }
1871 : return NULL_TREE;
1872 : }
1873 :
1874 : tree
1875 0 : generic_simplify_349 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1876 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1877 : const enum tree_code ARG_UNUSED (cmp))
1878 : {
1879 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1880 0 : if (INTEGRAL_TYPE_P (type)
1881 : )
1882 : {
1883 0 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail626;
1884 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail626;
1885 0 : {
1886 0 : tree _r;
1887 0 : _r = captures[2];
1888 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1889 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1890 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 517, __FILE__, __LINE__, true);
1891 0 : return _r;
1892 : }
1893 : next_after_fail626:;
1894 : }
1895 : return NULL_TREE;
1896 : }
1897 :
1898 : tree
1899 21 : generic_simplify_353 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1900 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures))
1901 : {
1902 21 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1903 21 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail630;
1904 21 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail630;
1905 21 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail630;
1906 21 : {
1907 21 : tree _r;
1908 21 : _r = captures[2];
1909 21 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 521, __FILE__, __LINE__, true);
1910 : return _r;
1911 : }
1912 : next_after_fail630:;
1913 : return NULL_TREE;
1914 : }
1915 :
1916 : tree
1917 0 : generic_simplify_356 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1918 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1919 : const enum tree_code ARG_UNUSED (op))
1920 : {
1921 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1922 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail633;
1923 0 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail633;
1924 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail633;
1925 0 : {
1926 0 : tree _r;
1927 0 : _r = captures[2];
1928 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 524, __FILE__, __LINE__, true);
1929 : return _r;
1930 : }
1931 : next_after_fail633:;
1932 : return NULL_TREE;
1933 : }
1934 :
1935 : tree
1936 0 : generic_simplify_363 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1937 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures))
1938 : {
1939 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1940 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail640;
1941 0 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail640;
1942 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail640;
1943 0 : {
1944 0 : tree _r;
1945 0 : _r = captures[2];
1946 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 531, __FILE__, __LINE__, true);
1947 : return _r;
1948 : }
1949 : next_after_fail640:;
1950 : return NULL_TREE;
1951 : }
1952 :
1953 : tree
1954 0 : generic_simplify_369 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1955 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1956 : const combined_fn ARG_UNUSED (func))
1957 : {
1958 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1959 0 : if (wi::to_widest (captures[4]) == TYPE_PRECISION (TREE_TYPE (captures[3])) - 1
1960 : )
1961 : {
1962 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail647;
1963 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail647;
1964 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail647;
1965 0 : {
1966 0 : tree _r;
1967 0 : _r = captures[2];
1968 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1969 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1970 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 538, __FILE__, __LINE__, true);
1971 0 : return _r;
1972 : }
1973 : next_after_fail647:;
1974 : }
1975 : return NULL_TREE;
1976 : }
1977 :
1978 : tree
1979 19719 : generic_simplify_377 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1980 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1981 : const enum tree_code ARG_UNUSED (cmp))
1982 : {
1983 19719 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1984 39438 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1985 39377 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
1986 : )
1987 : {
1988 16258 : if (tree_expr_nonnegative_p (captures[1]) && tree_expr_nonzero_p (captures[1])
1989 : )
1990 : {
1991 12742 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail658;
1992 12742 : {
1993 12742 : tree res_op0;
1994 12742 : res_op0 = captures[0];
1995 12742 : tree res_op1;
1996 12742 : res_op1 = captures[2];
1997 12742 : tree _r;
1998 12742 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1999 12742 : if (TREE_SIDE_EFFECTS (captures[1]))
2000 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2001 12742 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 547, __FILE__, __LINE__, true);
2002 12742 : return _r;
2003 : }
2004 0 : next_after_fail658:;
2005 : }
2006 : else
2007 : {
2008 3516 : if (TREE_CODE (captures[1]) == INTEGER_CST
2009 3516 : && wi::neg_p (wi::to_wide (captures[1]), TYPE_SIGN (TREE_TYPE (captures[1])))
2010 : )
2011 : {
2012 1076 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail659;
2013 1076 : {
2014 1076 : tree res_op0;
2015 1076 : res_op0 = captures[2];
2016 1076 : tree res_op1;
2017 1076 : res_op1 = captures[0];
2018 1076 : tree _r;
2019 1076 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2020 1076 : if (TREE_SIDE_EFFECTS (captures[1]))
2021 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2022 1076 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 548, __FILE__, __LINE__, true);
2023 1076 : return _r;
2024 : }
2025 0 : next_after_fail659:;
2026 : }
2027 : }
2028 : }
2029 : return NULL_TREE;
2030 : }
2031 :
2032 : tree
2033 37245 : generic_simplify_390 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2034 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2035 : const enum tree_code ARG_UNUSED (cmp),
2036 : const enum tree_code ARG_UNUSED (out))
2037 : {
2038 37245 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2039 37245 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))
2040 37229 : && types_match (TREE_TYPE (captures[3]), TREE_TYPE (captures[0]))
2041 37229 : && tree_nop_conversion_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[3]))
2042 37245 : && wi::to_wide (captures[4]) != 0
2043 0 : && single_use (captures[1])
2044 : )
2045 : {
2046 37229 : {
2047 37229 : unsigned int prec = TYPE_PRECISION (TREE_TYPE (captures[3]));
2048 37229 : signop sign = TYPE_SIGN (TREE_TYPE (captures[3]));
2049 37229 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail673;
2050 37229 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail673;
2051 37229 : {
2052 37229 : tree res_op0;
2053 37229 : res_op0 = captures[3];
2054 37229 : tree res_op1;
2055 37229 : res_op1 = wide_int_to_tree (TREE_TYPE (captures[3]),
2056 37229 : wi::max_value (prec, sign)
2057 111687 : - wi::to_wide (captures[4]));
2058 37229 : tree _r;
2059 37229 : _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
2060 37229 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 562, __FILE__, __LINE__, true);
2061 37229 : return _r;
2062 : }
2063 : next_after_fail673:;
2064 : }
2065 : }
2066 : return NULL_TREE;
2067 : }
2068 :
2069 : tree
2070 1091 : generic_simplify_400 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2071 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2072 : const enum tree_code ARG_UNUSED (cmp),
2073 : const enum tree_code ARG_UNUSED (out))
2074 : {
2075 1091 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2076 1091 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2])) && !VECTOR_TYPE_P (TREE_TYPE (captures[2]))
2077 : )
2078 : {
2079 1073 : {
2080 1073 : tree t = TREE_TYPE (captures[2]), cpx = build_complex_type (t);
2081 1073 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail715;
2082 1061 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail715;
2083 1061 : {
2084 1061 : tree res_op0;
2085 1061 : {
2086 1061 : tree _o1[1], _r1;
2087 1061 : {
2088 1061 : tree _o2[2], _r2;
2089 1061 : _o2[0] = captures[2];
2090 1061 : _o2[1] = captures[1];
2091 1061 : _r2 = maybe_build_call_expr_loc (loc, CFN_MUL_OVERFLOW, cpx, 2, _o2[0], _o2[1]);
2092 1061 : if (!_r2)
2093 0 : goto next_after_fail715;
2094 1061 : _o1[0] = _r2;
2095 : }
2096 1061 : _r1 = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
2097 1061 : res_op0 = _r1;
2098 : }
2099 1061 : tree res_op1;
2100 1061 : res_op1 = build_zero_cst (t);
2101 1061 : tree _r;
2102 1061 : _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
2103 1061 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 587, __FILE__, __LINE__, true);
2104 1061 : return _r;
2105 : }
2106 : next_after_fail715:;
2107 : }
2108 : }
2109 : return NULL_TREE;
2110 : }
2111 :
2112 : tree
2113 11965 : generic_simplify_407 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2114 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2115 : const enum tree_code ARG_UNUSED (cmp),
2116 : const enum tree_code ARG_UNUSED (eqcmp))
2117 : {
2118 11965 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2119 11965 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2120 : )
2121 : {
2122 11965 : {
2123 11965 : tree ty = TREE_TYPE (captures[0]);
2124 11965 : unsigned prec = TYPE_PRECISION (ty);
2125 11965 : wide_int mask = wi::to_wide (captures[2], prec);
2126 11965 : wide_int rhs = wi::to_wide (captures[3], prec);
2127 11965 : signop sgn = TYPE_SIGN (ty);
2128 33689 : if ((mask & (mask + 1)) == 0 && wi::gt_p (rhs, 0, sgn)
2129 43280 : && (rhs & (rhs + 1)) == 0 && wi::ge_p (mask, rhs, sgn)
2130 : )
2131 : {
2132 556 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail729;
2133 556 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail729;
2134 556 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail729;
2135 556 : {
2136 556 : tree res_op0;
2137 556 : {
2138 556 : tree _o1[2], _r1;
2139 556 : _o1[0] = captures[1];
2140 556 : _o1[1] = wide_int_to_tree (ty, mask - rhs);
2141 556 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2142 556 : res_op0 = _r1;
2143 : }
2144 556 : tree res_op1;
2145 556 : res_op1 = build_zero_cst (ty);
2146 556 : tree _r;
2147 556 : _r = fold_build2_loc (loc, eqcmp, type, res_op0, res_op1);
2148 556 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 601, __FILE__, __LINE__, true);
2149 556 : return _r;
2150 : }
2151 11409 : next_after_fail729:;
2152 : }
2153 11965 : }
2154 : }
2155 : return NULL_TREE;
2156 : }
2157 :
2158 : tree
2159 1 : generic_simplify_413 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2160 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2161 : const combined_fn ARG_UNUSED (logs),
2162 : const combined_fn ARG_UNUSED (exps),
2163 : const enum tree_code ARG_UNUSED (cmp))
2164 : {
2165 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2166 1 : if (flag_unsafe_math_optimizations
2167 : )
2168 : {
2169 1 : if (! HONOR_SIGN_DEPENDENT_ROUNDING (type)
2170 1 : && ! HONOR_NANS (type) && ! HONOR_INFINITIES (type)
2171 1 : && ! flag_trapping_math
2172 2 : && ! flag_errno_math
2173 : )
2174 : {
2175 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail735;
2176 1 : {
2177 1 : tree res_op0;
2178 1 : res_op0 = captures[1];
2179 1 : tree res_op1;
2180 1 : {
2181 1 : tree _o1[1], _r1;
2182 1 : _o1[0] = captures[2];
2183 1 : _r1 = maybe_build_call_expr_loc (loc, logs, TREE_TYPE (_o1[0]), 1, _o1[0]);
2184 1 : if (!_r1)
2185 0 : goto next_after_fail735;
2186 1 : if (EXPR_P (_r1))
2187 1 : goto next_after_fail735;
2188 0 : res_op1 = _r1;
2189 : }
2190 0 : tree _r;
2191 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2192 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 603, __FILE__, __LINE__, true);
2193 0 : return _r;
2194 : }
2195 : next_after_fail735:;
2196 : }
2197 : }
2198 : return NULL_TREE;
2199 : }
2200 :
2201 : tree
2202 0 : generic_simplify_421 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2203 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2204 : const enum tree_code ARG_UNUSED (shiftrotate))
2205 : {
2206 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2207 0 : {
2208 0 : tree tem = uniform_vector_p (captures[1]);
2209 0 : if (tem
2210 : )
2211 : {
2212 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail747;
2213 0 : {
2214 0 : tree res_op0;
2215 0 : res_op0 = captures[0];
2216 0 : tree res_op1;
2217 0 : res_op1 = tem;
2218 0 : tree _r;
2219 0 : _r = fold_build2_loc (loc, shiftrotate, type, res_op0, res_op1);
2220 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2221 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2222 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 615, __FILE__, __LINE__, true);
2223 0 : return _r;
2224 : }
2225 0 : next_after_fail747:;
2226 : }
2227 : }
2228 : return NULL_TREE;
2229 : }
2230 :
2231 : tree
2232 3402823 : generic_simplify_428 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2233 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2234 : const enum tree_code ARG_UNUSED (bitop))
2235 : {
2236 3402823 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2237 3402823 : if (0
2238 : && TREE_CODE (captures[3]) != INTEGER_CST
2239 : && tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
2240 : && types_match (type, captures[2])
2241 : && !POINTER_TYPE_P (TREE_TYPE (captures[2]))
2242 : && TREE_CODE (TREE_TYPE (captures[2])) != OFFSET_TYPE
2243 : )
2244 : {
2245 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail761;
2246 : {
2247 : tree res_op0;
2248 : res_op0 = captures[2];
2249 : tree res_op1;
2250 : {
2251 : tree _o1[1], _r1;
2252 : _o1[0] = captures[3];
2253 : if (TREE_TYPE (_o1[0]) != type)
2254 : {
2255 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2256 : }
2257 : else
2258 : _r1 = _o1[0];
2259 : res_op1 = _r1;
2260 : }
2261 : tree _r;
2262 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
2263 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 627, __FILE__, __LINE__, true);
2264 : return _r;
2265 : }
2266 : next_after_fail761:;
2267 : }
2268 3402823 : return NULL_TREE;
2269 : }
2270 :
2271 : tree
2272 861900 : generic_simplify_432 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2273 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2274 : const enum tree_code ARG_UNUSED (op))
2275 : {
2276 861900 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2277 861900 : if (INTEGRAL_TYPE_P (type)
2278 763077 : && op != MULT_EXPR
2279 763077 : && op != RDIV_EXPR
2280 449500 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2281 390389 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2282 390389 : && type_has_mode_precision_p (TREE_TYPE (captures[2]))
2283 345146 : && type_has_mode_precision_p (TREE_TYPE (captures[4]))
2284 344863 : && type_has_mode_precision_p (type)
2285 344841 : && TYPE_PRECISION (TREE_TYPE (captures[1])) > TYPE_PRECISION (TREE_TYPE (captures[2]))
2286 24060 : && types_match (captures[2], type)
2287 864496 : && (types_match (captures[2], captures[4])
2288 2527 : || poly_int_tree_p (captures[3]))
2289 : )
2290 : {
2291 69 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))
2292 : )
2293 : {
2294 15 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail767;
2295 15 : {
2296 15 : tree res_op0;
2297 15 : res_op0 = captures[2];
2298 15 : tree res_op1;
2299 15 : {
2300 15 : tree _o1[1], _r1;
2301 15 : _o1[0] = captures[4];
2302 15 : if (TREE_TYPE (_o1[0]) != type)
2303 : {
2304 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2305 : }
2306 : else
2307 : _r1 = _o1[0];
2308 15 : res_op1 = _r1;
2309 : }
2310 15 : tree _r;
2311 15 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2312 15 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 633, __FILE__, __LINE__, true);
2313 15 : return _r;
2314 : }
2315 0 : next_after_fail767:;
2316 : }
2317 : else
2318 : {
2319 54 : {
2320 54 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
2321 54 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail768;
2322 54 : {
2323 54 : tree res_op0;
2324 54 : {
2325 54 : tree _o1[2], _r1;
2326 54 : {
2327 54 : tree _o2[1], _r2;
2328 54 : _o2[0] = captures[2];
2329 54 : if (TREE_TYPE (_o2[0]) != utype)
2330 : {
2331 54 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2332 : }
2333 : else
2334 : _r2 = _o2[0];
2335 54 : _o1[0] = _r2;
2336 : }
2337 54 : {
2338 54 : tree _o2[1], _r2;
2339 54 : _o2[0] = captures[4];
2340 54 : if (TREE_TYPE (_o2[0]) != utype)
2341 : {
2342 54 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2343 : }
2344 : else
2345 : _r2 = _o2[0];
2346 54 : _o1[1] = _r2;
2347 : }
2348 54 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2349 54 : res_op0 = _r1;
2350 : }
2351 54 : tree _r;
2352 54 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2353 54 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 634, __FILE__, __LINE__, true);
2354 54 : return _r;
2355 : }
2356 0 : next_after_fail768:;
2357 : }
2358 : }
2359 : }
2360 : else
2361 : {
2362 851347 : if (FLOAT_TYPE_P (type)
2363 872315 : && DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
2364 10484 : == DECIMAL_FLOAT_TYPE_P (type)
2365 : )
2366 : {
2367 10461 : {
2368 10461 : tree arg0 = strip_float_extensions (captures[2]);
2369 10461 : tree arg1 = strip_float_extensions (captures[4]);
2370 10461 : tree itype = TREE_TYPE (captures[0]);
2371 10461 : tree ty1 = TREE_TYPE (arg0);
2372 10461 : tree ty2 = TREE_TYPE (arg1);
2373 10461 : enum tree_code code = TREE_CODE (itype);
2374 0 : if (FLOAT_TYPE_P (ty1)
2375 10461 : && FLOAT_TYPE_P (ty2)
2376 : )
2377 : {
2378 10461 : {
2379 10461 : tree newtype = type;
2380 10461 : if (TYPE_MODE (ty1) == SDmode
2381 10452 : || TYPE_MODE (ty2) == SDmode
2382 20913 : || TYPE_MODE (type) == SDmode)
2383 9 : newtype = dfloat32_type_node;
2384 10461 : if (TYPE_MODE (ty1) == DDmode
2385 10455 : || TYPE_MODE (ty2) == DDmode
2386 20916 : || TYPE_MODE (type) == DDmode)
2387 6 : newtype = dfloat64_type_node;
2388 10461 : if (TYPE_MODE (ty1) == TDmode
2389 10461 : || TYPE_MODE (ty2) == TDmode
2390 20922 : || TYPE_MODE (type) == TDmode)
2391 15 : newtype = dfloat128_type_node;
2392 10461 : if ((newtype == dfloat32_type_node
2393 10461 : || newtype == dfloat64_type_node
2394 10461 : || newtype == dfloat128_type_node)
2395 15 : && newtype == type
2396 10467 : && types_match (newtype, type)
2397 : )
2398 : {
2399 6 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail769;
2400 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail769;
2401 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail769;
2402 0 : {
2403 0 : tree res_op0;
2404 0 : {
2405 0 : tree _o1[1], _r1;
2406 0 : _o1[0] = captures[2];
2407 0 : if (TREE_TYPE (_o1[0]) != newtype)
2408 : {
2409 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
2410 : }
2411 : else
2412 : _r1 = _o1[0];
2413 0 : res_op0 = _r1;
2414 : }
2415 0 : tree res_op1;
2416 0 : {
2417 0 : tree _o1[1], _r1;
2418 0 : _o1[0] = captures[4];
2419 0 : if (TREE_TYPE (_o1[0]) != newtype)
2420 : {
2421 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
2422 : }
2423 : else
2424 : _r1 = _o1[0];
2425 0 : res_op1 = _r1;
2426 : }
2427 0 : tree _r;
2428 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2429 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 635, __FILE__, __LINE__, true);
2430 0 : return _r;
2431 : }
2432 : next_after_fail769:;
2433 : }
2434 : else
2435 : {
2436 10455 : {
2437 10455 : if (element_precision (ty1) > element_precision (newtype))
2438 4 : newtype = ty1;
2439 10455 : if (element_precision (ty2) > element_precision (newtype))
2440 2 : newtype = ty2;
2441 10455 : if (element_precision (newtype) < element_precision (itype)
2442 10210 : && (!VECTOR_MODE_P (TYPE_MODE (newtype))
2443 0 : || target_supports_op_p (newtype, op, optab_default))
2444 10210 : && (flag_unsafe_math_optimizations
2445 10193 : || (element_precision (newtype) == element_precision (type)
2446 10189 : && real_can_shorten_arithmetic (element_mode (itype),
2447 : element_mode (type))
2448 3412 : && !excess_precision_type (newtype)))
2449 10480 : && !types_match (itype, newtype)
2450 : )
2451 : {
2452 25 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail770;
2453 25 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail770;
2454 17 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail770;
2455 17 : {
2456 17 : tree res_op0;
2457 17 : {
2458 17 : tree _o1[2], _r1;
2459 17 : {
2460 17 : tree _o2[1], _r2;
2461 17 : _o2[0] = captures[2];
2462 17 : if (TREE_TYPE (_o2[0]) != newtype)
2463 : {
2464 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
2465 : }
2466 : else
2467 : _r2 = _o2[0];
2468 17 : _o1[0] = _r2;
2469 : }
2470 17 : {
2471 17 : tree _o2[1], _r2;
2472 17 : _o2[0] = captures[4];
2473 17 : if (TREE_TYPE (_o2[0]) != newtype)
2474 : {
2475 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
2476 : }
2477 : else
2478 : _r2 = _o2[0];
2479 17 : _o1[1] = _r2;
2480 : }
2481 17 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2482 17 : res_op0 = _r1;
2483 : }
2484 17 : tree _r;
2485 17 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2486 17 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 636, __FILE__, __LINE__, true);
2487 17 : return _r;
2488 : }
2489 : next_after_fail770:;
2490 : }
2491 : }
2492 : }
2493 : }
2494 : }
2495 : }
2496 : }
2497 : }
2498 : return NULL_TREE;
2499 : }
2500 :
2501 : tree
2502 15 : generic_simplify_460 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2503 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2504 : const enum tree_code ARG_UNUSED (bitop))
2505 : {
2506 15 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2507 15 : {
2508 15 : tree pmop[2];
2509 15 : tree utype = fold_bit_and_mask (TREE_TYPE (captures[1]), captures[4], NEGATE_EXPR, captures[1],
2510 : bitop, captures[2], captures[3], NULL_TREE, ERROR_MARK,
2511 : NULL_TREE, NULL_TREE, pmop);
2512 15 : if (utype
2513 : )
2514 : {
2515 7 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail807;
2516 7 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail807;
2517 7 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail807;
2518 7 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail807;
2519 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail807;
2520 7 : {
2521 7 : tree res_op0;
2522 7 : {
2523 7 : tree _o1[2], _r1;
2524 7 : {
2525 7 : tree _o2[1], _r2;
2526 7 : {
2527 7 : tree _o3[1], _r3;
2528 7 : _o3[0] = pmop[0];
2529 7 : if (TREE_TYPE (_o3[0]) != utype)
2530 : {
2531 4 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
2532 : }
2533 : else
2534 : _r3 = _o3[0];
2535 7 : _o2[0] = _r3;
2536 : }
2537 7 : _r2 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
2538 7 : _o1[0] = _r2;
2539 : }
2540 7 : {
2541 7 : tree _o2[1], _r2;
2542 7 : _o2[0] = captures[4];
2543 7 : if (TREE_TYPE (_o2[0]) != utype)
2544 : {
2545 4 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2546 : }
2547 : else
2548 : _r2 = _o2[0];
2549 7 : _o1[1] = _r2;
2550 : }
2551 7 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2552 7 : res_op0 = _r1;
2553 : }
2554 7 : tree _r;
2555 7 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2556 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 660, __FILE__, __LINE__, true);
2557 7 : return _r;
2558 : }
2559 8 : next_after_fail807:;
2560 : }
2561 : }
2562 8 : return NULL_TREE;
2563 : }
2564 :
2565 : tree
2566 0 : generic_simplify_472 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2567 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2568 : const enum tree_code ARG_UNUSED (code2),
2569 : const enum tree_code ARG_UNUSED (code1))
2570 : {
2571 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2572 0 : if ((TREE_CODE (captures[2]) == INTEGER_CST
2573 0 : && TREE_CODE (captures[5]) == INTEGER_CST)
2574 0 : || ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2575 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[2]))
2576 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, code2))
2577 0 : || POINTER_TYPE_P (TREE_TYPE (captures[2])))
2578 0 : && bitwise_equal_p (captures[2], captures[5]))
2579 : )
2580 : {
2581 0 : {
2582 0 : bool one_before = false;
2583 0 : bool one_after = false;
2584 0 : int cmp = 0;
2585 0 : bool allbits = true;
2586 0 : if (TREE_CODE (captures[2]) == INTEGER_CST
2587 0 : && TREE_CODE (captures[5]) == INTEGER_CST)
2588 : {
2589 0 : allbits = TYPE_PRECISION (TREE_TYPE (captures[2])) <= TYPE_PRECISION (TREE_TYPE (captures[5]));
2590 0 : auto t1 = wi::to_wide (fold_convert (TREE_TYPE (captures[5]), captures[2]));
2591 0 : auto t2 = wi::to_wide (captures[5]);
2592 0 : cmp = wi::cmp (t1, t2, TYPE_SIGN (TREE_TYPE (captures[5])));
2593 0 : if (cmp < 0
2594 0 : && t1 == t2 - 1)
2595 : one_before = true;
2596 0 : if (cmp > 0
2597 0 : && t1 == t2 + 1)
2598 : one_after = true;
2599 : }
2600 0 : bool val;
2601 0 : switch (code2)
2602 : {
2603 0 : case EQ_EXPR: val = (cmp == 0); break;
2604 0 : case NE_EXPR: val = (cmp != 0); break;
2605 0 : case LT_EXPR: val = (cmp < 0); break;
2606 0 : case GT_EXPR: val = (cmp > 0); break;
2607 0 : case LE_EXPR: val = (cmp <= 0); break;
2608 0 : case GE_EXPR: val = (cmp >= 0); break;
2609 0 : default: gcc_unreachable ();
2610 : }
2611 0 : if (code1 == EQ_EXPR && val
2612 : )
2613 : {
2614 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail821;
2615 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail821;
2616 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail821;
2617 0 : {
2618 0 : tree _r;
2619 0 : _r = captures[0];
2620 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 673, __FILE__, __LINE__, true);
2621 0 : return _r;
2622 : }
2623 : next_after_fail821:;
2624 : }
2625 : else
2626 : {
2627 0 : if (code1 == EQ_EXPR && !val
2628 : )
2629 : {
2630 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail822;
2631 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail822;
2632 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail822;
2633 0 : {
2634 0 : tree _r;
2635 0 : _r = constant_boolean_node (false, type);
2636 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2637 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2638 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 674, __FILE__, __LINE__, true);
2639 0 : return _r;
2640 : }
2641 : next_after_fail822:;
2642 : }
2643 : else
2644 : {
2645 0 : if (code1 == NE_EXPR && !val && allbits
2646 : )
2647 : {
2648 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail823;
2649 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail823;
2650 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail823;
2651 0 : {
2652 0 : tree _r;
2653 0 : _r = captures[3];
2654 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 675, __FILE__, __LINE__, true);
2655 0 : return _r;
2656 : }
2657 : next_after_fail823:;
2658 : }
2659 : else
2660 : {
2661 0 : if ((code1 == NE_EXPR
2662 0 : && code2 == GE_EXPR
2663 0 : && cmp == 0
2664 0 : && allbits)
2665 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
2666 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GT_EXPR))
2667 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
2668 : )
2669 : {
2670 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail824;
2671 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail824;
2672 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail824;
2673 0 : {
2674 0 : tree res_op0;
2675 0 : res_op0 = captures[4];
2676 0 : tree res_op1;
2677 0 : {
2678 0 : tree _o1[1], _r1;
2679 0 : _o1[0] = captures[2];
2680 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
2681 : {
2682 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
2683 : }
2684 : else
2685 : _r1 = _o1[0];
2686 0 : res_op1 = _r1;
2687 : }
2688 0 : tree _r;
2689 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
2690 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 676, __FILE__, __LINE__, true);
2691 0 : return _r;
2692 : }
2693 : next_after_fail824:;
2694 : }
2695 : else
2696 : {
2697 0 : if ((code1 == NE_EXPR
2698 0 : && code2 == LE_EXPR
2699 0 : && cmp == 0
2700 0 : && allbits)
2701 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
2702 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LT_EXPR))
2703 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
2704 : )
2705 : {
2706 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail825;
2707 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail825;
2708 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail825;
2709 0 : {
2710 0 : tree res_op0;
2711 0 : res_op0 = captures[4];
2712 0 : tree res_op1;
2713 0 : {
2714 0 : tree _o1[1], _r1;
2715 0 : _o1[0] = captures[2];
2716 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
2717 : {
2718 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
2719 : }
2720 : else
2721 : _r1 = _o1[0];
2722 0 : res_op1 = _r1;
2723 : }
2724 0 : tree _r;
2725 0 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
2726 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 677, __FILE__, __LINE__, true);
2727 0 : return _r;
2728 : }
2729 : next_after_fail825:;
2730 : }
2731 : else
2732 : {
2733 0 : if ((code1 == NE_EXPR
2734 0 : && code2 == GT_EXPR
2735 : && one_after
2736 0 : && allbits)
2737 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
2738 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GT_EXPR))
2739 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
2740 : )
2741 : {
2742 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail826;
2743 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail826;
2744 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail826;
2745 0 : {
2746 0 : tree res_op0;
2747 0 : res_op0 = captures[4];
2748 0 : tree res_op1;
2749 0 : {
2750 0 : tree _o1[1], _r1;
2751 0 : _o1[0] = captures[2];
2752 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
2753 : {
2754 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
2755 : }
2756 : else
2757 : _r1 = _o1[0];
2758 0 : res_op1 = _r1;
2759 : }
2760 0 : tree _r;
2761 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
2762 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 678, __FILE__, __LINE__, true);
2763 0 : return _r;
2764 : }
2765 : next_after_fail826:;
2766 : }
2767 : else
2768 : {
2769 0 : if ((code1 == NE_EXPR
2770 0 : && code2 == LT_EXPR
2771 : && one_before
2772 0 : && allbits)
2773 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
2774 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LT_EXPR))
2775 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
2776 : )
2777 : {
2778 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail827;
2779 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail827;
2780 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail827;
2781 0 : {
2782 0 : tree res_op0;
2783 0 : res_op0 = captures[4];
2784 0 : tree res_op1;
2785 0 : {
2786 0 : tree _o1[1], _r1;
2787 0 : _o1[0] = captures[2];
2788 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
2789 : {
2790 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
2791 : }
2792 : else
2793 : _r1 = _o1[0];
2794 0 : res_op1 = _r1;
2795 : }
2796 0 : tree _r;
2797 0 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
2798 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 679, __FILE__, __LINE__, true);
2799 0 : return _r;
2800 : }
2801 : next_after_fail827:;
2802 : }
2803 : }
2804 : }
2805 : }
2806 : }
2807 : }
2808 : }
2809 : }
2810 : }
2811 : return NULL_TREE;
2812 : }
2813 :
2814 : tree
2815 31 : generic_simplify_502 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2816 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2817 : {
2818 31 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2819 31 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[2]))
2820 54 : && (element_precision (TREE_TYPE (captures[2]))
2821 23 : <= element_precision (TREE_TYPE (captures[3]))
2822 1 : || !TYPE_UNSIGNED (TREE_TYPE (captures[3])))
2823 : )
2824 : {
2825 22 : {
2826 22 : tree shift_type = TREE_TYPE (captures[2]);
2827 22 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail893;
2828 22 : {
2829 22 : tree res_op0;
2830 22 : {
2831 22 : tree _o1[2], _r1;
2832 22 : {
2833 22 : tree _o2[1], _r2;
2834 22 : _o2[0] = captures[3];
2835 22 : if (TREE_TYPE (_o2[0]) != shift_type)
2836 : {
2837 1 : _r2 = fold_build1_loc (loc, NOP_EXPR, shift_type, _o2[0]);
2838 : }
2839 : else
2840 : _r2 = _o2[0];
2841 22 : _o1[0] = _r2;
2842 : }
2843 22 : _o1[1] = captures[4];
2844 22 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2845 22 : res_op0 = _r1;
2846 : }
2847 22 : tree _r;
2848 22 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2849 22 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 707, __FILE__, __LINE__, true);
2850 22 : return _r;
2851 : }
2852 0 : next_after_fail893:;
2853 : }
2854 : }
2855 : return NULL_TREE;
2856 : }
2857 :
2858 : tree
2859 3769 : generic_simplify_514 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2860 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2861 : {
2862 3769 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2863 3769 : if (!TYPE_SATURATING (type)
2864 : )
2865 : {
2866 3734 : if (!TYPE_OVERFLOW_SANITIZED (type)
2867 7490 : && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[0]))
2868 : )
2869 : {
2870 3756 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail906;
2871 3756 : {
2872 3756 : tree res_op0;
2873 3756 : {
2874 3756 : tree _o1[1], _r1;
2875 3756 : _o1[0] = captures[0];
2876 3756 : if (TREE_TYPE (_o1[0]) != type)
2877 : {
2878 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
2879 : }
2880 : else
2881 : _r1 = _o1[0];
2882 3756 : res_op0 = _r1;
2883 : }
2884 3756 : tree _r;
2885 3756 : _r = non_lvalue_loc (loc, res_op0);
2886 3756 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 718, __FILE__, __LINE__, true);
2887 3756 : return _r;
2888 : }
2889 0 : next_after_fail906:;
2890 : }
2891 : }
2892 : return NULL_TREE;
2893 : }
2894 :
2895 : tree
2896 4 : generic_simplify_521 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2897 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2898 : {
2899 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2900 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail914;
2901 4 : {
2902 4 : tree _r;
2903 4 : _r = captures[1];
2904 4 : if (TREE_SIDE_EFFECTS (captures[0]))
2905 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2906 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 725, __FILE__, __LINE__, true);
2907 : return _r;
2908 : }
2909 0 : next_after_fail914:;
2910 0 : return NULL_TREE;
2911 : }
2912 :
2913 : tree
2914 20 : generic_simplify_530 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2915 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2916 : const enum tree_code ARG_UNUSED (minmax),
2917 : const enum tree_code ARG_UNUSED (cmp))
2918 : {
2919 20 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2920 20 : {
2921 20 : poly_int64 off0, off1;
2922 20 : tree base0, base1;
2923 20 : int equal = address_compare (cmp, TREE_TYPE (captures[0]), captures[1], captures[3], base0, base1,
2924 : off0, off1,
2925 : 1
2926 : );
2927 20 : if (equal == 1
2928 : )
2929 : {
2930 0 : if (minmax == MIN_EXPR
2931 : )
2932 : {
2933 0 : if (known_le (off0, off1)
2934 : )
2935 : {
2936 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail934;
2937 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail934;
2938 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail934;
2939 0 : {
2940 0 : tree _r;
2941 0 : _r = captures[0];
2942 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 733, __FILE__, __LINE__, true);
2943 0 : return _r;
2944 : }
2945 20 : next_after_fail934:;
2946 : }
2947 : else
2948 : {
2949 0 : if (known_gt (off0, off1)
2950 : )
2951 : {
2952 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail935;
2953 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail935;
2954 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail935;
2955 0 : {
2956 0 : tree _r;
2957 0 : _r = captures[2];
2958 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 734, __FILE__, __LINE__, true);
2959 0 : return _r;
2960 : }
2961 20 : next_after_fail935:;
2962 : }
2963 : }
2964 : }
2965 : else
2966 : {
2967 0 : if (known_ge (off0, off1)
2968 : )
2969 : {
2970 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail936;
2971 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail936;
2972 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail936;
2973 0 : {
2974 0 : tree _r;
2975 0 : _r = captures[0];
2976 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 735, __FILE__, __LINE__, true);
2977 0 : return _r;
2978 : }
2979 20 : next_after_fail936:;
2980 : }
2981 : else
2982 : {
2983 0 : if (known_lt (off0, off1)
2984 : )
2985 : {
2986 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail937;
2987 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail937;
2988 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail937;
2989 0 : {
2990 0 : tree _r;
2991 0 : _r = captures[2];
2992 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 736, __FILE__, __LINE__, true);
2993 0 : return _r;
2994 : }
2995 20 : next_after_fail937:;
2996 : }
2997 : }
2998 : }
2999 : }
3000 : }
3001 20 : return NULL_TREE;
3002 : }
3003 :
3004 : tree
3005 0 : generic_simplify_551 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3006 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
3007 : const combined_fn ARG_UNUSED (cond_len_op))
3008 : {
3009 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3010 0 : {
3011 0 : tree op_type = TREE_TYPE (captures[6]);
3012 0 : if (inverse_conditions_p (captures[0], captures[2])
3013 0 : && element_precision (type) == element_precision (op_type)
3014 : )
3015 : {
3016 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail958;
3017 0 : {
3018 0 : tree res_op0;
3019 0 : {
3020 0 : tree _o1[7], _r1;
3021 0 : _o1[0] = captures[2];
3022 0 : _o1[1] = captures[3];
3023 0 : _o1[2] = captures[4];
3024 0 : _o1[3] = captures[5];
3025 0 : {
3026 0 : tree _o2[1], _r2;
3027 0 : _o2[0] = captures[1];
3028 0 : if (TREE_TYPE (_o2[0]) != op_type)
3029 : {
3030 0 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
3031 : }
3032 : else
3033 : _r2 = _o2[0];
3034 0 : _o1[4] = _r2;
3035 : }
3036 0 : _o1[5] = captures[7];
3037 0 : _o1[6] = captures[8];
3038 0 : _r1 = maybe_build_call_expr_loc (loc, cond_len_op, TREE_TYPE (_o1[1]), 7, _o1[0], _o1[1], _o1[2], _o1[3], _o1[4], _o1[5], _o1[6]);
3039 0 : if (!_r1)
3040 0 : goto next_after_fail958;
3041 0 : res_op0 = _r1;
3042 : }
3043 0 : tree _r;
3044 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3045 0 : if (TREE_SIDE_EFFECTS (captures[0]))
3046 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3047 0 : if (TREE_SIDE_EFFECTS (captures[6]))
3048 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[6]), _r);
3049 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 752, __FILE__, __LINE__, true);
3050 0 : return _r;
3051 : }
3052 : next_after_fail958:;
3053 : }
3054 : }
3055 : return NULL_TREE;
3056 : }
3057 :
3058 : tree
3059 0 : generic_simplify_564 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3060 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
3061 : const combined_fn ARG_UNUSED (ovf))
3062 : {
3063 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3064 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
3065 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3066 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (TREE_TYPE (captures[1]))
3067 0 : && (!TYPE_UNSIGNED (TREE_TYPE (captures[0])) || TYPE_UNSIGNED (TREE_TYPE (captures[1])))
3068 : )
3069 : {
3070 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail974;
3071 0 : {
3072 0 : tree res_op0;
3073 0 : res_op0 = captures[1];
3074 0 : tree res_op1;
3075 0 : res_op1 = captures[2];
3076 0 : tree _r;
3077 0 : _r = maybe_build_call_expr_loc (loc, ovf, type, 2, res_op0, res_op1);
3078 0 : if (!_r)
3079 0 : goto next_after_fail974;
3080 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 768, __FILE__, __LINE__, true);
3081 0 : return _r;
3082 : }
3083 : next_after_fail974:;
3084 : }
3085 : return NULL_TREE;
3086 : }
3087 :
3088 : tree
3089 0 : generic_simplify_572 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3090 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3091 : const combined_fn ARG_UNUSED (fns))
3092 : {
3093 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3094 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail982;
3095 0 : {
3096 0 : tree res_op0;
3097 0 : res_op0 = captures[0];
3098 0 : tree _r;
3099 0 : _r = maybe_build_call_expr_loc (loc, fns, type, 1, res_op0);
3100 0 : if (!_r)
3101 0 : goto next_after_fail982;
3102 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 776, __FILE__, __LINE__, true);
3103 : return _r;
3104 : }
3105 : next_after_fail982:;
3106 : return NULL_TREE;
3107 : }
3108 :
3109 : tree
3110 0 : generic_simplify_580 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3111 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3112 : const combined_fn ARG_UNUSED (froms),
3113 : const combined_fn ARG_UNUSED (tos))
3114 : {
3115 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3116 0 : if (optimize && canonicalize_math_p ()
3117 : )
3118 : {
3119 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail990;
3120 0 : {
3121 0 : tree res_op0;
3122 0 : res_op0 = captures[0];
3123 0 : tree _r;
3124 0 : _r = maybe_build_call_expr_loc (loc, tos, type, 1, res_op0);
3125 0 : if (!_r)
3126 0 : goto next_after_fail990;
3127 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 784, __FILE__, __LINE__, true);
3128 0 : return _r;
3129 : }
3130 : next_after_fail990:;
3131 : }
3132 : return NULL_TREE;
3133 : }
3134 :
3135 : tree
3136 0 : generic_simplify_588 (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 : const combined_fn ARG_UNUSED (fmas))
3139 : {
3140 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3141 0 : if (canonicalize_math_after_vectorization_p ()
3142 : )
3143 : {
3144 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail998;
3145 : {
3146 : tree res_op0;
3147 : res_op0 = captures[0];
3148 : tree res_op1;
3149 : res_op1 = captures[1];
3150 : tree res_op2;
3151 : res_op2 = captures[2];
3152 : tree _r;
3153 : _r = maybe_build_call_expr_loc (loc, CFN_FNMA, type, 3, res_op0, res_op1, res_op2);
3154 : if (!_r)
3155 : goto next_after_fail998;
3156 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 792, __FILE__, __LINE__, true);
3157 : return _r;
3158 : }
3159 0 : next_after_fail998:;
3160 : }
3161 0 : return NULL_TREE;
3162 : }
3163 :
3164 : tree
3165 0 : generic_simplify_598 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3166 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree ARG_UNUSED (_p3), tree ARG_UNUSED (_p4), tree *ARG_UNUSED (captures),
3167 : const combined_fn ARG_UNUSED (fmas))
3168 : {
3169 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3170 0 : if (canonicalize_math_after_vectorization_p ()
3171 : )
3172 : {
3173 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1008;
3174 : {
3175 : tree res_op0;
3176 : res_op0 = captures[0];
3177 : tree res_op1;
3178 : res_op1 = captures[1];
3179 : tree res_op2;
3180 : res_op2 = captures[2];
3181 : tree res_op3;
3182 : res_op3 = captures[3];
3183 : tree res_op4;
3184 : res_op4 = captures[4];
3185 : tree _r;
3186 : _r = maybe_build_call_expr_loc (loc, CFN_COND_FNMA, type, 5, res_op0, res_op1, res_op2, res_op3, res_op4);
3187 : if (!_r)
3188 : goto next_after_fail1008;
3189 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 802, __FILE__, __LINE__, true);
3190 : return _r;
3191 : }
3192 0 : next_after_fail1008:;
3193 : }
3194 0 : return NULL_TREE;
3195 : }
3196 :
3197 : tree
3198 0 : generic_simplify_607 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3199 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3200 : const combined_fn ARG_UNUSED (ctz))
3201 : {
3202 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3203 0 : {
3204 0 : tree t = TREE_TYPE (captures[0]);
3205 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1017;
3206 0 : {
3207 0 : tree res_op0;
3208 0 : {
3209 0 : tree _o1[1], _r1;
3210 0 : _o1[0] = captures[1];
3211 0 : if (TREE_TYPE (_o1[0]) != t)
3212 : {
3213 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, t, _o1[0]);
3214 : }
3215 : else
3216 : _r1 = _o1[0];
3217 0 : res_op0 = _r1;
3218 : }
3219 0 : tree _r;
3220 0 : _r = maybe_build_call_expr_loc (loc, ctz, type, 1, res_op0);
3221 0 : if (!_r)
3222 0 : goto next_after_fail1017;
3223 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 810, __FILE__, __LINE__, true);
3224 : return _r;
3225 : }
3226 : next_after_fail1017:;
3227 : }
3228 : return NULL_TREE;
3229 : }
3230 :
3231 : tree
3232 0 : generic_simplify_617 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3233 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3234 : const combined_fn ARG_UNUSED (bswap),
3235 : const combined_fn ARG_UNUSED (parity))
3236 : {
3237 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3238 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3239 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
3240 0 : && TYPE_PRECISION (TREE_TYPE (captures[0]))
3241 0 : >= TYPE_PRECISION (TREE_TYPE (captures[1]))
3242 : )
3243 : {
3244 0 : {
3245 0 : tree type0 = TREE_TYPE (captures[0]);
3246 0 : tree type1 = TREE_TYPE (captures[1]);
3247 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1028;
3248 0 : {
3249 0 : tree res_op0;
3250 0 : {
3251 0 : tree _o1[1], _r1;
3252 0 : {
3253 0 : tree _o2[1], _r2;
3254 0 : _o2[0] = captures[2];
3255 0 : if (TREE_TYPE (_o2[0]) != type1)
3256 : {
3257 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, type1, _o2[0]);
3258 : }
3259 : else
3260 : _r2 = _o2[0];
3261 0 : _o1[0] = _r2;
3262 : }
3263 0 : if (TREE_TYPE (_o1[0]) != type0)
3264 : {
3265 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type0, _o1[0]);
3266 : }
3267 : else
3268 : _r1 = _o1[0];
3269 0 : res_op0 = _r1;
3270 : }
3271 0 : tree _r;
3272 0 : _r = maybe_build_call_expr_loc (loc, parity, type, 1, res_op0);
3273 0 : if (!_r)
3274 0 : goto next_after_fail1028;
3275 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 817, __FILE__, __LINE__, true);
3276 0 : return _r;
3277 : }
3278 : next_after_fail1028:;
3279 : }
3280 : }
3281 : return NULL_TREE;
3282 : }
3283 :
3284 : tree
3285 714288288 : generic_simplify_CONVERT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0)
3286 : {
3287 714288288 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3288 714288288 : switch (TREE_CODE (_p0))
3289 : {
3290 729198 : case NEGATE_EXPR:
3291 729198 : {
3292 729198 : tree _q20 = TREE_OPERAND (_p0, 0);
3293 729198 : switch (TREE_CODE (_q20))
3294 : {
3295 395003 : CASE_CONVERT:
3296 395003 : {
3297 395003 : tree _q30 = TREE_OPERAND (_q20, 0);
3298 395003 : {
3299 395003 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q30 };
3300 395003 : if (INTEGRAL_TYPE_P (type)
3301 394702 : && tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
3302 390962 : && (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (captures[2]))
3303 390111 : || TYPE_UNSIGNED (type))
3304 420213 : && TREE_CODE (type) != BOOLEAN_TYPE
3305 : )
3306 : {
3307 25210 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1042;
3308 25210 : {
3309 25210 : tree res_op0;
3310 25210 : {
3311 25210 : tree _o1[1], _r1;
3312 25210 : _o1[0] = captures[2];
3313 25210 : if (TREE_TYPE (_o1[0]) != type)
3314 : {
3315 25168 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3316 : }
3317 : else
3318 : _r1 = _o1[0];
3319 25210 : res_op0 = _r1;
3320 : }
3321 25210 : tree _r;
3322 25210 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
3323 25210 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 829, __FILE__, __LINE__, true);
3324 25210 : return _r;
3325 : }
3326 0 : next_after_fail1042:;
3327 : }
3328 : }
3329 369793 : break;
3330 : }
3331 : default:;
3332 : }
3333 : break;
3334 : }
3335 1191942 : case BIT_AND_EXPR:
3336 1191942 : {
3337 1191942 : tree _q20 = TREE_OPERAND (_p0, 0);
3338 1191942 : tree _q21 = TREE_OPERAND (_p0, 1);
3339 1191942 : {
3340 1191942 : tree _q20_pops[1];
3341 1191942 : if (tree_nop_convert (_q20, _q20_pops))
3342 : {
3343 601812 : tree _q30 = _q20_pops[0];
3344 601812 : {
3345 601812 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3346 601812 : tree res = generic_simplify_428 (loc, type, _p0, captures, BIT_AND_EXPR);
3347 601812 : if (res) return res;
3348 : }
3349 : }
3350 : }
3351 1191942 : {
3352 1191942 : tree _q21_pops[1];
3353 1191942 : if (tree_nop_convert (_q21, _q21_pops))
3354 : {
3355 513521 : tree _q40 = _q21_pops[0];
3356 513521 : {
3357 513521 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3358 513521 : tree res = generic_simplify_428 (loc, type, _p0, captures, BIT_AND_EXPR);
3359 513521 : if (res) return res;
3360 : }
3361 : }
3362 : }
3363 1191942 : switch (TREE_CODE (_q20))
3364 : {
3365 673533 : CASE_CONVERT:
3366 673533 : {
3367 673533 : tree _q30 = TREE_OPERAND (_q20, 0);
3368 673533 : {
3369 673533 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3370 673533 : tree res = generic_simplify_429 (loc, type, _p0, captures, BIT_AND_EXPR);
3371 673533 : if (res) return res;
3372 : }
3373 673533 : break;
3374 : }
3375 1191942 : default:;
3376 : }
3377 1191942 : switch (TREE_CODE (_q21))
3378 : {
3379 514302 : CASE_CONVERT:
3380 514302 : {
3381 514302 : tree _q40 = TREE_OPERAND (_q21, 0);
3382 514302 : {
3383 514302 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3384 514302 : tree res = generic_simplify_429 (loc, type, _p0, captures, BIT_AND_EXPR);
3385 514302 : if (res) return res;
3386 : }
3387 514302 : break;
3388 : }
3389 : default:;
3390 : }
3391 : break;
3392 : }
3393 1138414 : case BIT_IOR_EXPR:
3394 1138414 : {
3395 1138414 : tree _q20 = TREE_OPERAND (_p0, 0);
3396 1138414 : tree _q21 = TREE_OPERAND (_p0, 1);
3397 1138414 : {
3398 1138414 : tree _q20_pops[1];
3399 1138414 : if (tree_nop_convert (_q20, _q20_pops))
3400 : {
3401 419046 : tree _q30 = _q20_pops[0];
3402 419046 : {
3403 419046 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3404 419046 : tree res = generic_simplify_428 (loc, type, _p0, captures, BIT_IOR_EXPR);
3405 419046 : if (res) return res;
3406 : }
3407 : }
3408 : }
3409 1138414 : {
3410 1138414 : tree _q21_pops[1];
3411 1138414 : if (tree_nop_convert (_q21, _q21_pops))
3412 : {
3413 1067127 : tree _q40 = _q21_pops[0];
3414 1067127 : {
3415 1067127 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3416 1067127 : tree res = generic_simplify_428 (loc, type, _p0, captures, BIT_IOR_EXPR);
3417 1067127 : if (res) return res;
3418 : }
3419 : }
3420 : }
3421 1138414 : switch (TREE_CODE (_q20))
3422 : {
3423 436049 : CASE_CONVERT:
3424 436049 : {
3425 436049 : tree _q30 = TREE_OPERAND (_q20, 0);
3426 436049 : {
3427 436049 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3428 436049 : tree res = generic_simplify_429 (loc, type, _p0, captures, BIT_IOR_EXPR);
3429 436049 : if (res) return res;
3430 : }
3431 436049 : break;
3432 : }
3433 1138414 : default:;
3434 : }
3435 1138414 : switch (TREE_CODE (_q21))
3436 : {
3437 1074961 : CASE_CONVERT:
3438 1074961 : {
3439 1074961 : tree _q40 = TREE_OPERAND (_q21, 0);
3440 1074961 : {
3441 1074961 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3442 1074961 : tree res = generic_simplify_429 (loc, type, _p0, captures, BIT_IOR_EXPR);
3443 1074961 : if (res) return res;
3444 : }
3445 1074961 : break;
3446 : }
3447 : default:;
3448 : }
3449 : break;
3450 : }
3451 583857 : case BIT_XOR_EXPR:
3452 583857 : {
3453 583857 : tree _q20 = TREE_OPERAND (_p0, 0);
3454 583857 : tree _q21 = TREE_OPERAND (_p0, 1);
3455 583857 : {
3456 583857 : tree _q20_pops[1];
3457 583857 : if (tree_nop_convert (_q20, _q20_pops))
3458 : {
3459 332659 : tree _q30 = _q20_pops[0];
3460 332659 : {
3461 332659 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3462 332659 : tree res = generic_simplify_428 (loc, type, _p0, captures, BIT_XOR_EXPR);
3463 332659 : if (res) return res;
3464 : }
3465 : }
3466 : }
3467 583857 : {
3468 583857 : tree _q21_pops[1];
3469 583857 : if (tree_nop_convert (_q21, _q21_pops))
3470 : {
3471 468658 : tree _q40 = _q21_pops[0];
3472 468658 : {
3473 468658 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3474 468658 : tree res = generic_simplify_428 (loc, type, _p0, captures, BIT_XOR_EXPR);
3475 468658 : if (res) return res;
3476 : }
3477 : }
3478 : }
3479 583857 : switch (TREE_CODE (_q20))
3480 : {
3481 373551 : CASE_CONVERT:
3482 373551 : {
3483 373551 : tree _q30 = TREE_OPERAND (_q20, 0);
3484 373551 : {
3485 373551 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3486 373551 : tree res = generic_simplify_429 (loc, type, _p0, captures, BIT_XOR_EXPR);
3487 373551 : if (res) return res;
3488 : }
3489 373551 : break;
3490 : }
3491 583857 : default:;
3492 : }
3493 583857 : switch (TREE_CODE (_q21))
3494 : {
3495 508539 : CASE_CONVERT:
3496 508539 : {
3497 508539 : tree _q40 = TREE_OPERAND (_q21, 0);
3498 508539 : {
3499 508539 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3500 508539 : tree res = generic_simplify_429 (loc, type, _p0, captures, BIT_XOR_EXPR);
3501 508539 : if (res) return res;
3502 : }
3503 508539 : break;
3504 : }
3505 : default:;
3506 : }
3507 : break;
3508 : }
3509 9082043 : case MULT_EXPR:
3510 9082043 : {
3511 9082043 : tree _q20 = TREE_OPERAND (_p0, 0);
3512 9082043 : tree _q21 = TREE_OPERAND (_p0, 1);
3513 9082043 : if (tree_zero_one_valued_p (_q20))
3514 : {
3515 57510 : switch (TREE_CODE (_q21))
3516 : {
3517 52033 : case INTEGER_CST:
3518 52033 : {
3519 52033 : {
3520 52033 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
3521 52033 : if (INTEGRAL_TYPE_P (type)
3522 52033 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3523 52033 : && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (captures[0]))
3524 52039 : && (TYPE_UNSIGNED (type) || TYPE_PRECISION (type) > 1)
3525 : )
3526 : {
3527 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1043;
3528 6 : {
3529 6 : tree res_op0;
3530 6 : {
3531 6 : tree _o1[1], _r1;
3532 6 : _o1[0] = captures[1];
3533 6 : if (TREE_TYPE (_o1[0]) != type)
3534 : {
3535 6 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3536 : }
3537 : else
3538 : _r1 = _o1[0];
3539 6 : res_op0 = _r1;
3540 : }
3541 6 : tree res_op1;
3542 6 : {
3543 6 : tree _o1[1], _r1;
3544 6 : _o1[0] = captures[2];
3545 6 : if (TREE_TYPE (_o1[0]) != type)
3546 : {
3547 6 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3548 : }
3549 : else
3550 : _r1 = _o1[0];
3551 6 : res_op1 = _r1;
3552 : }
3553 6 : tree _r;
3554 6 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
3555 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 830, __FILE__, __LINE__, true);
3556 6 : return _r;
3557 : }
3558 0 : next_after_fail1043:;
3559 : }
3560 : }
3561 52027 : break;
3562 : }
3563 : default:;
3564 : }
3565 : }
3566 : break;
3567 : }
3568 1115517 : case POINTER_DIFF_EXPR:
3569 1115517 : {
3570 1115517 : tree _q20 = TREE_OPERAND (_p0, 0);
3571 1115517 : tree _q21 = TREE_OPERAND (_p0, 1);
3572 1115517 : switch (TREE_CODE (_q21))
3573 : {
3574 200 : case INTEGER_CST:
3575 200 : {
3576 200 : {
3577 200 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3578 200 : if (POINTER_TYPE_P (type)
3579 : )
3580 : {
3581 18 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1044;
3582 18 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1044;
3583 18 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1044;
3584 18 : {
3585 18 : tree _r;
3586 18 : _r = build_fold_addr_expr_with_type
3587 : (build2 (MEM_REF, char_type_node, captures[0],
3588 : wide_int_to_tree (ptr_type_node, wi::neg (wi::to_wide (captures[1])))),
3589 : type);
3590 18 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 831, __FILE__, __LINE__, true);
3591 18 : return _r;
3592 : }
3593 182 : next_after_fail1044:;
3594 : }
3595 : }
3596 182 : break;
3597 : }
3598 : default:;
3599 : }
3600 : break;
3601 : }
3602 207337 : case EQ_EXPR:
3603 207337 : {
3604 207337 : tree _q20 = TREE_OPERAND (_p0, 0);
3605 207337 : tree _q21 = TREE_OPERAND (_p0, 1);
3606 207337 : if (tree_zero_one_valued_p (_q20))
3607 : {
3608 1638 : switch (TREE_CODE (_q21))
3609 : {
3610 761 : case INTEGER_CST:
3611 761 : {
3612 761 : {
3613 761 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3614 761 : tree res = generic_simplify_430 (loc, type, _p0, captures, EQ_EXPR);
3615 761 : if (res) return res;
3616 : }
3617 714 : break;
3618 : }
3619 : default:;
3620 : }
3621 : }
3622 : break;
3623 : }
3624 263055 : case NE_EXPR:
3625 263055 : {
3626 263055 : tree _q20 = TREE_OPERAND (_p0, 0);
3627 263055 : tree _q21 = TREE_OPERAND (_p0, 1);
3628 263055 : if (tree_zero_one_valued_p (_q20))
3629 : {
3630 1862 : switch (TREE_CODE (_q21))
3631 : {
3632 1536 : case INTEGER_CST:
3633 1536 : {
3634 1536 : {
3635 1536 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3636 1536 : tree res = generic_simplify_430 (loc, type, _p0, captures, NE_EXPR);
3637 1536 : if (res) return res;
3638 : }
3639 1 : break;
3640 : }
3641 : default:;
3642 : }
3643 : }
3644 : break;
3645 : }
3646 1999 : case MIN_EXPR:
3647 1999 : {
3648 1999 : tree _q20 = TREE_OPERAND (_p0, 0);
3649 1999 : tree _q21 = TREE_OPERAND (_p0, 1);
3650 1999 : switch (TREE_CODE (_q20))
3651 : {
3652 733 : CASE_CONVERT:
3653 733 : {
3654 733 : tree _q30 = TREE_OPERAND (_q20, 0);
3655 733 : switch (TREE_CODE (_q21))
3656 : {
3657 659 : case INTEGER_CST:
3658 659 : {
3659 659 : {
3660 659 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q21 };
3661 659 : tree res = generic_simplify_431 (loc, type, _p0, captures, MIN_EXPR);
3662 659 : if (res) return res;
3663 : }
3664 659 : break;
3665 : }
3666 : default:;
3667 : }
3668 : break;
3669 : }
3670 : default:;
3671 : }
3672 : break;
3673 : }
3674 304436 : case MAX_EXPR:
3675 304436 : {
3676 304436 : tree _q20 = TREE_OPERAND (_p0, 0);
3677 304436 : tree _q21 = TREE_OPERAND (_p0, 1);
3678 304436 : switch (TREE_CODE (_q20))
3679 : {
3680 6652 : CASE_CONVERT:
3681 6652 : {
3682 6652 : tree _q30 = TREE_OPERAND (_q20, 0);
3683 6652 : switch (TREE_CODE (_q21))
3684 : {
3685 6616 : case INTEGER_CST:
3686 6616 : {
3687 6616 : {
3688 6616 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q21 };
3689 6616 : tree res = generic_simplify_431 (loc, type, _p0, captures, MAX_EXPR);
3690 6616 : if (res) return res;
3691 : }
3692 6616 : break;
3693 : }
3694 : default:;
3695 : }
3696 : break;
3697 : }
3698 : default:;
3699 : }
3700 : break;
3701 : }
3702 464397 : case LSHIFT_EXPR:
3703 464397 : {
3704 464397 : tree _q20 = TREE_OPERAND (_p0, 0);
3705 464397 : tree _q21 = TREE_OPERAND (_p0, 1);
3706 464397 : switch (TREE_CODE (_q21))
3707 : {
3708 141050 : case INTEGER_CST:
3709 141050 : {
3710 141050 : {
3711 141050 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
3712 141050 : if (INTEGRAL_TYPE_P (type)
3713 141023 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3714 141023 : && !integer_zerop (captures[2])
3715 281300 : && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (captures[0]))
3716 : )
3717 : {
3718 138967 : if (TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (captures[0]))
3719 138967 : || wi::ltu_p (wi::to_wide (captures[2]), TYPE_PRECISION (type))
3720 : )
3721 : {
3722 138659 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1045;
3723 138659 : {
3724 138659 : tree res_op0;
3725 138659 : {
3726 138659 : tree _o1[1], _r1;
3727 138659 : _o1[0] = captures[1];
3728 138659 : if (TREE_TYPE (_o1[0]) != type)
3729 : {
3730 129585 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3731 : }
3732 : else
3733 : _r1 = _o1[0];
3734 138659 : res_op0 = _r1;
3735 : }
3736 138659 : tree res_op1;
3737 138659 : res_op1 = captures[2];
3738 138659 : tree _r;
3739 138659 : _r = fold_build2_loc (loc, LSHIFT_EXPR, type, res_op0, res_op1);
3740 138659 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 832, __FILE__, __LINE__, true);
3741 138659 : return _r;
3742 : }
3743 0 : next_after_fail1045:;
3744 : }
3745 : else
3746 : {
3747 308 : if (wi::ltu_p (wi::to_wide (captures[2]), TYPE_PRECISION (TREE_TYPE (captures[0])))
3748 : )
3749 : {
3750 259 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1046;
3751 259 : {
3752 259 : tree _r;
3753 259 : _r = build_zero_cst (type);
3754 259 : if (TREE_SIDE_EFFECTS (captures[1]))
3755 14 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3756 259 : if (TREE_SIDE_EFFECTS (captures[2]))
3757 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
3758 259 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 833, __FILE__, __LINE__, true);
3759 259 : return _r;
3760 : }
3761 0 : next_after_fail1046:;
3762 : }
3763 : }
3764 : }
3765 : }
3766 2132 : break;
3767 : }
3768 : default:;
3769 : }
3770 : break;
3771 : }
3772 714122554 : default:;
3773 : }
3774 714122554 : {
3775 714122554 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3776 1428245108 : if ((
3777 :
3778 : && useless_type_conversion_p (type, TREE_TYPE (captures[0])))
3779 : || (
3780 : 1
3781 714122554 : && type == TREE_TYPE (captures[0]))
3782 : )
3783 : {
3784 47775962 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1047;
3785 47775962 : {
3786 47775962 : tree _r;
3787 47775962 : _r = captures[0];
3788 47775962 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 834, __FILE__, __LINE__, true);
3789 47775962 : return _r;
3790 : }
3791 0 : next_after_fail1047:;
3792 : }
3793 : }
3794 666346592 : switch (TREE_CODE (_p0))
3795 : {
3796 94349630 : CASE_CONVERT:
3797 94349630 : {
3798 94349630 : tree _q20 = TREE_OPERAND (_p0, 0);
3799 94349630 : {
3800 94349630 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3801 94349630 : {
3802 94349630 : tree inside_type = TREE_TYPE (captures[1]);
3803 94349630 : tree inter_type = TREE_TYPE (captures[0]);
3804 94349630 : int inside_int = INTEGRAL_TYPE_P (inside_type);
3805 94349630 : int inside_ptr = POINTER_TYPE_P (inside_type);
3806 94349630 : int inside_float = FLOAT_TYPE_P (inside_type);
3807 94349630 : int inside_vec = VECTOR_TYPE_P (inside_type);
3808 94349630 : unsigned int inside_prec = element_precision (inside_type);
3809 94349630 : int inside_unsignedp = TYPE_UNSIGNED (inside_type);
3810 94349630 : int inter_int = INTEGRAL_TYPE_P (inter_type);
3811 94349630 : int inter_ptr = POINTER_TYPE_P (inter_type);
3812 94349630 : int inter_float = FLOAT_TYPE_P (inter_type);
3813 94349630 : int inter_vec = VECTOR_TYPE_P (inter_type);
3814 94349630 : unsigned int inter_prec = element_precision (inter_type);
3815 94349630 : int inter_unsignedp = TYPE_UNSIGNED (inter_type);
3816 94349630 : int final_int = INTEGRAL_TYPE_P (type);
3817 94349630 : int final_ptr = POINTER_TYPE_P (type);
3818 94349630 : int final_float = FLOAT_TYPE_P (type);
3819 94349630 : int final_vec = VECTOR_TYPE_P (type);
3820 94349630 : unsigned int final_prec = element_precision (type);
3821 94349630 : int final_unsignedp = TYPE_UNSIGNED (type);
3822 94349630 : if (((
3823 :
3824 : && useless_type_conversion_p (type, inside_type))
3825 : || (
3826 : 1
3827 94349630 : && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
3828 22321739 : && (((inter_int || inter_ptr) && final_int)
3829 16720973 : || (inter_float && final_float))
3830 100029976 : && inter_prec >= final_prec
3831 : )
3832 : {
3833 5157381 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1048;
3834 5157381 : {
3835 5157381 : tree res_op0;
3836 5157381 : res_op0 = captures[1];
3837 5157381 : tree _r;
3838 5157381 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3839 5157381 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 835, __FILE__, __LINE__, true);
3840 5157381 : return _r;
3841 : }
3842 0 : next_after_fail1048:;
3843 : }
3844 : else
3845 : {
3846 89192249 : if (((inter_int && inside_int) || (inter_float && inside_float))
3847 12442748 : && (final_int || final_float)
3848 12312212 : && inter_prec >= inside_prec
3849 11068591 : && (inter_float || inter_unsignedp == inside_unsignedp)
3850 : )
3851 : {
3852 7648950 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1049;
3853 7648950 : {
3854 7648950 : tree res_op0;
3855 7648950 : res_op0 = captures[1];
3856 7648950 : tree _r;
3857 7648950 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3858 7648950 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 836, __FILE__, __LINE__, true);
3859 7648950 : return _r;
3860 : }
3861 0 : next_after_fail1049:;
3862 0 : }
3863 : else
3864 : {
3865 81543299 : if (inside_int && inter_int && final_int
3866 4656961 : && ((inside_prec < inter_prec && inter_prec < final_prec
3867 193220 : && inside_unsignedp && !inter_unsignedp)
3868 4490517 : || final_prec == inter_prec
3869 2327239 : || (inside_prec < inter_prec && inter_prec > final_prec
3870 153562 : && !inside_unsignedp && inter_unsignedp))
3871 : )
3872 : {
3873 2395366 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1050;
3874 2395366 : {
3875 2395366 : tree res_op0;
3876 2395366 : res_op0 = captures[1];
3877 2395366 : tree _r;
3878 2395366 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3879 2395366 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 837, __FILE__, __LINE__, true);
3880 2395366 : return _r;
3881 : }
3882 0 : next_after_fail1050:;
3883 0 : }
3884 : else
3885 : {
3886 79147933 : if (! inside_float && ! inter_float && ! final_float
3887 : && ! inside_vec && ! inter_vec && ! final_vec
3888 79141628 : && (inter_prec >= inside_prec || inter_prec >= final_prec)
3889 78411797 : && ! (inside_int && inter_int
3890 1662296 : && inter_unsignedp != inside_unsignedp
3891 1662296 : && inter_prec < final_prec)
3892 77048842 : && ((inter_unsignedp && inter_prec > inside_prec)
3893 77048842 : == (final_unsignedp && final_prec > inter_prec))
3894 77026120 : && ! (inside_ptr && inter_prec != final_prec)
3895 76550285 : && ! (final_ptr && inside_prec != inter_prec)
3896 : )
3897 : {
3898 76529483 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1051;
3899 76529483 : {
3900 76529483 : tree res_op0;
3901 76529483 : res_op0 = captures[1];
3902 76529483 : tree _r;
3903 76529483 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3904 76529483 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 838, __FILE__, __LINE__, true);
3905 76529483 : return _r;
3906 : }
3907 0 : next_after_fail1051:;
3908 0 : }
3909 : else
3910 : {
3911 2618450 : if (inside_int && inter_int && final_int
3912 2122377 : && final_prec <= inside_prec
3913 670714 : && inter_prec >= inside_prec
3914 : )
3915 : {
3916 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1052;
3917 0 : {
3918 0 : tree res_op0;
3919 0 : res_op0 = captures[1];
3920 0 : tree _r;
3921 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3922 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 839, __FILE__, __LINE__, true);
3923 0 : return _r;
3924 : }
3925 0 : next_after_fail1052:;
3926 0 : }
3927 : else
3928 : {
3929 : if (0
3930 : && final_int && inter_int && inside_int
3931 : && final_prec >= inside_prec
3932 : && inside_prec > inter_prec
3933 : && inter_unsignedp
3934 : )
3935 : {
3936 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1053;
3937 : {
3938 : tree res_op0;
3939 : {
3940 : tree _o1[2], _r1;
3941 : _o1[0] = captures[1];
3942 : _o1[1] = wide_int_to_tree
3943 : (inside_type,
3944 : wi::mask (inter_prec, false,
3945 : TYPE_PRECISION (inside_type)));
3946 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3947 : res_op0 = _r1;
3948 : }
3949 : tree _r;
3950 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3951 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 840, __FILE__, __LINE__, true);
3952 : return _r;
3953 : }
3954 : next_after_fail1053:;
3955 : }
3956 : else
3957 : {
3958 : if (0
3959 : && inside_int && inter_float && final_int &&
3960 : (unsigned) significand_size (TYPE_MODE (inter_type))
3961 : >= inside_prec - !inside_unsignedp
3962 : )
3963 : {
3964 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1054;
3965 : {
3966 : tree res_op0;
3967 : res_op0 = captures[1];
3968 : tree _r;
3969 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3970 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 841, __FILE__, __LINE__, true);
3971 : return _r;
3972 : }
3973 : next_after_fail1054:;
3974 : }
3975 : }
3976 : }
3977 : }
3978 : }
3979 : }
3980 : }
3981 : }
3982 : }
3983 2618450 : break;
3984 : }
3985 3065 : case FLOAT_EXPR:
3986 3065 : {
3987 3065 : tree _q20 = TREE_OPERAND (_p0, 0);
3988 3065 : {
3989 3065 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3990 3065 : {
3991 3065 : tree inside_type = TREE_TYPE (captures[1]);
3992 3065 : tree inter_type = TREE_TYPE (captures[0]);
3993 3065 : int inside_int = INTEGRAL_TYPE_P (inside_type);
3994 3065 : int inside_ptr = POINTER_TYPE_P (inside_type);
3995 3065 : int inside_float = FLOAT_TYPE_P (inside_type);
3996 3065 : int inside_vec = VECTOR_TYPE_P (inside_type);
3997 3065 : unsigned int inside_prec = element_precision (inside_type);
3998 3065 : int inside_unsignedp = TYPE_UNSIGNED (inside_type);
3999 3065 : int inter_int = INTEGRAL_TYPE_P (inter_type);
4000 3065 : int inter_ptr = POINTER_TYPE_P (inter_type);
4001 3065 : int inter_float = FLOAT_TYPE_P (inter_type);
4002 3065 : int inter_vec = VECTOR_TYPE_P (inter_type);
4003 3065 : unsigned int inter_prec = element_precision (inter_type);
4004 3065 : int inter_unsignedp = TYPE_UNSIGNED (inter_type);
4005 3065 : int final_int = INTEGRAL_TYPE_P (type);
4006 3065 : int final_ptr = POINTER_TYPE_P (type);
4007 3065 : int final_float = FLOAT_TYPE_P (type);
4008 3065 : int final_vec = VECTOR_TYPE_P (type);
4009 3065 : unsigned int final_prec = element_precision (type);
4010 3065 : int final_unsignedp = TYPE_UNSIGNED (type);
4011 3065 : if (((
4012 :
4013 : && useless_type_conversion_p (type, inside_type))
4014 : || (
4015 : 1
4016 3065 : && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
4017 0 : && (((inter_int || inter_ptr) && final_int)
4018 0 : || (inter_float && final_float))
4019 3065 : && inter_prec >= final_prec
4020 : )
4021 : {
4022 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1055;
4023 0 : {
4024 0 : tree res_op0;
4025 0 : res_op0 = captures[1];
4026 0 : tree _r;
4027 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4028 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 835, __FILE__, __LINE__, true);
4029 0 : return _r;
4030 : }
4031 0 : next_after_fail1055:;
4032 : }
4033 : else
4034 : {
4035 3065 : if (((inter_int && inside_int) || (inter_float && inside_float))
4036 0 : && (final_int || final_float)
4037 0 : && inter_prec >= inside_prec
4038 0 : && (inter_float || inter_unsignedp == inside_unsignedp)
4039 : )
4040 : {
4041 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1056;
4042 0 : {
4043 0 : tree res_op0;
4044 0 : res_op0 = captures[1];
4045 0 : tree _r;
4046 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4047 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 836, __FILE__, __LINE__, true);
4048 0 : return _r;
4049 : }
4050 0 : next_after_fail1056:;
4051 0 : }
4052 : else
4053 : {
4054 3065 : if (inside_int && inter_int && final_int
4055 0 : && ((inside_prec < inter_prec && inter_prec < final_prec
4056 0 : && inside_unsignedp && !inter_unsignedp)
4057 0 : || final_prec == inter_prec
4058 0 : || (inside_prec < inter_prec && inter_prec > final_prec
4059 0 : && !inside_unsignedp && inter_unsignedp))
4060 : )
4061 : {
4062 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1057;
4063 0 : {
4064 0 : tree res_op0;
4065 0 : res_op0 = captures[1];
4066 0 : tree _r;
4067 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4068 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 837, __FILE__, __LINE__, true);
4069 0 : return _r;
4070 : }
4071 0 : next_after_fail1057:;
4072 0 : }
4073 : else
4074 : {
4075 3065 : if (! inside_float && ! inter_float && ! final_float
4076 : && ! inside_vec && ! inter_vec && ! final_vec
4077 0 : && (inter_prec >= inside_prec || inter_prec >= final_prec)
4078 0 : && ! (inside_int && inter_int
4079 0 : && inter_unsignedp != inside_unsignedp
4080 0 : && inter_prec < final_prec)
4081 0 : && ((inter_unsignedp && inter_prec > inside_prec)
4082 0 : == (final_unsignedp && final_prec > inter_prec))
4083 0 : && ! (inside_ptr && inter_prec != final_prec)
4084 0 : && ! (final_ptr && inside_prec != inter_prec)
4085 : )
4086 : {
4087 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1058;
4088 0 : {
4089 0 : tree res_op0;
4090 0 : res_op0 = captures[1];
4091 0 : tree _r;
4092 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4093 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 838, __FILE__, __LINE__, true);
4094 0 : return _r;
4095 : }
4096 0 : next_after_fail1058:;
4097 0 : }
4098 : else
4099 : {
4100 3065 : if (inside_int && inter_int && final_int
4101 0 : && final_prec <= inside_prec
4102 0 : && inter_prec >= inside_prec
4103 : )
4104 : {
4105 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1059;
4106 0 : {
4107 0 : tree res_op0;
4108 0 : res_op0 = captures[1];
4109 0 : tree _r;
4110 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4111 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 839, __FILE__, __LINE__, true);
4112 0 : return _r;
4113 : }
4114 0 : next_after_fail1059:;
4115 0 : }
4116 : else
4117 : {
4118 : if (0
4119 : && final_int && inter_int && inside_int
4120 : && final_prec >= inside_prec
4121 : && inside_prec > inter_prec
4122 : && inter_unsignedp
4123 : )
4124 : {
4125 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1060;
4126 : {
4127 : tree res_op0;
4128 : {
4129 : tree _o1[2], _r1;
4130 : _o1[0] = captures[1];
4131 : _o1[1] = wide_int_to_tree
4132 : (inside_type,
4133 : wi::mask (inter_prec, false,
4134 : TYPE_PRECISION (inside_type)));
4135 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4136 : res_op0 = _r1;
4137 : }
4138 : tree _r;
4139 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4140 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 840, __FILE__, __LINE__, true);
4141 : return _r;
4142 : }
4143 : next_after_fail1060:;
4144 : }
4145 : else
4146 : {
4147 : if (0
4148 : && inside_int && inter_float && final_int &&
4149 : (unsigned) significand_size (TYPE_MODE (inter_type))
4150 : >= inside_prec - !inside_unsignedp
4151 : )
4152 : {
4153 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1061;
4154 : {
4155 : tree res_op0;
4156 : res_op0 = captures[1];
4157 : tree _r;
4158 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4159 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 841, __FILE__, __LINE__, true);
4160 : return _r;
4161 : }
4162 : next_after_fail1061:;
4163 : }
4164 : }
4165 : }
4166 : }
4167 : }
4168 : }
4169 : }
4170 : }
4171 : }
4172 3065 : break;
4173 : }
4174 836951 : case BIT_AND_EXPR:
4175 836951 : {
4176 836951 : tree _q20 = TREE_OPERAND (_p0, 0);
4177 836951 : tree _q21 = TREE_OPERAND (_p0, 1);
4178 836951 : switch (TREE_CODE (_q21))
4179 : {
4180 210730 : case INTEGER_CST:
4181 210730 : {
4182 210730 : {
4183 210730 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4184 210730 : if (INTEGRAL_TYPE_P (type)
4185 210222 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4186 210222 : && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (captures[0]))
4187 355070 : && operand_equal_p (captures[1], build_low_bits_mask (TREE_TYPE (captures[1]),
4188 144340 : TYPE_PRECISION (type)), 0)
4189 : )
4190 : {
4191 12477 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1062;
4192 12477 : {
4193 12477 : tree res_op0;
4194 12477 : res_op0 = captures[0];
4195 12477 : tree _r;
4196 12477 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4197 12477 : if (TREE_SIDE_EFFECTS (captures[1]))
4198 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4199 12477 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 842, __FILE__, __LINE__, true);
4200 12477 : return _r;
4201 : }
4202 0 : next_after_fail1062:;
4203 : }
4204 : }
4205 198253 : break;
4206 : }
4207 : default:;
4208 : }
4209 : break;
4210 : }
4211 5 : case VEC_COND_EXPR:
4212 5 : {
4213 5 : tree _q20 = TREE_OPERAND (_p0, 0);
4214 5 : tree _q21 = TREE_OPERAND (_p0, 1);
4215 5 : tree _q22 = TREE_OPERAND (_p0, 2);
4216 5 : {
4217 5 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
4218 5 : if (VECTOR_TYPE_P (type)
4219 0 : && types_match (TREE_TYPE (captures[1]), truth_type_for (type))
4220 5 : && (expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
4221 0 : || !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1])))
4222 : )
4223 : {
4224 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1063;
4225 0 : {
4226 0 : tree res_op0;
4227 0 : res_op0 = captures[1];
4228 0 : tree res_op1;
4229 0 : {
4230 0 : tree _o1[1], _r1;
4231 0 : _o1[0] = captures[2];
4232 0 : if (TREE_TYPE (_o1[0]) != type)
4233 : {
4234 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4235 0 : if (EXPR_P (_r1))
4236 0 : goto next_after_fail1063;
4237 : }
4238 : else
4239 : _r1 = _o1[0];
4240 0 : res_op1 = _r1;
4241 : }
4242 0 : tree res_op2;
4243 0 : {
4244 0 : tree _o1[1], _r1;
4245 0 : _o1[0] = captures[3];
4246 0 : if (TREE_TYPE (_o1[0]) != type)
4247 : {
4248 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4249 0 : if (EXPR_P (_r1))
4250 0 : goto next_after_fail1063;
4251 : }
4252 : else
4253 : _r1 = _o1[0];
4254 0 : res_op2 = _r1;
4255 : }
4256 0 : tree _r;
4257 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4258 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 843, __FILE__, __LINE__, true);
4259 0 : return _r;
4260 : }
4261 5 : next_after_fail1063:;
4262 : }
4263 : }
4264 5 : break;
4265 : }
4266 611470 : case COND_EXPR:
4267 611470 : {
4268 611470 : tree _q20 = TREE_OPERAND (_p0, 0);
4269 611470 : tree _q21 = TREE_OPERAND (_p0, 1);
4270 611470 : tree _q22 = TREE_OPERAND (_p0, 2);
4271 611470 : switch (TREE_CODE (_q21))
4272 : {
4273 176369 : case INTEGER_CST:
4274 176369 : {
4275 176369 : switch (TREE_CODE (_q22))
4276 : {
4277 111075 : case INTEGER_CST:
4278 111075 : {
4279 111075 : {
4280 111075 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
4281 111075 : if (INTEGRAL_TYPE_P (type)
4282 111075 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4283 : )
4284 : {
4285 111075 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1064;
4286 111075 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1064;
4287 111075 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1064;
4288 111075 : {
4289 111075 : tree res_op0;
4290 111075 : res_op0 = captures[1];
4291 111075 : tree res_op1;
4292 111075 : {
4293 111075 : tree _o1[1], _r1;
4294 111075 : _o1[0] = captures[2];
4295 111075 : if (TREE_TYPE (_o1[0]) != type)
4296 : {
4297 111075 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4298 : }
4299 : else
4300 : _r1 = _o1[0];
4301 111075 : res_op1 = _r1;
4302 : }
4303 111075 : tree res_op2;
4304 111075 : {
4305 111075 : tree _o1[1], _r1;
4306 111075 : _o1[0] = captures[3];
4307 111075 : if (TREE_TYPE (_o1[0]) != type)
4308 : {
4309 111075 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4310 : }
4311 : else
4312 : _r1 = _o1[0];
4313 111075 : res_op2 = _r1;
4314 : }
4315 111075 : tree _r;
4316 111075 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
4317 111075 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 844, __FILE__, __LINE__, true);
4318 111075 : return _r;
4319 : }
4320 0 : next_after_fail1064:;
4321 : }
4322 : }
4323 0 : break;
4324 : }
4325 : default:;
4326 : }
4327 : break;
4328 : }
4329 : default:;
4330 : }
4331 : break;
4332 : }
4333 11609409 : case PLUS_EXPR:
4334 11609409 : {
4335 11609409 : tree _q20 = TREE_OPERAND (_p0, 0);
4336 11609409 : tree _q21 = TREE_OPERAND (_p0, 1);
4337 11609409 : switch (TREE_CODE (_q20))
4338 : {
4339 4511639 : CASE_CONVERT:
4340 4511639 : {
4341 4511639 : tree _q30 = TREE_OPERAND (_q20, 0);
4342 4511639 : switch (TREE_CODE (_q21))
4343 : {
4344 344896 : CASE_CONVERT:
4345 344896 : {
4346 344896 : tree _q50 = TREE_OPERAND (_q21, 0);
4347 344896 : {
4348 344896 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4349 344896 : tree res = generic_simplify_432 (loc, type, _p0, captures, PLUS_EXPR);
4350 344896 : if (res) return res;
4351 : }
4352 344840 : break;
4353 : }
4354 4511583 : default:;
4355 : }
4356 4511583 : {
4357 4511583 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4358 4511583 : tree res = generic_simplify_433 (loc, type, _p0, captures, PLUS_EXPR);
4359 4511583 : if (res) return res;
4360 : }
4361 4498624 : break;
4362 : }
4363 11596394 : default:;
4364 : }
4365 11596394 : switch (TREE_CODE (_q21))
4366 : {
4367 1496617 : CASE_CONVERT:
4368 1496617 : {
4369 1496617 : tree _q40 = TREE_OPERAND (_q21, 0);
4370 1496617 : {
4371 1496617 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4372 1496617 : tree res = generic_simplify_434 (loc, type, _p0, captures, PLUS_EXPR);
4373 1496617 : if (res) return res;
4374 : }
4375 1496617 : break;
4376 : }
4377 11596394 : default:;
4378 : }
4379 11596394 : {
4380 11596394 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4381 11596394 : tree res = generic_simplify_435 (loc, type, _p0, captures, PLUS_EXPR);
4382 11596394 : if (res) return res;
4383 : }
4384 11596360 : break;
4385 : }
4386 917795 : case MINUS_EXPR:
4387 917795 : {
4388 917795 : tree _q20 = TREE_OPERAND (_p0, 0);
4389 917795 : tree _q21 = TREE_OPERAND (_p0, 1);
4390 917795 : switch (TREE_CODE (_q20))
4391 : {
4392 349218 : CASE_CONVERT:
4393 349218 : {
4394 349218 : tree _q30 = TREE_OPERAND (_q20, 0);
4395 349218 : switch (TREE_CODE (_q21))
4396 : {
4397 197529 : CASE_CONVERT:
4398 197529 : {
4399 197529 : tree _q50 = TREE_OPERAND (_q21, 0);
4400 197529 : {
4401 197529 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4402 197529 : tree res = generic_simplify_432 (loc, type, _p0, captures, MINUS_EXPR);
4403 197529 : if (res) return res;
4404 : }
4405 197500 : break;
4406 : }
4407 349189 : default:;
4408 : }
4409 349189 : {
4410 349189 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4411 349189 : tree res = generic_simplify_433 (loc, type, _p0, captures, MINUS_EXPR);
4412 349189 : if (res) return res;
4413 : }
4414 348069 : break;
4415 : }
4416 916646 : default:;
4417 : }
4418 916646 : switch (TREE_CODE (_q21))
4419 : {
4420 255975 : CASE_CONVERT:
4421 255975 : {
4422 255975 : tree _q40 = TREE_OPERAND (_q21, 0);
4423 255975 : {
4424 255975 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4425 255975 : tree res = generic_simplify_434 (loc, type, _p0, captures, MINUS_EXPR);
4426 255975 : if (res) return res;
4427 : }
4428 255965 : break;
4429 : }
4430 916636 : default:;
4431 : }
4432 916636 : {
4433 916636 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4434 916636 : tree res = generic_simplify_435 (loc, type, _p0, captures, MINUS_EXPR);
4435 916636 : if (res) return res;
4436 : }
4437 916604 : break;
4438 : }
4439 8864387 : case MULT_EXPR:
4440 8864387 : {
4441 8864387 : tree _q20 = TREE_OPERAND (_p0, 0);
4442 8864387 : tree _q21 = TREE_OPERAND (_p0, 1);
4443 8864387 : switch (TREE_CODE (_q20))
4444 : {
4445 4007349 : CASE_CONVERT:
4446 4007349 : {
4447 4007349 : tree _q30 = TREE_OPERAND (_q20, 0);
4448 4007349 : switch (TREE_CODE (_q21))
4449 : {
4450 318807 : CASE_CONVERT:
4451 318807 : {
4452 318807 : tree _q50 = TREE_OPERAND (_q21, 0);
4453 318807 : {
4454 318807 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4455 318807 : tree res = generic_simplify_432 (loc, type, _p0, captures, MULT_EXPR);
4456 318807 : if (res) return res;
4457 : }
4458 318807 : break;
4459 : }
4460 4007349 : default:;
4461 : }
4462 4007349 : {
4463 4007349 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4464 4007349 : tree res = generic_simplify_433 (loc, type, _p0, captures, MULT_EXPR);
4465 4007349 : if (res) return res;
4466 : }
4467 4007228 : break;
4468 : }
4469 8864266 : default:;
4470 : }
4471 8864266 : switch (TREE_CODE (_q21))
4472 : {
4473 685617 : CASE_CONVERT:
4474 685617 : {
4475 685617 : tree _q40 = TREE_OPERAND (_q21, 0);
4476 685617 : {
4477 685617 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4478 685617 : tree res = generic_simplify_434 (loc, type, _p0, captures, MULT_EXPR);
4479 685617 : if (res) return res;
4480 : }
4481 685617 : break;
4482 : }
4483 8864266 : default:;
4484 : }
4485 8864266 : {
4486 8864266 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4487 8864266 : tree res = generic_simplify_435 (loc, type, _p0, captures, MULT_EXPR);
4488 8864266 : if (res) return res;
4489 : }
4490 8864233 : break;
4491 : }
4492 3070 : case RDIV_EXPR:
4493 3070 : {
4494 3070 : tree _q20 = TREE_OPERAND (_p0, 0);
4495 3070 : tree _q21 = TREE_OPERAND (_p0, 1);
4496 3070 : switch (TREE_CODE (_q20))
4497 : {
4498 972 : CASE_CONVERT:
4499 972 : {
4500 972 : tree _q30 = TREE_OPERAND (_q20, 0);
4501 972 : switch (TREE_CODE (_q21))
4502 : {
4503 668 : CASE_CONVERT:
4504 668 : {
4505 668 : tree _q50 = TREE_OPERAND (_q21, 0);
4506 668 : {
4507 668 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4508 668 : tree res = generic_simplify_432 (loc, type, _p0, captures, RDIV_EXPR);
4509 668 : if (res) return res;
4510 : }
4511 667 : break;
4512 : }
4513 971 : default:;
4514 : }
4515 971 : {
4516 971 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4517 971 : tree res = generic_simplify_433 (loc, type, _p0, captures, RDIV_EXPR);
4518 971 : if (res) return res;
4519 : }
4520 969 : break;
4521 : }
4522 3067 : default:;
4523 : }
4524 3067 : switch (TREE_CODE (_q21))
4525 : {
4526 1657 : CASE_CONVERT:
4527 1657 : {
4528 1657 : tree _q40 = TREE_OPERAND (_q21, 0);
4529 1657 : {
4530 1657 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4531 1657 : tree res = generic_simplify_434 (loc, type, _p0, captures, RDIV_EXPR);
4532 1657 : if (res) return res;
4533 : }
4534 1012 : break;
4535 : }
4536 2422 : default:;
4537 : }
4538 2422 : {
4539 2422 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4540 2422 : tree res = generic_simplify_435 (loc, type, _p0, captures, RDIV_EXPR);
4541 2422 : if (res) return res;
4542 : }
4543 2380 : break;
4544 : }
4545 688488 : case NEGATE_EXPR:
4546 688488 : {
4547 688488 : tree _q20 = TREE_OPERAND (_p0, 0);
4548 688488 : {
4549 688488 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4550 688488 : tree res = generic_simplify_436 (loc, type, _p0, captures);
4551 688488 : if (res) return res;
4552 : }
4553 688466 : break;
4554 : }
4555 : default:;
4556 : }
4557 : return NULL_TREE;
4558 : }
4559 :
4560 : tree
4561 7008 : 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)
4562 : {
4563 7008 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4564 7008 : if (integer_onep (_p1))
4565 : {
4566 1755 : {
4567 1755 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4568 1755 : tree res = generic_simplify_181 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4569 1755 : if (res) return res;
4570 : }
4571 : }
4572 5253 : if (integer_zerop (_p0))
4573 : {
4574 0 : {
4575 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4576 0 : tree res = generic_simplify_311 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4577 0 : if (res) return res;
4578 : }
4579 : }
4580 5253 : switch (TREE_CODE (_p1))
4581 : {
4582 34 : case SSA_NAME:
4583 34 : {
4584 34 : {
4585 34 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4586 34 : tree res = generic_simplify_313 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4587 34 : if (res) return res;
4588 : }
4589 34 : break;
4590 : }
4591 5253 : default:;
4592 : }
4593 5253 : if (integer_minus_onep (_p1))
4594 : {
4595 0 : {
4596 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4597 0 : tree res = generic_simplify_312 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4598 0 : if (res) return res;
4599 : }
4600 : }
4601 5253 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
4602 : {
4603 0 : {
4604 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4605 0 : tree res = generic_simplify_314 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4606 0 : if (res) return res;
4607 : }
4608 : }
4609 5253 : switch (TREE_CODE (_p1))
4610 : {
4611 0 : case ABS_EXPR:
4612 0 : {
4613 0 : tree _q30 = TREE_OPERAND (_p1, 0);
4614 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
4615 : {
4616 0 : {
4617 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4618 0 : tree res = generic_simplify_315 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4619 0 : if (res) return res;
4620 : }
4621 : }
4622 : break;
4623 : }
4624 5253 : default:;
4625 : }
4626 5253 : switch (TREE_CODE (_p0))
4627 : {
4628 0 : case ABS_EXPR:
4629 0 : {
4630 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4631 0 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4632 : {
4633 0 : {
4634 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4635 0 : tree res = generic_simplify_315 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4636 0 : if (res) return res;
4637 : }
4638 : }
4639 : break;
4640 : }
4641 5253 : default:;
4642 : }
4643 5253 : switch (TREE_CODE (_p1))
4644 : {
4645 0 : case NEGATE_EXPR:
4646 0 : {
4647 0 : tree _q30 = TREE_OPERAND (_p1, 0);
4648 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
4649 : {
4650 0 : {
4651 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4652 0 : tree res = generic_simplify_316 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4653 0 : if (res) return res;
4654 : }
4655 : }
4656 : break;
4657 : }
4658 5253 : default:;
4659 : }
4660 5253 : switch (TREE_CODE (_p0))
4661 : {
4662 0 : case NEGATE_EXPR:
4663 0 : {
4664 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4665 0 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4666 : {
4667 0 : {
4668 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4669 0 : tree res = generic_simplify_316 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4670 0 : if (res) return res;
4671 : }
4672 : }
4673 : break;
4674 : }
4675 536 : CASE_CONVERT:
4676 536 : {
4677 536 : tree _q20 = TREE_OPERAND (_p0, 0);
4678 536 : switch (TREE_CODE (_q20))
4679 : {
4680 0 : case BIT_AND_EXPR:
4681 0 : {
4682 0 : tree _q30 = TREE_OPERAND (_q20, 0);
4683 0 : tree _q31 = TREE_OPERAND (_q20, 1);
4684 0 : switch (TREE_CODE (_q31))
4685 : {
4686 0 : case INTEGER_CST:
4687 0 : {
4688 0 : switch (TREE_CODE (_p1))
4689 : {
4690 0 : case INTEGER_CST:
4691 0 : {
4692 0 : {
4693 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
4694 0 : tree res = generic_simplify_318 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4695 0 : if (res) return res;
4696 : }
4697 0 : break;
4698 : }
4699 : default:;
4700 : }
4701 : break;
4702 : }
4703 : default:;
4704 : }
4705 : break;
4706 : }
4707 : default:;
4708 : }
4709 : break;
4710 : }
4711 0 : case BIT_AND_EXPR:
4712 0 : {
4713 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4714 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4715 0 : switch (TREE_CODE (_q21))
4716 : {
4717 0 : case INTEGER_CST:
4718 0 : {
4719 0 : switch (TREE_CODE (_p1))
4720 : {
4721 0 : case INTEGER_CST:
4722 0 : {
4723 0 : {
4724 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4725 0 : tree res = generic_simplify_318 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4726 0 : if (res) return res;
4727 : }
4728 0 : break;
4729 : }
4730 : default:;
4731 : }
4732 : break;
4733 : }
4734 : default:;
4735 : }
4736 : break;
4737 : }
4738 0 : case MULT_EXPR:
4739 0 : {
4740 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4741 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4742 0 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
4743 : {
4744 0 : {
4745 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
4746 0 : tree res = generic_simplify_320 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4747 0 : if (res) return res;
4748 : }
4749 : }
4750 0 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4751 : {
4752 0 : {
4753 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
4754 0 : tree res = generic_simplify_320 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4755 0 : if (res) return res;
4756 : }
4757 : }
4758 0 : switch (TREE_CODE (_q21))
4759 : {
4760 0 : case INTEGER_CST:
4761 0 : {
4762 0 : switch (TREE_CODE (_p1))
4763 : {
4764 0 : case MULT_EXPR:
4765 0 : {
4766 0 : tree _q50 = TREE_OPERAND (_p1, 0);
4767 0 : tree _q51 = TREE_OPERAND (_p1, 1);
4768 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4769 : {
4770 0 : switch (TREE_CODE (_q51))
4771 : {
4772 0 : case INTEGER_CST:
4773 0 : {
4774 0 : {
4775 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
4776 0 : tree res = generic_simplify_321 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4777 0 : if (res) return res;
4778 : }
4779 0 : break;
4780 : }
4781 : default:;
4782 : }
4783 : }
4784 : break;
4785 : }
4786 : default:;
4787 : }
4788 : break;
4789 : }
4790 : default:;
4791 : }
4792 : break;
4793 : }
4794 0 : case VEC_COND_EXPR:
4795 0 : {
4796 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4797 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4798 0 : tree _q22 = TREE_OPERAND (_p0, 2);
4799 0 : switch (TREE_CODE (_p1))
4800 : {
4801 0 : case VEC_COND_EXPR:
4802 0 : {
4803 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4804 0 : tree _q61 = TREE_OPERAND (_p1, 1);
4805 0 : tree _q62 = TREE_OPERAND (_p1, 2);
4806 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4807 : {
4808 0 : {
4809 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
4810 0 : if (VECTOR_TYPE_P (type)
4811 0 : && (TREE_CODE_CLASS (CEIL_DIV_EXPR) != tcc_comparison
4812 : || types_match (type, TREE_TYPE (captures[2]))
4813 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
4814 : || (optimize_vectors_before_lowering_p ()
4815 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
4816 : )
4817 : {
4818 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1578;
4819 0 : {
4820 0 : tree res_op0;
4821 0 : res_op0 = captures[1];
4822 0 : tree res_op1;
4823 0 : {
4824 0 : tree _o1[2], _r1;
4825 0 : _o1[0] = captures[2];
4826 0 : _o1[1] = captures[5];
4827 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4828 0 : if (EXPR_P (_r1))
4829 0 : goto next_after_fail1578;
4830 0 : res_op1 = _r1;
4831 : }
4832 0 : tree res_op2;
4833 0 : {
4834 0 : tree _o1[2], _r1;
4835 0 : _o1[0] = captures[3];
4836 0 : _o1[1] = captures[6];
4837 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4838 0 : if (EXPR_P (_r1))
4839 0 : goto next_after_fail1578;
4840 0 : res_op2 = _r1;
4841 : }
4842 0 : tree _r;
4843 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4844 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
4845 0 : return _r;
4846 : }
4847 0 : next_after_fail1578:;
4848 : }
4849 : }
4850 : }
4851 : break;
4852 : }
4853 0 : default:;
4854 : }
4855 0 : {
4856 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
4857 0 : if (VECTOR_TYPE_P (type)
4858 0 : && (TREE_CODE_CLASS (CEIL_DIV_EXPR) != tcc_comparison
4859 : || types_match (type, TREE_TYPE (captures[2]))
4860 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
4861 : || (optimize_vectors_before_lowering_p ()
4862 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
4863 : )
4864 : {
4865 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1579;
4866 0 : {
4867 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1579;
4868 0 : tree res_op0;
4869 0 : res_op0 = captures[1];
4870 0 : tree res_op1;
4871 0 : {
4872 0 : tree _o1[2], _r1;
4873 0 : _o1[0] = captures[2];
4874 0 : _o1[1] = unshare_expr (captures[4]);
4875 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4876 0 : if (EXPR_P (_r1))
4877 0 : goto next_after_fail1579;
4878 0 : res_op1 = _r1;
4879 : }
4880 0 : tree res_op2;
4881 0 : {
4882 0 : tree _o1[2], _r1;
4883 0 : _o1[0] = captures[3];
4884 0 : _o1[1] = captures[4];
4885 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4886 0 : if (EXPR_P (_r1))
4887 0 : goto next_after_fail1579;
4888 0 : res_op2 = _r1;
4889 : }
4890 0 : tree _r;
4891 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4892 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 895, __FILE__, __LINE__, true);
4893 0 : return _r;
4894 : }
4895 0 : next_after_fail1579:;
4896 : }
4897 : }
4898 0 : break;
4899 : }
4900 5253 : default:;
4901 : }
4902 5253 : switch (TREE_CODE (_p1))
4903 : {
4904 0 : case VEC_COND_EXPR:
4905 0 : {
4906 0 : tree _q30 = TREE_OPERAND (_p1, 0);
4907 0 : tree _q31 = TREE_OPERAND (_p1, 1);
4908 0 : tree _q32 = TREE_OPERAND (_p1, 2);
4909 0 : {
4910 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
4911 0 : if (VECTOR_TYPE_P (type)
4912 0 : && (TREE_CODE_CLASS (CEIL_DIV_EXPR) != tcc_comparison
4913 : || types_match (type, TREE_TYPE (captures[3]))
4914 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
4915 : || (optimize_vectors_before_lowering_p ()
4916 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
4917 : )
4918 : {
4919 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1580;
4920 0 : {
4921 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1580;
4922 0 : tree res_op0;
4923 0 : res_op0 = captures[2];
4924 0 : tree res_op1;
4925 0 : {
4926 0 : tree _o1[2], _r1;
4927 0 : _o1[0] = unshare_expr (captures[0]);
4928 0 : _o1[1] = captures[3];
4929 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4930 0 : if (EXPR_P (_r1))
4931 0 : goto next_after_fail1580;
4932 0 : res_op1 = _r1;
4933 : }
4934 0 : tree res_op2;
4935 0 : {
4936 0 : tree _o1[2], _r1;
4937 0 : _o1[0] = captures[0];
4938 0 : _o1[1] = captures[4];
4939 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4940 0 : if (EXPR_P (_r1))
4941 0 : goto next_after_fail1580;
4942 0 : res_op2 = _r1;
4943 : }
4944 0 : tree _r;
4945 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4946 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
4947 0 : return _r;
4948 : }
4949 0 : next_after_fail1580:;
4950 : }
4951 : }
4952 0 : break;
4953 : }
4954 : default:;
4955 : }
4956 : return NULL_TREE;
4957 : }
4958 :
4959 : tree
4960 3371566 : 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)
4961 : {
4962 3371566 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4963 3371566 : if (integer_onep (_p1))
4964 : {
4965 2023233 : {
4966 2023233 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4967 2023233 : tree res = generic_simplify_181 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
4968 2023233 : if (res) return res;
4969 : }
4970 : }
4971 1348333 : switch (TREE_CODE (_p0))
4972 : {
4973 8831 : CASE_CONVERT:
4974 8831 : {
4975 8831 : tree _q20 = TREE_OPERAND (_p0, 0);
4976 8831 : switch (TREE_CODE (_p1))
4977 : {
4978 0 : CASE_CONVERT:
4979 0 : {
4980 0 : tree _q40 = TREE_OPERAND (_p1, 0);
4981 0 : switch (TREE_CODE (_q40))
4982 : {
4983 0 : case LSHIFT_EXPR:
4984 0 : {
4985 0 : tree _q50 = TREE_OPERAND (_q40, 0);
4986 0 : tree _q51 = TREE_OPERAND (_q40, 1);
4987 0 : if (integer_onep (_q50))
4988 : {
4989 0 : {
4990 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q50, _q51 };
4991 0 : tree res = generic_simplify_309 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
4992 0 : if (res) return res;
4993 : }
4994 : }
4995 : break;
4996 : }
4997 : default:;
4998 : }
4999 : break;
5000 : }
5001 0 : case LSHIFT_EXPR:
5002 0 : {
5003 0 : tree _q40 = TREE_OPERAND (_p1, 0);
5004 0 : tree _q41 = TREE_OPERAND (_p1, 1);
5005 0 : if (integer_onep (_q40))
5006 : {
5007 0 : {
5008 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q41 };
5009 0 : tree res = generic_simplify_309 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5010 0 : if (res) return res;
5011 : }
5012 : }
5013 : break;
5014 : }
5015 : default:;
5016 : }
5017 : break;
5018 : }
5019 1348333 : default:;
5020 : }
5021 1348333 : switch (TREE_CODE (_p1))
5022 : {
5023 2 : CASE_CONVERT:
5024 2 : {
5025 2 : tree _q30 = TREE_OPERAND (_p1, 0);
5026 2 : switch (TREE_CODE (_q30))
5027 : {
5028 0 : case LSHIFT_EXPR:
5029 0 : {
5030 0 : tree _q40 = TREE_OPERAND (_q30, 0);
5031 0 : tree _q41 = TREE_OPERAND (_q30, 1);
5032 0 : if (integer_onep (_q40))
5033 : {
5034 0 : {
5035 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q40, _q41 };
5036 0 : tree res = generic_simplify_310 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5037 0 : if (res) return res;
5038 : }
5039 : }
5040 : break;
5041 : }
5042 : default:;
5043 : }
5044 : break;
5045 : }
5046 0 : case LSHIFT_EXPR:
5047 0 : {
5048 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5049 0 : tree _q31 = TREE_OPERAND (_p1, 1);
5050 0 : if (integer_onep (_q30))
5051 : {
5052 0 : {
5053 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q30, _q31 };
5054 0 : tree res = generic_simplify_310 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5055 0 : if (res) return res;
5056 : }
5057 : }
5058 : break;
5059 : }
5060 1348333 : default:;
5061 : }
5062 1348333 : if (integer_zerop (_p0))
5063 : {
5064 0 : {
5065 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
5066 0 : tree res = generic_simplify_311 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5067 0 : if (res) return res;
5068 : }
5069 : }
5070 1348333 : switch (TREE_CODE (_p1))
5071 : {
5072 0 : case SSA_NAME:
5073 0 : {
5074 0 : {
5075 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
5076 0 : tree res = generic_simplify_313 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5077 0 : if (res) return res;
5078 : }
5079 0 : break;
5080 : }
5081 1348333 : default:;
5082 : }
5083 1348333 : if (integer_minus_onep (_p1))
5084 : {
5085 0 : {
5086 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
5087 0 : tree res = generic_simplify_312 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5088 0 : if (res) return res;
5089 : }
5090 : }
5091 1348333 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
5092 : {
5093 0 : {
5094 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
5095 0 : tree res = generic_simplify_314 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5096 0 : if (res) return res;
5097 : }
5098 : }
5099 1348333 : switch (TREE_CODE (_p1))
5100 : {
5101 0 : case ABS_EXPR:
5102 0 : {
5103 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5104 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5105 : {
5106 0 : {
5107 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
5108 0 : tree res = generic_simplify_315 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5109 0 : if (res) return res;
5110 : }
5111 : }
5112 : break;
5113 : }
5114 1348333 : default:;
5115 : }
5116 1348333 : switch (TREE_CODE (_p0))
5117 : {
5118 0 : case ABS_EXPR:
5119 0 : {
5120 0 : tree _q20 = TREE_OPERAND (_p0, 0);
5121 0 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5122 : {
5123 0 : {
5124 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
5125 0 : tree res = generic_simplify_315 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5126 0 : if (res) return res;
5127 : }
5128 : }
5129 : break;
5130 : }
5131 1348333 : default:;
5132 : }
5133 1348333 : switch (TREE_CODE (_p1))
5134 : {
5135 0 : case NEGATE_EXPR:
5136 0 : {
5137 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5138 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5139 : {
5140 0 : {
5141 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
5142 0 : tree res = generic_simplify_316 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5143 0 : if (res) return res;
5144 : }
5145 : }
5146 : break;
5147 : }
5148 1348333 : default:;
5149 : }
5150 1348333 : switch (TREE_CODE (_p0))
5151 : {
5152 1193 : case NEGATE_EXPR:
5153 1193 : {
5154 1193 : tree _q20 = TREE_OPERAND (_p0, 0);
5155 1193 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5156 : {
5157 0 : {
5158 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
5159 0 : tree res = generic_simplify_316 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5160 0 : if (res) return res;
5161 : }
5162 : }
5163 : break;
5164 : }
5165 0 : case EXACT_DIV_EXPR:
5166 0 : {
5167 0 : tree _q20 = TREE_OPERAND (_p0, 0);
5168 0 : tree _q21 = TREE_OPERAND (_p0, 1);
5169 0 : switch (TREE_CODE (_q21))
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[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _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 8831 : CASE_CONVERT:
5193 8831 : {
5194 8831 : tree _q20 = TREE_OPERAND (_p0, 0);
5195 8831 : switch (TREE_CODE (_q20))
5196 : {
5197 0 : case BIT_AND_EXPR:
5198 0 : {
5199 0 : tree _q30 = TREE_OPERAND (_q20, 0);
5200 0 : tree _q31 = TREE_OPERAND (_q20, 1);
5201 0 : switch (TREE_CODE (_q31))
5202 : {
5203 0 : case INTEGER_CST:
5204 0 : {
5205 0 : switch (TREE_CODE (_p1))
5206 : {
5207 0 : case INTEGER_CST:
5208 0 : {
5209 0 : {
5210 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
5211 0 : tree res = generic_simplify_318 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5212 0 : if (res) return res;
5213 : }
5214 0 : break;
5215 : }
5216 : default:;
5217 : }
5218 : break;
5219 : }
5220 : default:;
5221 : }
5222 : break;
5223 : }
5224 : default:;
5225 : }
5226 : break;
5227 : }
5228 0 : case BIT_AND_EXPR:
5229 0 : {
5230 0 : tree _q20 = TREE_OPERAND (_p0, 0);
5231 0 : tree _q21 = TREE_OPERAND (_p0, 1);
5232 0 : switch (TREE_CODE (_q21))
5233 : {
5234 0 : case INTEGER_CST:
5235 0 : {
5236 0 : switch (TREE_CODE (_p1))
5237 : {
5238 0 : case INTEGER_CST:
5239 0 : {
5240 0 : {
5241 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5242 0 : tree res = generic_simplify_318 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5243 0 : if (res) return res;
5244 : }
5245 0 : break;
5246 : }
5247 : default:;
5248 : }
5249 : break;
5250 : }
5251 : default:;
5252 : }
5253 : break;
5254 : }
5255 18688 : case MULT_EXPR:
5256 18688 : {
5257 18688 : tree _q20 = TREE_OPERAND (_p0, 0);
5258 18688 : tree _q21 = TREE_OPERAND (_p0, 1);
5259 18688 : if (integer_pow2p (_q21))
5260 : {
5261 17579 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5262 : {
5263 17551 : {
5264 17551 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5265 17551 : tree res = generic_simplify_319 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5266 17551 : if (res) return res;
5267 : }
5268 : }
5269 : }
5270 1144 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5271 : {
5272 7 : {
5273 7 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
5274 7 : tree res = generic_simplify_320 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5275 7 : if (res) return res;
5276 : }
5277 : }
5278 1137 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5279 : {
5280 0 : {
5281 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
5282 0 : tree res = generic_simplify_320 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5283 0 : if (res) return res;
5284 : }
5285 : }
5286 1137 : switch (TREE_CODE (_q21))
5287 : {
5288 1137 : case INTEGER_CST:
5289 1137 : {
5290 1137 : switch (TREE_CODE (_p1))
5291 : {
5292 0 : case MULT_EXPR:
5293 0 : {
5294 0 : tree _q50 = TREE_OPERAND (_p1, 0);
5295 0 : tree _q51 = TREE_OPERAND (_p1, 1);
5296 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5297 : {
5298 0 : switch (TREE_CODE (_q51))
5299 : {
5300 0 : case INTEGER_CST:
5301 0 : {
5302 0 : {
5303 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
5304 0 : tree res = generic_simplify_321 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5305 0 : if (res) return res;
5306 : }
5307 0 : break;
5308 : }
5309 : default:;
5310 : }
5311 : }
5312 : break;
5313 : }
5314 : default:;
5315 : }
5316 : break;
5317 : }
5318 : default:;
5319 : }
5320 : break;
5321 : }
5322 0 : case VEC_COND_EXPR:
5323 0 : {
5324 0 : tree _q20 = TREE_OPERAND (_p0, 0);
5325 0 : tree _q21 = TREE_OPERAND (_p0, 1);
5326 0 : tree _q22 = TREE_OPERAND (_p0, 2);
5327 0 : switch (TREE_CODE (_p1))
5328 : {
5329 0 : case VEC_COND_EXPR:
5330 0 : {
5331 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5332 0 : tree _q61 = TREE_OPERAND (_p1, 1);
5333 0 : tree _q62 = TREE_OPERAND (_p1, 2);
5334 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
5335 : {
5336 0 : {
5337 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
5338 0 : if (VECTOR_TYPE_P (type)
5339 0 : && (TREE_CODE_CLASS (EXACT_DIV_EXPR) != tcc_comparison
5340 : || types_match (type, TREE_TYPE (captures[2]))
5341 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
5342 : || (optimize_vectors_before_lowering_p ()
5343 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
5344 : )
5345 : {
5346 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1587;
5347 0 : {
5348 0 : tree res_op0;
5349 0 : res_op0 = captures[1];
5350 0 : tree res_op1;
5351 0 : {
5352 0 : tree _o1[2], _r1;
5353 0 : _o1[0] = captures[2];
5354 0 : _o1[1] = captures[5];
5355 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5356 0 : if (EXPR_P (_r1))
5357 0 : goto next_after_fail1587;
5358 0 : res_op1 = _r1;
5359 : }
5360 0 : tree res_op2;
5361 0 : {
5362 0 : tree _o1[2], _r1;
5363 0 : _o1[0] = captures[3];
5364 0 : _o1[1] = captures[6];
5365 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5366 0 : if (EXPR_P (_r1))
5367 0 : goto next_after_fail1587;
5368 0 : res_op2 = _r1;
5369 : }
5370 0 : tree _r;
5371 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
5372 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
5373 0 : return _r;
5374 : }
5375 0 : next_after_fail1587:;
5376 : }
5377 : }
5378 : }
5379 : break;
5380 : }
5381 0 : default:;
5382 : }
5383 0 : {
5384 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
5385 0 : if (VECTOR_TYPE_P (type)
5386 0 : && (TREE_CODE_CLASS (EXACT_DIV_EXPR) != tcc_comparison
5387 : || types_match (type, TREE_TYPE (captures[2]))
5388 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
5389 : || (optimize_vectors_before_lowering_p ()
5390 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
5391 : )
5392 : {
5393 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1588;
5394 0 : {
5395 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1588;
5396 0 : tree res_op0;
5397 0 : res_op0 = captures[1];
5398 0 : tree res_op1;
5399 0 : {
5400 0 : tree _o1[2], _r1;
5401 0 : _o1[0] = captures[2];
5402 0 : _o1[1] = unshare_expr (captures[4]);
5403 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5404 0 : if (EXPR_P (_r1))
5405 0 : goto next_after_fail1588;
5406 0 : res_op1 = _r1;
5407 : }
5408 0 : tree res_op2;
5409 0 : {
5410 0 : tree _o1[2], _r1;
5411 0 : _o1[0] = captures[3];
5412 0 : _o1[1] = captures[4];
5413 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5414 0 : if (EXPR_P (_r1))
5415 0 : goto next_after_fail1588;
5416 0 : res_op2 = _r1;
5417 : }
5418 0 : tree _r;
5419 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
5420 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 895, __FILE__, __LINE__, true);
5421 0 : return _r;
5422 : }
5423 0 : next_after_fail1588:;
5424 : }
5425 : }
5426 0 : break;
5427 : }
5428 1330782 : default:;
5429 : }
5430 1330782 : switch (TREE_CODE (_p1))
5431 : {
5432 0 : case VEC_COND_EXPR:
5433 0 : {
5434 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5435 0 : tree _q31 = TREE_OPERAND (_p1, 1);
5436 0 : tree _q32 = TREE_OPERAND (_p1, 2);
5437 0 : {
5438 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
5439 0 : if (VECTOR_TYPE_P (type)
5440 0 : && (TREE_CODE_CLASS (EXACT_DIV_EXPR) != tcc_comparison
5441 : || types_match (type, TREE_TYPE (captures[3]))
5442 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
5443 : || (optimize_vectors_before_lowering_p ()
5444 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
5445 : )
5446 : {
5447 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1589;
5448 0 : {
5449 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1589;
5450 0 : tree res_op0;
5451 0 : res_op0 = captures[2];
5452 0 : tree res_op1;
5453 0 : {
5454 0 : tree _o1[2], _r1;
5455 0 : _o1[0] = unshare_expr (captures[0]);
5456 0 : _o1[1] = captures[3];
5457 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5458 0 : if (EXPR_P (_r1))
5459 0 : goto next_after_fail1589;
5460 0 : res_op1 = _r1;
5461 : }
5462 0 : tree res_op2;
5463 0 : {
5464 0 : tree _o1[2], _r1;
5465 0 : _o1[0] = captures[0];
5466 0 : _o1[1] = captures[4];
5467 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5468 0 : if (EXPR_P (_r1))
5469 0 : goto next_after_fail1589;
5470 0 : res_op2 = _r1;
5471 : }
5472 0 : tree _r;
5473 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
5474 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
5475 0 : return _r;
5476 : }
5477 0 : next_after_fail1589:;
5478 : }
5479 : }
5480 0 : break;
5481 : }
5482 : default:;
5483 : }
5484 : return NULL_TREE;
5485 : }
5486 :
5487 : tree
5488 9309746 : generic_simplify_LE_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
5489 : {
5490 9309746 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
5491 9309746 : switch (TREE_CODE (_p0))
5492 : {
5493 2318 : case RDIV_EXPR:
5494 2318 : {
5495 2318 : tree _q20 = TREE_OPERAND (_p0, 0);
5496 2318 : tree _q21 = TREE_OPERAND (_p0, 1);
5497 2318 : switch (TREE_CODE (_q20))
5498 : {
5499 548 : case REAL_CST:
5500 548 : {
5501 548 : if (real_zerop (_p1))
5502 : {
5503 2 : {
5504 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5505 2 : tree res = generic_simplify_375 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
5506 2 : if (res) return res;
5507 : }
5508 : }
5509 : break;
5510 : }
5511 : default:;
5512 : }
5513 : break;
5514 : }
5515 9309744 : default:;
5516 : }
5517 9309744 : switch (TREE_CODE (_p1))
5518 : {
5519 7 : case TRUNC_MOD_EXPR:
5520 7 : {
5521 7 : tree _q30 = TREE_OPERAND (_p1, 0);
5522 7 : tree _q31 = TREE_OPERAND (_p1, 1);
5523 7 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5524 : {
5525 0 : {
5526 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
5527 0 : tree res = generic_simplify_376 (loc, type, _p0, _p1, captures, GE_EXPR);
5528 0 : if (res) return res;
5529 : }
5530 : }
5531 : break;
5532 : }
5533 9309744 : default:;
5534 : }
5535 9309744 : switch (TREE_CODE (_p0))
5536 : {
5537 63064 : case MULT_EXPR:
5538 63064 : {
5539 63064 : tree _q20 = TREE_OPERAND (_p0, 0);
5540 63064 : tree _q21 = TREE_OPERAND (_p0, 1);
5541 63064 : switch (TREE_CODE (_p1))
5542 : {
5543 2714 : case MULT_EXPR:
5544 2714 : {
5545 2714 : tree _q50 = TREE_OPERAND (_p1, 0);
5546 2714 : tree _q51 = TREE_OPERAND (_p1, 1);
5547 2714 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5548 : {
5549 1863 : {
5550 1863 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5551 1863 : tree res = generic_simplify_377 (loc, type, _p0, _p1, captures, LE_EXPR);
5552 1863 : if (res) return res;
5553 : }
5554 : }
5555 1733 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5556 : {
5557 1 : {
5558 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5559 1 : tree res = generic_simplify_377 (loc, type, _p0, _p1, captures, LE_EXPR);
5560 1 : if (res) return res;
5561 : }
5562 : }
5563 1733 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5564 : {
5565 4 : {
5566 4 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
5567 4 : tree res = generic_simplify_377 (loc, type, _p0, _p1, captures, LE_EXPR);
5568 4 : if (res) return res;
5569 : }
5570 : }
5571 1733 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5572 : {
5573 315 : {
5574 315 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
5575 315 : tree res = generic_simplify_377 (loc, type, _p0, _p1, captures, LE_EXPR);
5576 315 : if (res) return res;
5577 : }
5578 : }
5579 : break;
5580 : }
5581 : default:;
5582 : }
5583 : break;
5584 : }
5585 1610519 : case PLUS_EXPR:
5586 1610519 : {
5587 1610519 : tree _q20 = TREE_OPERAND (_p0, 0);
5588 1610519 : tree _q21 = TREE_OPERAND (_p0, 1);
5589 1610519 : if (integer_minus_onep (_q21))
5590 : {
5591 533003 : switch (TREE_CODE (_p1))
5592 : {
5593 329940 : case INTEGER_CST:
5594 329940 : {
5595 329940 : {
5596 329940 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5597 329940 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR);
5598 329940 : if (res) return res;
5599 : }
5600 329938 : break;
5601 : }
5602 : default:;
5603 : }
5604 : }
5605 1610517 : switch (TREE_CODE (_p1))
5606 : {
5607 87435 : case PLUS_EXPR:
5608 87435 : {
5609 87435 : tree _q50 = TREE_OPERAND (_p1, 0);
5610 87435 : tree _q51 = TREE_OPERAND (_p1, 1);
5611 87435 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5612 : {
5613 7252 : {
5614 7252 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5615 7252 : tree res = generic_simplify_378 (loc, type, _p0, _p1, captures, LE_EXPR);
5616 7252 : if (res) return res;
5617 : }
5618 : }
5619 83272 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5620 : {
5621 13 : {
5622 13 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5623 13 : tree res = generic_simplify_378 (loc, type, _p0, _p1, captures, LE_EXPR);
5624 13 : if (res) return res;
5625 : }
5626 : }
5627 83272 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5628 : {
5629 205 : {
5630 205 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
5631 205 : tree res = generic_simplify_378 (loc, type, _p0, _p1, captures, LE_EXPR);
5632 205 : if (res) return res;
5633 : }
5634 : }
5635 83264 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5636 : {
5637 6993 : {
5638 6993 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
5639 6993 : tree res = generic_simplify_378 (loc, type, _p0, _p1, captures, LE_EXPR);
5640 6993 : if (res) return res;
5641 : }
5642 : }
5643 : break;
5644 : }
5645 1605824 : default:;
5646 : }
5647 1605824 : switch (TREE_CODE (_q21))
5648 : {
5649 1484565 : case INTEGER_CST:
5650 1484565 : {
5651 1484565 : switch (TREE_CODE (_p1))
5652 : {
5653 80692 : case PLUS_EXPR:
5654 80692 : {
5655 80692 : tree _q50 = TREE_OPERAND (_p1, 0);
5656 80692 : tree _q51 = TREE_OPERAND (_p1, 1);
5657 80692 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5658 : {
5659 3031 : {
5660 3031 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5661 3031 : tree res = generic_simplify_379 (loc, type, _p0, _p1, captures, LE_EXPR);
5662 3031 : if (res) return res;
5663 : }
5664 : }
5665 : break;
5666 : }
5667 : default:;
5668 : }
5669 : break;
5670 : }
5671 1605824 : default:;
5672 : }
5673 1605824 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5674 : {
5675 73047 : {
5676 73047 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
5677 73047 : tree res = generic_simplify_380 (loc, type, _p0, _p1, captures, LE_EXPR);
5678 73047 : if (res) return res;
5679 : }
5680 : }
5681 1563819 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5682 : {
5683 3115 : {
5684 3115 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
5685 3115 : tree res = generic_simplify_380 (loc, type, _p0, _p1, captures, LE_EXPR);
5686 3115 : if (res) return res;
5687 : }
5688 : }
5689 : break;
5690 : }
5691 1675426 : CASE_CONVERT:
5692 1675426 : {
5693 1675426 : tree _q20 = TREE_OPERAND (_p0, 0);
5694 1675426 : switch (TREE_CODE (_q20))
5695 : {
5696 0 : case EXACT_DIV_EXPR:
5697 0 : {
5698 0 : tree _q30 = TREE_OPERAND (_q20, 0);
5699 0 : tree _q31 = TREE_OPERAND (_q20, 1);
5700 0 : switch (TREE_CODE (_q31))
5701 : {
5702 0 : case INTEGER_CST:
5703 0 : {
5704 0 : switch (TREE_CODE (_p1))
5705 : {
5706 0 : CASE_CONVERT:
5707 0 : {
5708 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5709 0 : switch (TREE_CODE (_q60))
5710 : {
5711 0 : case EXACT_DIV_EXPR:
5712 0 : {
5713 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5714 0 : tree _q71 = TREE_OPERAND (_q60, 1);
5715 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
5716 : {
5717 0 : {
5718 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q70 };
5719 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, LE_EXPR);
5720 0 : if (res) return res;
5721 : }
5722 : }
5723 : break;
5724 : }
5725 : default:;
5726 : }
5727 : break;
5728 : }
5729 : default:;
5730 : }
5731 : break;
5732 : }
5733 : default:;
5734 : }
5735 : break;
5736 : }
5737 : default:;
5738 : }
5739 : break;
5740 : }
5741 432 : case EXACT_DIV_EXPR:
5742 432 : {
5743 432 : tree _q20 = TREE_OPERAND (_p0, 0);
5744 432 : tree _q21 = TREE_OPERAND (_p0, 1);
5745 432 : switch (TREE_CODE (_q21))
5746 : {
5747 432 : case INTEGER_CST:
5748 432 : {
5749 432 : switch (TREE_CODE (_p1))
5750 : {
5751 0 : case EXACT_DIV_EXPR:
5752 0 : {
5753 0 : tree _q50 = TREE_OPERAND (_p1, 0);
5754 0 : tree _q51 = TREE_OPERAND (_p1, 1);
5755 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5756 : {
5757 0 : {
5758 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
5759 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, LE_EXPR);
5760 0 : if (res) return res;
5761 : }
5762 : }
5763 : break;
5764 : }
5765 : default:;
5766 : }
5767 : break;
5768 : }
5769 : default:;
5770 : }
5771 : break;
5772 : }
5773 10955 : case TRUNC_DIV_EXPR:
5774 10955 : {
5775 10955 : tree _q20 = TREE_OPERAND (_p0, 0);
5776 10955 : tree _q21 = TREE_OPERAND (_p0, 1);
5777 10955 : switch (TREE_CODE (_q21))
5778 : {
5779 2814 : case INTEGER_CST:
5780 2814 : {
5781 2814 : switch (TREE_CODE (_p1))
5782 : {
5783 1387 : case INTEGER_CST:
5784 1387 : {
5785 1387 : {
5786 1387 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
5787 1387 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, LE_EXPR);
5788 1387 : if (res) return res;
5789 : }
5790 679 : break;
5791 : }
5792 : default:;
5793 : }
5794 : break;
5795 : }
5796 : default:;
5797 : }
5798 : break;
5799 : }
5800 65122 : case MINUS_EXPR:
5801 65122 : {
5802 65122 : tree _q20 = TREE_OPERAND (_p0, 0);
5803 65122 : tree _q21 = TREE_OPERAND (_p0, 1);
5804 65122 : switch (TREE_CODE (_p1))
5805 : {
5806 489 : case MINUS_EXPR:
5807 489 : {
5808 489 : tree _q50 = TREE_OPERAND (_p1, 0);
5809 489 : tree _q51 = TREE_OPERAND (_p1, 1);
5810 489 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5811 : {
5812 54 : {
5813 54 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5814 54 : tree res = generic_simplify_381 (loc, type, _p0, _p1, captures, LE_EXPR);
5815 54 : if (res) return res;
5816 : }
5817 : }
5818 489 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5819 : {
5820 26 : {
5821 26 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5822 26 : tree res = generic_simplify_382 (loc, type, _p0, _p1, captures, LE_EXPR);
5823 26 : if (res) return res;
5824 : }
5825 : }
5826 : break;
5827 : }
5828 : default:;
5829 : }
5830 : break;
5831 : }
5832 5362 : case POINTER_DIFF_EXPR:
5833 5362 : {
5834 5362 : tree _q20 = TREE_OPERAND (_p0, 0);
5835 5362 : tree _q21 = TREE_OPERAND (_p0, 1);
5836 5362 : switch (TREE_CODE (_p1))
5837 : {
5838 223 : case POINTER_DIFF_EXPR:
5839 223 : {
5840 223 : tree _q50 = TREE_OPERAND (_p1, 0);
5841 223 : tree _q51 = TREE_OPERAND (_p1, 1);
5842 223 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5843 : {
5844 0 : {
5845 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
5846 0 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, LE_EXPR);
5847 0 : if (res) return res;
5848 : }
5849 : }
5850 223 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5851 : {
5852 0 : {
5853 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
5854 0 : tree res = generic_simplify_221 (loc, type, _p0, _p1, captures, LE_EXPR);
5855 0 : if (res) return res;
5856 : }
5857 : }
5858 : break;
5859 : }
5860 : default:;
5861 : }
5862 : break;
5863 : }
5864 9261047 : default:;
5865 : }
5866 9261047 : switch (TREE_CODE (_p1))
5867 : {
5868 118487 : case PLUS_EXPR:
5869 118487 : {
5870 118487 : tree _q30 = TREE_OPERAND (_p1, 0);
5871 118487 : tree _q31 = TREE_OPERAND (_p1, 1);
5872 118487 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5873 : {
5874 0 : {
5875 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
5876 0 : tree res = generic_simplify_380 (loc, type, _p0, _p1, captures, GE_EXPR);
5877 0 : if (res) return res;
5878 : }
5879 : }
5880 118487 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5881 : {
5882 57 : {
5883 57 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q31, _p0 };
5884 57 : tree res = generic_simplify_380 (loc, type, _p0, _p1, captures, GE_EXPR);
5885 57 : if (res) return res;
5886 : }
5887 : }
5888 : break;
5889 : }
5890 1208 : case MINUS_EXPR:
5891 1208 : {
5892 1208 : tree _q30 = TREE_OPERAND (_p1, 0);
5893 1208 : tree _q31 = TREE_OPERAND (_p1, 1);
5894 1208 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5895 : {
5896 0 : {
5897 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
5898 0 : tree res = generic_simplify_219 (loc, type, _p0, _p1, captures, LE_EXPR);
5899 0 : if (res) return res;
5900 : }
5901 : }
5902 : break;
5903 : }
5904 9261020 : default:;
5905 : }
5906 9261020 : switch (TREE_CODE (_p0))
5907 : {
5908 65122 : case MINUS_EXPR:
5909 65122 : {
5910 65122 : tree _q20 = TREE_OPERAND (_p0, 0);
5911 65122 : tree _q21 = TREE_OPERAND (_p0, 1);
5912 65122 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5913 : {
5914 2509 : {
5915 2509 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
5916 2509 : tree res = generic_simplify_219 (loc, type, _p0, _p1, captures, GE_EXPR);
5917 2509 : if (res) return res;
5918 : }
5919 : }
5920 : break;
5921 : }
5922 5251 : case BIT_AND_EXPR:
5923 5251 : {
5924 5251 : tree _q20 = TREE_OPERAND (_p0, 0);
5925 5251 : tree _q21 = TREE_OPERAND (_p0, 1);
5926 5251 : if (tree_expr_nonnegative_p (_q20))
5927 : {
5928 4447 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5929 : {
5930 0 : {
5931 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5932 0 : tree res = generic_simplify_383 (loc, type, _p0, _p1, captures, LE_EXPR, BIT_AND_EXPR);
5933 0 : if (res) return res;
5934 : }
5935 : }
5936 : }
5937 5251 : if (tree_expr_nonnegative_p (_q21))
5938 : {
5939 4857 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5940 : {
5941 0 : {
5942 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
5943 0 : tree res = generic_simplify_383 (loc, type, _p0, _p1, captures, LE_EXPR, BIT_AND_EXPR);
5944 0 : if (res) return res;
5945 : }
5946 : }
5947 : }
5948 : break;
5949 : }
5950 9261020 : default:;
5951 : }
5952 9261020 : switch (TREE_CODE (_p1))
5953 : {
5954 46 : case BIT_IOR_EXPR:
5955 46 : {
5956 46 : tree _q30 = TREE_OPERAND (_p1, 0);
5957 46 : tree _q31 = TREE_OPERAND (_p1, 1);
5958 46 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5959 : {
5960 0 : if (tree_expr_nonnegative_p (_q30))
5961 : {
5962 0 : {
5963 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
5964 0 : tree res = generic_simplify_383 (loc, type, _p0, _p1, captures, GE_EXPR, BIT_IOR_EXPR);
5965 0 : if (res) return res;
5966 : }
5967 : }
5968 : }
5969 46 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5970 : {
5971 0 : if (tree_expr_nonnegative_p (_q31))
5972 : {
5973 0 : {
5974 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
5975 0 : tree res = generic_simplify_383 (loc, type, _p0, _p1, captures, GE_EXPR, BIT_IOR_EXPR);
5976 0 : if (res) return res;
5977 : }
5978 : }
5979 : }
5980 : break;
5981 : }
5982 9261020 : default:;
5983 : }
5984 9261020 : switch (TREE_CODE (_p0))
5985 : {
5986 10192 : case MIN_EXPR:
5987 10192 : {
5988 10192 : tree _q20 = TREE_OPERAND (_p0, 0);
5989 10192 : tree _q21 = TREE_OPERAND (_p0, 1);
5990 10192 : switch (TREE_CODE (_p1))
5991 : {
5992 4 : case MAX_EXPR:
5993 4 : {
5994 4 : tree _q50 = TREE_OPERAND (_p1, 0);
5995 4 : tree _q51 = TREE_OPERAND (_p1, 1);
5996 4 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5997 : {
5998 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5999 : {
6000 0 : {
6001 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6002 0 : tree res = generic_simplify_384 (loc, type, _p0, _p1, captures, LE_EXPR);
6003 0 : if (res) return res;
6004 : }
6005 : }
6006 : }
6007 : break;
6008 : }
6009 : default:;
6010 : }
6011 : break;
6012 : }
6013 4359 : case MAX_EXPR:
6014 4359 : {
6015 4359 : tree _q20 = TREE_OPERAND (_p0, 0);
6016 4359 : tree _q21 = TREE_OPERAND (_p0, 1);
6017 4359 : switch (TREE_CODE (_p1))
6018 : {
6019 4 : case MIN_EXPR:
6020 4 : {
6021 4 : tree _q50 = TREE_OPERAND (_p1, 0);
6022 4 : tree _q51 = TREE_OPERAND (_p1, 1);
6023 4 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6024 : {
6025 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6026 : {
6027 0 : {
6028 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6029 0 : tree res = generic_simplify_385 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
6030 0 : if (res) return res;
6031 : }
6032 : }
6033 : }
6034 : break;
6035 : }
6036 4359 : default:;
6037 : }
6038 4359 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
6039 : {
6040 0 : {
6041 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6042 0 : tree res = generic_simplify_229 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR, GE_EXPR);
6043 0 : if (res) return res;
6044 : }
6045 : }
6046 4359 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
6047 : {
6048 1 : {
6049 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6050 1 : tree res = generic_simplify_229 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR, GE_EXPR);
6051 1 : if (res) return res;
6052 : }
6053 : }
6054 : break;
6055 : }
6056 9261019 : default:;
6057 : }
6058 9261019 : switch (TREE_CODE (_p1))
6059 : {
6060 298 : case MIN_EXPR:
6061 298 : {
6062 298 : tree _q30 = TREE_OPERAND (_p1, 0);
6063 298 : tree _q31 = TREE_OPERAND (_p1, 1);
6064 298 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
6065 : {
6066 0 : {
6067 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
6068 0 : tree res = generic_simplify_229 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR, LE_EXPR);
6069 0 : if (res) return res;
6070 : }
6071 : }
6072 298 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6073 : {
6074 0 : {
6075 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
6076 0 : tree res = generic_simplify_229 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR, LE_EXPR);
6077 0 : if (res) return res;
6078 : }
6079 : }
6080 : break;
6081 : }
6082 13 : case MAX_EXPR:
6083 13 : {
6084 13 : tree _q30 = TREE_OPERAND (_p1, 0);
6085 13 : tree _q31 = TREE_OPERAND (_p1, 1);
6086 13 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
6087 : {
6088 0 : {
6089 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
6090 0 : tree res = generic_simplify_386 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR);
6091 0 : if (res) return res;
6092 : }
6093 : }
6094 13 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6095 : {
6096 0 : {
6097 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
6098 0 : tree res = generic_simplify_386 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR);
6099 0 : if (res) return res;
6100 : }
6101 : }
6102 : break;
6103 : }
6104 9261019 : default:;
6105 : }
6106 9261019 : switch (TREE_CODE (_p0))
6107 : {
6108 10192 : case MIN_EXPR:
6109 10192 : {
6110 10192 : tree _q20 = TREE_OPERAND (_p0, 0);
6111 10192 : tree _q21 = TREE_OPERAND (_p0, 1);
6112 10192 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
6113 : {
6114 0 : {
6115 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6116 0 : tree res = generic_simplify_386 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR);
6117 0 : if (res) return res;
6118 : }
6119 : }
6120 10192 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
6121 : {
6122 0 : {
6123 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6124 0 : tree res = generic_simplify_386 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR);
6125 0 : if (res) return res;
6126 : }
6127 : }
6128 10192 : switch (TREE_CODE (_q21))
6129 : {
6130 939 : case INTEGER_CST:
6131 939 : {
6132 939 : switch (TREE_CODE (_p1))
6133 : {
6134 0 : case INTEGER_CST:
6135 0 : {
6136 0 : {
6137 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6138 0 : tree res = generic_simplify_387 (loc, type, _p0, _p1, captures, MIN_EXPR, LE_EXPR, BIT_IOR_EXPR);
6139 0 : if (res) return res;
6140 : }
6141 0 : break;
6142 : }
6143 : default:;
6144 : }
6145 : break;
6146 : }
6147 : default:;
6148 : }
6149 : break;
6150 : }
6151 4358 : case MAX_EXPR:
6152 4358 : {
6153 4358 : tree _q20 = TREE_OPERAND (_p0, 0);
6154 4358 : tree _q21 = TREE_OPERAND (_p0, 1);
6155 4358 : switch (TREE_CODE (_q21))
6156 : {
6157 4124 : case INTEGER_CST:
6158 4124 : {
6159 4124 : switch (TREE_CODE (_p1))
6160 : {
6161 0 : case INTEGER_CST:
6162 0 : {
6163 0 : {
6164 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6165 0 : tree res = generic_simplify_387 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR, BIT_AND_EXPR);
6166 0 : if (res) return res;
6167 : }
6168 0 : break;
6169 : }
6170 : default:;
6171 : }
6172 : break;
6173 : }
6174 : default:;
6175 : }
6176 : break;
6177 : }
6178 9 : case VEC_COND_EXPR:
6179 9 : {
6180 9 : tree _q20 = TREE_OPERAND (_p0, 0);
6181 9 : tree _q21 = TREE_OPERAND (_p0, 1);
6182 9 : tree _q22 = TREE_OPERAND (_p0, 2);
6183 9 : switch (TREE_CODE (_p1))
6184 : {
6185 2 : case VEC_COND_EXPR:
6186 2 : {
6187 2 : tree _q60 = TREE_OPERAND (_p1, 0);
6188 2 : tree _q61 = TREE_OPERAND (_p1, 1);
6189 2 : tree _q62 = TREE_OPERAND (_p1, 2);
6190 2 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6191 : {
6192 0 : {
6193 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
6194 0 : if (VECTOR_TYPE_P (type)
6195 0 : && (TREE_CODE_CLASS (LE_EXPR) != tcc_comparison
6196 0 : || types_match (type, TREE_TYPE (captures[2]))
6197 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
6198 : || (optimize_vectors_before_lowering_p ()
6199 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
6200 : )
6201 : {
6202 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1635;
6203 0 : {
6204 0 : tree res_op0;
6205 0 : res_op0 = captures[1];
6206 0 : tree res_op1;
6207 0 : {
6208 0 : tree _o1[2], _r1;
6209 0 : _o1[0] = captures[2];
6210 0 : _o1[1] = captures[5];
6211 0 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6212 0 : if (EXPR_P (_r1))
6213 0 : goto next_after_fail1635;
6214 0 : res_op1 = _r1;
6215 : }
6216 0 : tree res_op2;
6217 0 : {
6218 0 : tree _o1[2], _r1;
6219 0 : _o1[0] = captures[3];
6220 0 : _o1[1] = captures[6];
6221 0 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6222 0 : if (EXPR_P (_r1))
6223 0 : goto next_after_fail1635;
6224 0 : res_op2 = _r1;
6225 : }
6226 0 : tree _r;
6227 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
6228 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
6229 0 : return _r;
6230 : }
6231 0 : next_after_fail1635:;
6232 : }
6233 : }
6234 : }
6235 : break;
6236 : }
6237 9 : default:;
6238 : }
6239 9 : {
6240 9 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
6241 9 : if (VECTOR_TYPE_P (type)
6242 9 : && (TREE_CODE_CLASS (LE_EXPR) != tcc_comparison
6243 9 : || types_match (type, TREE_TYPE (captures[2]))
6244 9 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
6245 : || (optimize_vectors_before_lowering_p ()
6246 1 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
6247 : )
6248 : {
6249 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1636;
6250 9 : {
6251 9 : if (! tree_invariant_p (captures[4])) goto next_after_fail1636;
6252 7 : tree res_op0;
6253 7 : res_op0 = captures[1];
6254 7 : tree res_op1;
6255 7 : {
6256 7 : tree _o1[2], _r1;
6257 7 : _o1[0] = captures[2];
6258 7 : _o1[1] = unshare_expr (captures[4]);
6259 7 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6260 7 : if (EXPR_P (_r1))
6261 0 : goto next_after_fail1636;
6262 7 : res_op1 = _r1;
6263 : }
6264 7 : tree res_op2;
6265 7 : {
6266 7 : tree _o1[2], _r1;
6267 7 : _o1[0] = captures[3];
6268 7 : _o1[1] = captures[4];
6269 7 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6270 7 : if (EXPR_P (_r1))
6271 0 : goto next_after_fail1636;
6272 7 : res_op2 = _r1;
6273 : }
6274 7 : tree _r;
6275 7 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
6276 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 895, __FILE__, __LINE__, true);
6277 7 : return _r;
6278 : }
6279 2 : next_after_fail1636:;
6280 : }
6281 : }
6282 2 : break;
6283 : }
6284 9261012 : default:;
6285 : }
6286 9261012 : switch (TREE_CODE (_p1))
6287 : {
6288 2 : case VEC_COND_EXPR:
6289 2 : {
6290 2 : tree _q30 = TREE_OPERAND (_p1, 0);
6291 2 : tree _q31 = TREE_OPERAND (_p1, 1);
6292 2 : tree _q32 = TREE_OPERAND (_p1, 2);
6293 2 : {
6294 2 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
6295 2 : if (VECTOR_TYPE_P (type)
6296 2 : && (TREE_CODE_CLASS (LE_EXPR) != tcc_comparison
6297 2 : || types_match (type, TREE_TYPE (captures[3]))
6298 2 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
6299 : || (optimize_vectors_before_lowering_p ()
6300 1 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
6301 : )
6302 : {
6303 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1637;
6304 2 : {
6305 2 : if (! tree_invariant_p (captures[0])) goto next_after_fail1637;
6306 0 : tree res_op0;
6307 0 : res_op0 = captures[2];
6308 0 : tree res_op1;
6309 0 : {
6310 0 : tree _o1[2], _r1;
6311 0 : _o1[0] = unshare_expr (captures[0]);
6312 0 : _o1[1] = captures[3];
6313 0 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6314 0 : if (EXPR_P (_r1))
6315 0 : goto next_after_fail1637;
6316 0 : res_op1 = _r1;
6317 : }
6318 0 : tree res_op2;
6319 0 : {
6320 0 : tree _o1[2], _r1;
6321 0 : _o1[0] = captures[0];
6322 0 : _o1[1] = captures[4];
6323 0 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6324 0 : if (EXPR_P (_r1))
6325 0 : goto next_after_fail1637;
6326 0 : res_op2 = _r1;
6327 : }
6328 0 : tree _r;
6329 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
6330 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6331 0 : return _r;
6332 : }
6333 2 : next_after_fail1637:;
6334 : }
6335 : }
6336 2 : break;
6337 : }
6338 9261012 : default:;
6339 : }
6340 9261012 : if (uniform_integer_cst_p (_p1))
6341 : {
6342 6782730 : {
6343 6782730 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
6344 6782730 : tree res = generic_simplify_406 (loc, type, _p0, _p1, captures, LE_EXPR, LT_EXPR);
6345 6782730 : if (res) return res;
6346 : }
6347 : }
6348 9163638 : switch (TREE_CODE (_p0))
6349 : {
6350 61662 : case MULT_EXPR:
6351 61662 : {
6352 61662 : tree _q20 = TREE_OPERAND (_p0, 0);
6353 61662 : tree _q21 = TREE_OPERAND (_p0, 1);
6354 61662 : switch (TREE_CODE (_q21))
6355 : {
6356 54214 : case INTEGER_CST:
6357 54214 : {
6358 54214 : if (integer_zerop (_p1))
6359 : {
6360 987 : {
6361 987 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
6362 987 : tree res = generic_simplify_249 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6363 987 : if (res) return res;
6364 : }
6365 : }
6366 : break;
6367 : }
6368 : default:;
6369 : }
6370 : break;
6371 : }
6372 9162854 : default:;
6373 : }
6374 9162854 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
6375 : {
6376 4973 : {
6377 4973 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
6378 4973 : tree res = generic_simplify_251 (loc, type, _p0, _p1, captures, LE_EXPR);
6379 4973 : if (res) return res;
6380 : }
6381 : }
6382 9157923 : switch (TREE_CODE (_p0))
6383 : {
6384 2584 : case BIT_NOT_EXPR:
6385 2584 : {
6386 2584 : tree _q20 = TREE_OPERAND (_p0, 0);
6387 2584 : switch (TREE_CODE (_p1))
6388 : {
6389 0 : case BIT_NOT_EXPR:
6390 0 : {
6391 0 : tree _q40 = TREE_OPERAND (_p1, 0);
6392 0 : {
6393 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _p1, _q40 };
6394 0 : tree res = generic_simplify_255 (loc, type, _p0, _p1, captures, LE_EXPR);
6395 0 : if (res) return res;
6396 : }
6397 0 : break;
6398 : }
6399 2584 : default:;
6400 : }
6401 2584 : {
6402 2584 : tree _p1_pops[1];
6403 2584 : if (tree_nop_convert (_p1, _p1_pops))
6404 : {
6405 0 : tree _q40 = _p1_pops[0];
6406 0 : switch (TREE_CODE (_q40))
6407 : {
6408 0 : case BIT_NOT_EXPR:
6409 0 : {
6410 0 : tree _q50 = TREE_OPERAND (_q40, 0);
6411 0 : {
6412 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40, _q50 };
6413 0 : tree res = generic_simplify_255 (loc, type, _p0, _p1, captures, LE_EXPR);
6414 0 : if (res) return res;
6415 : }
6416 0 : break;
6417 : }
6418 : default:;
6419 : }
6420 : }
6421 : }
6422 2584 : if (CONSTANT_CLASS_P (_p1))
6423 : {
6424 2292 : {
6425 2292 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
6426 2292 : tree res = generic_simplify_254 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6427 2292 : if (res) return res;
6428 : }
6429 : }
6430 : break;
6431 : }
6432 9155631 : default:;
6433 : }
6434 9155631 : {
6435 9155631 : tree _p0_pops[1];
6436 9155631 : if (tree_nop_convert (_p0, _p0_pops))
6437 : {
6438 839108 : tree _q20 = _p0_pops[0];
6439 839108 : switch (TREE_CODE (_q20))
6440 : {
6441 0 : case BIT_NOT_EXPR:
6442 0 : {
6443 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6444 0 : switch (TREE_CODE (_p1))
6445 : {
6446 0 : case BIT_NOT_EXPR:
6447 0 : {
6448 0 : tree _q50 = TREE_OPERAND (_p1, 0);
6449 0 : {
6450 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _p1, _q50 };
6451 0 : tree res = generic_simplify_253 (loc, type, _p0, _p1, captures, LE_EXPR);
6452 0 : if (res) return res;
6453 : }
6454 0 : break;
6455 : }
6456 0 : default:;
6457 : }
6458 0 : {
6459 0 : tree _p1_pops[1];
6460 0 : if (tree_nop_convert (_p1, _p1_pops))
6461 : {
6462 0 : tree _q50 = _p1_pops[0];
6463 0 : switch (TREE_CODE (_q50))
6464 : {
6465 0 : case BIT_NOT_EXPR:
6466 0 : {
6467 0 : tree _q60 = TREE_OPERAND (_q50, 0);
6468 0 : {
6469 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50, _q60 };
6470 0 : tree res = generic_simplify_253 (loc, type, _p0, _p1, captures, LE_EXPR);
6471 0 : if (res) return res;
6472 : }
6473 0 : break;
6474 : }
6475 : default:;
6476 : }
6477 : }
6478 : }
6479 0 : if (CONSTANT_CLASS_P (_p1))
6480 : {
6481 0 : {
6482 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
6483 0 : tree res = generic_simplify_254 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6484 0 : if (res) return res;
6485 : }
6486 : }
6487 : break;
6488 : }
6489 : default:;
6490 : }
6491 : }
6492 : }
6493 9155631 : switch (TREE_CODE (_p1))
6494 : {
6495 188353 : case REAL_CST:
6496 188353 : {
6497 188353 : {
6498 188353 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
6499 188353 : tree res = generic_simplify_256 (loc, type, _p0, _p1, captures, LE_EXPR);
6500 188353 : if (res) return res;
6501 : }
6502 188290 : break;
6503 : }
6504 9155568 : default:;
6505 : }
6506 9155568 : switch (TREE_CODE (_p0))
6507 : {
6508 1562194 : case PLUS_EXPR:
6509 1562194 : {
6510 1562194 : tree _q20 = TREE_OPERAND (_p0, 0);
6511 1562194 : tree _q21 = TREE_OPERAND (_p0, 1);
6512 1562194 : switch (TREE_CODE (_q21))
6513 : {
6514 86 : case REAL_CST:
6515 86 : {
6516 86 : switch (TREE_CODE (_p1))
6517 : {
6518 81 : case REAL_CST:
6519 81 : {
6520 81 : {
6521 81 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6522 81 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, PLUS_EXPR, LE_EXPR);
6523 81 : if (res) return res;
6524 : }
6525 81 : break;
6526 : }
6527 : default:;
6528 : }
6529 : break;
6530 : }
6531 1461679 : case INTEGER_CST:
6532 1461679 : {
6533 1461679 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
6534 : {
6535 1968 : {
6536 1968 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q20, _q21 };
6537 1968 : tree res = generic_simplify_390 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR);
6538 1968 : if (res) return res;
6539 : }
6540 : }
6541 : break;
6542 : }
6543 : default:;
6544 : }
6545 : break;
6546 : }
6547 59487 : case MINUS_EXPR:
6548 59487 : {
6549 59487 : tree _q20 = TREE_OPERAND (_p0, 0);
6550 59487 : tree _q21 = TREE_OPERAND (_p0, 1);
6551 59487 : switch (TREE_CODE (_q21))
6552 : {
6553 1225 : case REAL_CST:
6554 1225 : {
6555 1225 : switch (TREE_CODE (_p1))
6556 : {
6557 1202 : case REAL_CST:
6558 1202 : {
6559 1202 : {
6560 1202 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6561 1202 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, MINUS_EXPR, LE_EXPR);
6562 1202 : if (res) return res;
6563 : }
6564 1202 : break;
6565 : }
6566 : default:;
6567 : }
6568 : break;
6569 : }
6570 59487 : default:;
6571 : }
6572 59487 : switch (TREE_CODE (_q20))
6573 : {
6574 2 : case REAL_CST:
6575 2 : {
6576 2 : switch (TREE_CODE (_p1))
6577 : {
6578 0 : case REAL_CST:
6579 0 : {
6580 0 : {
6581 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6582 0 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, LE_EXPR);
6583 0 : if (res) return res;
6584 : }
6585 0 : break;
6586 : }
6587 : default:;
6588 : }
6589 : break;
6590 : }
6591 : default:;
6592 : }
6593 : break;
6594 : }
6595 11856 : case FLOAT_EXPR:
6596 11856 : {
6597 11856 : tree _q20 = TREE_OPERAND (_p0, 0);
6598 11856 : switch (TREE_CODE (_p1))
6599 : {
6600 0 : case FLOAT_EXPR:
6601 0 : {
6602 0 : tree _q40 = TREE_OPERAND (_p1, 0);
6603 0 : {
6604 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
6605 0 : tree res = generic_simplify_261 (loc, type, _p0, _p1, captures, LE_EXPR, LE_EXPR);
6606 0 : if (res) return res;
6607 : }
6608 0 : break;
6609 : }
6610 235 : case REAL_CST:
6611 235 : {
6612 235 : {
6613 235 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6614 235 : tree res = generic_simplify_262 (loc, type, _p0, _p1, captures, LE_EXPR, LE_EXPR);
6615 235 : if (res) return res;
6616 : }
6617 156 : break;
6618 : }
6619 : default:;
6620 : }
6621 : break;
6622 : }
6623 432 : case EXACT_DIV_EXPR:
6624 432 : {
6625 432 : tree _q20 = TREE_OPERAND (_p0, 0);
6626 432 : tree _q21 = TREE_OPERAND (_p0, 1);
6627 432 : switch (TREE_CODE (_q21))
6628 : {
6629 432 : case INTEGER_CST:
6630 432 : {
6631 432 : switch (TREE_CODE (_p1))
6632 : {
6633 355 : case INTEGER_CST:
6634 355 : {
6635 355 : {
6636 355 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6637 355 : tree res = generic_simplify_391 (loc, type, _p0, _p1, captures, LE_EXPR);
6638 355 : if (res) return res;
6639 : }
6640 0 : break;
6641 : }
6642 : default:;
6643 : }
6644 : break;
6645 : }
6646 : default:;
6647 : }
6648 : break;
6649 : }
6650 1672195 : CASE_CONVERT:
6651 1672195 : {
6652 1672195 : tree _q20 = TREE_OPERAND (_p0, 0);
6653 1672195 : switch (TREE_CODE (_q20))
6654 : {
6655 0 : case EXACT_DIV_EXPR:
6656 0 : {
6657 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6658 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6659 0 : switch (TREE_CODE (_q31))
6660 : {
6661 0 : case INTEGER_CST:
6662 0 : {
6663 0 : switch (TREE_CODE (_p1))
6664 : {
6665 0 : case INTEGER_CST:
6666 0 : {
6667 0 : {
6668 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
6669 0 : tree res = generic_simplify_392 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6670 0 : if (res) return res;
6671 : }
6672 0 : break;
6673 : }
6674 : default:;
6675 : }
6676 : break;
6677 : }
6678 : default:;
6679 : }
6680 : break;
6681 : }
6682 1672195 : default:;
6683 : }
6684 1672195 : switch (TREE_CODE (_p1))
6685 : {
6686 77604 : CASE_CONVERT:
6687 77604 : {
6688 77604 : tree _q40 = TREE_OPERAND (_p1, 0);
6689 77604 : {
6690 77604 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
6691 77604 : tree res = generic_simplify_266 (loc, type, _p0, _p1, captures, LE_EXPR);
6692 77604 : if (res) return res;
6693 : }
6694 28985 : break;
6695 : }
6696 1623576 : default:;
6697 : }
6698 1623576 : {
6699 1623576 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
6700 1623576 : tree res = generic_simplify_267 (loc, type, _p0, _p1, captures, LE_EXPR);
6701 1623576 : if (res) return res;
6702 : }
6703 941016 : switch (TREE_CODE (_q20))
6704 : {
6705 5801 : case ADDR_EXPR:
6706 5801 : {
6707 5801 : switch (TREE_CODE (_p1))
6708 : {
6709 5485 : CASE_CONVERT:
6710 5485 : {
6711 5485 : tree _q40 = TREE_OPERAND (_p1, 0);
6712 5485 : switch (TREE_CODE (_q40))
6713 : {
6714 5485 : case ADDR_EXPR:
6715 5485 : {
6716 5485 : {
6717 5485 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
6718 5485 : tree res = generic_simplify_285 (loc, type, _p0, _p1, captures, LE_EXPR);
6719 5485 : if (res) return res;
6720 : }
6721 160 : break;
6722 : }
6723 : default:;
6724 : }
6725 : break;
6726 : }
6727 7 : case ADDR_EXPR:
6728 7 : {
6729 7 : {
6730 7 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
6731 7 : tree res = generic_simplify_285 (loc, type, _p0, _p1, captures, LE_EXPR);
6732 7 : if (res) return res;
6733 : }
6734 0 : break;
6735 : }
6736 : default:;
6737 : }
6738 : break;
6739 : }
6740 935684 : default:;
6741 : }
6742 935684 : if (uniform_integer_cst_p (_p1))
6743 : {
6744 486368 : {
6745 486368 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
6746 486368 : tree res = generic_simplify_393 (loc, type, _p0, _p1, captures, LE_EXPR);
6747 486368 : if (res) return res;
6748 : }
6749 : }
6750 : break;
6751 : }
6752 5251 : case BIT_AND_EXPR:
6753 5251 : {
6754 5251 : tree _q20 = TREE_OPERAND (_p0, 0);
6755 5251 : tree _q21 = TREE_OPERAND (_p0, 1);
6756 5251 : switch (TREE_CODE (_q21))
6757 : {
6758 4769 : case INTEGER_CST:
6759 4769 : {
6760 4769 : switch (TREE_CODE (_p1))
6761 : {
6762 2710 : case INTEGER_CST:
6763 2710 : {
6764 2710 : {
6765 2710 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
6766 2710 : tree res = generic_simplify_407 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR);
6767 2710 : if (res) return res;
6768 : }
6769 2663 : break;
6770 : }
6771 : default:;
6772 : }
6773 : break;
6774 : }
6775 : default:;
6776 : }
6777 : break;
6778 : }
6779 5494 : case NEGATE_EXPR:
6780 5494 : {
6781 5494 : tree _q20 = TREE_OPERAND (_p0, 0);
6782 5494 : switch (TREE_CODE (_p1))
6783 : {
6784 32 : case NEGATE_EXPR:
6785 32 : {
6786 32 : tree _q40 = TREE_OPERAND (_p1, 0);
6787 32 : {
6788 32 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6789 32 : tree res = generic_simplify_264 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6790 32 : if (res) return res;
6791 : }
6792 32 : break;
6793 : }
6794 5494 : default:;
6795 : }
6796 5494 : if (CONSTANT_CLASS_P (_p1))
6797 : {
6798 461 : {
6799 461 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6800 461 : tree res = generic_simplify_265 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6801 461 : if (res) return res;
6802 : }
6803 : }
6804 : break;
6805 : }
6806 1498 : case ADDR_EXPR:
6807 1498 : {
6808 1498 : switch (TREE_CODE (_p1))
6809 : {
6810 19 : CASE_CONVERT:
6811 19 : {
6812 19 : tree _q30 = TREE_OPERAND (_p1, 0);
6813 19 : switch (TREE_CODE (_q30))
6814 : {
6815 19 : case ADDR_EXPR:
6816 19 : {
6817 19 : {
6818 19 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q30 };
6819 19 : tree res = generic_simplify_286 (loc, type, _p0, _p1, captures, LE_EXPR);
6820 19 : if (res) return res;
6821 : }
6822 0 : break;
6823 : }
6824 : default:;
6825 : }
6826 : break;
6827 : }
6828 659 : case ADDR_EXPR:
6829 659 : {
6830 659 : {
6831 659 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
6832 659 : tree res = generic_simplify_286 (loc, type, _p0, _p1, captures, LE_EXPR);
6833 659 : if (res) return res;
6834 : }
6835 300 : break;
6836 : }
6837 : default:;
6838 : }
6839 : break;
6840 : }
6841 125273 : case CALL_EXPR:
6842 125273 : switch (get_call_combined_fn (_p0))
6843 : {
6844 2 : case CFN_BUILT_IN_SQRTF:
6845 2 : if (call_expr_nargs (_p0) == 1)
6846 : {
6847 2 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
6848 2 : switch (TREE_CODE (_p1))
6849 : {
6850 2 : case REAL_CST:
6851 2 : {
6852 2 : {
6853 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6854 2 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, LE_EXPR);
6855 2 : if (res) return res;
6856 : }
6857 0 : break;
6858 : }
6859 0 : case CALL_EXPR:
6860 0 : switch (get_call_combined_fn (_p1))
6861 : {
6862 0 : case CFN_BUILT_IN_SQRTF:
6863 0 : if (call_expr_nargs (_p1) == 1)
6864 : {
6865 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
6866 0 : {
6867 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6868 0 : tree res = generic_simplify_260 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, LE_EXPR);
6869 0 : if (res) return res;
6870 : }
6871 : }
6872 : break;
6873 : default:;
6874 : }
6875 : break;
6876 : default:;
6877 : }
6878 : }
6879 : break;
6880 0 : case CFN_BUILT_IN_SQRTL:
6881 0 : if (call_expr_nargs (_p0) == 1)
6882 : {
6883 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
6884 0 : switch (TREE_CODE (_p1))
6885 : {
6886 0 : case REAL_CST:
6887 0 : {
6888 0 : {
6889 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6890 0 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, LE_EXPR);
6891 0 : if (res) return res;
6892 : }
6893 0 : break;
6894 : }
6895 0 : case CALL_EXPR:
6896 0 : switch (get_call_combined_fn (_p1))
6897 : {
6898 0 : case CFN_BUILT_IN_SQRTL:
6899 0 : if (call_expr_nargs (_p1) == 1)
6900 : {
6901 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
6902 0 : {
6903 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6904 0 : tree res = generic_simplify_260 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, LE_EXPR);
6905 0 : if (res) return res;
6906 : }
6907 : }
6908 : break;
6909 : default:;
6910 : }
6911 : break;
6912 : default:;
6913 : }
6914 : }
6915 : break;
6916 2 : case CFN_BUILT_IN_SQRT:
6917 2 : if (call_expr_nargs (_p0) == 1)
6918 : {
6919 2 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
6920 2 : switch (TREE_CODE (_p1))
6921 : {
6922 2 : case REAL_CST:
6923 2 : {
6924 2 : {
6925 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6926 2 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, LE_EXPR);
6927 2 : if (res) return res;
6928 : }
6929 2 : break;
6930 : }
6931 0 : case CALL_EXPR:
6932 0 : switch (get_call_combined_fn (_p1))
6933 : {
6934 0 : case CFN_BUILT_IN_SQRT:
6935 0 : if (call_expr_nargs (_p1) == 1)
6936 : {
6937 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
6938 0 : {
6939 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6940 0 : tree res = generic_simplify_260 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, LE_EXPR);
6941 0 : if (res) return res;
6942 : }
6943 : }
6944 : break;
6945 : default:;
6946 : }
6947 : break;
6948 : default:;
6949 : }
6950 : }
6951 : break;
6952 0 : case CFN_SQRT:
6953 0 : if (call_expr_nargs (_p0) == 1)
6954 : {
6955 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
6956 0 : switch (TREE_CODE (_p1))
6957 : {
6958 0 : case REAL_CST:
6959 0 : {
6960 0 : {
6961 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6962 0 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, CFN_SQRT, LE_EXPR);
6963 0 : if (res) return res;
6964 : }
6965 0 : break;
6966 : }
6967 0 : case CALL_EXPR:
6968 0 : switch (get_call_combined_fn (_p1))
6969 : {
6970 0 : case CFN_SQRT:
6971 0 : if (call_expr_nargs (_p1) == 1)
6972 : {
6973 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
6974 0 : {
6975 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6976 0 : tree res = generic_simplify_260 (loc, type, _p0, _p1, captures, CFN_SQRT, LE_EXPR);
6977 0 : if (res) return res;
6978 : }
6979 : }
6980 : break;
6981 : default:;
6982 : }
6983 : break;
6984 : default:;
6985 : }
6986 : }
6987 : break;
6988 : default:;
6989 : }
6990 : break;
6991 8393041 : default:;
6992 : }
6993 8393041 : if (uniform_integer_cst_p (_p1))
6994 : {
6995 5976237 : {
6996 5976237 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
6997 5976237 : tree res = generic_simplify_394 (loc, type, _p0, _p1, captures, LE_EXPR);
6998 5976237 : if (res) return res;
6999 : }
7000 : }
7001 7984113 : switch (TREE_CODE (_p0))
7002 : {
7003 897102 : CASE_CONVERT:
7004 897102 : {
7005 897102 : tree _q20 = TREE_OPERAND (_p0, 0);
7006 897102 : switch (TREE_CODE (_q20))
7007 : {
7008 96854 : case PLUS_EXPR:
7009 96854 : {
7010 96854 : tree _q30 = TREE_OPERAND (_q20, 0);
7011 96854 : tree _q31 = TREE_OPERAND (_q20, 1);
7012 96854 : switch (TREE_CODE (_q30))
7013 : {
7014 82044 : CASE_CONVERT:
7015 82044 : {
7016 82044 : tree _q40 = TREE_OPERAND (_q30, 0);
7017 82044 : switch (TREE_CODE (_q31))
7018 : {
7019 81459 : case INTEGER_CST:
7020 81459 : {
7021 81459 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
7022 : {
7023 4 : {
7024 4 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q40, _q31 };
7025 4 : tree res = generic_simplify_395 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR);
7026 4 : if (res) return res;
7027 : }
7028 : }
7029 : break;
7030 : }
7031 : default:;
7032 : }
7033 : break;
7034 : }
7035 : default:;
7036 : }
7037 : break;
7038 : }
7039 : default:;
7040 : }
7041 : break;
7042 : }
7043 7984109 : default:;
7044 : }
7045 7984109 : switch (TREE_CODE (_p1))
7046 : {
7047 191830 : CASE_CONVERT:
7048 191830 : {
7049 191830 : tree _q30 = TREE_OPERAND (_p1, 0);
7050 191830 : switch (TREE_CODE (_q30))
7051 : {
7052 1889 : case PLUS_EXPR:
7053 1889 : {
7054 1889 : tree _q40 = TREE_OPERAND (_q30, 0);
7055 1889 : tree _q41 = TREE_OPERAND (_q30, 1);
7056 1889 : switch (TREE_CODE (_q40))
7057 : {
7058 442 : CASE_CONVERT:
7059 442 : {
7060 442 : tree _q50 = TREE_OPERAND (_q40, 0);
7061 442 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
7062 : {
7063 0 : switch (TREE_CODE (_q41))
7064 : {
7065 0 : case INTEGER_CST:
7066 0 : {
7067 0 : {
7068 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0, _q41 };
7069 0 : tree res = generic_simplify_395 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR);
7070 0 : if (res) return res;
7071 : }
7072 0 : break;
7073 : }
7074 : default:;
7075 : }
7076 : }
7077 : break;
7078 : }
7079 : default:;
7080 : }
7081 : break;
7082 : }
7083 : default:;
7084 : }
7085 : break;
7086 : }
7087 118144 : case PLUS_EXPR:
7088 118144 : {
7089 118144 : tree _q30 = TREE_OPERAND (_p1, 0);
7090 118144 : tree _q31 = TREE_OPERAND (_p1, 1);
7091 118144 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
7092 : {
7093 30 : switch (TREE_CODE (_q31))
7094 : {
7095 30 : case INTEGER_CST:
7096 30 : {
7097 30 : {
7098 30 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0, _q31 };
7099 30 : tree res = generic_simplify_390 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR);
7100 30 : if (res) return res;
7101 : }
7102 0 : break;
7103 : }
7104 : default:;
7105 : }
7106 : }
7107 : break;
7108 : }
7109 7984079 : default:;
7110 : }
7111 7984079 : switch (TREE_CODE (_p0))
7112 : {
7113 57366 : case MINUS_EXPR:
7114 57366 : {
7115 57366 : tree _q20 = TREE_OPERAND (_p0, 0);
7116 57366 : tree _q21 = TREE_OPERAND (_p0, 1);
7117 57366 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
7118 : {
7119 2509 : {
7120 2509 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
7121 2509 : tree res = generic_simplify_396 (loc, type, _p0, _p1, captures, LE_EXPR);
7122 2509 : if (res) return res;
7123 : }
7124 : }
7125 : break;
7126 : }
7127 7983952 : default:;
7128 : }
7129 7983952 : switch (TREE_CODE (_p1))
7130 : {
7131 118114 : case PLUS_EXPR:
7132 118114 : {
7133 118114 : tree _q30 = TREE_OPERAND (_p1, 0);
7134 118114 : tree _q31 = TREE_OPERAND (_p1, 1);
7135 118114 : switch (TREE_CODE (_q30))
7136 : {
7137 4 : case MINUS_EXPR:
7138 4 : {
7139 4 : tree _q40 = TREE_OPERAND (_q30, 0);
7140 4 : tree _q41 = TREE_OPERAND (_q30, 1);
7141 4 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
7142 : {
7143 0 : if (integer_minus_onep (_q31))
7144 : {
7145 0 : {
7146 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
7147 0 : tree res = generic_simplify_408 (loc, type, _p0, _p1, captures, GE_EXPR);
7148 0 : if (res) return res;
7149 : }
7150 : }
7151 : }
7152 : break;
7153 : }
7154 : default:;
7155 : }
7156 : break;
7157 : }
7158 7983952 : default:;
7159 : }
7160 7983952 : switch (TREE_CODE (_p0))
7161 : {
7162 12 : case REALPART_EXPR:
7163 12 : {
7164 12 : tree _q20 = TREE_OPERAND (_p0, 0);
7165 12 : switch (TREE_CODE (_q20))
7166 : {
7167 0 : case CALL_EXPR:
7168 0 : switch (get_call_combined_fn (_q20))
7169 : {
7170 0 : case CFN_SUB_OVERFLOW:
7171 0 : if (call_expr_nargs (_q20) == 2)
7172 : {
7173 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
7174 0 : tree _q31 = CALL_EXPR_ARG (_q20, 1);
7175 0 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
7176 : {
7177 0 : {
7178 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7179 0 : tree res = generic_simplify_409 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR);
7180 0 : if (res) return res;
7181 : }
7182 : }
7183 : }
7184 : break;
7185 : default:;
7186 : }
7187 : break;
7188 : default:;
7189 : }
7190 : break;
7191 : }
7192 7983952 : default:;
7193 : }
7194 7983952 : switch (TREE_CODE (_p1))
7195 : {
7196 0 : case REALPART_EXPR:
7197 0 : {
7198 0 : tree _q30 = TREE_OPERAND (_p1, 0);
7199 0 : switch (TREE_CODE (_q30))
7200 : {
7201 0 : case CALL_EXPR:
7202 0 : switch (get_call_combined_fn (_q30))
7203 : {
7204 0 : case CFN_ADD_OVERFLOW:
7205 0 : if (call_expr_nargs (_q30) == 2)
7206 : {
7207 0 : tree _q40 = CALL_EXPR_ARG (_q30, 0);
7208 0 : tree _q41 = CALL_EXPR_ARG (_q30, 1);
7209 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
7210 : {
7211 0 : {
7212 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p0, _q41 };
7213 0 : tree res = generic_simplify_410 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
7214 0 : if (res) return res;
7215 : }
7216 : }
7217 0 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
7218 : {
7219 0 : {
7220 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p0, _q40 };
7221 0 : tree res = generic_simplify_410 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
7222 0 : if (res) return res;
7223 : }
7224 : }
7225 : }
7226 : break;
7227 : default:;
7228 : }
7229 : break;
7230 : default:;
7231 : }
7232 : break;
7233 : }
7234 335 : case TRUNC_DIV_EXPR:
7235 335 : {
7236 335 : tree _q30 = TREE_OPERAND (_p1, 0);
7237 335 : tree _q31 = TREE_OPERAND (_p1, 1);
7238 335 : if (integer_all_onesp (_q30))
7239 : {
7240 0 : {
7241 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q31, _p0 };
7242 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
7243 0 : if (res) return res;
7244 : }
7245 : }
7246 : break;
7247 : }
7248 7983952 : default:;
7249 : }
7250 7983952 : switch (TREE_CODE (_p0))
7251 : {
7252 58577 : case MULT_EXPR:
7253 58577 : {
7254 58577 : tree _q20 = TREE_OPERAND (_p0, 0);
7255 58577 : tree _q21 = TREE_OPERAND (_p0, 1);
7256 58577 : switch (TREE_CODE (_q21))
7257 : {
7258 812 : case REAL_CST:
7259 812 : {
7260 812 : switch (TREE_CODE (_p1))
7261 : {
7262 544 : case REAL_CST:
7263 544 : {
7264 544 : {
7265 544 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7266 544 : tree res = generic_simplify_401 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
7267 544 : if (res) return res;
7268 : }
7269 542 : break;
7270 : }
7271 : default:;
7272 : }
7273 : break;
7274 : }
7275 : default:;
7276 : }
7277 : break;
7278 : }
7279 22 : case REAL_CST:
7280 22 : {
7281 22 : switch (TREE_CODE (_p1))
7282 : {
7283 0 : case CALL_EXPR:
7284 0 : switch (get_call_combined_fn (_p1))
7285 : {
7286 0 : case CFN_BUILT_IN_EXP:
7287 0 : if (call_expr_nargs (_p1) == 1)
7288 : {
7289 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7290 0 : {
7291 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7292 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, GE_EXPR);
7293 0 : if (res) return res;
7294 : }
7295 : }
7296 : break;
7297 0 : case CFN_BUILT_IN_LOG:
7298 0 : if (call_expr_nargs (_p1) == 1)
7299 : {
7300 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7301 0 : {
7302 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7303 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, GE_EXPR);
7304 0 : if (res) return res;
7305 : }
7306 : }
7307 : break;
7308 0 : case CFN_BUILT_IN_EXP10F:
7309 0 : if (call_expr_nargs (_p1) == 1)
7310 : {
7311 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7312 0 : {
7313 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7314 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, GE_EXPR);
7315 0 : if (res) return res;
7316 : }
7317 : }
7318 : break;
7319 0 : case CFN_BUILT_IN_EXP10L:
7320 0 : if (call_expr_nargs (_p1) == 1)
7321 : {
7322 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7323 0 : {
7324 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7325 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, GE_EXPR);
7326 0 : if (res) return res;
7327 : }
7328 : }
7329 : break;
7330 0 : case CFN_BUILT_IN_EXP2:
7331 0 : if (call_expr_nargs (_p1) == 1)
7332 : {
7333 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7334 0 : {
7335 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7336 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, GE_EXPR);
7337 0 : if (res) return res;
7338 : }
7339 : }
7340 : break;
7341 0 : case CFN_BUILT_IN_EXPF:
7342 0 : if (call_expr_nargs (_p1) == 1)
7343 : {
7344 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7345 0 : {
7346 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7347 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, GE_EXPR);
7348 0 : if (res) return res;
7349 : }
7350 : }
7351 : break;
7352 0 : case CFN_BUILT_IN_EXPL:
7353 0 : if (call_expr_nargs (_p1) == 1)
7354 : {
7355 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7356 0 : {
7357 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7358 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, GE_EXPR);
7359 0 : if (res) return res;
7360 : }
7361 : }
7362 : break;
7363 0 : case CFN_BUILT_IN_LOG2:
7364 0 : if (call_expr_nargs (_p1) == 1)
7365 : {
7366 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7367 0 : {
7368 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7369 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, GE_EXPR);
7370 0 : if (res) return res;
7371 : }
7372 : }
7373 : break;
7374 0 : case CFN_BUILT_IN_LOGF:
7375 0 : if (call_expr_nargs (_p1) == 1)
7376 : {
7377 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7378 0 : {
7379 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7380 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, GE_EXPR);
7381 0 : if (res) return res;
7382 : }
7383 : }
7384 : break;
7385 0 : case CFN_BUILT_IN_LOGL:
7386 0 : if (call_expr_nargs (_p1) == 1)
7387 : {
7388 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7389 0 : {
7390 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7391 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, GE_EXPR);
7392 0 : if (res) return res;
7393 : }
7394 : }
7395 : break;
7396 0 : case CFN_BUILT_IN_LOG10F:
7397 0 : if (call_expr_nargs (_p1) == 1)
7398 : {
7399 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7400 0 : {
7401 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7402 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, GE_EXPR);
7403 0 : if (res) return res;
7404 : }
7405 : }
7406 : break;
7407 0 : case CFN_BUILT_IN_LOG10L:
7408 0 : if (call_expr_nargs (_p1) == 1)
7409 : {
7410 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7411 0 : {
7412 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7413 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, GE_EXPR);
7414 0 : if (res) return res;
7415 : }
7416 : }
7417 : break;
7418 0 : case CFN_EXP:
7419 0 : if (call_expr_nargs (_p1) == 1)
7420 : {
7421 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7422 0 : {
7423 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7424 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, GE_EXPR);
7425 0 : if (res) return res;
7426 : }
7427 : }
7428 : break;
7429 0 : case CFN_LOG:
7430 0 : if (call_expr_nargs (_p1) == 1)
7431 : {
7432 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7433 0 : {
7434 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7435 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, GE_EXPR);
7436 0 : if (res) return res;
7437 : }
7438 : }
7439 : break;
7440 0 : case CFN_EXP2:
7441 0 : if (call_expr_nargs (_p1) == 1)
7442 : {
7443 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7444 0 : {
7445 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7446 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, GE_EXPR);
7447 0 : if (res) return res;
7448 : }
7449 : }
7450 : break;
7451 0 : case CFN_LOG2:
7452 0 : if (call_expr_nargs (_p1) == 1)
7453 : {
7454 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7455 0 : {
7456 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7457 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, GE_EXPR);
7458 0 : if (res) return res;
7459 : }
7460 : }
7461 : break;
7462 0 : case CFN_EXP10:
7463 0 : if (call_expr_nargs (_p1) == 1)
7464 : {
7465 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7466 0 : {
7467 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7468 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, GE_EXPR);
7469 0 : if (res) return res;
7470 : }
7471 : }
7472 : break;
7473 0 : case CFN_LOG10:
7474 0 : if (call_expr_nargs (_p1) == 1)
7475 : {
7476 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7477 0 : {
7478 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7479 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, GE_EXPR);
7480 0 : if (res) return res;
7481 : }
7482 : }
7483 : break;
7484 0 : case CFN_BUILT_IN_EXP10:
7485 0 : if (call_expr_nargs (_p1) == 1)
7486 : {
7487 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7488 0 : {
7489 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7490 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, GE_EXPR);
7491 0 : if (res) return res;
7492 : }
7493 : }
7494 : break;
7495 0 : case CFN_BUILT_IN_EXP2F:
7496 0 : if (call_expr_nargs (_p1) == 1)
7497 : {
7498 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7499 0 : {
7500 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7501 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, GE_EXPR);
7502 0 : if (res) return res;
7503 : }
7504 : }
7505 : break;
7506 0 : case CFN_BUILT_IN_EXP2L:
7507 0 : if (call_expr_nargs (_p1) == 1)
7508 : {
7509 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7510 0 : {
7511 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7512 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, GE_EXPR);
7513 0 : if (res) return res;
7514 : }
7515 : }
7516 : break;
7517 0 : case CFN_BUILT_IN_LOG10:
7518 0 : if (call_expr_nargs (_p1) == 1)
7519 : {
7520 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7521 0 : {
7522 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7523 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, GE_EXPR);
7524 0 : if (res) return res;
7525 : }
7526 : }
7527 : break;
7528 0 : case CFN_BUILT_IN_LOG2F:
7529 0 : if (call_expr_nargs (_p1) == 1)
7530 : {
7531 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7532 0 : {
7533 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7534 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, GE_EXPR);
7535 0 : if (res) return res;
7536 : }
7537 : }
7538 : break;
7539 0 : case CFN_BUILT_IN_LOG2L:
7540 0 : if (call_expr_nargs (_p1) == 1)
7541 : {
7542 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7543 0 : {
7544 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7545 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, GE_EXPR);
7546 0 : if (res) return res;
7547 : }
7548 : }
7549 : break;
7550 : default:;
7551 : }
7552 : break;
7553 : default:;
7554 : }
7555 : break;
7556 : }
7557 1476946 : case PLUS_EXPR:
7558 1476946 : {
7559 1476946 : tree _q20 = TREE_OPERAND (_p0, 0);
7560 1476946 : tree _q21 = TREE_OPERAND (_p0, 1);
7561 1476946 : switch (TREE_CODE (_q21))
7562 : {
7563 1378935 : case INTEGER_CST:
7564 1378935 : {
7565 1378935 : switch (TREE_CODE (_p1))
7566 : {
7567 859524 : case INTEGER_CST:
7568 859524 : {
7569 859524 : {
7570 859524 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
7571 859524 : tree res = generic_simplify_402 (loc, type, _p0, _p1, captures, PLUS_EXPR, MINUS_EXPR, LE_EXPR, GE_EXPR);
7572 859524 : if (res) return res;
7573 : }
7574 675860 : break;
7575 : }
7576 : default:;
7577 : }
7578 : break;
7579 : }
7580 : default:;
7581 : }
7582 : break;
7583 : }
7584 57239 : case MINUS_EXPR:
7585 57239 : {
7586 57239 : tree _q20 = TREE_OPERAND (_p0, 0);
7587 57239 : tree _q21 = TREE_OPERAND (_p0, 1);
7588 57239 : switch (TREE_CODE (_q21))
7589 : {
7590 2205 : case INTEGER_CST:
7591 2205 : {
7592 2205 : switch (TREE_CODE (_p1))
7593 : {
7594 2205 : case INTEGER_CST:
7595 2205 : {
7596 2205 : {
7597 2205 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
7598 2205 : tree res = generic_simplify_402 (loc, type, _p0, _p1, captures, MINUS_EXPR, PLUS_EXPR, LE_EXPR, GE_EXPR);
7599 2205 : if (res) return res;
7600 : }
7601 2204 : break;
7602 : }
7603 : default:;
7604 : }
7605 : break;
7606 : }
7607 57238 : default:;
7608 : }
7609 57238 : switch (TREE_CODE (_q20))
7610 : {
7611 2041 : case INTEGER_CST:
7612 2041 : {
7613 2041 : switch (TREE_CODE (_p1))
7614 : {
7615 1083 : case INTEGER_CST:
7616 1083 : {
7617 1083 : {
7618 1083 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7619 1083 : tree res = generic_simplify_292 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
7620 1083 : if (res) return res;
7621 : }
7622 0 : break;
7623 : }
7624 : default:;
7625 : }
7626 : break;
7627 : }
7628 : default:;
7629 : }
7630 : break;
7631 : }
7632 124859 : case CALL_EXPR:
7633 124859 : switch (get_call_combined_fn (_p0))
7634 : {
7635 18 : case CFN_BUILT_IN_CTZ:
7636 18 : if (call_expr_nargs (_p0) == 1)
7637 : {
7638 18 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7639 18 : switch (TREE_CODE (_p1))
7640 : {
7641 18 : case INTEGER_CST:
7642 18 : {
7643 18 : {
7644 18 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7645 18 : tree res = generic_simplify_403 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_BUILT_IN_CTZ);
7646 18 : if (res) return res;
7647 : }
7648 16 : break;
7649 : }
7650 : default:;
7651 : }
7652 : }
7653 : break;
7654 0 : case CFN_BUILT_IN_EXP:
7655 0 : if (call_expr_nargs (_p0) == 1)
7656 : {
7657 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7658 0 : switch (TREE_CODE (_p1))
7659 : {
7660 0 : case REAL_CST:
7661 0 : {
7662 0 : {
7663 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7664 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, LE_EXPR);
7665 0 : if (res) return res;
7666 : }
7667 0 : break;
7668 : }
7669 : default:;
7670 : }
7671 : }
7672 : break;
7673 8 : case CFN_BUILT_IN_FFS:
7674 8 : if (call_expr_nargs (_p0) == 1)
7675 : {
7676 8 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7677 8 : switch (TREE_CODE (_p1))
7678 : {
7679 8 : case INTEGER_CST:
7680 8 : {
7681 8 : {
7682 8 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7683 8 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_FFS);
7684 8 : if (res) return res;
7685 : }
7686 2 : break;
7687 : }
7688 : default:;
7689 : }
7690 : }
7691 : break;
7692 0 : case CFN_BUILT_IN_LOG:
7693 0 : if (call_expr_nargs (_p0) == 1)
7694 : {
7695 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7696 0 : switch (TREE_CODE (_p1))
7697 : {
7698 0 : case REAL_CST:
7699 0 : {
7700 0 : {
7701 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7702 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, LE_EXPR);
7703 0 : if (res) return res;
7704 : }
7705 0 : break;
7706 : }
7707 : default:;
7708 : }
7709 : }
7710 : break;
7711 0 : case CFN_BUILT_IN_FFSIMAX:
7712 0 : if (call_expr_nargs (_p0) == 1)
7713 : {
7714 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7715 0 : switch (TREE_CODE (_p1))
7716 : {
7717 0 : case INTEGER_CST:
7718 0 : {
7719 0 : {
7720 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7721 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_FFSIMAX);
7722 0 : if (res) return res;
7723 : }
7724 0 : break;
7725 : }
7726 : default:;
7727 : }
7728 : }
7729 : break;
7730 0 : case CFN_BUILT_IN_EXP10F:
7731 0 : if (call_expr_nargs (_p0) == 1)
7732 : {
7733 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7734 0 : switch (TREE_CODE (_p1))
7735 : {
7736 0 : case REAL_CST:
7737 0 : {
7738 0 : {
7739 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7740 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, LE_EXPR);
7741 0 : if (res) return res;
7742 : }
7743 0 : break;
7744 : }
7745 : default:;
7746 : }
7747 : }
7748 : break;
7749 0 : case CFN_BUILT_IN_EXP10L:
7750 0 : if (call_expr_nargs (_p0) == 1)
7751 : {
7752 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7753 0 : switch (TREE_CODE (_p1))
7754 : {
7755 0 : case REAL_CST:
7756 0 : {
7757 0 : {
7758 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7759 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, LE_EXPR);
7760 0 : if (res) return res;
7761 : }
7762 0 : break;
7763 : }
7764 : default:;
7765 : }
7766 : }
7767 : break;
7768 37 : case CFN_BUILT_IN_POPCOUNT:
7769 37 : if (call_expr_nargs (_p0) == 1)
7770 : {
7771 37 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7772 37 : if (integer_zerop (_p1))
7773 : {
7774 1 : {
7775 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
7776 1 : tree res = generic_simplify_297 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNT);
7777 1 : if (res) return res;
7778 : }
7779 : }
7780 : }
7781 : break;
7782 0 : case CFN_BUILT_IN_CTZL:
7783 0 : if (call_expr_nargs (_p0) == 1)
7784 : {
7785 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7786 0 : switch (TREE_CODE (_p1))
7787 : {
7788 0 : case INTEGER_CST:
7789 0 : {
7790 0 : {
7791 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7792 0 : tree res = generic_simplify_403 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_BUILT_IN_CTZL);
7793 0 : if (res) return res;
7794 : }
7795 0 : break;
7796 : }
7797 : default:;
7798 : }
7799 : }
7800 : break;
7801 0 : case CFN_BUILT_IN_EXP2:
7802 0 : if (call_expr_nargs (_p0) == 1)
7803 : {
7804 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7805 0 : switch (TREE_CODE (_p1))
7806 : {
7807 0 : case REAL_CST:
7808 0 : {
7809 0 : {
7810 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7811 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, LE_EXPR);
7812 0 : if (res) return res;
7813 : }
7814 0 : break;
7815 : }
7816 : default:;
7817 : }
7818 : }
7819 : break;
7820 0 : case CFN_BUILT_IN_EXPF:
7821 0 : if (call_expr_nargs (_p0) == 1)
7822 : {
7823 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7824 0 : switch (TREE_CODE (_p1))
7825 : {
7826 0 : case REAL_CST:
7827 0 : {
7828 0 : {
7829 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7830 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, LE_EXPR);
7831 0 : if (res) return res;
7832 : }
7833 0 : break;
7834 : }
7835 : default:;
7836 : }
7837 : }
7838 : break;
7839 0 : case CFN_BUILT_IN_EXPL:
7840 0 : if (call_expr_nargs (_p0) == 1)
7841 : {
7842 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7843 0 : switch (TREE_CODE (_p1))
7844 : {
7845 0 : case REAL_CST:
7846 0 : {
7847 0 : {
7848 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7849 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, LE_EXPR);
7850 0 : if (res) return res;
7851 : }
7852 0 : break;
7853 : }
7854 : default:;
7855 : }
7856 : }
7857 : break;
7858 3 : case CFN_BUILT_IN_FFSL:
7859 3 : if (call_expr_nargs (_p0) == 1)
7860 : {
7861 3 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7862 3 : switch (TREE_CODE (_p1))
7863 : {
7864 3 : case INTEGER_CST:
7865 3 : {
7866 3 : {
7867 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7868 3 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_FFSL);
7869 3 : if (res) return res;
7870 : }
7871 0 : break;
7872 : }
7873 : default:;
7874 : }
7875 : }
7876 : break;
7877 0 : case CFN_BUILT_IN_LOG2:
7878 0 : if (call_expr_nargs (_p0) == 1)
7879 : {
7880 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7881 0 : switch (TREE_CODE (_p1))
7882 : {
7883 0 : case REAL_CST:
7884 0 : {
7885 0 : {
7886 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7887 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, LE_EXPR);
7888 0 : if (res) return res;
7889 : }
7890 0 : break;
7891 : }
7892 : default:;
7893 : }
7894 : }
7895 : break;
7896 0 : case CFN_BUILT_IN_LOGF:
7897 0 : if (call_expr_nargs (_p0) == 1)
7898 : {
7899 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7900 0 : switch (TREE_CODE (_p1))
7901 : {
7902 0 : case REAL_CST:
7903 0 : {
7904 0 : {
7905 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7906 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, LE_EXPR);
7907 0 : if (res) return res;
7908 : }
7909 0 : break;
7910 : }
7911 : default:;
7912 : }
7913 : }
7914 : break;
7915 0 : case CFN_BUILT_IN_LOGL:
7916 0 : if (call_expr_nargs (_p0) == 1)
7917 : {
7918 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7919 0 : switch (TREE_CODE (_p1))
7920 : {
7921 0 : case REAL_CST:
7922 0 : {
7923 0 : {
7924 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7925 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, LE_EXPR);
7926 0 : if (res) return res;
7927 : }
7928 0 : break;
7929 : }
7930 : default:;
7931 : }
7932 : }
7933 : break;
7934 1 : case CFN_BUILT_IN_POPCOUNTLL:
7935 1 : if (call_expr_nargs (_p0) == 1)
7936 : {
7937 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7938 1 : if (integer_zerop (_p1))
7939 : {
7940 1 : {
7941 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
7942 1 : tree res = generic_simplify_297 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNTLL);
7943 1 : if (res) return res;
7944 : }
7945 : }
7946 : }
7947 : break;
7948 0 : case CFN_BUILT_IN_LOG10F:
7949 0 : if (call_expr_nargs (_p0) == 1)
7950 : {
7951 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7952 0 : switch (TREE_CODE (_p1))
7953 : {
7954 0 : case REAL_CST:
7955 0 : {
7956 0 : {
7957 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7958 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, LE_EXPR);
7959 0 : if (res) return res;
7960 : }
7961 0 : break;
7962 : }
7963 : default:;
7964 : }
7965 : }
7966 : break;
7967 0 : case CFN_BUILT_IN_LOG10L:
7968 0 : if (call_expr_nargs (_p0) == 1)
7969 : {
7970 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7971 0 : switch (TREE_CODE (_p1))
7972 : {
7973 0 : case REAL_CST:
7974 0 : {
7975 0 : {
7976 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7977 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, LE_EXPR);
7978 0 : if (res) return res;
7979 : }
7980 0 : break;
7981 : }
7982 : default:;
7983 : }
7984 : }
7985 : break;
7986 0 : case CFN_BUILT_IN_CTZIMAX:
7987 0 : if (call_expr_nargs (_p0) == 1)
7988 : {
7989 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7990 0 : switch (TREE_CODE (_p1))
7991 : {
7992 0 : case INTEGER_CST:
7993 0 : {
7994 0 : {
7995 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7996 0 : tree res = generic_simplify_403 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_BUILT_IN_CTZIMAX);
7997 0 : if (res) return res;
7998 : }
7999 0 : break;
8000 : }
8001 : default:;
8002 : }
8003 : }
8004 : break;
8005 0 : case CFN_POPCOUNT:
8006 0 : if (call_expr_nargs (_p0) == 1)
8007 : {
8008 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8009 0 : if (integer_zerop (_p1))
8010 : {
8011 0 : {
8012 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8013 0 : tree res = generic_simplify_297 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_POPCOUNT);
8014 0 : if (res) return res;
8015 : }
8016 : }
8017 : }
8018 : break;
8019 0 : case CFN_CTZ:
8020 0 : if (call_expr_nargs (_p0) == 2)
8021 : {
8022 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8023 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
8024 0 : switch (TREE_CODE (_p1))
8025 : {
8026 0 : case INTEGER_CST:
8027 0 : {
8028 0 : {
8029 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
8030 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR);
8031 0 : if (res) return res;
8032 : }
8033 0 : break;
8034 : }
8035 : default:;
8036 : }
8037 : }
8038 0 : if (call_expr_nargs (_p0) == 1)
8039 : {
8040 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8041 0 : switch (TREE_CODE (_p1))
8042 : {
8043 0 : case INTEGER_CST:
8044 0 : {
8045 0 : {
8046 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8047 0 : tree res = generic_simplify_403 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_CTZ);
8048 0 : if (res) return res;
8049 : }
8050 0 : break;
8051 : }
8052 : default:;
8053 : }
8054 : }
8055 : break;
8056 0 : case CFN_EXP:
8057 0 : if (call_expr_nargs (_p0) == 1)
8058 : {
8059 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8060 0 : switch (TREE_CODE (_p1))
8061 : {
8062 0 : case REAL_CST:
8063 0 : {
8064 0 : {
8065 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8066 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, LE_EXPR);
8067 0 : if (res) return res;
8068 : }
8069 0 : break;
8070 : }
8071 : default:;
8072 : }
8073 : }
8074 : break;
8075 0 : case CFN_FFS:
8076 0 : if (call_expr_nargs (_p0) == 1)
8077 : {
8078 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8079 0 : switch (TREE_CODE (_p1))
8080 : {
8081 0 : case INTEGER_CST:
8082 0 : {
8083 0 : {
8084 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8085 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_FFS);
8086 0 : if (res) return res;
8087 : }
8088 0 : break;
8089 : }
8090 : default:;
8091 : }
8092 : }
8093 : break;
8094 0 : case CFN_LOG:
8095 0 : if (call_expr_nargs (_p0) == 1)
8096 : {
8097 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8098 0 : switch (TREE_CODE (_p1))
8099 : {
8100 0 : case REAL_CST:
8101 0 : {
8102 0 : {
8103 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8104 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, LE_EXPR);
8105 0 : if (res) return res;
8106 : }
8107 0 : break;
8108 : }
8109 : default:;
8110 : }
8111 : }
8112 : break;
8113 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
8114 0 : if (call_expr_nargs (_p0) == 1)
8115 : {
8116 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8117 0 : if (integer_zerop (_p1))
8118 : {
8119 0 : {
8120 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8121 0 : tree res = generic_simplify_297 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
8122 0 : if (res) return res;
8123 : }
8124 : }
8125 : }
8126 : break;
8127 0 : case CFN_EXP2:
8128 0 : if (call_expr_nargs (_p0) == 1)
8129 : {
8130 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8131 0 : switch (TREE_CODE (_p1))
8132 : {
8133 0 : case REAL_CST:
8134 0 : {
8135 0 : {
8136 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8137 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, LE_EXPR);
8138 0 : if (res) return res;
8139 : }
8140 0 : break;
8141 : }
8142 : default:;
8143 : }
8144 : }
8145 : break;
8146 0 : case CFN_LOG2:
8147 0 : if (call_expr_nargs (_p0) == 1)
8148 : {
8149 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8150 0 : switch (TREE_CODE (_p1))
8151 : {
8152 0 : case REAL_CST:
8153 0 : {
8154 0 : {
8155 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8156 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, LE_EXPR);
8157 0 : if (res) return res;
8158 : }
8159 0 : break;
8160 : }
8161 : default:;
8162 : }
8163 : }
8164 : break;
8165 0 : case CFN_EXP10:
8166 0 : if (call_expr_nargs (_p0) == 1)
8167 : {
8168 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8169 0 : switch (TREE_CODE (_p1))
8170 : {
8171 0 : case REAL_CST:
8172 0 : {
8173 0 : {
8174 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8175 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, LE_EXPR);
8176 0 : if (res) return res;
8177 : }
8178 0 : break;
8179 : }
8180 : default:;
8181 : }
8182 : }
8183 : break;
8184 1 : case CFN_BUILT_IN_POPCOUNTL:
8185 1 : if (call_expr_nargs (_p0) == 1)
8186 : {
8187 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8188 1 : if (integer_zerop (_p1))
8189 : {
8190 1 : {
8191 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8192 1 : tree res = generic_simplify_297 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNTL);
8193 1 : if (res) return res;
8194 : }
8195 : }
8196 : }
8197 : break;
8198 0 : case CFN_BUILT_IN_CTZLL:
8199 0 : if (call_expr_nargs (_p0) == 1)
8200 : {
8201 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8202 0 : switch (TREE_CODE (_p1))
8203 : {
8204 0 : case INTEGER_CST:
8205 0 : {
8206 0 : {
8207 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8208 0 : tree res = generic_simplify_403 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_BUILT_IN_CTZLL);
8209 0 : if (res) return res;
8210 : }
8211 0 : break;
8212 : }
8213 : default:;
8214 : }
8215 : }
8216 : break;
8217 0 : case CFN_LOG10:
8218 0 : if (call_expr_nargs (_p0) == 1)
8219 : {
8220 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8221 0 : switch (TREE_CODE (_p1))
8222 : {
8223 0 : case REAL_CST:
8224 0 : {
8225 0 : {
8226 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8227 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, LE_EXPR);
8228 0 : if (res) return res;
8229 : }
8230 0 : break;
8231 : }
8232 : default:;
8233 : }
8234 : }
8235 : break;
8236 0 : case CFN_BUILT_IN_EXP10:
8237 0 : if (call_expr_nargs (_p0) == 1)
8238 : {
8239 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8240 0 : switch (TREE_CODE (_p1))
8241 : {
8242 0 : case REAL_CST:
8243 0 : {
8244 0 : {
8245 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8246 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, LE_EXPR);
8247 0 : if (res) return res;
8248 : }
8249 0 : break;
8250 : }
8251 : default:;
8252 : }
8253 : }
8254 : break;
8255 0 : case CFN_BUILT_IN_EXP2F:
8256 0 : if (call_expr_nargs (_p0) == 1)
8257 : {
8258 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8259 0 : switch (TREE_CODE (_p1))
8260 : {
8261 0 : case REAL_CST:
8262 0 : {
8263 0 : {
8264 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8265 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, LE_EXPR);
8266 0 : if (res) return res;
8267 : }
8268 0 : break;
8269 : }
8270 : default:;
8271 : }
8272 : }
8273 : break;
8274 0 : case CFN_BUILT_IN_EXP2L:
8275 0 : if (call_expr_nargs (_p0) == 1)
8276 : {
8277 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8278 0 : switch (TREE_CODE (_p1))
8279 : {
8280 0 : case REAL_CST:
8281 0 : {
8282 0 : {
8283 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8284 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, LE_EXPR);
8285 0 : if (res) return res;
8286 : }
8287 0 : break;
8288 : }
8289 : default:;
8290 : }
8291 : }
8292 : break;
8293 3 : case CFN_BUILT_IN_FFSLL:
8294 3 : if (call_expr_nargs (_p0) == 1)
8295 : {
8296 3 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8297 3 : switch (TREE_CODE (_p1))
8298 : {
8299 3 : case INTEGER_CST:
8300 3 : {
8301 3 : {
8302 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8303 3 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_FFSLL);
8304 3 : if (res) return res;
8305 : }
8306 0 : break;
8307 : }
8308 : default:;
8309 : }
8310 : }
8311 : break;
8312 0 : case CFN_BUILT_IN_LOG10:
8313 0 : if (call_expr_nargs (_p0) == 1)
8314 : {
8315 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8316 0 : switch (TREE_CODE (_p1))
8317 : {
8318 0 : case REAL_CST:
8319 0 : {
8320 0 : {
8321 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8322 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, LE_EXPR);
8323 0 : if (res) return res;
8324 : }
8325 0 : break;
8326 : }
8327 : default:;
8328 : }
8329 : }
8330 : break;
8331 0 : case CFN_BUILT_IN_LOG2F:
8332 0 : if (call_expr_nargs (_p0) == 1)
8333 : {
8334 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8335 0 : switch (TREE_CODE (_p1))
8336 : {
8337 0 : case REAL_CST:
8338 0 : {
8339 0 : {
8340 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8341 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, LE_EXPR);
8342 0 : if (res) return res;
8343 : }
8344 0 : break;
8345 : }
8346 : default:;
8347 : }
8348 : }
8349 : break;
8350 0 : case CFN_BUILT_IN_LOG2L:
8351 0 : if (call_expr_nargs (_p0) == 1)
8352 : {
8353 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8354 0 : switch (TREE_CODE (_p1))
8355 : {
8356 0 : case REAL_CST:
8357 0 : {
8358 0 : {
8359 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8360 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, LE_EXPR);
8361 0 : if (res) return res;
8362 : }
8363 0 : break;
8364 : }
8365 : default:;
8366 : }
8367 : }
8368 : break;
8369 : default:;
8370 : }
8371 : break;
8372 : default:;
8373 : }
8374 : return NULL_TREE;
8375 : }
8376 :
8377 : tree
8378 4140 : generic_simplify_CEIL_MOD_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
8379 : {
8380 4140 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8381 4140 : if (integer_zerop (_p0))
8382 : {
8383 0 : {
8384 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8385 0 : tree res = generic_simplify_323 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8386 0 : if (res) return res;
8387 : }
8388 : }
8389 4140 : if (integer_onep (_p1))
8390 : {
8391 0 : {
8392 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8393 0 : tree res = generic_simplify_324 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8394 0 : if (res) return res;
8395 : }
8396 : }
8397 4140 : if (integer_minus_onep (_p1))
8398 : {
8399 0 : {
8400 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8401 0 : tree res = generic_simplify_325 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8402 0 : if (res) return res;
8403 : }
8404 : }
8405 4140 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
8406 : {
8407 0 : {
8408 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8409 0 : tree res = generic_simplify_326 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8410 0 : if (res) return res;
8411 : }
8412 : }
8413 4140 : switch (TREE_CODE (_p0))
8414 : {
8415 0 : case CEIL_MOD_EXPR:
8416 0 : {
8417 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8418 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8419 0 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8420 : {
8421 0 : {
8422 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8423 0 : tree res = generic_simplify_327 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8424 0 : if (res) return res;
8425 : }
8426 : }
8427 : break;
8428 : }
8429 0 : case MULT_EXPR:
8430 0 : {
8431 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8432 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8433 0 : switch (TREE_CODE (_q21))
8434 : {
8435 0 : case INTEGER_CST:
8436 0 : {
8437 0 : switch (TREE_CODE (_p1))
8438 : {
8439 0 : case INTEGER_CST:
8440 0 : {
8441 0 : {
8442 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8443 0 : tree res = generic_simplify_328 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8444 0 : if (res) return res;
8445 : }
8446 0 : break;
8447 : }
8448 : default:;
8449 : }
8450 : break;
8451 : }
8452 : default:;
8453 : }
8454 : break;
8455 : }
8456 0 : case VEC_COND_EXPR:
8457 0 : {
8458 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8459 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8460 0 : tree _q22 = TREE_OPERAND (_p0, 2);
8461 0 : switch (TREE_CODE (_p1))
8462 : {
8463 0 : case VEC_COND_EXPR:
8464 0 : {
8465 0 : tree _q60 = TREE_OPERAND (_p1, 0);
8466 0 : tree _q61 = TREE_OPERAND (_p1, 1);
8467 0 : tree _q62 = TREE_OPERAND (_p1, 2);
8468 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
8469 : {
8470 0 : {
8471 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
8472 0 : if (VECTOR_TYPE_P (type)
8473 0 : && (TREE_CODE_CLASS (CEIL_MOD_EXPR) != tcc_comparison
8474 : || types_match (type, TREE_TYPE (captures[2]))
8475 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8476 : || (optimize_vectors_before_lowering_p ()
8477 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8478 : )
8479 : {
8480 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1645;
8481 0 : {
8482 0 : tree res_op0;
8483 0 : res_op0 = captures[1];
8484 0 : tree res_op1;
8485 0 : {
8486 0 : tree _o1[2], _r1;
8487 0 : _o1[0] = captures[2];
8488 0 : _o1[1] = captures[5];
8489 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8490 0 : if (EXPR_P (_r1))
8491 0 : goto next_after_fail1645;
8492 0 : res_op1 = _r1;
8493 : }
8494 0 : tree res_op2;
8495 0 : {
8496 0 : tree _o1[2], _r1;
8497 0 : _o1[0] = captures[3];
8498 0 : _o1[1] = captures[6];
8499 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8500 0 : if (EXPR_P (_r1))
8501 0 : goto next_after_fail1645;
8502 0 : res_op2 = _r1;
8503 : }
8504 0 : tree _r;
8505 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8506 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
8507 0 : return _r;
8508 : }
8509 0 : next_after_fail1645:;
8510 : }
8511 : }
8512 : }
8513 : break;
8514 : }
8515 0 : default:;
8516 : }
8517 0 : {
8518 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
8519 0 : if (VECTOR_TYPE_P (type)
8520 0 : && (TREE_CODE_CLASS (CEIL_MOD_EXPR) != tcc_comparison
8521 : || types_match (type, TREE_TYPE (captures[2]))
8522 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8523 : || (optimize_vectors_before_lowering_p ()
8524 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8525 : )
8526 : {
8527 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1646;
8528 0 : {
8529 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1646;
8530 0 : tree res_op0;
8531 0 : res_op0 = captures[1];
8532 0 : tree res_op1;
8533 0 : {
8534 0 : tree _o1[2], _r1;
8535 0 : _o1[0] = captures[2];
8536 0 : _o1[1] = unshare_expr (captures[4]);
8537 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8538 0 : if (EXPR_P (_r1))
8539 0 : goto next_after_fail1646;
8540 0 : res_op1 = _r1;
8541 : }
8542 0 : tree res_op2;
8543 0 : {
8544 0 : tree _o1[2], _r1;
8545 0 : _o1[0] = captures[3];
8546 0 : _o1[1] = captures[4];
8547 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8548 0 : if (EXPR_P (_r1))
8549 0 : goto next_after_fail1646;
8550 0 : res_op2 = _r1;
8551 : }
8552 0 : tree _r;
8553 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8554 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 895, __FILE__, __LINE__, true);
8555 0 : return _r;
8556 : }
8557 0 : next_after_fail1646:;
8558 : }
8559 : }
8560 0 : break;
8561 : }
8562 4140 : default:;
8563 : }
8564 4140 : switch (TREE_CODE (_p1))
8565 : {
8566 0 : case VEC_COND_EXPR:
8567 0 : {
8568 0 : tree _q30 = TREE_OPERAND (_p1, 0);
8569 0 : tree _q31 = TREE_OPERAND (_p1, 1);
8570 0 : tree _q32 = TREE_OPERAND (_p1, 2);
8571 0 : {
8572 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
8573 0 : if (VECTOR_TYPE_P (type)
8574 0 : && (TREE_CODE_CLASS (CEIL_MOD_EXPR) != tcc_comparison
8575 : || types_match (type, TREE_TYPE (captures[3]))
8576 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
8577 : || (optimize_vectors_before_lowering_p ()
8578 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
8579 : )
8580 : {
8581 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1647;
8582 0 : {
8583 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1647;
8584 0 : tree res_op0;
8585 0 : res_op0 = captures[2];
8586 0 : tree res_op1;
8587 0 : {
8588 0 : tree _o1[2], _r1;
8589 0 : _o1[0] = unshare_expr (captures[0]);
8590 0 : _o1[1] = captures[3];
8591 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8592 0 : if (EXPR_P (_r1))
8593 0 : goto next_after_fail1647;
8594 0 : res_op1 = _r1;
8595 : }
8596 0 : tree res_op2;
8597 0 : {
8598 0 : tree _o1[2], _r1;
8599 0 : _o1[0] = captures[0];
8600 0 : _o1[1] = captures[4];
8601 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8602 0 : if (EXPR_P (_r1))
8603 0 : goto next_after_fail1647;
8604 0 : res_op2 = _r1;
8605 : }
8606 0 : tree _r;
8607 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8608 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
8609 0 : return _r;
8610 : }
8611 0 : next_after_fail1647:;
8612 : }
8613 : }
8614 0 : break;
8615 : }
8616 : default:;
8617 : }
8618 : return NULL_TREE;
8619 : }
8620 :
8621 : tree
8622 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)
8623 : {
8624 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8625 0 : if (integer_zerop (_p0))
8626 : {
8627 0 : {
8628 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8629 0 : tree res = generic_simplify_323 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8630 0 : if (res) return res;
8631 : }
8632 : }
8633 0 : if (integer_onep (_p1))
8634 : {
8635 0 : {
8636 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8637 0 : tree res = generic_simplify_324 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8638 0 : if (res) return res;
8639 : }
8640 : }
8641 0 : if (integer_minus_onep (_p1))
8642 : {
8643 0 : {
8644 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8645 0 : tree res = generic_simplify_325 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8646 0 : if (res) return res;
8647 : }
8648 : }
8649 0 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
8650 : {
8651 0 : {
8652 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8653 0 : tree res = generic_simplify_326 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8654 0 : if (res) return res;
8655 : }
8656 : }
8657 0 : switch (TREE_CODE (_p0))
8658 : {
8659 0 : case ROUND_MOD_EXPR:
8660 0 : {
8661 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8662 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8663 0 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8664 : {
8665 0 : {
8666 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8667 0 : tree res = generic_simplify_327 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8668 0 : if (res) return res;
8669 : }
8670 : }
8671 : break;
8672 : }
8673 0 : case MULT_EXPR:
8674 0 : {
8675 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8676 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8677 0 : switch (TREE_CODE (_q21))
8678 : {
8679 0 : case INTEGER_CST:
8680 0 : {
8681 0 : switch (TREE_CODE (_p1))
8682 : {
8683 0 : case INTEGER_CST:
8684 0 : {
8685 0 : {
8686 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8687 0 : tree res = generic_simplify_328 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8688 0 : if (res) return res;
8689 : }
8690 0 : break;
8691 : }
8692 : default:;
8693 : }
8694 : break;
8695 : }
8696 : default:;
8697 : }
8698 : break;
8699 : }
8700 0 : case VEC_COND_EXPR:
8701 0 : {
8702 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8703 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8704 0 : tree _q22 = TREE_OPERAND (_p0, 2);
8705 0 : switch (TREE_CODE (_p1))
8706 : {
8707 0 : case VEC_COND_EXPR:
8708 0 : {
8709 0 : tree _q60 = TREE_OPERAND (_p1, 0);
8710 0 : tree _q61 = TREE_OPERAND (_p1, 1);
8711 0 : tree _q62 = TREE_OPERAND (_p1, 2);
8712 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
8713 : {
8714 0 : {
8715 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
8716 0 : if (VECTOR_TYPE_P (type)
8717 0 : && (TREE_CODE_CLASS (ROUND_MOD_EXPR) != tcc_comparison
8718 : || types_match (type, TREE_TYPE (captures[2]))
8719 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8720 : || (optimize_vectors_before_lowering_p ()
8721 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8722 : )
8723 : {
8724 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1648;
8725 0 : {
8726 0 : tree res_op0;
8727 0 : res_op0 = captures[1];
8728 0 : tree res_op1;
8729 0 : {
8730 0 : tree _o1[2], _r1;
8731 0 : _o1[0] = captures[2];
8732 0 : _o1[1] = captures[5];
8733 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8734 0 : if (EXPR_P (_r1))
8735 0 : goto next_after_fail1648;
8736 0 : res_op1 = _r1;
8737 : }
8738 0 : tree res_op2;
8739 0 : {
8740 0 : tree _o1[2], _r1;
8741 0 : _o1[0] = captures[3];
8742 0 : _o1[1] = captures[6];
8743 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8744 0 : if (EXPR_P (_r1))
8745 0 : goto next_after_fail1648;
8746 0 : res_op2 = _r1;
8747 : }
8748 0 : tree _r;
8749 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8750 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
8751 0 : return _r;
8752 : }
8753 0 : next_after_fail1648:;
8754 : }
8755 : }
8756 : }
8757 : break;
8758 : }
8759 0 : default:;
8760 : }
8761 0 : {
8762 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
8763 0 : if (VECTOR_TYPE_P (type)
8764 0 : && (TREE_CODE_CLASS (ROUND_MOD_EXPR) != tcc_comparison
8765 : || types_match (type, TREE_TYPE (captures[2]))
8766 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8767 : || (optimize_vectors_before_lowering_p ()
8768 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8769 : )
8770 : {
8771 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1649;
8772 0 : {
8773 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1649;
8774 0 : tree res_op0;
8775 0 : res_op0 = captures[1];
8776 0 : tree res_op1;
8777 0 : {
8778 0 : tree _o1[2], _r1;
8779 0 : _o1[0] = captures[2];
8780 0 : _o1[1] = unshare_expr (captures[4]);
8781 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8782 0 : if (EXPR_P (_r1))
8783 0 : goto next_after_fail1649;
8784 0 : res_op1 = _r1;
8785 : }
8786 0 : tree res_op2;
8787 0 : {
8788 0 : tree _o1[2], _r1;
8789 0 : _o1[0] = captures[3];
8790 0 : _o1[1] = captures[4];
8791 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8792 0 : if (EXPR_P (_r1))
8793 0 : goto next_after_fail1649;
8794 0 : res_op2 = _r1;
8795 : }
8796 0 : tree _r;
8797 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8798 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 895, __FILE__, __LINE__, true);
8799 0 : return _r;
8800 : }
8801 0 : next_after_fail1649:;
8802 : }
8803 : }
8804 0 : break;
8805 : }
8806 0 : default:;
8807 : }
8808 0 : switch (TREE_CODE (_p1))
8809 : {
8810 0 : case VEC_COND_EXPR:
8811 0 : {
8812 0 : tree _q30 = TREE_OPERAND (_p1, 0);
8813 0 : tree _q31 = TREE_OPERAND (_p1, 1);
8814 0 : tree _q32 = TREE_OPERAND (_p1, 2);
8815 0 : {
8816 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
8817 0 : if (VECTOR_TYPE_P (type)
8818 0 : && (TREE_CODE_CLASS (ROUND_MOD_EXPR) != tcc_comparison
8819 : || types_match (type, TREE_TYPE (captures[3]))
8820 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
8821 : || (optimize_vectors_before_lowering_p ()
8822 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
8823 : )
8824 : {
8825 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1650;
8826 0 : {
8827 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1650;
8828 0 : tree res_op0;
8829 0 : res_op0 = captures[2];
8830 0 : tree res_op1;
8831 0 : {
8832 0 : tree _o1[2], _r1;
8833 0 : _o1[0] = unshare_expr (captures[0]);
8834 0 : _o1[1] = captures[3];
8835 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8836 0 : if (EXPR_P (_r1))
8837 0 : goto next_after_fail1650;
8838 0 : res_op1 = _r1;
8839 : }
8840 0 : tree res_op2;
8841 0 : {
8842 0 : tree _o1[2], _r1;
8843 0 : _o1[0] = captures[0];
8844 0 : _o1[1] = captures[4];
8845 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8846 0 : if (EXPR_P (_r1))
8847 0 : goto next_after_fail1650;
8848 0 : res_op2 = _r1;
8849 : }
8850 0 : tree _r;
8851 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8852 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
8853 0 : return _r;
8854 : }
8855 0 : next_after_fail1650:;
8856 : }
8857 : }
8858 0 : break;
8859 : }
8860 : default:;
8861 : }
8862 : return NULL_TREE;
8863 : }
8864 :
8865 : tree
8866 2059730 : 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)
8867 : {
8868 2059730 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8869 2059730 : if (integer_zerop (_p0))
8870 : {
8871 919 : {
8872 919 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8873 919 : tree res = generic_simplify_323 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8874 919 : if (res) return res;
8875 : }
8876 : }
8877 2058945 : if (integer_onep (_p1))
8878 : {
8879 213396 : {
8880 213396 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8881 213396 : tree res = generic_simplify_324 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8882 213396 : if (res) return res;
8883 : }
8884 : }
8885 1845549 : if (integer_minus_onep (_p1))
8886 : {
8887 529 : {
8888 529 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8889 529 : tree res = generic_simplify_325 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8890 529 : if (res) return res;
8891 : }
8892 : }
8893 1845529 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
8894 : {
8895 227 : {
8896 227 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8897 227 : tree res = generic_simplify_326 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8898 227 : if (res) return res;
8899 : }
8900 : }
8901 1845436 : switch (TREE_CODE (_p0))
8902 : {
8903 107 : case TRUNC_MOD_EXPR:
8904 107 : {
8905 107 : tree _q20 = TREE_OPERAND (_p0, 0);
8906 107 : tree _q21 = TREE_OPERAND (_p0, 1);
8907 107 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8908 : {
8909 52 : {
8910 52 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8911 52 : tree res = generic_simplify_327 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8912 52 : if (res) return res;
8913 : }
8914 : }
8915 : break;
8916 : }
8917 7144 : case MULT_EXPR:
8918 7144 : {
8919 7144 : tree _q20 = TREE_OPERAND (_p0, 0);
8920 7144 : tree _q21 = TREE_OPERAND (_p0, 1);
8921 7144 : switch (TREE_CODE (_q21))
8922 : {
8923 7051 : case INTEGER_CST:
8924 7051 : {
8925 7051 : switch (TREE_CODE (_p1))
8926 : {
8927 7029 : case INTEGER_CST:
8928 7029 : {
8929 7029 : {
8930 7029 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8931 7029 : tree res = generic_simplify_328 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8932 7029 : if (res) return res;
8933 : }
8934 7029 : break;
8935 : }
8936 : default:;
8937 : }
8938 : break;
8939 : }
8940 : default:;
8941 : }
8942 : break;
8943 : }
8944 1845384 : default:;
8945 : }
8946 1845384 : switch (TREE_CODE (_p1))
8947 : {
8948 1574450 : case INTEGER_CST:
8949 1574450 : {
8950 1574450 : {
8951 1574450 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8952 1574450 : if (TYPE_SIGN (type) == SIGNED
8953 279372 : && !TREE_OVERFLOW (captures[1])
8954 1574454 : && wi::neg_p (wi::to_wide (captures[1]))
8955 313 : && !TYPE_OVERFLOW_TRAPS (type)
8956 1574763 : && !sign_bit_p (captures[1], captures[1])
8957 : )
8958 : {
8959 309 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1651;
8960 309 : {
8961 309 : tree res_op0;
8962 309 : res_op0 = captures[0];
8963 309 : tree res_op1;
8964 309 : {
8965 309 : tree _o1[1], _r1;
8966 309 : _o1[0] = captures[1];
8967 309 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
8968 309 : res_op1 = _r1;
8969 : }
8970 309 : tree _r;
8971 309 : _r = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, res_op0, res_op1);
8972 309 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1003, __FILE__, __LINE__, true);
8973 309 : return _r;
8974 : }
8975 0 : next_after_fail1651:;
8976 : }
8977 : }
8978 1574141 : break;
8979 : }
8980 55282 : CASE_CONVERT:
8981 55282 : {
8982 55282 : tree _q30 = TREE_OPERAND (_p1, 0);
8983 55282 : switch (TREE_CODE (_q30))
8984 : {
8985 0 : case NEGATE_EXPR:
8986 0 : {
8987 0 : tree _q40 = TREE_OPERAND (_q30, 0);
8988 0 : {
8989 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q40 };
8990 0 : tree res = generic_simplify_415 (loc, type, _p0, _p1, captures);
8991 0 : if (res) return res;
8992 : }
8993 0 : break;
8994 : }
8995 55282 : default:;
8996 : }
8997 55282 : {
8998 55282 : tree _q30_pops[1];
8999 55282 : if (tree_power_of_two_cand (_q30, _q30_pops))
9000 : {
9001 7 : tree _q40 = _q30_pops[0];
9002 7 : {
9003 7 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q40 };
9004 7 : tree res = generic_simplify_329 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
9005 7 : if (res) return res;
9006 : }
9007 : }
9008 : }
9009 55275 : break;
9010 : }
9011 94 : case NEGATE_EXPR:
9012 94 : {
9013 94 : tree _q30 = TREE_OPERAND (_p1, 0);
9014 94 : {
9015 94 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q30 };
9016 94 : tree res = generic_simplify_415 (loc, type, _p0, _p1, captures);
9017 94 : if (res) return res;
9018 : }
9019 94 : break;
9020 : }
9021 1845068 : default:;
9022 : }
9023 1845068 : {
9024 1845068 : tree _p1_pops[1];
9025 1845068 : if (tree_power_of_two_cand (_p1, _p1_pops))
9026 : {
9027 1574150 : tree _q30 = _p1_pops[0];
9028 1574150 : {
9029 1574150 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q30 };
9030 1574150 : tree res = generic_simplify_329 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
9031 1574150 : if (res) return res;
9032 : }
9033 : }
9034 : }
9035 891634 : switch (TREE_CODE (_p0))
9036 : {
9037 0 : case VEC_COND_EXPR:
9038 0 : {
9039 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9040 0 : tree _q21 = TREE_OPERAND (_p0, 1);
9041 0 : tree _q22 = TREE_OPERAND (_p0, 2);
9042 0 : switch (TREE_CODE (_p1))
9043 : {
9044 0 : case VEC_COND_EXPR:
9045 0 : {
9046 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9047 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9048 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9049 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9050 : {
9051 0 : {
9052 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
9053 0 : if (VECTOR_TYPE_P (type)
9054 0 : && (TREE_CODE_CLASS (TRUNC_MOD_EXPR) != tcc_comparison
9055 : || types_match (type, TREE_TYPE (captures[2]))
9056 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9057 : || (optimize_vectors_before_lowering_p ()
9058 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9059 : )
9060 : {
9061 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1652;
9062 0 : {
9063 0 : tree res_op0;
9064 0 : res_op0 = captures[1];
9065 0 : tree res_op1;
9066 0 : {
9067 0 : tree _o1[2], _r1;
9068 0 : _o1[0] = captures[2];
9069 0 : _o1[1] = captures[5];
9070 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9071 0 : if (EXPR_P (_r1))
9072 0 : goto next_after_fail1652;
9073 0 : res_op1 = _r1;
9074 : }
9075 0 : tree res_op2;
9076 0 : {
9077 0 : tree _o1[2], _r1;
9078 0 : _o1[0] = captures[3];
9079 0 : _o1[1] = captures[6];
9080 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9081 0 : if (EXPR_P (_r1))
9082 0 : goto next_after_fail1652;
9083 0 : res_op2 = _r1;
9084 : }
9085 0 : tree _r;
9086 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9087 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
9088 0 : return _r;
9089 : }
9090 0 : next_after_fail1652:;
9091 : }
9092 : }
9093 : }
9094 : break;
9095 : }
9096 0 : default:;
9097 : }
9098 0 : {
9099 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
9100 0 : if (VECTOR_TYPE_P (type)
9101 0 : && (TREE_CODE_CLASS (TRUNC_MOD_EXPR) != tcc_comparison
9102 : || types_match (type, TREE_TYPE (captures[2]))
9103 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9104 : || (optimize_vectors_before_lowering_p ()
9105 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9106 : )
9107 : {
9108 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1653;
9109 0 : {
9110 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1653;
9111 0 : tree res_op0;
9112 0 : res_op0 = captures[1];
9113 0 : tree res_op1;
9114 0 : {
9115 0 : tree _o1[2], _r1;
9116 0 : _o1[0] = captures[2];
9117 0 : _o1[1] = unshare_expr (captures[4]);
9118 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9119 0 : if (EXPR_P (_r1))
9120 0 : goto next_after_fail1653;
9121 0 : res_op1 = _r1;
9122 : }
9123 0 : tree res_op2;
9124 0 : {
9125 0 : tree _o1[2], _r1;
9126 0 : _o1[0] = captures[3];
9127 0 : _o1[1] = captures[4];
9128 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9129 0 : if (EXPR_P (_r1))
9130 0 : goto next_after_fail1653;
9131 0 : res_op2 = _r1;
9132 : }
9133 0 : tree _r;
9134 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9135 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 895, __FILE__, __LINE__, true);
9136 0 : return _r;
9137 : }
9138 0 : next_after_fail1653:;
9139 : }
9140 : }
9141 0 : break;
9142 : }
9143 891634 : default:;
9144 : }
9145 891634 : switch (TREE_CODE (_p1))
9146 : {
9147 7 : case VEC_COND_EXPR:
9148 7 : {
9149 7 : tree _q30 = TREE_OPERAND (_p1, 0);
9150 7 : tree _q31 = TREE_OPERAND (_p1, 1);
9151 7 : tree _q32 = TREE_OPERAND (_p1, 2);
9152 7 : {
9153 7 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
9154 7 : if (VECTOR_TYPE_P (type)
9155 7 : && (TREE_CODE_CLASS (TRUNC_MOD_EXPR) != tcc_comparison
9156 : || types_match (type, TREE_TYPE (captures[3]))
9157 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
9158 : || (optimize_vectors_before_lowering_p ()
9159 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
9160 : )
9161 : {
9162 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1654;
9163 7 : {
9164 7 : if (! tree_invariant_p (captures[0])) goto next_after_fail1654;
9165 0 : tree res_op0;
9166 0 : res_op0 = captures[2];
9167 0 : tree res_op1;
9168 0 : {
9169 0 : tree _o1[2], _r1;
9170 0 : _o1[0] = unshare_expr (captures[0]);
9171 0 : _o1[1] = captures[3];
9172 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9173 0 : if (EXPR_P (_r1))
9174 0 : goto next_after_fail1654;
9175 0 : res_op1 = _r1;
9176 : }
9177 0 : tree res_op2;
9178 0 : {
9179 0 : tree _o1[2], _r1;
9180 0 : _o1[0] = captures[0];
9181 0 : _o1[1] = captures[4];
9182 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9183 0 : if (EXPR_P (_r1))
9184 0 : goto next_after_fail1654;
9185 0 : res_op2 = _r1;
9186 : }
9187 0 : tree _r;
9188 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9189 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
9190 0 : return _r;
9191 : }
9192 7 : next_after_fail1654:;
9193 : }
9194 : }
9195 7 : break;
9196 : }
9197 : default:;
9198 : }
9199 : return NULL_TREE;
9200 : }
9201 :
9202 : tree
9203 970716 : generic_simplify_RSHIFT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
9204 : {
9205 970716 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
9206 970716 : switch (TREE_CODE (_p1))
9207 : {
9208 119 : case TRUNC_MOD_EXPR:
9209 119 : {
9210 119 : tree _q30 = TREE_OPERAND (_p1, 0);
9211 119 : tree _q31 = TREE_OPERAND (_p1, 1);
9212 119 : {
9213 119 : tree _q31_pops[1];
9214 119 : if (tree_power_of_two_cand (_q31, _q31_pops))
9215 : {
9216 111 : tree _q50 = _q31_pops[0];
9217 111 : {
9218 111 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q50 };
9219 111 : tree res = generic_simplify_416 (loc, type, _p0, _p1, captures, RSHIFT_EXPR, TRUNC_MOD_EXPR);
9220 111 : if (res) return res;
9221 : }
9222 : }
9223 : }
9224 14 : break;
9225 : }
9226 0 : case FLOOR_MOD_EXPR:
9227 0 : {
9228 0 : tree _q30 = TREE_OPERAND (_p1, 0);
9229 0 : tree _q31 = TREE_OPERAND (_p1, 1);
9230 0 : {
9231 0 : tree _q31_pops[1];
9232 0 : if (tree_power_of_two_cand (_q31, _q31_pops))
9233 : {
9234 0 : tree _q50 = _q31_pops[0];
9235 0 : {
9236 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q50 };
9237 0 : tree res = generic_simplify_416 (loc, type, _p0, _p1, captures, RSHIFT_EXPR, FLOOR_MOD_EXPR);
9238 0 : if (res) return res;
9239 : }
9240 : }
9241 : }
9242 0 : break;
9243 : }
9244 970611 : default:;
9245 : }
9246 970611 : if (uniform_integer_cst_p (_p1))
9247 : {
9248 773471 : {
9249 773471 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9250 773471 : tree res = generic_simplify_417 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9251 773471 : if (res) return res;
9252 : }
9253 : }
9254 969854 : switch (TREE_CODE (_p0))
9255 : {
9256 58 : case NEGATE_EXPR:
9257 58 : {
9258 58 : tree _q20 = TREE_OPERAND (_p0, 0);
9259 58 : switch (TREE_CODE (_p1))
9260 : {
9261 57 : case INTEGER_CST:
9262 57 : {
9263 57 : {
9264 57 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9265 57 : if (!TYPE_UNSIGNED (type)
9266 57 : && TYPE_OVERFLOW_UNDEFINED (type)
9267 : )
9268 : {
9269 32 : {
9270 32 : tree stype = TREE_TYPE (captures[2]);
9271 32 : tree bt = truth_type_for (type);
9272 32 : tree zeros = build_zero_cst (type);
9273 32 : tree INTEGER_CST = NULL_TREE;
9274 32 : if (INTEGRAL_TYPE_P (type)
9275 : && canonicalize_math_after_vectorization_p ()
9276 : && wi::eq_p (wi::to_wide (captures[2]), TYPE_PRECISION (type) - 1)
9277 : )
9278 : {
9279 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1663;
9280 : {
9281 : tree res_op0;
9282 : {
9283 : tree _o1[1], _r1;
9284 : {
9285 : tree _o2[2], _r2;
9286 : _o2[0] = captures[1];
9287 : _o2[1] = zeros;
9288 : _r2 = fold_build2_loc (loc, GT_EXPR, boolean_type_node, _o2[0], _o2[1]);
9289 : _o1[0] = _r2;
9290 : }
9291 : if (TREE_TYPE (_o1[0]) != type)
9292 : {
9293 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
9294 : }
9295 : else
9296 : _r1 = _o1[0];
9297 : res_op0 = _r1;
9298 : }
9299 : tree _r;
9300 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
9301 : if (TREE_SIDE_EFFECTS (captures[2]))
9302 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
9303 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1008, __FILE__, __LINE__, true);
9304 : return _r;
9305 : }
9306 : next_after_fail1663:;
9307 : }
9308 : else
9309 : {
9310 0 : if (VECTOR_INTEGER_TYPE_P (type)
9311 0 : && TYPE_MODE (bt) == TYPE_MODE (type)
9312 0 : && expand_vec_cmp_expr_p (type, bt, GT_EXPR)
9313 0 : && (INTEGER_CST = uniform_integer_cst_p (captures[2])) != NULL
9314 32 : && wi::eq_p (wi::to_wide (INTEGER_CST), element_precision (type) - 1)
9315 : )
9316 : {
9317 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1664;
9318 0 : {
9319 0 : tree res_op0;
9320 0 : {
9321 0 : tree _o1[2], _r1;
9322 0 : _o1[0] = captures[1];
9323 0 : _o1[1] = zeros;
9324 0 : _r1 = fold_build2_loc (loc, GT_EXPR, bt, _o1[0], _o1[1]);
9325 0 : res_op0 = _r1;
9326 : }
9327 0 : tree _r;
9328 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
9329 0 : if (TREE_SIDE_EFFECTS (captures[2]))
9330 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
9331 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1009, __FILE__, __LINE__, true);
9332 0 : return _r;
9333 : }
9334 0 : next_after_fail1664:;
9335 : }
9336 : }
9337 : }
9338 : }
9339 : }
9340 57 : break;
9341 : }
9342 0 : case VECTOR_CST:
9343 0 : {
9344 0 : {
9345 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9346 0 : if (!TYPE_UNSIGNED (type)
9347 0 : && TYPE_OVERFLOW_UNDEFINED (type)
9348 : )
9349 : {
9350 0 : {
9351 0 : tree stype = TREE_TYPE (captures[2]);
9352 0 : tree bt = truth_type_for (type);
9353 0 : tree zeros = build_zero_cst (type);
9354 0 : tree VECTOR_CST = NULL_TREE;
9355 0 : if (INTEGRAL_TYPE_P (type)
9356 : && canonicalize_math_after_vectorization_p ()
9357 : && wi::eq_p (wi::to_wide (captures[2]), TYPE_PRECISION (type) - 1)
9358 : )
9359 : {
9360 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1665;
9361 : {
9362 : tree res_op0;
9363 : {
9364 : tree _o1[1], _r1;
9365 : {
9366 : tree _o2[2], _r2;
9367 : _o2[0] = captures[1];
9368 : _o2[1] = zeros;
9369 : _r2 = fold_build2_loc (loc, GT_EXPR, boolean_type_node, _o2[0], _o2[1]);
9370 : _o1[0] = _r2;
9371 : }
9372 : if (TREE_TYPE (_o1[0]) != type)
9373 : {
9374 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
9375 : }
9376 : else
9377 : _r1 = _o1[0];
9378 : res_op0 = _r1;
9379 : }
9380 : tree _r;
9381 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
9382 : if (TREE_SIDE_EFFECTS (captures[2]))
9383 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
9384 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1008, __FILE__, __LINE__, true);
9385 : return _r;
9386 : }
9387 : next_after_fail1665:;
9388 : }
9389 : else
9390 : {
9391 0 : if (VECTOR_INTEGER_TYPE_P (type)
9392 0 : && TYPE_MODE (bt) == TYPE_MODE (type)
9393 0 : && expand_vec_cmp_expr_p (type, bt, GT_EXPR)
9394 0 : && (VECTOR_CST = uniform_integer_cst_p (captures[2])) != NULL
9395 0 : && wi::eq_p (wi::to_wide (VECTOR_CST), element_precision (type) - 1)
9396 : )
9397 : {
9398 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1666;
9399 0 : {
9400 0 : tree res_op0;
9401 0 : {
9402 0 : tree _o1[2], _r1;
9403 0 : _o1[0] = captures[1];
9404 0 : _o1[1] = zeros;
9405 0 : _r1 = fold_build2_loc (loc, GT_EXPR, bt, _o1[0], _o1[1]);
9406 0 : res_op0 = _r1;
9407 : }
9408 0 : tree _r;
9409 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
9410 0 : if (TREE_SIDE_EFFECTS (captures[2]))
9411 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
9412 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1009, __FILE__, __LINE__, true);
9413 0 : return _r;
9414 : }
9415 0 : next_after_fail1666:;
9416 : }
9417 : }
9418 : }
9419 : }
9420 : }
9421 0 : break;
9422 : }
9423 : default:;
9424 : }
9425 : break;
9426 : }
9427 437 : case LSHIFT_EXPR:
9428 437 : {
9429 437 : tree _q20 = TREE_OPERAND (_p0, 0);
9430 437 : tree _q21 = TREE_OPERAND (_p0, 1);
9431 437 : switch (TREE_CODE (_q21))
9432 : {
9433 358 : case INTEGER_CST:
9434 358 : {
9435 358 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q21, 0))
9436 : {
9437 67 : {
9438 67 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p1, _q21 };
9439 67 : tree res = generic_simplify_426 (loc, type, _p0, _p1, captures);
9440 67 : if (res) return res;
9441 : }
9442 : }
9443 : break;
9444 : }
9445 : default:;
9446 : }
9447 : break;
9448 : }
9449 969827 : default:;
9450 : }
9451 969827 : {
9452 969827 : tree _p0_pops[1];
9453 969827 : if (tree_nop_convert (_p0, _p0_pops))
9454 : {
9455 154668 : tree _q20 = _p0_pops[0];
9456 154668 : switch (TREE_CODE (_q20))
9457 : {
9458 20 : case LSHIFT_EXPR:
9459 20 : {
9460 20 : tree _q30 = TREE_OPERAND (_q20, 0);
9461 20 : tree _q31 = TREE_OPERAND (_q20, 1);
9462 20 : switch (TREE_CODE (_q31))
9463 : {
9464 0 : case INTEGER_CST:
9465 0 : {
9466 0 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q31, 0))
9467 : {
9468 0 : {
9469 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p1, _q31 };
9470 0 : tree res = generic_simplify_426 (loc, type, _p0, _p1, captures);
9471 0 : if (res) return res;
9472 : }
9473 : }
9474 : break;
9475 : }
9476 : default:;
9477 : }
9478 : break;
9479 : }
9480 : default:;
9481 : }
9482 : }
9483 : }
9484 969827 : if (integer_all_onesp (_p0))
9485 : {
9486 11007 : {
9487 11007 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9488 11007 : if (!TYPE_UNSIGNED (type)
9489 : )
9490 : {
9491 119 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1667;
9492 119 : {
9493 119 : tree _r;
9494 119 : _r = captures[0];
9495 119 : if (TREE_SIDE_EFFECTS (captures[1]))
9496 1 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
9497 119 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1010, __FILE__, __LINE__, true);
9498 119 : return _r;
9499 : }
9500 0 : next_after_fail1667:;
9501 : }
9502 : }
9503 : }
9504 969708 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
9505 : {
9506 25 : {
9507 25 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
9508 25 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1668;
9509 25 : {
9510 25 : tree _r;
9511 25 : _r = build_zero_cst (type);
9512 25 : if (TREE_SIDE_EFFECTS (captures[0]))
9513 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
9514 25 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1011, __FILE__, __LINE__, true);
9515 25 : return _r;
9516 : }
9517 0 : next_after_fail1668:;
9518 : }
9519 : }
9520 969683 : if (integer_zerop (_p1))
9521 : {
9522 1295 : {
9523 1295 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
9524 1295 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9525 1295 : if (res) return res;
9526 : }
9527 : }
9528 968388 : if (integer_zerop (_p0))
9529 : {
9530 152 : {
9531 152 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9532 152 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9533 152 : if (res) return res;
9534 : }
9535 : }
9536 968236 : switch (TREE_CODE (_p1))
9537 : {
9538 0 : case VECTOR_CST:
9539 0 : {
9540 0 : {
9541 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9542 0 : tree res = generic_simplify_421 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9543 0 : if (res) return res;
9544 : }
9545 0 : break;
9546 : }
9547 0 : case CONSTRUCTOR:
9548 0 : {
9549 0 : {
9550 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9551 0 : tree res = generic_simplify_422 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9552 0 : if (res) return res;
9553 : }
9554 0 : break;
9555 : }
9556 968236 : default:;
9557 : }
9558 968236 : switch (TREE_CODE (_p0))
9559 : {
9560 118 : case RSHIFT_EXPR:
9561 118 : {
9562 118 : tree _q20 = TREE_OPERAND (_p0, 0);
9563 118 : tree _q21 = TREE_OPERAND (_p0, 1);
9564 118 : switch (TREE_CODE (_q21))
9565 : {
9566 73 : case INTEGER_CST:
9567 73 : {
9568 73 : switch (TREE_CODE (_p1))
9569 : {
9570 47 : case INTEGER_CST:
9571 47 : {
9572 47 : {
9573 47 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
9574 47 : tree res = generic_simplify_423 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9575 47 : if (res) return res;
9576 : }
9577 0 : break;
9578 : }
9579 : default:;
9580 : }
9581 : break;
9582 : }
9583 : default:;
9584 : }
9585 : break;
9586 : }
9587 178958 : CASE_CONVERT:
9588 178958 : {
9589 178958 : tree _q20 = TREE_OPERAND (_p0, 0);
9590 178958 : switch (TREE_CODE (_q20))
9591 : {
9592 6 : case BIT_AND_EXPR:
9593 6 : {
9594 6 : tree _q30 = TREE_OPERAND (_q20, 0);
9595 6 : tree _q31 = TREE_OPERAND (_q20, 1);
9596 6 : switch (TREE_CODE (_q31))
9597 : {
9598 0 : case INTEGER_CST:
9599 0 : {
9600 0 : switch (TREE_CODE (_p1))
9601 : {
9602 0 : case INTEGER_CST:
9603 0 : {
9604 0 : {
9605 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
9606 0 : tree res = generic_simplify_424 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, RSHIFT_EXPR);
9607 0 : if (res) return res;
9608 : }
9609 0 : break;
9610 : }
9611 : default:;
9612 : }
9613 : break;
9614 : }
9615 : default:;
9616 : }
9617 : break;
9618 : }
9619 14 : case BIT_XOR_EXPR:
9620 14 : {
9621 14 : tree _q30 = TREE_OPERAND (_q20, 0);
9622 14 : tree _q31 = TREE_OPERAND (_q20, 1);
9623 14 : switch (TREE_CODE (_q31))
9624 : {
9625 0 : case INTEGER_CST:
9626 0 : {
9627 0 : switch (TREE_CODE (_p1))
9628 : {
9629 0 : case INTEGER_CST:
9630 0 : {
9631 0 : {
9632 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
9633 0 : tree res = generic_simplify_424 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, RSHIFT_EXPR);
9634 0 : if (res) return res;
9635 : }
9636 0 : break;
9637 : }
9638 : default:;
9639 : }
9640 : break;
9641 : }
9642 : default:;
9643 : }
9644 : break;
9645 : }
9646 43 : case BIT_IOR_EXPR:
9647 43 : {
9648 43 : tree _q30 = TREE_OPERAND (_q20, 0);
9649 43 : tree _q31 = TREE_OPERAND (_q20, 1);
9650 43 : switch (TREE_CODE (_q31))
9651 : {
9652 24 : case INTEGER_CST:
9653 24 : {
9654 24 : switch (TREE_CODE (_p1))
9655 : {
9656 7 : case INTEGER_CST:
9657 7 : {
9658 7 : {
9659 7 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
9660 7 : tree res = generic_simplify_424 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, RSHIFT_EXPR);
9661 7 : if (res) return res;
9662 : }
9663 0 : break;
9664 : }
9665 : default:;
9666 : }
9667 : break;
9668 : }
9669 : default:;
9670 : }
9671 : break;
9672 : }
9673 131 : case CALL_EXPR:
9674 131 : switch (get_call_combined_fn (_q20))
9675 : {
9676 0 : case CFN_BUILT_IN_BSWAP128:
9677 0 : if (call_expr_nargs (_q20) == 1)
9678 : {
9679 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
9680 0 : switch (TREE_CODE (_p1))
9681 : {
9682 0 : case INTEGER_CST:
9683 0 : {
9684 0 : {
9685 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9686 0 : tree res = generic_simplify_427 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP128);
9687 0 : if (res) return res;
9688 : }
9689 0 : break;
9690 : }
9691 : default:;
9692 : }
9693 : }
9694 : break;
9695 8 : case CFN_BUILT_IN_BSWAP16:
9696 8 : if (call_expr_nargs (_q20) == 1)
9697 : {
9698 8 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
9699 8 : switch (TREE_CODE (_p1))
9700 : {
9701 7 : case INTEGER_CST:
9702 7 : {
9703 7 : {
9704 7 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9705 7 : tree res = generic_simplify_427 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP16);
9706 7 : if (res) return res;
9707 : }
9708 2 : break;
9709 : }
9710 : default:;
9711 : }
9712 : }
9713 : break;
9714 13 : case CFN_BUILT_IN_BSWAP32:
9715 13 : if (call_expr_nargs (_q20) == 1)
9716 : {
9717 13 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
9718 13 : switch (TREE_CODE (_p1))
9719 : {
9720 13 : case INTEGER_CST:
9721 13 : {
9722 13 : {
9723 13 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9724 13 : tree res = generic_simplify_427 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP32);
9725 13 : if (res) return res;
9726 : }
9727 9 : break;
9728 : }
9729 : default:;
9730 : }
9731 : }
9732 : break;
9733 18 : case CFN_BUILT_IN_BSWAP64:
9734 18 : if (call_expr_nargs (_q20) == 1)
9735 : {
9736 18 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
9737 18 : switch (TREE_CODE (_p1))
9738 : {
9739 18 : case INTEGER_CST:
9740 18 : {
9741 18 : {
9742 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9743 18 : tree res = generic_simplify_427 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP64);
9744 18 : if (res) return res;
9745 : }
9746 12 : break;
9747 : }
9748 : default:;
9749 : }
9750 : }
9751 : break;
9752 : default:;
9753 : }
9754 : break;
9755 : default:;
9756 : }
9757 : break;
9758 : }
9759 13893 : case BIT_AND_EXPR:
9760 13893 : {
9761 13893 : tree _q20 = TREE_OPERAND (_p0, 0);
9762 13893 : tree _q21 = TREE_OPERAND (_p0, 1);
9763 13893 : switch (TREE_CODE (_q21))
9764 : {
9765 13843 : case INTEGER_CST:
9766 13843 : {
9767 13843 : switch (TREE_CODE (_p1))
9768 : {
9769 13820 : case INTEGER_CST:
9770 13820 : {
9771 13820 : {
9772 13820 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
9773 13820 : tree res = generic_simplify_425 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, RSHIFT_EXPR);
9774 13820 : if (res) return res;
9775 : }
9776 0 : break;
9777 : }
9778 : default:;
9779 : }
9780 : break;
9781 : }
9782 : default:;
9783 : }
9784 : break;
9785 : }
9786 240 : case BIT_XOR_EXPR:
9787 240 : {
9788 240 : tree _q20 = TREE_OPERAND (_p0, 0);
9789 240 : tree _q21 = TREE_OPERAND (_p0, 1);
9790 240 : switch (TREE_CODE (_q21))
9791 : {
9792 97 : case INTEGER_CST:
9793 97 : {
9794 97 : switch (TREE_CODE (_p1))
9795 : {
9796 97 : case INTEGER_CST:
9797 97 : {
9798 97 : {
9799 97 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
9800 97 : tree res = generic_simplify_425 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, RSHIFT_EXPR);
9801 97 : if (res) return res;
9802 : }
9803 0 : break;
9804 : }
9805 : default:;
9806 : }
9807 : break;
9808 : }
9809 : default:;
9810 : }
9811 : break;
9812 : }
9813 55 : case BIT_IOR_EXPR:
9814 55 : {
9815 55 : tree _q20 = TREE_OPERAND (_p0, 0);
9816 55 : tree _q21 = TREE_OPERAND (_p0, 1);
9817 55 : switch (TREE_CODE (_q21))
9818 : {
9819 10 : case INTEGER_CST:
9820 10 : {
9821 10 : switch (TREE_CODE (_p1))
9822 : {
9823 8 : case INTEGER_CST:
9824 8 : {
9825 8 : {
9826 8 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
9827 8 : tree res = generic_simplify_425 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, RSHIFT_EXPR);
9828 8 : if (res) return res;
9829 : }
9830 0 : break;
9831 : }
9832 : default:;
9833 : }
9834 : break;
9835 : }
9836 : default:;
9837 : }
9838 : break;
9839 : }
9840 0 : case VEC_COND_EXPR:
9841 0 : {
9842 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9843 0 : tree _q21 = TREE_OPERAND (_p0, 1);
9844 0 : tree _q22 = TREE_OPERAND (_p0, 2);
9845 0 : switch (TREE_CODE (_p1))
9846 : {
9847 0 : case VEC_COND_EXPR:
9848 0 : {
9849 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9850 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9851 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9852 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9853 : {
9854 0 : {
9855 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
9856 0 : if (VECTOR_TYPE_P (type)
9857 0 : && (TREE_CODE_CLASS (RSHIFT_EXPR) != tcc_comparison
9858 : || types_match (type, TREE_TYPE (captures[2]))
9859 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9860 : || (optimize_vectors_before_lowering_p ()
9861 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9862 : )
9863 : {
9864 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1669;
9865 0 : {
9866 0 : tree res_op0;
9867 0 : res_op0 = captures[1];
9868 0 : tree res_op1;
9869 0 : {
9870 0 : tree _o1[2], _r1;
9871 0 : _o1[0] = captures[2];
9872 0 : _o1[1] = captures[5];
9873 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
9874 0 : if (EXPR_P (_r1))
9875 0 : goto next_after_fail1669;
9876 0 : res_op1 = _r1;
9877 : }
9878 0 : tree res_op2;
9879 0 : {
9880 0 : tree _o1[2], _r1;
9881 0 : _o1[0] = captures[3];
9882 0 : _o1[1] = captures[6];
9883 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
9884 0 : if (EXPR_P (_r1))
9885 0 : goto next_after_fail1669;
9886 0 : res_op2 = _r1;
9887 : }
9888 0 : tree _r;
9889 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9890 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
9891 0 : return _r;
9892 : }
9893 0 : next_after_fail1669:;
9894 : }
9895 : }
9896 : }
9897 : break;
9898 : }
9899 0 : default:;
9900 : }
9901 0 : {
9902 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
9903 0 : if (VECTOR_TYPE_P (type)
9904 0 : && (TREE_CODE_CLASS (RSHIFT_EXPR) != tcc_comparison
9905 : || types_match (type, TREE_TYPE (captures[2]))
9906 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9907 : || (optimize_vectors_before_lowering_p ()
9908 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9909 : )
9910 : {
9911 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1670;
9912 0 : {
9913 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1670;
9914 0 : tree res_op0;
9915 0 : res_op0 = captures[1];
9916 0 : tree res_op1;
9917 0 : {
9918 0 : tree _o1[2], _r1;
9919 0 : _o1[0] = captures[2];
9920 0 : _o1[1] = unshare_expr (captures[4]);
9921 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
9922 0 : if (EXPR_P (_r1))
9923 0 : goto next_after_fail1670;
9924 0 : res_op1 = _r1;
9925 : }
9926 0 : tree res_op2;
9927 0 : {
9928 0 : tree _o1[2], _r1;
9929 0 : _o1[0] = captures[3];
9930 0 : _o1[1] = captures[4];
9931 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
9932 0 : if (EXPR_P (_r1))
9933 0 : goto next_after_fail1670;
9934 0 : res_op2 = _r1;
9935 : }
9936 0 : tree _r;
9937 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9938 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 895, __FILE__, __LINE__, true);
9939 0 : return _r;
9940 : }
9941 0 : next_after_fail1670:;
9942 : }
9943 : }
9944 0 : break;
9945 : }
9946 566 : case CALL_EXPR:
9947 566 : switch (get_call_combined_fn (_p0))
9948 : {
9949 0 : case CFN_BUILT_IN_BSWAP128:
9950 0 : if (call_expr_nargs (_p0) == 1)
9951 : {
9952 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9953 0 : switch (TREE_CODE (_p1))
9954 : {
9955 0 : case INTEGER_CST:
9956 0 : {
9957 0 : {
9958 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9959 0 : tree res = generic_simplify_427 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP128);
9960 0 : if (res) return res;
9961 : }
9962 0 : break;
9963 : }
9964 : default:;
9965 : }
9966 : }
9967 : break;
9968 32 : case CFN_BUILT_IN_BSWAP16:
9969 32 : if (call_expr_nargs (_p0) == 1)
9970 : {
9971 32 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9972 32 : switch (TREE_CODE (_p1))
9973 : {
9974 32 : case INTEGER_CST:
9975 32 : {
9976 32 : {
9977 32 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9978 32 : tree res = generic_simplify_427 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP16);
9979 32 : if (res) return res;
9980 : }
9981 9 : break;
9982 : }
9983 : default:;
9984 : }
9985 : }
9986 : break;
9987 99 : case CFN_BUILT_IN_BSWAP32:
9988 99 : if (call_expr_nargs (_p0) == 1)
9989 : {
9990 99 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9991 99 : switch (TREE_CODE (_p1))
9992 : {
9993 98 : case INTEGER_CST:
9994 98 : {
9995 98 : {
9996 98 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9997 98 : tree res = generic_simplify_427 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP32);
9998 98 : if (res) return res;
9999 : }
10000 59 : break;
10001 : }
10002 : default:;
10003 : }
10004 : }
10005 : break;
10006 100 : case CFN_BUILT_IN_BSWAP64:
10007 100 : if (call_expr_nargs (_p0) == 1)
10008 : {
10009 100 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10010 100 : switch (TREE_CODE (_p1))
10011 : {
10012 99 : case INTEGER_CST:
10013 99 : {
10014 99 : {
10015 99 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10016 99 : tree res = generic_simplify_427 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP64);
10017 99 : if (res) return res;
10018 : }
10019 73 : break;
10020 : }
10021 : default:;
10022 : }
10023 : }
10024 : break;
10025 : default:;
10026 : }
10027 : break;
10028 954154 : default:;
10029 : }
10030 954154 : if (integer_onep (_p0))
10031 : {
10032 524 : {
10033 524 : tree captures[1] ATTRIBUTE_UNUSED = { _p1 };
10034 524 : if (INTEGRAL_TYPE_P (type)
10035 : )
10036 : {
10037 524 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1671;
10038 524 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1671;
10039 524 : {
10040 524 : tree res_op0;
10041 524 : {
10042 524 : tree _o1[2], _r1;
10043 524 : _o1[0] = captures[0];
10044 524 : _o1[1] = build_zero_cst (TREE_TYPE (captures[0]));
10045 524 : _r1 = fold_build2_loc (loc, EQ_EXPR, boolean_type_node, _o1[0], _o1[1]);
10046 524 : res_op0 = _r1;
10047 : }
10048 524 : tree _r;
10049 524 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
10050 524 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1012, __FILE__, __LINE__, true);
10051 524 : return _r;
10052 : }
10053 : next_after_fail1671:;
10054 : }
10055 : }
10056 : }
10057 953630 : switch (TREE_CODE (_p1))
10058 : {
10059 11 : case VEC_COND_EXPR:
10060 11 : {
10061 11 : tree _q30 = TREE_OPERAND (_p1, 0);
10062 11 : tree _q31 = TREE_OPERAND (_p1, 1);
10063 11 : tree _q32 = TREE_OPERAND (_p1, 2);
10064 11 : {
10065 11 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
10066 11 : if (VECTOR_TYPE_P (type)
10067 11 : && (TREE_CODE_CLASS (RSHIFT_EXPR) != tcc_comparison
10068 : || types_match (type, TREE_TYPE (captures[3]))
10069 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
10070 : || (optimize_vectors_before_lowering_p ()
10071 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
10072 : )
10073 : {
10074 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1672;
10075 11 : {
10076 11 : if (! tree_invariant_p (captures[0])) goto next_after_fail1672;
10077 0 : tree res_op0;
10078 0 : res_op0 = captures[2];
10079 0 : tree res_op1;
10080 0 : {
10081 0 : tree _o1[2], _r1;
10082 0 : _o1[0] = unshare_expr (captures[0]);
10083 0 : _o1[1] = captures[3];
10084 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
10085 0 : if (EXPR_P (_r1))
10086 0 : goto next_after_fail1672;
10087 0 : res_op1 = _r1;
10088 : }
10089 0 : tree res_op2;
10090 0 : {
10091 0 : tree _o1[2], _r1;
10092 0 : _o1[0] = captures[0];
10093 0 : _o1[1] = captures[4];
10094 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
10095 0 : if (EXPR_P (_r1))
10096 0 : goto next_after_fail1672;
10097 0 : res_op2 = _r1;
10098 : }
10099 0 : tree _r;
10100 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10101 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
10102 0 : return _r;
10103 : }
10104 11 : next_after_fail1672:;
10105 : }
10106 : }
10107 11 : break;
10108 : }
10109 953630 : default:;
10110 : }
10111 953630 : switch (TREE_CODE (_p0))
10112 : {
10113 0 : case VEC_PERM_EXPR:
10114 0 : {
10115 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10116 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10117 0 : tree _q22 = TREE_OPERAND (_p0, 2);
10118 0 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
10119 : {
10120 0 : switch (TREE_CODE (_p1))
10121 : {
10122 0 : case VEC_PERM_EXPR:
10123 0 : {
10124 0 : tree _q60 = TREE_OPERAND (_p1, 0);
10125 0 : tree _q61 = TREE_OPERAND (_p1, 1);
10126 0 : tree _q62 = TREE_OPERAND (_p1, 2);
10127 0 : if ((_q61 == _q60 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q60, 0) && types_match (_q61, _q60)))
10128 : {
10129 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
10130 : {
10131 0 : {
10132 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q22, _q60 };
10133 0 : if (VECTOR_INTEGER_TYPE_P (type)
10134 : )
10135 : {
10136 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1673;
10137 0 : {
10138 0 : tree res_op0;
10139 0 : {
10140 0 : tree _o1[2], _r1;
10141 0 : _o1[0] = captures[0];
10142 0 : _o1[1] = captures[2];
10143 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10144 0 : captures[3] = _r1;
10145 : }
10146 0 : res_op0 = unshare_expr (captures[3]);
10147 0 : tree res_op1;
10148 0 : res_op1 = captures[3];
10149 0 : tree res_op2;
10150 0 : res_op2 = captures[1];
10151 0 : tree _r;
10152 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
10153 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10154 0 : return _r;
10155 : }
10156 0 : next_after_fail1673:;
10157 : }
10158 : }
10159 : }
10160 : }
10161 : break;
10162 : }
10163 : default:;
10164 : }
10165 : }
10166 : break;
10167 : }
10168 : default:;
10169 : }
10170 : return NULL_TREE;
10171 : }
10172 :
10173 : tree
10174 387747 : generic_simplify_MAX_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
10175 : {
10176 387747 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10177 387747 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
10178 : {
10179 0 : {
10180 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10181 0 : tree res = generic_simplify_518 (loc, type, _p0, _p1, captures, MAX_EXPR);
10182 0 : if (res) return res;
10183 : }
10184 : }
10185 387747 : switch (TREE_CODE (_p0))
10186 : {
10187 111 : case MAX_EXPR:
10188 111 : {
10189 111 : tree _q20 = TREE_OPERAND (_p0, 0);
10190 111 : tree _q21 = TREE_OPERAND (_p0, 1);
10191 111 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
10192 : {
10193 0 : {
10194 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
10195 0 : tree res = generic_simplify_519 (loc, type, _p0, _p1, captures, MAX_EXPR);
10196 0 : if (res) return res;
10197 : }
10198 : }
10199 111 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
10200 : {
10201 0 : {
10202 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
10203 0 : tree res = generic_simplify_519 (loc, type, _p0, _p1, captures, MAX_EXPR);
10204 0 : if (res) return res;
10205 : }
10206 : }
10207 : break;
10208 : }
10209 387747 : default:;
10210 : }
10211 387747 : switch (TREE_CODE (_p1))
10212 : {
10213 0 : case MAX_EXPR:
10214 0 : {
10215 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10216 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10217 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10218 : {
10219 0 : {
10220 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q31 };
10221 0 : tree res = generic_simplify_520 (loc, type, _p0, _p1, captures, MAX_EXPR);
10222 0 : if (res) return res;
10223 : }
10224 : }
10225 0 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
10226 : {
10227 0 : {
10228 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q30 };
10229 0 : tree res = generic_simplify_520 (loc, type, _p0, _p1, captures, MAX_EXPR);
10230 0 : if (res) return res;
10231 : }
10232 : }
10233 : break;
10234 : }
10235 387747 : default:;
10236 : }
10237 387747 : switch (TREE_CODE (_p0))
10238 : {
10239 3365 : case MIN_EXPR:
10240 3365 : {
10241 3365 : tree _q20 = TREE_OPERAND (_p0, 0);
10242 3365 : tree _q21 = TREE_OPERAND (_p0, 1);
10243 3365 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
10244 : {
10245 1 : {
10246 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10247 1 : tree res = generic_simplify_533 (loc, type, _p0, _p1, captures);
10248 1 : if (res) return res;
10249 : }
10250 : }
10251 3364 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
10252 : {
10253 1 : {
10254 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10255 1 : tree res = generic_simplify_533 (loc, type, _p0, _p1, captures);
10256 1 : if (res) return res;
10257 : }
10258 : }
10259 : break;
10260 : }
10261 387745 : default:;
10262 : }
10263 387745 : switch (TREE_CODE (_p1))
10264 : {
10265 0 : case MIN_EXPR:
10266 0 : {
10267 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10268 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10269 0 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
10270 : {
10271 0 : {
10272 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
10273 0 : tree res = generic_simplify_533 (loc, type, _p0, _p1, captures);
10274 0 : if (res) return res;
10275 : }
10276 : }
10277 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10278 : {
10279 0 : {
10280 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _p0 };
10281 0 : tree res = generic_simplify_533 (loc, type, _p0, _p1, captures);
10282 0 : if (res) return res;
10283 : }
10284 : }
10285 : break;
10286 : }
10287 0 : case NEGATE_EXPR:
10288 0 : {
10289 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10290 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10291 : {
10292 0 : {
10293 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10294 0 : tree res = generic_simplify_534 (loc, type, _p0, _p1, captures);
10295 0 : if (res) return res;
10296 : }
10297 : }
10298 : break;
10299 : }
10300 387745 : default:;
10301 : }
10302 387745 : switch (TREE_CODE (_p0))
10303 : {
10304 76 : case NEGATE_EXPR:
10305 76 : {
10306 76 : tree _q20 = TREE_OPERAND (_p0, 0);
10307 76 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
10308 : {
10309 2 : {
10310 2 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10311 2 : tree res = generic_simplify_534 (loc, type, _p0, _p1, captures);
10312 2 : if (res) return res;
10313 : }
10314 : }
10315 : break;
10316 : }
10317 387743 : default:;
10318 : }
10319 387743 : {
10320 387743 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
10321 387743 : if (INTEGRAL_TYPE_P (type)
10322 385807 : && TYPE_MAX_VALUE (type)
10323 773550 : && operand_equal_p (captures[1], TYPE_MAX_VALUE (type), OEP_ONLY_CONST)
10324 : )
10325 : {
10326 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1740;
10327 0 : {
10328 0 : tree _r;
10329 0 : _r = captures[1];
10330 0 : if (TREE_SIDE_EFFECTS (captures[0]))
10331 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
10332 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1027, __FILE__, __LINE__, true);
10333 0 : return _r;
10334 : }
10335 0 : next_after_fail1740:;
10336 : }
10337 : else
10338 : {
10339 387743 : if (INTEGRAL_TYPE_P (type)
10340 385807 : && TYPE_MIN_VALUE (type)
10341 773550 : && operand_equal_p (captures[1], TYPE_MIN_VALUE (type), OEP_ONLY_CONST)
10342 : )
10343 : {
10344 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1741;
10345 11 : {
10346 11 : tree _r;
10347 11 : _r = captures[0];
10348 11 : if (TREE_SIDE_EFFECTS (captures[1]))
10349 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
10350 11 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1028, __FILE__, __LINE__, true);
10351 11 : return _r;
10352 : }
10353 0 : next_after_fail1741:;
10354 : }
10355 : }
10356 : }
10357 387732 : switch (TREE_CODE (_p0))
10358 : {
10359 23268 : case PLUS_EXPR:
10360 23268 : {
10361 23268 : tree _q20 = TREE_OPERAND (_p0, 0);
10362 23268 : tree _q21 = TREE_OPERAND (_p0, 1);
10363 23268 : switch (TREE_CODE (_p1))
10364 : {
10365 14 : case PLUS_EXPR:
10366 14 : {
10367 14 : tree _q50 = TREE_OPERAND (_p1, 0);
10368 14 : tree _q51 = TREE_OPERAND (_p1, 1);
10369 14 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10370 : {
10371 0 : {
10372 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
10373 0 : tree res = generic_simplify_523 (loc, type, _p0, _p1, captures, MAX_EXPR);
10374 0 : if (res) return res;
10375 : }
10376 0 : {
10377 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q50, _q21, _p0, _q20 };
10378 0 : tree res = generic_simplify_523 (loc, type, _p0, _p1, captures, MAX_EXPR);
10379 0 : if (res) return res;
10380 : }
10381 : }
10382 14 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10383 : {
10384 0 : {
10385 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q50 };
10386 0 : tree res = generic_simplify_523 (loc, type, _p0, _p1, captures, MAX_EXPR);
10387 0 : if (res) return res;
10388 : }
10389 : }
10390 14 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10391 : {
10392 0 : {
10393 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q51, _q21, _p0, _q20 };
10394 0 : tree res = generic_simplify_523 (loc, type, _p0, _p1, captures, MAX_EXPR);
10395 0 : if (res) return res;
10396 : }
10397 : }
10398 : break;
10399 : }
10400 23268 : default:;
10401 : }
10402 23268 : switch (TREE_CODE (_q21))
10403 : {
10404 23230 : case INTEGER_CST:
10405 23230 : {
10406 23230 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
10407 : {
10408 11 : {
10409 11 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
10410 11 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
10411 : )
10412 : {
10413 0 : if (tree_int_cst_sgn (captures[2]) > 0
10414 : )
10415 : {
10416 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1742;
10417 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1742;
10418 0 : {
10419 0 : tree _r;
10420 0 : _r = captures[1];
10421 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1029, __FILE__, __LINE__, true);
10422 0 : return _r;
10423 : }
10424 11 : next_after_fail1742:;
10425 : }
10426 : else
10427 : {
10428 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1743;
10429 0 : {
10430 0 : tree _r;
10431 0 : _r = captures[0];
10432 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10433 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10434 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1030, __FILE__, __LINE__, true);
10435 0 : return _r;
10436 : }
10437 0 : next_after_fail1743:;
10438 : }
10439 : }
10440 : }
10441 : }
10442 : break;
10443 : }
10444 : default:;
10445 : }
10446 : break;
10447 : }
10448 8164 : case MINUS_EXPR:
10449 8164 : {
10450 8164 : tree _q20 = TREE_OPERAND (_p0, 0);
10451 8164 : tree _q21 = TREE_OPERAND (_p0, 1);
10452 8164 : switch (TREE_CODE (_p1))
10453 : {
10454 0 : case MINUS_EXPR:
10455 0 : {
10456 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10457 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10458 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10459 : {
10460 0 : {
10461 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
10462 0 : tree res = generic_simplify_524 (loc, type, _p0, _p1, captures, MAX_EXPR);
10463 0 : if (res) return res;
10464 : }
10465 0 : {
10466 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q50, _q21, _p0, _q20 };
10467 0 : tree res = generic_simplify_524 (loc, type, _p0, _p1, captures, MAX_EXPR);
10468 0 : if (res) return res;
10469 : }
10470 : }
10471 : break;
10472 : }
10473 : default:;
10474 : }
10475 : break;
10476 : }
10477 387732 : default:;
10478 : }
10479 387732 : switch (TREE_CODE (_p1))
10480 : {
10481 110 : case PLUS_EXPR:
10482 110 : {
10483 110 : tree _q30 = TREE_OPERAND (_p1, 0);
10484 110 : tree _q31 = TREE_OPERAND (_p1, 1);
10485 110 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10486 : {
10487 0 : switch (TREE_CODE (_q31))
10488 : {
10489 0 : case INTEGER_CST:
10490 0 : {
10491 0 : {
10492 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
10493 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
10494 : )
10495 : {
10496 0 : if (tree_int_cst_sgn (captures[2]) > 0
10497 : )
10498 : {
10499 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1744;
10500 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1744;
10501 0 : {
10502 0 : tree _r;
10503 0 : _r = captures[1];
10504 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1029, __FILE__, __LINE__, true);
10505 0 : return _r;
10506 : }
10507 0 : next_after_fail1744:;
10508 : }
10509 : else
10510 : {
10511 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1745;
10512 0 : {
10513 0 : tree _r;
10514 0 : _r = captures[0];
10515 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10516 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10517 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1030, __FILE__, __LINE__, true);
10518 0 : return _r;
10519 : }
10520 0 : next_after_fail1745:;
10521 : }
10522 : }
10523 : }
10524 0 : break;
10525 : }
10526 : default:;
10527 : }
10528 : }
10529 : break;
10530 : }
10531 387732 : default:;
10532 : }
10533 387732 : switch (TREE_CODE (_p0))
10534 : {
10535 3363 : case MIN_EXPR:
10536 3363 : {
10537 3363 : tree _q20 = TREE_OPERAND (_p0, 0);
10538 3363 : tree _q21 = TREE_OPERAND (_p0, 1);
10539 3363 : switch (TREE_CODE (_p1))
10540 : {
10541 0 : case MAX_EXPR:
10542 0 : {
10543 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10544 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10545 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10546 : {
10547 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10548 : {
10549 0 : {
10550 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10551 0 : if (!HONOR_NANS (captures[0])
10552 : )
10553 : {
10554 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1746;
10555 0 : {
10556 0 : tree res_op0;
10557 0 : res_op0 = captures[0];
10558 0 : tree res_op1;
10559 0 : res_op1 = captures[1];
10560 0 : tree _r;
10561 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
10562 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
10563 0 : return _r;
10564 : }
10565 0 : next_after_fail1746:;
10566 : }
10567 : }
10568 : }
10569 : }
10570 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10571 : {
10572 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10573 : {
10574 0 : {
10575 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10576 0 : if (!HONOR_NANS (captures[0])
10577 : )
10578 : {
10579 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1747;
10580 0 : {
10581 0 : tree res_op0;
10582 0 : res_op0 = captures[0];
10583 0 : tree res_op1;
10584 0 : res_op1 = captures[1];
10585 0 : tree _r;
10586 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
10587 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
10588 0 : return _r;
10589 : }
10590 0 : next_after_fail1747:;
10591 : }
10592 : }
10593 : }
10594 : }
10595 : break;
10596 : }
10597 : default:;
10598 : }
10599 : break;
10600 : }
10601 111 : case MAX_EXPR:
10602 111 : {
10603 111 : tree _q20 = TREE_OPERAND (_p0, 0);
10604 111 : tree _q21 = TREE_OPERAND (_p0, 1);
10605 111 : switch (TREE_CODE (_p1))
10606 : {
10607 0 : case MIN_EXPR:
10608 0 : {
10609 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10610 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10611 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10612 : {
10613 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10614 : {
10615 0 : {
10616 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10617 0 : if (!HONOR_NANS (captures[0])
10618 : )
10619 : {
10620 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1748;
10621 0 : {
10622 0 : tree res_op0;
10623 0 : res_op0 = captures[0];
10624 0 : tree res_op1;
10625 0 : res_op1 = captures[1];
10626 0 : tree _r;
10627 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
10628 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
10629 0 : return _r;
10630 : }
10631 0 : next_after_fail1748:;
10632 : }
10633 : }
10634 : }
10635 : }
10636 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10637 : {
10638 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10639 : {
10640 0 : {
10641 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10642 0 : if (!HONOR_NANS (captures[0])
10643 : )
10644 : {
10645 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1749;
10646 0 : {
10647 0 : tree res_op0;
10648 0 : res_op0 = captures[0];
10649 0 : tree res_op1;
10650 0 : res_op1 = captures[1];
10651 0 : tree _r;
10652 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
10653 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
10654 0 : return _r;
10655 : }
10656 0 : next_after_fail1749:;
10657 : }
10658 : }
10659 : }
10660 : }
10661 : break;
10662 : }
10663 : default:;
10664 : }
10665 : break;
10666 : }
10667 0 : case BIT_AND_EXPR:
10668 0 : {
10669 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10670 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10671 0 : switch (TREE_CODE (_q21))
10672 : {
10673 0 : case INTEGER_CST:
10674 0 : {
10675 0 : switch (TREE_CODE (_p1))
10676 : {
10677 0 : case BIT_AND_EXPR:
10678 0 : {
10679 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10680 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10681 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10682 : {
10683 0 : switch (TREE_CODE (_q51))
10684 : {
10685 0 : case INTEGER_CST:
10686 0 : {
10687 0 : {
10688 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
10689 0 : tree res = generic_simplify_525 (loc, type, _p0, _p1, captures, MAX_EXPR);
10690 0 : if (res) return res;
10691 : }
10692 0 : break;
10693 : }
10694 : default:;
10695 : }
10696 : }
10697 : break;
10698 : }
10699 : default:;
10700 : }
10701 : break;
10702 : }
10703 : default:;
10704 : }
10705 : break;
10706 : }
10707 387732 : default:;
10708 : }
10709 387732 : switch (TREE_CODE (_p1))
10710 : {
10711 0 : case BIT_AND_EXPR:
10712 0 : {
10713 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10714 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10715 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10716 : {
10717 0 : switch (TREE_CODE (_q31))
10718 : {
10719 0 : case INTEGER_CST:
10720 0 : {
10721 0 : {
10722 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
10723 0 : tree res = generic_simplify_526 (loc, type, _p0, _p1, captures, MAX_EXPR);
10724 0 : if (res) return res;
10725 : }
10726 0 : break;
10727 : }
10728 : default:;
10729 : }
10730 : }
10731 : break;
10732 : }
10733 387732 : default:;
10734 : }
10735 387732 : switch (TREE_CODE (_p0))
10736 : {
10737 32882 : CASE_CONVERT:
10738 32882 : {
10739 32882 : tree _q20 = TREE_OPERAND (_p0, 0);
10740 32882 : switch (TREE_CODE (_q20))
10741 : {
10742 30 : case ADDR_EXPR:
10743 30 : {
10744 30 : switch (TREE_CODE (_p1))
10745 : {
10746 0 : CASE_CONVERT:
10747 0 : {
10748 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10749 0 : switch (TREE_CODE (_q40))
10750 : {
10751 0 : case ADDR_EXPR:
10752 0 : {
10753 0 : {
10754 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10755 0 : tree res = generic_simplify_527 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR);
10756 0 : if (res) return res;
10757 : }
10758 0 : break;
10759 : }
10760 : default:;
10761 : }
10762 : break;
10763 : }
10764 0 : case ADDR_EXPR:
10765 0 : {
10766 0 : {
10767 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
10768 0 : tree res = generic_simplify_528 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR);
10769 0 : if (res) return res;
10770 : }
10771 0 : break;
10772 : }
10773 : default:;
10774 : }
10775 : break;
10776 : }
10777 : default:;
10778 : }
10779 : break;
10780 : }
10781 10 : case ADDR_EXPR:
10782 10 : {
10783 10 : switch (TREE_CODE (_p1))
10784 : {
10785 0 : CASE_CONVERT:
10786 0 : {
10787 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10788 0 : switch (TREE_CODE (_q30))
10789 : {
10790 0 : case ADDR_EXPR:
10791 0 : {
10792 0 : {
10793 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _p1, _q30 };
10794 0 : tree res = generic_simplify_529 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR);
10795 0 : if (res) return res;
10796 : }
10797 0 : break;
10798 : }
10799 : default:;
10800 : }
10801 : break;
10802 : }
10803 10 : case ADDR_EXPR:
10804 10 : {
10805 10 : {
10806 10 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _p1, _p1 };
10807 10 : tree res = generic_simplify_530 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR);
10808 10 : if (res) return res;
10809 : }
10810 10 : break;
10811 : }
10812 : default:;
10813 : }
10814 : break;
10815 : }
10816 74 : case NEGATE_EXPR:
10817 74 : {
10818 74 : tree _q20 = TREE_OPERAND (_p0, 0);
10819 74 : switch (TREE_CODE (_p1))
10820 : {
10821 0 : case NEGATE_EXPR:
10822 0 : {
10823 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10824 0 : {
10825 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10826 0 : if (FLOAT_TYPE_P (TREE_TYPE (captures[1]))
10827 0 : || (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
10828 0 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1])))
10829 : )
10830 : {
10831 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1750;
10832 0 : {
10833 0 : tree res_op0;
10834 0 : {
10835 0 : tree _o1[2], _r1;
10836 0 : _o1[0] = captures[1];
10837 0 : _o1[1] = captures[3];
10838 0 : _r1 = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10839 0 : res_op0 = _r1;
10840 : }
10841 0 : tree _r;
10842 0 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
10843 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1026, __FILE__, __LINE__, true);
10844 0 : return _r;
10845 : }
10846 0 : next_after_fail1750:;
10847 : }
10848 : }
10849 0 : break;
10850 : }
10851 : default:;
10852 : }
10853 : break;
10854 : }
10855 0 : case BIT_NOT_EXPR:
10856 0 : {
10857 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10858 0 : switch (TREE_CODE (_p1))
10859 : {
10860 0 : case BIT_NOT_EXPR:
10861 0 : {
10862 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10863 0 : {
10864 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10865 0 : tree res = generic_simplify_531 (loc, type, _p0, _p1, captures, MAX_EXPR, MIN_EXPR);
10866 0 : if (res) return res;
10867 : }
10868 0 : break;
10869 : }
10870 : default:;
10871 : }
10872 : break;
10873 : }
10874 0 : case VEC_COND_EXPR:
10875 0 : {
10876 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10877 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10878 0 : tree _q22 = TREE_OPERAND (_p0, 2);
10879 0 : switch (TREE_CODE (_p1))
10880 : {
10881 0 : case VEC_COND_EXPR:
10882 0 : {
10883 0 : tree _q60 = TREE_OPERAND (_p1, 0);
10884 0 : tree _q61 = TREE_OPERAND (_p1, 1);
10885 0 : tree _q62 = TREE_OPERAND (_p1, 2);
10886 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
10887 : {
10888 0 : {
10889 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
10890 0 : if (VECTOR_TYPE_P (type)
10891 0 : && (TREE_CODE_CLASS (MAX_EXPR) != tcc_comparison
10892 : || types_match (type, TREE_TYPE (captures[2]))
10893 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10894 : || (optimize_vectors_before_lowering_p ()
10895 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10896 : )
10897 : {
10898 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1751;
10899 0 : {
10900 0 : tree res_op0;
10901 0 : res_op0 = captures[1];
10902 0 : tree res_op1;
10903 0 : {
10904 0 : tree _o1[2], _r1;
10905 0 : _o1[0] = captures[2];
10906 0 : _o1[1] = captures[5];
10907 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
10908 0 : if (EXPR_P (_r1))
10909 0 : goto next_after_fail1751;
10910 0 : res_op1 = _r1;
10911 : }
10912 0 : tree res_op2;
10913 0 : {
10914 0 : tree _o1[2], _r1;
10915 0 : _o1[0] = captures[3];
10916 0 : _o1[1] = captures[6];
10917 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
10918 0 : if (EXPR_P (_r1))
10919 0 : goto next_after_fail1751;
10920 0 : res_op2 = _r1;
10921 : }
10922 0 : tree _r;
10923 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10924 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
10925 0 : return _r;
10926 : }
10927 0 : next_after_fail1751:;
10928 : }
10929 : }
10930 : }
10931 : break;
10932 : }
10933 0 : default:;
10934 : }
10935 0 : {
10936 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
10937 0 : if (VECTOR_TYPE_P (type)
10938 0 : && (TREE_CODE_CLASS (MAX_EXPR) != tcc_comparison
10939 : || types_match (type, TREE_TYPE (captures[2]))
10940 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10941 : || (optimize_vectors_before_lowering_p ()
10942 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10943 : )
10944 : {
10945 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1752;
10946 0 : {
10947 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1752;
10948 0 : tree res_op0;
10949 0 : res_op0 = captures[1];
10950 0 : tree res_op1;
10951 0 : {
10952 0 : tree _o1[2], _r1;
10953 0 : _o1[0] = captures[2];
10954 0 : _o1[1] = unshare_expr (captures[4]);
10955 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
10956 0 : if (EXPR_P (_r1))
10957 0 : goto next_after_fail1752;
10958 0 : res_op1 = _r1;
10959 : }
10960 0 : tree res_op2;
10961 0 : {
10962 0 : tree _o1[2], _r1;
10963 0 : _o1[0] = captures[3];
10964 0 : _o1[1] = captures[4];
10965 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
10966 0 : if (EXPR_P (_r1))
10967 0 : goto next_after_fail1752;
10968 0 : res_op2 = _r1;
10969 : }
10970 0 : tree _r;
10971 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10972 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 895, __FILE__, __LINE__, true);
10973 0 : return _r;
10974 : }
10975 0 : next_after_fail1752:;
10976 : }
10977 : }
10978 0 : break;
10979 : }
10980 387732 : default:;
10981 : }
10982 387732 : switch (TREE_CODE (_p1))
10983 : {
10984 0 : case VEC_COND_EXPR:
10985 0 : {
10986 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10987 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10988 0 : tree _q32 = TREE_OPERAND (_p1, 2);
10989 0 : {
10990 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
10991 0 : if (VECTOR_TYPE_P (type)
10992 0 : && (TREE_CODE_CLASS (MAX_EXPR) != tcc_comparison
10993 : || types_match (type, TREE_TYPE (captures[3]))
10994 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
10995 : || (optimize_vectors_before_lowering_p ()
10996 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
10997 : )
10998 : {
10999 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1753;
11000 0 : {
11001 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1753;
11002 0 : tree res_op0;
11003 0 : res_op0 = captures[2];
11004 0 : tree res_op1;
11005 0 : {
11006 0 : tree _o1[2], _r1;
11007 0 : _o1[0] = unshare_expr (captures[0]);
11008 0 : _o1[1] = captures[3];
11009 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
11010 0 : if (EXPR_P (_r1))
11011 0 : goto next_after_fail1753;
11012 0 : res_op1 = _r1;
11013 : }
11014 0 : tree res_op2;
11015 0 : {
11016 0 : tree _o1[2], _r1;
11017 0 : _o1[0] = captures[0];
11018 0 : _o1[1] = captures[4];
11019 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
11020 0 : if (EXPR_P (_r1))
11021 0 : goto next_after_fail1753;
11022 0 : res_op2 = _r1;
11023 : }
11024 0 : tree _r;
11025 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11026 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
11027 0 : return _r;
11028 : }
11029 0 : next_after_fail1753:;
11030 : }
11031 : }
11032 0 : break;
11033 : }
11034 387732 : default:;
11035 : }
11036 387732 : if (tree_zero_one_valued_p (_p0))
11037 : {
11038 10 : if (tree_zero_one_valued_p (_p1))
11039 : {
11040 0 : {
11041 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
11042 0 : tree res = generic_simplify_532 (loc, type, _p0, _p1, captures, MAX_EXPR, BIT_IOR_EXPR);
11043 0 : if (res) return res;
11044 : }
11045 : }
11046 : }
11047 : return NULL_TREE;
11048 : }
11049 :
11050 : tree
11051 409349 : generic_simplify_UNGE_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
11052 : {
11053 409349 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
11054 409349 : switch (TREE_CODE (_p0))
11055 : {
11056 0 : case VEC_COND_EXPR:
11057 0 : {
11058 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11059 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11060 0 : tree _q22 = TREE_OPERAND (_p0, 2);
11061 0 : switch (TREE_CODE (_p1))
11062 : {
11063 0 : case VEC_COND_EXPR:
11064 0 : {
11065 0 : tree _q60 = TREE_OPERAND (_p1, 0);
11066 0 : tree _q61 = TREE_OPERAND (_p1, 1);
11067 0 : tree _q62 = TREE_OPERAND (_p1, 2);
11068 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
11069 : {
11070 0 : {
11071 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
11072 0 : if (VECTOR_TYPE_P (type)
11073 0 : && (TREE_CODE_CLASS (UNGE_EXPR) != tcc_comparison
11074 0 : || types_match (type, TREE_TYPE (captures[2]))
11075 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
11076 : || (optimize_vectors_before_lowering_p ()
11077 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
11078 : )
11079 : {
11080 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1775;
11081 0 : {
11082 0 : tree res_op0;
11083 0 : res_op0 = captures[1];
11084 0 : tree res_op1;
11085 0 : {
11086 0 : tree _o1[2], _r1;
11087 0 : _o1[0] = captures[2];
11088 0 : _o1[1] = captures[5];
11089 0 : _r1 = fold_build2_loc (loc, UNGE_EXPR, type, _o1[0], _o1[1]);
11090 0 : if (EXPR_P (_r1))
11091 0 : goto next_after_fail1775;
11092 0 : res_op1 = _r1;
11093 : }
11094 0 : tree res_op2;
11095 0 : {
11096 0 : tree _o1[2], _r1;
11097 0 : _o1[0] = captures[3];
11098 0 : _o1[1] = captures[6];
11099 0 : _r1 = fold_build2_loc (loc, UNGE_EXPR, type, _o1[0], _o1[1]);
11100 0 : if (EXPR_P (_r1))
11101 0 : goto next_after_fail1775;
11102 0 : res_op2 = _r1;
11103 : }
11104 0 : tree _r;
11105 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11106 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
11107 0 : return _r;
11108 : }
11109 0 : next_after_fail1775:;
11110 : }
11111 : }
11112 : }
11113 : break;
11114 : }
11115 0 : default:;
11116 : }
11117 0 : {
11118 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
11119 0 : if (VECTOR_TYPE_P (type)
11120 0 : && (TREE_CODE_CLASS (UNGE_EXPR) != tcc_comparison
11121 0 : || types_match (type, TREE_TYPE (captures[2]))
11122 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
11123 : || (optimize_vectors_before_lowering_p ()
11124 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
11125 : )
11126 : {
11127 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1776;
11128 0 : {
11129 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1776;
11130 0 : tree res_op0;
11131 0 : res_op0 = captures[1];
11132 0 : tree res_op1;
11133 0 : {
11134 0 : tree _o1[2], _r1;
11135 0 : _o1[0] = captures[2];
11136 0 : _o1[1] = unshare_expr (captures[4]);
11137 0 : _r1 = fold_build2_loc (loc, UNGE_EXPR, type, _o1[0], _o1[1]);
11138 0 : if (EXPR_P (_r1))
11139 0 : goto next_after_fail1776;
11140 0 : res_op1 = _r1;
11141 : }
11142 0 : tree res_op2;
11143 0 : {
11144 0 : tree _o1[2], _r1;
11145 0 : _o1[0] = captures[3];
11146 0 : _o1[1] = captures[4];
11147 0 : _r1 = fold_build2_loc (loc, UNGE_EXPR, type, _o1[0], _o1[1]);
11148 0 : if (EXPR_P (_r1))
11149 0 : goto next_after_fail1776;
11150 0 : res_op2 = _r1;
11151 : }
11152 0 : tree _r;
11153 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11154 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 895, __FILE__, __LINE__, true);
11155 0 : return _r;
11156 : }
11157 0 : next_after_fail1776:;
11158 : }
11159 : }
11160 0 : break;
11161 : }
11162 409349 : default:;
11163 : }
11164 409349 : switch (TREE_CODE (_p1))
11165 : {
11166 0 : case VEC_COND_EXPR:
11167 0 : {
11168 0 : tree _q30 = TREE_OPERAND (_p1, 0);
11169 0 : tree _q31 = TREE_OPERAND (_p1, 1);
11170 0 : tree _q32 = TREE_OPERAND (_p1, 2);
11171 0 : {
11172 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
11173 0 : if (VECTOR_TYPE_P (type)
11174 0 : && (TREE_CODE_CLASS (UNGE_EXPR) != tcc_comparison
11175 0 : || types_match (type, TREE_TYPE (captures[3]))
11176 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
11177 : || (optimize_vectors_before_lowering_p ()
11178 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
11179 : )
11180 : {
11181 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1777;
11182 0 : {
11183 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1777;
11184 0 : tree res_op0;
11185 0 : res_op0 = captures[2];
11186 0 : tree res_op1;
11187 0 : {
11188 0 : tree _o1[2], _r1;
11189 0 : _o1[0] = unshare_expr (captures[0]);
11190 0 : _o1[1] = captures[3];
11191 0 : _r1 = fold_build2_loc (loc, UNGE_EXPR, type, _o1[0], _o1[1]);
11192 0 : if (EXPR_P (_r1))
11193 0 : goto next_after_fail1777;
11194 0 : res_op1 = _r1;
11195 : }
11196 0 : tree res_op2;
11197 0 : {
11198 0 : tree _o1[2], _r1;
11199 0 : _o1[0] = captures[0];
11200 0 : _o1[1] = captures[4];
11201 0 : _r1 = fold_build2_loc (loc, UNGE_EXPR, type, _o1[0], _o1[1]);
11202 0 : if (EXPR_P (_r1))
11203 0 : goto next_after_fail1777;
11204 0 : res_op2 = _r1;
11205 : }
11206 0 : tree _r;
11207 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11208 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
11209 0 : return _r;
11210 : }
11211 0 : next_after_fail1777:;
11212 : }
11213 : }
11214 0 : break;
11215 : }
11216 409349 : default:;
11217 : }
11218 409349 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
11219 : {
11220 30 : {
11221 30 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
11222 30 : tree res = generic_simplify_563 (loc, type, _p0, _p1, captures, UNGE_EXPR);
11223 30 : if (res) return res;
11224 : }
11225 : }
11226 409319 : switch (TREE_CODE (_p0))
11227 : {
11228 299 : case FLOAT_EXPR:
11229 299 : {
11230 299 : tree _q20 = TREE_OPERAND (_p0, 0);
11231 299 : switch (TREE_CODE (_p1))
11232 : {
11233 0 : case FLOAT_EXPR:
11234 0 : {
11235 0 : tree _q40 = TREE_OPERAND (_p1, 0);
11236 0 : {
11237 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
11238 0 : tree res = generic_simplify_261 (loc, type, _p0, _p1, captures, UNGE_EXPR, GE_EXPR);
11239 0 : if (res) return res;
11240 : }
11241 0 : break;
11242 : }
11243 : default:;
11244 : }
11245 : break;
11246 : }
11247 112 : case NEGATE_EXPR:
11248 112 : {
11249 112 : tree _q20 = TREE_OPERAND (_p0, 0);
11250 112 : switch (TREE_CODE (_p1))
11251 : {
11252 0 : case NEGATE_EXPR:
11253 0 : {
11254 0 : tree _q40 = TREE_OPERAND (_p1, 0);
11255 0 : {
11256 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
11257 0 : tree res = generic_simplify_264 (loc, type, _p0, _p1, captures, UNGE_EXPR, UNLE_EXPR);
11258 0 : if (res) return res;
11259 : }
11260 0 : break;
11261 : }
11262 112 : default:;
11263 : }
11264 112 : if (CONSTANT_CLASS_P (_p1))
11265 : {
11266 112 : {
11267 112 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
11268 112 : tree res = generic_simplify_265 (loc, type, _p0, _p1, captures, UNGE_EXPR, UNLE_EXPR);
11269 112 : if (res) return res;
11270 : }
11271 : }
11272 : break;
11273 : }
11274 409207 : default:;
11275 : }
11276 409207 : switch (TREE_CODE (_p1))
11277 : {
11278 53837 : case REAL_CST:
11279 53837 : {
11280 53837 : {
11281 53837 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
11282 53837 : tree res = generic_simplify_561 (loc, type, _p0, _p1, captures, UNGE_EXPR);
11283 53837 : if (res) return res;
11284 : }
11285 53835 : break;
11286 : }
11287 : default:;
11288 : }
11289 : return NULL_TREE;
11290 : }
11291 :
11292 : tree
11293 596678881 : generic_simplify (location_t loc, enum tree_code code, const tree type ATTRIBUTE_UNUSED, tree _p0, tree _p1)
11294 : {
11295 596678881 : switch (code)
11296 : {
11297 998490 : case BIT_XOR_EXPR:
11298 998490 : return generic_simplify_BIT_XOR_EXPR (loc, code, type, _p0, _p1);
11299 96116649 : case PLUS_EXPR:
11300 96116649 : return generic_simplify_PLUS_EXPR (loc, code, type, _p0, _p1);
11301 49580352 : case POINTER_PLUS_EXPR:
11302 49580352 : return generic_simplify_POINTER_PLUS_EXPR (loc, code, type, _p0, _p1);
11303 32685241 : case MINUS_EXPR:
11304 32685241 : return generic_simplify_MINUS_EXPR (loc, code, type, _p0, _p1);
11305 1851440 : case BIT_IOR_EXPR:
11306 1851440 : return generic_simplify_BIT_IOR_EXPR (loc, code, type, _p0, _p1);
11307 2870107 : case POINTER_DIFF_EXPR:
11308 2870107 : return generic_simplify_POINTER_DIFF_EXPR (loc, code, type, _p0, _p1);
11309 70287781 : case MULT_EXPR:
11310 70287781 : return generic_simplify_MULT_EXPR (loc, code, type, _p0, _p1);
11311 26705762 : case EQ_EXPR:
11312 26705762 : return generic_simplify_EQ_EXPR (loc, code, type, _p0, _p1);
11313 36146400 : case NE_EXPR:
11314 36146400 : return generic_simplify_NE_EXPR (loc, code, type, _p0, _p1);
11315 2219392 : case TRUNC_DIV_EXPR:
11316 2219392 : return generic_simplify_TRUNC_DIV_EXPR (loc, code, type, _p0, _p1);
11317 7008 : case CEIL_DIV_EXPR:
11318 7008 : return generic_simplify_CEIL_DIV_EXPR (loc, code, type, _p0, _p1);
11319 2194688 : case FLOOR_DIV_EXPR:
11320 2194688 : return generic_simplify_FLOOR_DIV_EXPR (loc, code, type, _p0, _p1);
11321 0 : case ROUND_DIV_EXPR:
11322 0 : return generic_simplify_ROUND_DIV_EXPR (loc, code, type, _p0, _p1);
11323 3371566 : case EXACT_DIV_EXPR:
11324 3371566 : return generic_simplify_EXACT_DIV_EXPR (loc, code, type, _p0, _p1);
11325 856679 : case FLOOR_MOD_EXPR:
11326 856679 : return generic_simplify_FLOOR_MOD_EXPR (loc, code, type, _p0, _p1);
11327 6224538 : case RDIV_EXPR:
11328 6224538 : return generic_simplify_RDIV_EXPR (loc, code, type, _p0, _p1);
11329 17487821 : case LT_EXPR:
11330 17487821 : return generic_simplify_LT_EXPR (loc, code, type, _p0, _p1);
11331 9309746 : case LE_EXPR:
11332 9309746 : return generic_simplify_LE_EXPR (loc, code, type, _p0, _p1);
11333 20783466 : case GT_EXPR:
11334 20783466 : return generic_simplify_GT_EXPR (loc, code, type, _p0, _p1);
11335 6611039 : case GE_EXPR:
11336 6611039 : return generic_simplify_GE_EXPR (loc, code, type, _p0, _p1);
11337 4140 : case CEIL_MOD_EXPR:
11338 4140 : return generic_simplify_CEIL_MOD_EXPR (loc, code, type, _p0, _p1);
11339 0 : case ROUND_MOD_EXPR:
11340 0 : return generic_simplify_ROUND_MOD_EXPR (loc, code, type, _p0, _p1);
11341 2059730 : case TRUNC_MOD_EXPR:
11342 2059730 : return generic_simplify_TRUNC_MOD_EXPR (loc, code, type, _p0, _p1);
11343 1248913 : case LSHIFT_EXPR:
11344 1248913 : return generic_simplify_LSHIFT_EXPR (loc, code, type, _p0, _p1);
11345 970716 : case RSHIFT_EXPR:
11346 970716 : return generic_simplify_RSHIFT_EXPR (loc, code, type, _p0, _p1);
11347 6789036 : case BIT_AND_EXPR:
11348 6789036 : return generic_simplify_BIT_AND_EXPR (loc, code, type, _p0, _p1);
11349 80919 : case MIN_EXPR:
11350 80919 : return generic_simplify_MIN_EXPR (loc, code, type, _p0, _p1);
11351 387747 : case MAX_EXPR:
11352 387747 : return generic_simplify_MAX_EXPR (loc, code, type, _p0, _p1);
11353 1891 : case LROTATE_EXPR:
11354 1891 : return generic_simplify_LROTATE_EXPR (loc, code, type, _p0, _p1);
11355 2736 : case RROTATE_EXPR:
11356 2736 : return generic_simplify_RROTATE_EXPR (loc, code, type, _p0, _p1);
11357 573915 : case COMPLEX_EXPR:
11358 573915 : return generic_simplify_COMPLEX_EXPR (loc, code, type, _p0, _p1);
11359 742052 : case UNORDERED_EXPR:
11360 742052 : return generic_simplify_UNORDERED_EXPR (loc, code, type, _p0, _p1);
11361 193399 : case ORDERED_EXPR:
11362 193399 : return generic_simplify_ORDERED_EXPR (loc, code, type, _p0, _p1);
11363 706748 : case UNLT_EXPR:
11364 706748 : return generic_simplify_UNLT_EXPR (loc, code, type, _p0, _p1);
11365 851992 : case UNLE_EXPR:
11366 851992 : return generic_simplify_UNLE_EXPR (loc, code, type, _p0, _p1);
11367 1259800 : case UNGT_EXPR:
11368 1259800 : return generic_simplify_UNGT_EXPR (loc, code, type, _p0, _p1);
11369 409349 : case UNGE_EXPR:
11370 409349 : return generic_simplify_UNGE_EXPR (loc, code, type, _p0, _p1);
11371 351790 : case UNEQ_EXPR:
11372 351790 : return generic_simplify_UNEQ_EXPR (loc, code, type, _p0, _p1);
11373 79 : case LTGT_EXPR:
11374 79 : return generic_simplify_LTGT_EXPR (loc, code, type, _p0, _p1);
11375 3249532 : case TRUTH_ORIF_EXPR:
11376 3249532 : return generic_simplify_TRUTH_ORIF_EXPR (loc, code, type, _p0, _p1);
11377 9404551 : case TRUTH_OR_EXPR:
11378 9404551 : return generic_simplify_TRUTH_OR_EXPR (loc, code, type, _p0, _p1);
11379 : default:;
11380 : }
11381 : return NULL_TREE;
11382 : }
11383 :
11384 : tree
11385 766220 : generic_simplify_BIT_FIELD_REF (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1, tree _p2)
11386 : {
11387 766220 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
11388 766220 : switch (TREE_CODE (_p0))
11389 : {
11390 8 : case BIT_FIELD_REF:
11391 8 : {
11392 8 : tree _q20 = TREE_OPERAND (_p0, 0);
11393 8 : tree _q21 = TREE_OPERAND (_p0, 1);
11394 8 : tree _q22 = TREE_OPERAND (_p0, 2);
11395 8 : {
11396 8 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _p1, _p2 };
11397 8 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1952;
11398 8 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1952;
11399 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1952;
11400 8 : {
11401 8 : tree res_op0;
11402 8 : res_op0 = captures[0];
11403 8 : tree res_op1;
11404 8 : res_op1 = captures[3];
11405 8 : tree res_op2;
11406 8 : res_op2 = const_binop (PLUS_EXPR, bitsizetype, captures[2], captures[4]);
11407 8 : tree _r;
11408 8 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11409 8 : if (TREE_SIDE_EFFECTS (captures[1]))
11410 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11411 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1081, __FILE__, __LINE__, true);
11412 8 : return _r;
11413 : }
11414 0 : next_after_fail1952:;
11415 : }
11416 0 : break;
11417 : }
11418 3 : case VIEW_CONVERT_EXPR:
11419 3 : {
11420 3 : tree _q20 = TREE_OPERAND (_p0, 0);
11421 3 : {
11422 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p1, _p2 };
11423 6 : if (! INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
11424 6 : || type_has_mode_precision_p (TREE_TYPE (captures[0]))
11425 : )
11426 : {
11427 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1953;
11428 0 : {
11429 0 : tree res_op0;
11430 0 : res_op0 = captures[0];
11431 0 : tree res_op1;
11432 0 : res_op1 = captures[1];
11433 0 : tree res_op2;
11434 0 : res_op2 = captures[2];
11435 0 : tree _r;
11436 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11437 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1082, __FILE__, __LINE__, true);
11438 0 : return _r;
11439 : }
11440 0 : next_after_fail1953:;
11441 : }
11442 : }
11443 3 : break;
11444 : }
11445 766212 : default:;
11446 : }
11447 766212 : if (integer_zerop (_p2))
11448 : {
11449 244357 : {
11450 244357 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
11451 244357 : if (tree_int_cst_equal (captures[1], TYPE_SIZE (TREE_TYPE (captures[0])))
11452 : )
11453 : {
11454 2589 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail1954;
11455 2589 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1954;
11456 2589 : {
11457 2589 : tree res_op0;
11458 2589 : res_op0 = captures[0];
11459 2589 : tree _r;
11460 2589 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11461 2589 : if (TREE_SIDE_EFFECTS (captures[1]))
11462 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11463 2589 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1083, __FILE__, __LINE__, true);
11464 2589 : return _r;
11465 : }
11466 241768 : next_after_fail1954:;
11467 : }
11468 : }
11469 : }
11470 763623 : {
11471 763623 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _p2 };
11472 763623 : if (TREE_CODE (TREE_TYPE (captures[0])) == COMPLEX_TYPE
11473 763623 : && tree_int_cst_equal (captures[1], TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0]))))
11474 : )
11475 : {
11476 2 : if (integer_zerop (captures[2])
11477 : )
11478 : {
11479 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1955;
11480 0 : {
11481 0 : tree res_op0;
11482 0 : {
11483 0 : tree _o1[1], _r1;
11484 0 : _o1[0] = captures[0];
11485 0 : _r1 = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
11486 0 : res_op0 = _r1;
11487 : }
11488 0 : tree _r;
11489 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11490 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11491 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11492 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11493 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11494 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1084, __FILE__, __LINE__, true);
11495 0 : return _r;
11496 : }
11497 0 : next_after_fail1955:;
11498 : }
11499 : else
11500 : {
11501 2 : if (tree_int_cst_equal (captures[2], TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0]))))
11502 : )
11503 : {
11504 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1956;
11505 0 : {
11506 0 : tree res_op0;
11507 0 : {
11508 0 : tree _o1[1], _r1;
11509 0 : _o1[0] = captures[0];
11510 0 : _r1 = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
11511 0 : res_op0 = _r1;
11512 : }
11513 0 : tree _r;
11514 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11515 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11516 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11517 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11518 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11519 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1085, __FILE__, __LINE__, true);
11520 0 : return _r;
11521 : }
11522 0 : next_after_fail1956:;
11523 : }
11524 : }
11525 : }
11526 : else
11527 : {
11528 1527180 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
11529 20555 : && INTEGRAL_TYPE_P (type)
11530 : && (!
11531 :
11532 : || is_gimple_reg (captures[0]))
11533 783198 : && ((compare_tree_int (captures[1], TYPE_PRECISION (TREE_TYPE (captures[0]))) == 0
11534 0 : && integer_zerop (captures[2]))
11535 : || (BYTES_BIG_ENDIAN == WORDS_BIG_ENDIAN
11536 : && canonicalize_math_after_vectorization_p ()
11537 : && TYPE_PRECISION (TREE_TYPE (captures[0])) % BITS_PER_UNIT == 0
11538 : && TYPE_PRECISION (type) % BITS_PER_UNIT == 0
11539 : && compare_tree_int (captures[2], (BYTES_BIG_ENDIAN
11540 : ? (TYPE_PRECISION (TREE_TYPE (captures[0]))
11541 : - TYPE_PRECISION (type))
11542 : : 0)) == 0))
11543 : )
11544 : {
11545 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1957;
11546 0 : {
11547 0 : tree res_op0;
11548 0 : res_op0 = captures[0];
11549 0 : tree _r;
11550 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
11551 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11552 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11553 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11554 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11555 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1086, __FILE__, __LINE__, true);
11556 0 : return _r;
11557 : }
11558 0 : next_after_fail1957:;
11559 : }
11560 : }
11561 : }
11562 763623 : switch (TREE_CODE (_p0))
11563 : {
11564 1511 : case CONSTRUCTOR:
11565 1511 : {
11566 1511 : {
11567 1511 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _p2 };
11568 1511 : if (VECTOR_TYPE_P (TREE_TYPE (captures[0]))
11569 1511 : && tree_fits_uhwi_p (TYPE_SIZE (type))
11570 3022 : && ((tree_to_uhwi (TYPE_SIZE (type))
11571 1511 : == tree_to_uhwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0])))))
11572 0 : || (VECTOR_TYPE_P (type)
11573 0 : && (tree_to_uhwi (TYPE_SIZE (TREE_TYPE (type)))
11574 0 : == tree_to_uhwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0])))))))
11575 : )
11576 : {
11577 1511 : {
11578 1511 : tree ctor = (TREE_CODE (captures[0]) == SSA_NAME
11579 : ? gimple_assign_rhs1 (SSA_NAME_DEF_STMT (captures[0])) : captures[0]);
11580 1511 : tree eltype = TREE_TYPE (TREE_TYPE (ctor));
11581 1511 : unsigned HOST_WIDE_INT width = tree_to_uhwi (TYPE_SIZE (eltype));
11582 1511 : unsigned HOST_WIDE_INT n = tree_to_uhwi (captures[1]);
11583 1511 : unsigned HOST_WIDE_INT idx = tree_to_uhwi (captures[2]);
11584 1511 : if (n != 0
11585 1511 : && (idx % width) == 0
11586 1511 : && (n % width) == 0
11587 3022 : && known_le ((idx + n) / width,
11588 : TYPE_VECTOR_SUBPARTS (TREE_TYPE (ctor)))
11589 : )
11590 : {
11591 1511 : {
11592 1511 : idx = idx / width;
11593 1511 : n = n / width;
11594 1511 : poly_uint64 k = 1;
11595 1511 : if (CONSTRUCTOR_NELTS (ctor) != 0)
11596 : {
11597 1511 : tree cons_elem = TREE_TYPE (CONSTRUCTOR_ELT (ctor, 0)->value);
11598 1511 : if (TREE_CODE (cons_elem) == VECTOR_TYPE)
11599 1511 : k = TYPE_VECTOR_SUBPARTS (cons_elem);
11600 : }
11601 1511 : unsigned HOST_WIDE_INT elt, count, const_k;
11602 1511 : if (multiple_p (idx, k, &elt) && multiple_p (n, k, &count)
11603 : )
11604 : {
11605 6 : if (CONSTRUCTOR_NELTS (ctor) == 0
11606 : )
11607 : {
11608 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1958;
11609 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1958;
11610 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1958;
11611 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1958;
11612 0 : {
11613 0 : tree _r;
11614 0 : _r = build_zero_cst (type);
11615 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1087, __FILE__, __LINE__, true);
11616 1511 : return _r;
11617 : }
11618 : next_after_fail1958:;
11619 : }
11620 : else
11621 : {
11622 6 : if (count == 1
11623 : )
11624 : {
11625 6 : if (elt < CONSTRUCTOR_NELTS (ctor)
11626 : )
11627 : {
11628 6 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1959;
11629 6 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1959;
11630 6 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1959;
11631 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1959;
11632 6 : {
11633 6 : tree res_op0;
11634 6 : res_op0 = CONSTRUCTOR_ELT (ctor, elt)->value;
11635 6 : tree _r;
11636 6 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11637 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1088, __FILE__, __LINE__, true);
11638 6 : return _r;
11639 : }
11640 : next_after_fail1959:;
11641 : }
11642 : else
11643 : {
11644 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1960;
11645 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1960;
11646 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1960;
11647 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1960;
11648 0 : {
11649 0 : tree _r;
11650 0 : _r = build_zero_cst (type);
11651 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1089, __FILE__, __LINE__, true);
11652 0 : return _r;
11653 : }
11654 : next_after_fail1960:;
11655 : }
11656 : }
11657 : else
11658 : {
11659 0 : if (single_use (captures[0])
11660 : )
11661 : {
11662 0 : {
11663 0 : vec<constructor_elt, va_gc> *vals;
11664 0 : vec_alloc (vals, count);
11665 0 : bool constant_p = true;
11666 0 : tree res;
11667 0 : for (unsigned i = 0;
11668 0 : i < count && elt + i < CONSTRUCTOR_NELTS (ctor); ++i)
11669 : {
11670 0 : tree e = CONSTRUCTOR_ELT (ctor, elt + i)->value;
11671 0 : CONSTRUCTOR_APPEND_ELT (vals, NULL_TREE, e);
11672 0 : if (!CONSTANT_CLASS_P (e))
11673 0 : constant_p = false;
11674 : }
11675 0 : tree evtype = (types_match (TREE_TYPE (type),
11676 0 : TREE_TYPE (TREE_TYPE (ctor)))
11677 0 : ? type
11678 0 : : build_vector_type (TREE_TYPE (TREE_TYPE (ctor)),
11679 0 : count * k));
11680 0 : res = (constant_p ? build_vector_from_ctor (evtype, vals)
11681 : : (
11682 :
11683 0 : ? NULL_TREE : build_constructor (evtype, vals)));
11684 0 : if (res
11685 : )
11686 : {
11687 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1961;
11688 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1961;
11689 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1961;
11690 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1961;
11691 0 : {
11692 0 : tree res_op0;
11693 0 : res_op0 = res;
11694 0 : tree _r;
11695 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11696 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1090, __FILE__, __LINE__, true);
11697 0 : return _r;
11698 : }
11699 0 : next_after_fail1961:;
11700 : }
11701 : }
11702 : }
11703 : }
11704 : }
11705 : }
11706 : else
11707 : {
11708 1505 : if (k.is_constant (&const_k)
11709 1505 : && idx + n <= (idx / const_k + 1) * const_k
11710 : )
11711 : {
11712 1505 : if (CONSTRUCTOR_NELTS (ctor) <= idx / const_k
11713 : )
11714 : {
11715 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1962;
11716 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1962;
11717 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1962;
11718 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1962;
11719 0 : {
11720 0 : tree _r;
11721 0 : _r = build_zero_cst (type);
11722 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1091, __FILE__, __LINE__, true);
11723 0 : return _r;
11724 : }
11725 : next_after_fail1962:;
11726 : }
11727 : else
11728 : {
11729 1505 : if (n == const_k
11730 : )
11731 : {
11732 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1963;
11733 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1963;
11734 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1963;
11735 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1963;
11736 0 : {
11737 0 : tree res_op0;
11738 0 : res_op0 = CONSTRUCTOR_ELT (ctor, idx / const_k)->value;
11739 0 : tree _r;
11740 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11741 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1092, __FILE__, __LINE__, true);
11742 0 : return _r;
11743 : }
11744 : next_after_fail1963:;
11745 : }
11746 : else
11747 : {
11748 1505 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1964;
11749 1505 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1964;
11750 1505 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1964;
11751 1505 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1964;
11752 1505 : {
11753 1505 : tree res_op0;
11754 1505 : res_op0 = CONSTRUCTOR_ELT (ctor, idx / const_k)->value;
11755 1505 : tree res_op1;
11756 1505 : res_op1 = captures[1];
11757 1505 : tree res_op2;
11758 1505 : res_op2 = bitsize_int ((idx % const_k) * width);
11759 1505 : tree _r;
11760 1505 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11761 1505 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1093, __FILE__, __LINE__, true);
11762 1505 : return _r;
11763 : }
11764 : next_after_fail1964:;
11765 : }
11766 : }
11767 : }
11768 : }
11769 : }
11770 : }
11771 : }
11772 : }
11773 : }
11774 0 : break;
11775 : }
11776 0 : case VEC_PERM_EXPR:
11777 0 : {
11778 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11779 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11780 0 : tree _q22 = TREE_OPERAND (_p0, 2);
11781 0 : switch (TREE_CODE (_q22))
11782 : {
11783 0 : case VECTOR_CST:
11784 0 : {
11785 0 : {
11786 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _p2 };
11787 0 : {
11788 0 : tree elem_type = TREE_TYPE (TREE_TYPE (captures[0]));
11789 0 : poly_uint64 elem_size = tree_to_poly_uint64 (TYPE_SIZE (elem_type));
11790 0 : poly_uint64 size = tree_to_poly_uint64 (TYPE_SIZE (type));
11791 0 : unsigned HOST_WIDE_INT nelts, idx;
11792 0 : unsigned HOST_WIDE_INT nelts_op = 0;
11793 0 : if (constant_multiple_p (tree_to_poly_uint64 (captures[5]), elem_size, &idx)
11794 0 : && VECTOR_CST_NELTS (captures[3]).is_constant (&nelts)
11795 0 : && (known_eq (size, elem_size)
11796 0 : || (constant_multiple_p (size, elem_size, &nelts_op)
11797 0 : && pow2p_hwi (nelts_op)))
11798 : )
11799 : {
11800 0 : {
11801 0 : bool ok = true;
11802 0 : if (known_eq (size, elem_size))
11803 0 : idx = TREE_INT_CST_LOW (VECTOR_CST_ELT (captures[3], idx)) % (2 * nelts);
11804 : else
11805 : {
11806 0 : unsigned start
11807 0 : = TREE_INT_CST_LOW (vector_cst_elt (captures[3], idx)) % (2 * nelts);
11808 0 : unsigned end
11809 0 : = (TREE_INT_CST_LOW (vector_cst_elt (captures[3], idx + nelts_op - 1))
11810 0 : % (2 * nelts));
11811 0 : if ((start < nelts) != (end < nelts))
11812 : ok = false;
11813 : else
11814 0 : for (unsigned HOST_WIDE_INT i = 1; i != nelts_op; i++)
11815 : {
11816 0 : if ((TREE_INT_CST_LOW (vector_cst_elt (captures[3], idx + i))
11817 0 : % (2 * nelts) - 1)
11818 0 : != (TREE_INT_CST_LOW (vector_cst_elt (captures[3], idx + i - 1))
11819 0 : % (2 * nelts)))
11820 : {
11821 : ok = false;
11822 : break;
11823 : }
11824 : }
11825 0 : if (start % nelts_op)
11826 : ok = false;
11827 0 : idx = start;
11828 : }
11829 0 : if (ok
11830 : )
11831 : {
11832 0 : if (idx < nelts
11833 : )
11834 : {
11835 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1965;
11836 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1965;
11837 0 : {
11838 0 : tree res_op0;
11839 0 : res_op0 = captures[1];
11840 0 : tree res_op1;
11841 0 : res_op1 = captures[4];
11842 0 : tree res_op2;
11843 0 : res_op2 = bitsize_int (idx * elem_size);
11844 0 : tree _r;
11845 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11846 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11847 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11848 0 : if (TREE_SIDE_EFFECTS (captures[5]))
11849 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
11850 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1094, __FILE__, __LINE__, true);
11851 0 : return _r;
11852 : }
11853 0 : next_after_fail1965:;
11854 : }
11855 : else
11856 : {
11857 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1966;
11858 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1966;
11859 0 : {
11860 0 : tree res_op0;
11861 0 : res_op0 = captures[2];
11862 0 : tree res_op1;
11863 0 : res_op1 = captures[4];
11864 0 : tree res_op2;
11865 0 : res_op2 = bitsize_int ((idx - nelts) * elem_size);
11866 0 : tree _r;
11867 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11868 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11869 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11870 0 : if (TREE_SIDE_EFFECTS (captures[5]))
11871 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
11872 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1095, __FILE__, __LINE__, true);
11873 0 : return _r;
11874 : }
11875 0 : next_after_fail1966:;
11876 : }
11877 : }
11878 : }
11879 : }
11880 : }
11881 : }
11882 0 : break;
11883 : }
11884 : default:;
11885 : }
11886 : break;
11887 : }
11888 0 : case BIT_INSERT_EXPR:
11889 0 : {
11890 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11891 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11892 0 : tree _q22 = TREE_OPERAND (_p0, 2);
11893 0 : {
11894 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _p1, _p2 };
11895 0 : {
11896 0 : unsigned HOST_WIDE_INT isize;
11897 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1])))
11898 0 : isize = TYPE_PRECISION (TREE_TYPE (captures[1]));
11899 : else
11900 0 : isize = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (captures[1])));
11901 0 : if ((!INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
11902 0 : || type_has_mode_precision_p (TREE_TYPE (captures[1])))
11903 0 : && wi::leu_p (wi::to_wide (captures[2]), wi::to_wide (captures[4]))
11904 0 : && wi::leu_p (wi::to_wide (captures[4]) + wi::to_wide (captures[3]),
11905 0 : wi::to_wide (captures[2]) + isize)
11906 : )
11907 : {
11908 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1967;
11909 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1967;
11910 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1967;
11911 0 : {
11912 0 : tree res_op0;
11913 0 : res_op0 = captures[1];
11914 0 : tree res_op1;
11915 0 : res_op1 = captures[3];
11916 0 : tree res_op2;
11917 0 : res_op2 = wide_int_to_tree (bitsizetype,
11918 0 : wi::to_wide (captures[4])
11919 0 : - wi::to_wide (captures[2]));
11920 0 : tree _r;
11921 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11922 0 : if (TREE_SIDE_EFFECTS (captures[0]))
11923 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
11924 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1096, __FILE__, __LINE__, true);
11925 0 : return _r;
11926 : }
11927 0 : next_after_fail1967:;
11928 : }
11929 : else
11930 : {
11931 0 : if (wi::eq_p (wi::to_wide (captures[2]), wi::to_wide (captures[4]))
11932 0 : && compare_tree_int (captures[3], isize) == 0
11933 : )
11934 : {
11935 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1968;
11936 0 : {
11937 0 : tree res_op0;
11938 0 : res_op0 = captures[1];
11939 0 : tree _r;
11940 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
11941 0 : if (TREE_SIDE_EFFECTS (captures[0]))
11942 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
11943 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11944 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11945 0 : if (TREE_SIDE_EFFECTS (captures[3]))
11946 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
11947 0 : if (TREE_SIDE_EFFECTS (captures[4]))
11948 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
11949 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1097, __FILE__, __LINE__, true);
11950 0 : return _r;
11951 : }
11952 0 : next_after_fail1968:;
11953 : }
11954 : else
11955 : {
11956 0 : if (wi::geu_p (wi::to_wide (captures[2]),
11957 0 : wi::to_wide (captures[4]) + wi::to_wide (captures[3]))
11958 0 : || wi::geu_p (wi::to_wide (captures[4]),
11959 0 : wi::to_wide (captures[2]) + isize)
11960 : )
11961 : {
11962 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1969;
11963 0 : {
11964 0 : tree res_op0;
11965 0 : res_op0 = captures[0];
11966 0 : tree res_op1;
11967 0 : res_op1 = captures[3];
11968 0 : tree res_op2;
11969 0 : res_op2 = captures[4];
11970 0 : tree _r;
11971 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11972 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11973 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11974 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11975 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11976 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1098, __FILE__, __LINE__, true);
11977 0 : return _r;
11978 : }
11979 0 : next_after_fail1969:;
11980 : }
11981 : }
11982 : }
11983 : }
11984 : }
11985 0 : break;
11986 : }
11987 : default:;
11988 : }
11989 : return NULL_TREE;
11990 : }
11991 : #pragma GCC diagnostic pop
|
