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 179886681 : tree_maybe_bit_not (tree t, tree *res_ops)
11 : {
12 179886681 : const tree type = TREE_TYPE (t);
13 179886681 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 179886681 : if (TREE_SIDE_EFFECTS (t)) return false;
15 172025310 : switch (TREE_CODE (t))
16 : {
17 52152685 : case INTEGER_CST:
18 52152685 : {
19 52152685 : {
20 52152685 : tree captures[1] ATTRIBUTE_UNUSED = { t };
21 52152685 : {
22 52152685 : res_ops[0] = captures[0];
23 52152685 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 8, __FILE__, __LINE__, false);
24 : return true;
25 : }
26 : }
27 119872625 : break;
28 : }
29 119872625 : default:;
30 : }
31 119872625 : {
32 119872625 : tree t_pops[1];
33 119872625 : if (tree_bit_not_with_nop (t, t_pops))
34 : {
35 160407 : tree _p0 = t_pops[0];
36 160407 : {
37 160407 : tree captures[2] ATTRIBUTE_UNUSED = { t, _p0 };
38 160407 : {
39 160407 : res_ops[0] = captures[0];
40 160407 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 9, __FILE__, __LINE__, false);
41 160407 : return true;
42 : }
43 : }
44 : }
45 : }
46 119712218 : {
47 119712218 : tree t_pops[1];
48 119712218 : if (tree_maybe_cmp (t, t_pops))
49 : {
50 571246 : tree _p0 = t_pops[0];
51 571246 : {
52 571246 : tree captures[2] ATTRIBUTE_UNUSED = { t, _p0 };
53 571246 : {
54 571246 : res_ops[0] = captures[0];
55 571246 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 10, __FILE__, __LINE__, false);
56 571246 : return true;
57 : }
58 : }
59 : }
60 : }
61 119140972 : {
62 119140972 : tree t_pops[2];
63 119140972 : if (tree_bit_xor_cst (t, t_pops))
64 : {
65 1598 : tree _p0 = t_pops[0];
66 1598 : tree _p1 = t_pops[1];
67 1598 : {
68 1598 : tree captures[3] ATTRIBUTE_UNUSED = { t, _p0, _p1 };
69 1598 : {
70 1598 : res_ops[0] = captures[0];
71 1598 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 11, __FILE__, __LINE__, false);
72 1598 : return true;
73 : }
74 : }
75 : }
76 : }
77 119139374 : return false;
78 : }
79 :
80 : bool
81 2470 : tree_min_value (tree t)
82 : {
83 2470 : const tree type = TREE_TYPE (t);
84 2470 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
85 2470 : if (TREE_SIDE_EFFECTS (t)) return false;
86 2462 : if (uniform_integer_cst_p (t))
87 : {
88 2188 : {
89 2188 : {
90 2188 : tree int_cst = uniform_integer_cst_p (t);
91 2188 : tree inner_type = TREE_TYPE (int_cst);
92 4376 : if ((INTEGRAL_TYPE_P (inner_type)
93 17 : || POINTER_TYPE_P (inner_type))
94 4393 : && wi::eq_p (wi::to_wide (int_cst), wi::min_value (inner_type))
95 : )
96 : {
97 134 : {
98 134 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 41, __FILE__, __LINE__, false);
99 : return true;
100 : }
101 : }
102 : }
103 : }
104 : }
105 : return false;
106 : }
107 :
108 : tree
109 3 : generic_simplify_1 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
110 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
111 : const enum tree_code ARG_UNUSED (op))
112 : {
113 3 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
114 3 : if (!flag_trapping_math
115 : )
116 : {
117 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail72;
118 2 : {
119 2 : tree res_op0;
120 2 : res_op0 = captures[0];
121 2 : tree _r;
122 2 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
123 2 : if (TREE_SIDE_EFFECTS (captures[1]))
124 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
125 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 49, __FILE__, __LINE__, true);
126 : return _r;
127 : }
128 0 : next_after_fail72:;
129 : }
130 : return NULL_TREE;
131 : }
132 :
133 : tree
134 0 : generic_simplify_9 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
135 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
136 : const enum tree_code ARG_UNUSED (bit_op))
137 : {
138 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
139 0 : if (bit_op == BIT_AND_EXPR
140 : )
141 : {
142 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail82;
143 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail82;
144 0 : {
145 0 : tree _r;
146 0 : _r = build_zero_cst (type);
147 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 57, __FILE__, __LINE__, true);
148 : return _r;
149 : }
150 0 : next_after_fail82:;
151 : }
152 : else
153 : {
154 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail83;
155 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail83;
156 0 : {
157 0 : tree _r;
158 0 : _r = build_minus_one_cst (type);
159 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 58, __FILE__, __LINE__, true);
160 : return _r;
161 : }
162 0 : next_after_fail83:;
163 : }
164 : return NULL_TREE;
165 : }
166 :
167 : tree
168 8 : generic_simplify_19 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
169 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
170 : {
171 8 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
172 8 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
173 : )
174 : {
175 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail93;
176 8 : {
177 8 : tree res_op0;
178 8 : {
179 8 : tree _o1[2], _r1;
180 8 : _o1[0] = captures[1];
181 8 : {
182 8 : tree _o2[1], _r2;
183 8 : _o2[0] = captures[0];
184 8 : _r2 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
185 8 : _o1[1] = _r2;
186 : }
187 8 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
188 8 : res_op0 = _r1;
189 : }
190 8 : tree _r;
191 8 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
192 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 68, __FILE__, __LINE__, true);
193 : return _r;
194 : }
195 0 : next_after_fail93:;
196 : }
197 : return NULL_TREE;
198 : }
199 :
200 : tree
201 0 : generic_simplify_28 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
202 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
203 : {
204 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
205 0 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[1]))
206 0 : && tree_nop_conversion_p (type, TREE_TYPE (captures[2]))
207 : )
208 : {
209 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail102;
210 0 : {
211 0 : tree res_op0;
212 0 : {
213 0 : tree _o1[1], _r1;
214 0 : _o1[0] = captures[1];
215 0 : if (TREE_TYPE (_o1[0]) != type)
216 : {
217 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
218 : }
219 : else
220 : _r1 = _o1[0];
221 0 : res_op0 = _r1;
222 : }
223 0 : tree res_op1;
224 0 : {
225 0 : tree _o1[1], _r1;
226 0 : _o1[0] = captures[2];
227 0 : if (TREE_TYPE (_o1[0]) != type)
228 : {
229 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
230 : }
231 : else
232 : _r1 = _o1[0];
233 0 : res_op1 = _r1;
234 : }
235 0 : tree _r;
236 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
237 0 : if (TREE_SIDE_EFFECTS (captures[0]))
238 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
239 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 77, __FILE__, __LINE__, true);
240 : return _r;
241 : }
242 0 : next_after_fail102:;
243 : }
244 : return NULL_TREE;
245 : }
246 :
247 : tree
248 0 : generic_simplify_36 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
249 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
250 : const enum tree_code ARG_UNUSED (op))
251 : {
252 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
253 0 : if (INTEGRAL_TYPE_P (type)
254 0 : && operand_equal_p (captures[2], captures[6], 0)
255 0 : && (tree_nonzero_bits (captures[0]) & tree_nonzero_bits (captures[4])) == 0
256 : )
257 : {
258 0 : {
259 0 : tree t = type;
260 0 : if (!TYPE_OVERFLOW_WRAPS (t))
261 0 : t = unsigned_type_for (t);
262 0 : wide_int c = wi::add (wi::to_wide (captures[3]), wi::to_wide (captures[7]));
263 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail112;
264 0 : if (TREE_SIDE_EFFECTS (captures[7])) goto next_after_fail112;
265 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail112;
266 0 : {
267 0 : tree res_op0;
268 0 : {
269 0 : tree _o1[2], _r1;
270 0 : {
271 0 : tree _o2[1], _r2;
272 0 : _o2[0] = captures[2];
273 0 : if (TREE_TYPE (_o2[0]) != t)
274 : {
275 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, t, _o2[0]);
276 : }
277 : else
278 : _r2 = _o2[0];
279 0 : _o1[0] = _r2;
280 : }
281 0 : _o1[1] = wide_int_to_tree (t, c);
282 0 : _r1 = fold_build2_loc (loc, MULT_EXPR, t, _o1[0], _o1[1]);
283 0 : res_op0 = _r1;
284 : }
285 0 : tree _r;
286 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
287 0 : if (TREE_SIDE_EFFECTS (captures[6]))
288 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[6]), _r);
289 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 85, __FILE__, __LINE__, true);
290 0 : return _r;
291 : }
292 0 : next_after_fail112:;
293 0 : }
294 : }
295 : return NULL_TREE;
296 : }
297 :
298 : tree
299 611 : generic_simplify_45 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
300 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
301 : const enum tree_code ARG_UNUSED (op))
302 : {
303 611 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
304 1222 : if (INTEGRAL_TYPE_P (type)
305 609 : && tree_int_cst_sgn (captures[2]) > 0
306 2438 : && (tree_nonzero_bits (captures[0]) & tree_nonzero_bits (captures[1])) == 0
307 : )
308 : {
309 6 : {
310 6 : tree t = type;
311 6 : if (!TYPE_OVERFLOW_WRAPS (t))
312 6 : t = unsigned_type_for (t);
313 6 : wide_int wone = wi::one (TYPE_PRECISION (t));
314 6 : wide_int c = wi::add (wi::lshift (wone, wi::to_wide (captures[2])), wone);
315 6 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail122;
316 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail122;
317 6 : {
318 6 : tree res_op0;
319 6 : {
320 6 : tree _o1[2], _r1;
321 6 : {
322 6 : tree _o2[1], _r2;
323 6 : _o2[0] = captures[1];
324 6 : if (TREE_TYPE (_o2[0]) != t)
325 : {
326 6 : _r2 = fold_build1_loc (loc, NOP_EXPR, t, _o2[0]);
327 : }
328 : else
329 : _r2 = _o2[0];
330 6 : _o1[0] = _r2;
331 : }
332 6 : _o1[1] = wide_int_to_tree (t, c);
333 6 : _r1 = fold_build2_loc (loc, MULT_EXPR, t, _o1[0], _o1[1]);
334 6 : res_op0 = _r1;
335 : }
336 6 : tree _r;
337 6 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
338 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 92, __FILE__, __LINE__, true);
339 6 : return _r;
340 : }
341 0 : next_after_fail122:;
342 6 : }
343 : }
344 : return NULL_TREE;
345 : }
346 :
347 : tree
348 1 : generic_simplify_60 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
349 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
350 : {
351 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
352 1 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail140;
353 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail140;
354 1 : {
355 1 : tree res_op0;
356 1 : res_op0 = captures[3];
357 1 : tree res_op1;
358 1 : {
359 1 : tree _o1[2], _r1;
360 1 : {
361 1 : tree _o2[2], _r2;
362 1 : _o2[0] = captures[0];
363 1 : _o2[1] = captures[2];
364 1 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
365 1 : _o1[0] = _r2;
366 : }
367 1 : _o1[1] = captures[1];
368 1 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
369 1 : res_op1 = _r1;
370 : }
371 1 : tree _r;
372 1 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
373 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 107, __FILE__, __LINE__, true);
374 : return _r;
375 : }
376 1 : next_after_fail140:;
377 : return NULL_TREE;
378 : }
379 :
380 : tree
381 7 : generic_simplify_70 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
382 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
383 : {
384 7 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
385 7 : if (!TYPE_SATURATING (type)
386 : )
387 : {
388 7 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
389 14 : && !FIXED_POINT_TYPE_P (type)
390 : )
391 : {
392 7 : if (TYPE_OVERFLOW_UNDEFINED (type)
393 14 : && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[0]))
394 : )
395 : {
396 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail158;
397 7 : {
398 7 : tree res_op0;
399 7 : res_op0 = captures[2];
400 7 : tree res_op1;
401 7 : res_op1 = captures[1];
402 7 : tree _r;
403 7 : _r = fold_build2_loc (loc, POINTER_DIFF_EXPR, type, res_op0, res_op1);
404 7 : if (TREE_SIDE_EFFECTS (captures[0]))
405 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
406 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 126, __FILE__, __LINE__, true);
407 : return _r;
408 : }
409 0 : next_after_fail158:;
410 : }
411 : }
412 : }
413 : return NULL_TREE;
414 : }
415 :
416 : tree
417 3844755 : generic_simplify_77 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
418 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
419 : {
420 3844755 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
421 3844755 : if (!TYPE_SATURATING (type)
422 3844755 : && (!FLOAT_TYPE_P (type) || flag_associative_math)
423 : )
424 : {
425 3844755 : if (!ALL_FRACT_MODE_P (TYPE_MODE (type))
426 : )
427 : {
428 7689510 : if (TREE_CODE (type) == INTEGER_TYPE
429 3844755 : && wi::neg_p (wi::to_wide (captures[3]))
430 8708561 : && wi::to_wide (captures[3]) != wi::min_value (TYPE_PRECISION (type), SIGNED)
431 : )
432 : {
433 1012790 : {
434 1012790 : wide_int c0 = wi::to_wide (captures[1]);
435 1012790 : wide_int c2 = wi::to_wide (captures[3]);
436 1012790 : wide_int c2_abs = wi::abs (c2);
437 1012790 : if (wi::multiple_of_p (c2_abs, c0, TYPE_SIGN (type))
438 : )
439 : {
440 462722 : {
441 462722 : wide_int div_res = wi::sdiv_trunc (c2, c0);
442 462722 : tree div_cst = wide_int_to_tree (type, div_res);
443 462722 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail166;
444 462722 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail166;
445 462722 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail166;
446 462722 : {
447 462722 : tree res_op0;
448 462722 : {
449 462722 : tree _o1[2], _r1;
450 462722 : _o1[0] = captures[2];
451 462722 : _o1[1] = div_cst;
452 462722 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
453 462722 : res_op0 = _r1;
454 : }
455 462722 : tree res_op1;
456 462722 : res_op1 = captures[1];
457 462722 : tree _r;
458 462722 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
459 462722 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 134, __FILE__, __LINE__, true);
460 462722 : return _r;
461 : }
462 0 : next_after_fail166:;
463 462722 : }
464 : }
465 1012790 : }
466 : }
467 : }
468 : }
469 : return NULL_TREE;
470 : }
471 :
472 : tree
473 4 : generic_simplify_87 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
474 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
475 : const enum tree_code ARG_UNUSED (log1),
476 : const enum tree_code ARG_UNUSED (log2),
477 : const combined_fn ARG_UNUSED (popcount))
478 : {
479 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
480 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail177;
481 4 : {
482 4 : tree res_op0;
483 4 : {
484 4 : tree _o1[2], _r1;
485 4 : _o1[0] = captures[2];
486 4 : _o1[1] = captures[5];
487 4 : _r1 = fold_build2_loc (loc, log2, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
488 4 : res_op0 = _r1;
489 : }
490 4 : tree _r;
491 4 : _r = maybe_build_call_expr_loc (loc, popcount, type, 1, res_op0);
492 4 : if (!_r)
493 0 : goto next_after_fail177;
494 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 145, __FILE__, __LINE__, true);
495 : return _r;
496 : }
497 4 : next_after_fail177:;
498 : return NULL_TREE;
499 : }
500 :
501 : tree
502 21 : generic_simplify_93 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
503 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
504 : {
505 21 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
506 21 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail183;
507 21 : {
508 21 : tree res_op0;
509 21 : {
510 21 : tree _o1[2], _r1;
511 21 : _o1[0] = captures[1];
512 21 : _o1[1] = unshare_expr (captures[2]);
513 21 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
514 21 : res_op0 = _r1;
515 : }
516 21 : tree res_op1;
517 21 : res_op1 = captures[2];
518 21 : tree _r;
519 21 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
520 21 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 151, __FILE__, __LINE__, true);
521 : return _r;
522 : }
523 0 : next_after_fail183:;
524 0 : return NULL_TREE;
525 : }
526 :
527 : tree
528 0 : generic_simplify_99 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
529 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
530 : const enum tree_code ARG_UNUSED (minmax),
531 : const enum tree_code ARG_UNUSED (maxmin))
532 : {
533 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
534 0 : if ((ANY_INTEGRAL_TYPE_P (type)
535 0 : && !TYPE_OVERFLOW_SANITIZED (type) && !TYPE_OVERFLOW_TRAPS (type))
536 0 : || (FLOAT_TYPE_P (type)
537 0 : && flag_associative_math
538 0 : && !HONOR_SIGNED_ZEROS (type)
539 0 : && !flag_trapping_math)
540 : )
541 : {
542 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail189;
543 0 : {
544 0 : tree res_op0;
545 0 : res_op0 = captures[0];
546 0 : tree res_op1;
547 0 : res_op1 = captures[1];
548 0 : tree _r;
549 0 : _r = fold_build2_loc (loc, maxmin, type, res_op0, res_op1);
550 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 157, __FILE__, __LINE__, true);
551 : return _r;
552 : }
553 0 : next_after_fail189:;
554 : }
555 : return NULL_TREE;
556 : }
557 :
558 : tree
559 0 : generic_simplify_108 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
560 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
561 : {
562 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
563 0 : if (!TYPE_SATURATING (type)
564 : )
565 : {
566 0 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
567 0 : && !FIXED_POINT_TYPE_P (type)
568 : )
569 : {
570 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail200;
571 0 : {
572 0 : tree res_op0;
573 0 : res_op0 = captures[1];
574 0 : tree res_op1;
575 0 : res_op1 = captures[2];
576 0 : tree _r;
577 0 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
578 0 : if (TREE_SIDE_EFFECTS (captures[0]))
579 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
580 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 167, __FILE__, __LINE__, true);
581 : return _r;
582 : }
583 0 : next_after_fail200:;
584 : }
585 : }
586 : return NULL_TREE;
587 : }
588 :
589 : tree
590 9 : generic_simplify_114 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
591 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
592 : {
593 9 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
594 9 : if (INTEGRAL_TYPE_P (type)
595 9 : && (
596 :
597 9 : || !TREE_SIDE_EFFECTS (captures[1]))
598 : )
599 : {
600 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail210;
601 2 : {
602 2 : tree res_op0;
603 2 : {
604 2 : tree _o1[1], _r1;
605 2 : _o1[0] = captures[2];
606 2 : if (TREE_TYPE (_o1[0]) != boolean_type_node)
607 : {
608 2 : _r1 = fold_build1_loc (loc, NOP_EXPR, boolean_type_node, _o1[0]);
609 : }
610 : else
611 : _r1 = _o1[0];
612 2 : res_op0 = _r1;
613 : }
614 2 : tree res_op1;
615 2 : res_op1 = captures[1];
616 2 : tree res_op2;
617 2 : res_op2 = captures[0];
618 2 : tree _r;
619 2 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
620 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 177, __FILE__, __LINE__, true);
621 : return _r;
622 : }
623 0 : next_after_fail210:;
624 : }
625 : return NULL_TREE;
626 : }
627 :
628 : tree
629 17 : generic_simplify_120 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
630 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
631 : const enum tree_code ARG_UNUSED (bitop))
632 : {
633 17 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
634 17 : if (INTEGRAL_TYPE_P (type)
635 17 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
636 17 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
637 17 : && TYPE_UNSIGNED (TREE_TYPE (captures[0])) != TYPE_UNSIGNED (TREE_TYPE (captures[1]))
638 17 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == TYPE_PRECISION (TREE_TYPE (captures[1]))
639 34 : && TYPE_PRECISION (TREE_TYPE (captures[0])) <= TYPE_PRECISION (type)
640 : )
641 : {
642 17 : if ((bitop == BIT_AND_EXPR) == TYPE_UNSIGNED (TREE_TYPE (captures[0]))
643 : )
644 : {
645 16 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail217;
646 16 : {
647 16 : tree res_op0;
648 16 : res_op0 = captures[0];
649 16 : tree _r;
650 16 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
651 16 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 182, __FILE__, __LINE__, true);
652 : return _r;
653 : }
654 0 : next_after_fail217:;
655 : }
656 : else
657 : {
658 1 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail218;
659 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail218;
660 1 : {
661 1 : tree res_op0;
662 1 : res_op0 = captures[1];
663 1 : tree _r;
664 1 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
665 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 183, __FILE__, __LINE__, true);
666 : return _r;
667 : }
668 17 : next_after_fail218:;
669 : }
670 : }
671 : return NULL_TREE;
672 : }
673 :
674 : tree
675 0 : generic_simplify_128 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
676 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
677 : {
678 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
679 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail228;
680 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail228;
681 0 : {
682 0 : tree _r;
683 0 : _r = captures[2];
684 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 192, __FILE__, __LINE__, true);
685 : return _r;
686 : }
687 0 : next_after_fail228:;
688 : return NULL_TREE;
689 : }
690 :
691 : tree
692 0 : generic_simplify_135 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
693 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
694 : const enum tree_code ARG_UNUSED (op))
695 : {
696 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
697 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail235;
698 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail235;
699 0 : {
700 0 : tree _r;
701 0 : _r = captures[0];
702 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 196, __FILE__, __LINE__, true);
703 : return _r;
704 : }
705 0 : next_after_fail235:;
706 : return NULL_TREE;
707 : }
708 :
709 : tree
710 253 : generic_simplify_140 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
711 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
712 : const enum tree_code ARG_UNUSED (bitop))
713 : {
714 253 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
715 253 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail240;
716 253 : {
717 253 : tree res_op0;
718 253 : res_op0 = captures[0];
719 253 : tree _r;
720 253 : _r = non_lvalue_loc (loc, res_op0);
721 253 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 200, __FILE__, __LINE__, true);
722 : return _r;
723 : }
724 0 : next_after_fail240:;
725 0 : return NULL_TREE;
726 : }
727 :
728 : tree
729 0 : generic_simplify_150 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
730 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
731 : const enum tree_code ARG_UNUSED (op))
732 : {
733 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
734 0 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[3]))
735 0 : && tree_nop_conversion_p (type, TREE_TYPE (captures[6]))
736 : )
737 : {
738 0 : if (single_use (captures[4]) && single_use (captures[5])
739 : )
740 : {
741 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail252;
742 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail252;
743 0 : {
744 0 : tree res_op0;
745 0 : res_op0 = captures[0];
746 0 : tree res_op1;
747 0 : {
748 0 : tree _o1[1], _r1;
749 0 : _o1[0] = captures[6];
750 0 : if (TREE_TYPE (_o1[0]) != type)
751 : {
752 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
753 : }
754 : else
755 : _r1 = _o1[0];
756 0 : res_op1 = _r1;
757 : }
758 0 : tree _r;
759 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
760 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 206, __FILE__, __LINE__, true);
761 : return _r;
762 : }
763 0 : next_after_fail252:;
764 : }
765 : else
766 : {
767 : if (single_use (captures[0]) && single_use (captures[1])
768 : )
769 : {
770 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail253;
771 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail253;
772 : {
773 : tree res_op0;
774 : {
775 : tree _o1[1], _r1;
776 : _o1[0] = captures[3];
777 : if (TREE_TYPE (_o1[0]) != type)
778 : {
779 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
780 : }
781 : else
782 : _r1 = _o1[0];
783 : res_op0 = _r1;
784 : }
785 : tree res_op1;
786 : res_op1 = captures[4];
787 : tree _r;
788 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
789 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 207, __FILE__, __LINE__, true);
790 : return _r;
791 : }
792 0 : next_after_fail253:;
793 : }
794 : }
795 : }
796 : return NULL_TREE;
797 : }
798 :
799 : tree
800 4 : generic_simplify_165 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
801 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
802 : {
803 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
804 4 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail273;
805 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail273;
806 4 : {
807 4 : tree _r;
808 4 : _r = captures[2];
809 4 : if (TREE_SIDE_EFFECTS (captures[1]))
810 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
811 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 220, __FILE__, __LINE__, true);
812 : return _r;
813 : }
814 4 : next_after_fail273:;
815 : return NULL_TREE;
816 : }
817 :
818 : tree
819 469 : generic_simplify_169 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
820 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
821 : const enum tree_code ARG_UNUSED (code2),
822 : const enum tree_code ARG_UNUSED (code1))
823 : {
824 469 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
825 469 : if ((TREE_CODE (captures[2]) == INTEGER_CST
826 437 : && TREE_CODE (captures[5]) == INTEGER_CST)
827 469 : || ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
828 3 : || (VECTOR_TYPE_P (TREE_TYPE (captures[2])))
829 0 : || POINTER_TYPE_P (TREE_TYPE (captures[2])))
830 32 : && bitwise_equal_p (captures[2], captures[5]))
831 : )
832 : {
833 439 : {
834 439 : bool one_before = false;
835 439 : bool one_after = false;
836 439 : int cmp = 0;
837 439 : bool allbits = true;
838 439 : if (TREE_CODE (captures[2]) == INTEGER_CST
839 437 : && TREE_CODE (captures[5]) == INTEGER_CST)
840 : {
841 437 : allbits = TYPE_PRECISION (TREE_TYPE (captures[2])) <= TYPE_PRECISION (TREE_TYPE (captures[5]));
842 437 : auto t1 = wi::to_wide (fold_convert (TREE_TYPE (captures[5]), captures[2]));
843 437 : auto t2 = wi::to_wide (captures[5]);
844 437 : cmp = wi::cmp (t1, t2, TYPE_SIGN (TREE_TYPE (captures[5])));
845 437 : if (cmp < 0
846 437 : && t1 == t2 - 1)
847 : one_before = true;
848 437 : if (cmp > 0
849 437 : && t1 == t2 + 1)
850 : one_after = true;
851 : }
852 439 : bool val;
853 439 : switch (code2)
854 : {
855 423 : case EQ_EXPR: val = (cmp == 0); break;
856 0 : case NE_EXPR: val = (cmp != 0); break;
857 2 : case LT_EXPR: val = (cmp < 0); break;
858 0 : case GT_EXPR: val = (cmp > 0); break;
859 14 : case LE_EXPR: val = (cmp <= 0); break;
860 0 : case GE_EXPR: val = (cmp >= 0); break;
861 0 : default: gcc_unreachable ();
862 : }
863 439 : if (code1 == EQ_EXPR && val
864 : )
865 : {
866 7 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail283;
867 7 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail283;
868 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail283;
869 7 : {
870 7 : tree _r;
871 7 : _r = captures[3];
872 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 223, __FILE__, __LINE__, true);
873 : return _r;
874 : }
875 469 : next_after_fail283:;
876 : }
877 : else
878 : {
879 432 : if (code1 == NE_EXPR && val && allbits
880 : )
881 : {
882 7 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail284;
883 7 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail284;
884 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail284;
885 7 : {
886 7 : tree _r;
887 7 : _r = constant_boolean_node (true, type);
888 7 : if (TREE_SIDE_EFFECTS (captures[4]))
889 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
890 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 224, __FILE__, __LINE__, true);
891 : return _r;
892 : }
893 469 : next_after_fail284:;
894 : }
895 : else
896 : {
897 425 : if (code1 == NE_EXPR && !val && allbits
898 : )
899 : {
900 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail285;
901 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail285;
902 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail285;
903 0 : {
904 0 : tree _r;
905 0 : _r = captures[0];
906 0 : if (TREE_SIDE_EFFECTS (captures[4]))
907 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
908 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 225, __FILE__, __LINE__, true);
909 : return _r;
910 : }
911 469 : next_after_fail285:;
912 : }
913 : else
914 : {
915 425 : if (code1 == EQ_EXPR
916 425 : && code2 == GT_EXPR
917 0 : && cmp == 0
918 0 : && allbits
919 425 : && ((VECTOR_BOOLEAN_TYPE_P (type)
920 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GE_EXPR))
921 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
922 : )
923 : {
924 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail286;
925 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail286;
926 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail286;
927 0 : {
928 0 : tree res_op0;
929 0 : res_op0 = captures[4];
930 0 : tree res_op1;
931 0 : res_op1 = captures[5];
932 0 : tree _r;
933 0 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
934 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 226, __FILE__, __LINE__, true);
935 : return _r;
936 : }
937 469 : next_after_fail286:;
938 : }
939 : else
940 : {
941 425 : if (code1 == EQ_EXPR
942 425 : && code2 == LT_EXPR
943 2 : && cmp == 0
944 2 : && allbits
945 427 : && ((VECTOR_BOOLEAN_TYPE_P (type)
946 2 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LE_EXPR))
947 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
948 : )
949 : {
950 2 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail287;
951 2 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail287;
952 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail287;
953 2 : {
954 2 : tree res_op0;
955 2 : res_op0 = captures[4];
956 2 : tree res_op1;
957 2 : res_op1 = captures[5];
958 2 : tree _r;
959 2 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
960 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 227, __FILE__, __LINE__, true);
961 : return _r;
962 : }
963 469 : next_after_fail287:;
964 : }
965 : else
966 : {
967 423 : if (code1 == EQ_EXPR
968 423 : && code2 == GE_EXPR
969 : && one_before
970 0 : && allbits
971 423 : && ((VECTOR_BOOLEAN_TYPE_P (type)
972 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GE_EXPR))
973 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
974 : )
975 : {
976 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail288;
977 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail288;
978 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail288;
979 0 : {
980 0 : tree res_op0;
981 0 : res_op0 = captures[4];
982 0 : tree res_op1;
983 0 : {
984 0 : tree _o1[1], _r1;
985 0 : _o1[0] = captures[2];
986 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
987 : {
988 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
989 : }
990 : else
991 : _r1 = _o1[0];
992 0 : res_op1 = _r1;
993 : }
994 0 : tree _r;
995 0 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
996 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 228, __FILE__, __LINE__, true);
997 : return _r;
998 : }
999 469 : next_after_fail288:;
1000 : }
1001 : else
1002 : {
1003 423 : if (code1 == EQ_EXPR
1004 423 : && code2 == LE_EXPR
1005 : && one_after
1006 0 : && allbits
1007 423 : && ((VECTOR_BOOLEAN_TYPE_P (type)
1008 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LE_EXPR))
1009 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
1010 : )
1011 : {
1012 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail289;
1013 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail289;
1014 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail289;
1015 0 : {
1016 0 : tree res_op0;
1017 0 : res_op0 = captures[4];
1018 0 : tree res_op1;
1019 0 : {
1020 0 : tree _o1[1], _r1;
1021 0 : _o1[0] = captures[2];
1022 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
1023 : {
1024 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
1025 : }
1026 : else
1027 : _r1 = _o1[0];
1028 0 : res_op1 = _r1;
1029 : }
1030 0 : tree _r;
1031 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1032 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 229, __FILE__, __LINE__, true);
1033 : return _r;
1034 : }
1035 469 : next_after_fail289:;
1036 : }
1037 : }
1038 : }
1039 : }
1040 : }
1041 : }
1042 : }
1043 : }
1044 : }
1045 : return NULL_TREE;
1046 : }
1047 :
1048 : tree
1049 9 : generic_simplify_214 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1050 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1051 : const combined_fn ARG_UNUSED (LDEXP))
1052 : {
1053 9 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1054 9 : if (flag_unsafe_math_optimizations
1055 : )
1056 : {
1057 9 : if (real_equal (TREE_REAL_CST_PTR (captures[1]), &dconst1)
1058 : )
1059 : {
1060 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail358;
1061 9 : {
1062 9 : tree res_op0;
1063 9 : res_op0 = captures[0];
1064 9 : tree res_op1;
1065 9 : res_op1 = captures[2];
1066 9 : tree _r;
1067 9 : _r = maybe_build_call_expr_loc (loc, LDEXP, type, 2, res_op0, res_op1);
1068 9 : if (!_r)
1069 0 : goto next_after_fail358;
1070 9 : if (TREE_SIDE_EFFECTS (captures[1]))
1071 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1072 9 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 270, __FILE__, __LINE__, true);
1073 : return _r;
1074 : }
1075 9 : next_after_fail358:;
1076 : }
1077 : }
1078 : return NULL_TREE;
1079 : }
1080 :
1081 : tree
1082 12 : generic_simplify_222 (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 12 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1087 12 : if (element_precision (captures[0]) >= element_precision (captures[1])
1088 12 : && types_match (captures[1], captures[3])
1089 : )
1090 : {
1091 12 : if (wi::lt_p (wi::to_wide (captures[2]), 0, TYPE_SIGN (TREE_TYPE (captures[2])))
1092 : )
1093 : {
1094 0 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1095 : )
1096 : {
1097 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail366;
1098 0 : {
1099 0 : tree res_op0;
1100 0 : res_op0 = captures[3];
1101 0 : tree res_op1;
1102 0 : res_op1 = captures[1];
1103 0 : tree _r;
1104 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1105 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1106 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1107 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 278, __FILE__, __LINE__, true);
1108 : return _r;
1109 : }
1110 0 : next_after_fail366:;
1111 : }
1112 : else
1113 : {
1114 0 : if (tree_expr_nonzero_p (captures[1]) && tree_expr_nonzero_p (captures[3])
1115 : )
1116 : {
1117 0 : {
1118 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[1]));
1119 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail367;
1120 0 : {
1121 0 : tree res_op0;
1122 0 : {
1123 0 : tree _o1[1], _r1;
1124 0 : _o1[0] = captures[3];
1125 0 : if (TREE_TYPE (_o1[0]) != utype)
1126 : {
1127 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, utype, _o1[0]);
1128 : }
1129 : else
1130 : _r1 = _o1[0];
1131 0 : res_op0 = _r1;
1132 : }
1133 0 : tree res_op1;
1134 0 : {
1135 0 : tree _o1[1], _r1;
1136 0 : _o1[0] = captures[1];
1137 0 : if (TREE_TYPE (_o1[0]) != utype)
1138 : {
1139 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, utype, _o1[0]);
1140 : }
1141 : else
1142 : _r1 = _o1[0];
1143 0 : res_op1 = _r1;
1144 : }
1145 0 : tree _r;
1146 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1147 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1148 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1149 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 279, __FILE__, __LINE__, true);
1150 : return _r;
1151 : }
1152 0 : next_after_fail367:;
1153 : }
1154 : }
1155 : }
1156 : }
1157 : else
1158 : {
1159 12 : if (wi::gt_p (wi::to_wide (captures[2]), 1, TYPE_SIGN (TREE_TYPE (captures[2])))
1160 : )
1161 : {
1162 12 : if (TYPE_UNSIGNED (TREE_TYPE (captures[1])) || !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1163 : )
1164 : {
1165 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail368;
1166 12 : {
1167 12 : tree res_op0;
1168 12 : res_op0 = captures[1];
1169 12 : tree res_op1;
1170 12 : res_op1 = captures[3];
1171 12 : tree _r;
1172 12 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1173 12 : if (TREE_SIDE_EFFECTS (captures[2]))
1174 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1175 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 280, __FILE__, __LINE__, true);
1176 : return _r;
1177 : }
1178 0 : next_after_fail368:;
1179 : }
1180 : else
1181 : {
1182 0 : {
1183 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[1]));
1184 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail369;
1185 0 : {
1186 0 : tree res_op0;
1187 0 : {
1188 0 : tree _o1[1], _r1;
1189 0 : _o1[0] = captures[1];
1190 0 : if (TREE_TYPE (_o1[0]) != utype)
1191 : {
1192 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, utype, _o1[0]);
1193 : }
1194 : else
1195 : _r1 = _o1[0];
1196 0 : res_op0 = _r1;
1197 : }
1198 0 : tree res_op1;
1199 0 : {
1200 0 : tree _o1[1], _r1;
1201 0 : _o1[0] = captures[3];
1202 0 : if (TREE_TYPE (_o1[0]) != utype)
1203 : {
1204 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, utype, _o1[0]);
1205 : }
1206 : else
1207 : _r1 = _o1[0];
1208 0 : res_op1 = _r1;
1209 : }
1210 0 : tree _r;
1211 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1212 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1213 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1214 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 281, __FILE__, __LINE__, true);
1215 : return _r;
1216 : }
1217 0 : next_after_fail369:;
1218 : }
1219 : }
1220 : }
1221 : }
1222 : }
1223 : return NULL_TREE;
1224 : }
1225 :
1226 : tree
1227 8 : generic_simplify_252 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1228 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1229 : const enum tree_code ARG_UNUSED (cmp),
1230 : const enum tree_code ARG_UNUSED (icmp))
1231 : {
1232 8 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1233 8 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1234 : )
1235 : {
1236 8 : {
1237 8 : int c = wi::exact_log2 (wi::to_wide (captures[1]));
1238 8 : if (wi::fits_to_tree_p (wi::shwi (c, HOST_BITS_PER_INT), TREE_TYPE (captures[0]))
1239 : )
1240 : {
1241 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail417;
1242 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail417;
1243 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail417;
1244 0 : {
1245 0 : tree res_op0;
1246 0 : res_op0 = captures[0];
1247 0 : tree res_op1;
1248 0 : res_op1 = wide_int_to_tree (TREE_TYPE (captures[0]), c);
1249 0 : tree _r;
1250 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
1251 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 327, __FILE__, __LINE__, true);
1252 8 : return _r;
1253 : }
1254 8 : next_after_fail417:;
1255 : }
1256 : }
1257 : }
1258 : return NULL_TREE;
1259 : }
1260 :
1261 : tree
1262 124 : generic_simplify_258 (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 (rotate),
1265 : const enum tree_code ARG_UNUSED (invrot),
1266 : const enum tree_code ARG_UNUSED (cmp))
1267 : {
1268 124 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1269 124 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail432;
1270 124 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail432;
1271 124 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail432;
1272 124 : {
1273 124 : tree res_op0;
1274 124 : res_op0 = captures[0];
1275 124 : tree res_op1;
1276 124 : res_op1 = const_binop (invrot, TREE_TYPE (captures[0]), captures[2], captures[1]);
1277 124 : tree _r;
1278 124 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1279 124 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 342, __FILE__, __LINE__, true);
1280 : return _r;
1281 : }
1282 124 : next_after_fail432:;
1283 : return NULL_TREE;
1284 : }
1285 :
1286 : tree
1287 182 : generic_simplify_263 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1288 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1289 : const enum tree_code ARG_UNUSED (cmp),
1290 : const enum tree_code ARG_UNUSED (icmp),
1291 : const enum tree_code ARG_UNUSED (ncmp))
1292 : {
1293 182 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1294 182 : if (types_match (type, TREE_TYPE (captures[0]))
1295 : )
1296 : {
1297 125 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail437;
1298 125 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail437;
1299 125 : {
1300 125 : tree res_op0;
1301 125 : res_op0 = captures[1];
1302 125 : tree res_op1;
1303 125 : res_op1 = captures[2];
1304 125 : tree _r;
1305 125 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1306 125 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 347, __FILE__, __LINE__, true);
1307 : return _r;
1308 : }
1309 182 : next_after_fail437:;
1310 : }
1311 : return NULL_TREE;
1312 : }
1313 :
1314 : tree
1315 47286680 : generic_simplify_270 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1316 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1317 : const enum tree_code ARG_UNUSED (cmp))
1318 : {
1319 47286680 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1320 47286680 : {
1321 47286680 : bool wascmp;
1322 47286680 : if (types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
1323 47286680 : && bitwise_inverted_equal_p (captures[0], captures[1], wascmp)
1324 : )
1325 : {
1326 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail450;
1327 6 : {
1328 6 : tree _r;
1329 6 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1330 6 : if (TREE_SIDE_EFFECTS (captures[0]))
1331 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1332 6 : if (TREE_SIDE_EFFECTS (captures[1]))
1333 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1334 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 359, __FILE__, __LINE__, true);
1335 6 : return _r;
1336 : }
1337 0 : next_after_fail450:;
1338 : }
1339 : }
1340 47286674 : return NULL_TREE;
1341 : }
1342 :
1343 : tree
1344 8893 : generic_simplify_275 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1345 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1346 : const enum tree_code ARG_UNUSED (op),
1347 : const enum tree_code ARG_UNUSED (cmp))
1348 : {
1349 8893 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1350 8893 : if (flag_unsafe_math_optimizations
1351 : )
1352 : {
1353 5 : {
1354 8 : tree tem = const_binop (op == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR,
1355 5 : TREE_TYPE (captures[1]), captures[2], captures[1]);
1356 5 : if (tem && !TREE_OVERFLOW (tem)
1357 : )
1358 : {
1359 4 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail469;
1360 4 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail469;
1361 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail469;
1362 4 : {
1363 4 : tree res_op0;
1364 4 : res_op0 = captures[0];
1365 4 : tree res_op1;
1366 4 : res_op1 = tem;
1367 4 : tree _r;
1368 4 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1369 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 377, __FILE__, __LINE__, true);
1370 : return _r;
1371 : }
1372 8893 : next_after_fail469:;
1373 : }
1374 : }
1375 : }
1376 : return NULL_TREE;
1377 : }
1378 :
1379 : tree
1380 69 : generic_simplify_281 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1381 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1382 : const enum tree_code ARG_UNUSED (cmp))
1383 : {
1384 69 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1385 69 : if (!integer_zerop (captures[1])
1386 : )
1387 : {
1388 69 : if (wi::to_wide (captures[2]) == 0
1389 : )
1390 : {
1391 22 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail500;
1392 22 : {
1393 22 : tree res_op0;
1394 22 : res_op0 = captures[0];
1395 22 : tree res_op1;
1396 22 : res_op1 = captures[2];
1397 22 : tree _r;
1398 22 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1399 22 : if (TREE_SIDE_EFFECTS (captures[1]))
1400 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1401 22 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 408, __FILE__, __LINE__, true);
1402 : return _r;
1403 : }
1404 0 : next_after_fail500:;
1405 : }
1406 : else
1407 : {
1408 47 : if (TREE_CODE (captures[1]) == INTEGER_CST
1409 : )
1410 : {
1411 47 : {
1412 47 : wi::overflow_type ovf;
1413 47 : wide_int prod = wi::mul (wi::to_wide (captures[2]), wi::to_wide (captures[1]),
1414 94 : TYPE_SIGN (TREE_TYPE (captures[1])), &ovf);
1415 47 : if (ovf
1416 : )
1417 : {
1418 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail501;
1419 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail501;
1420 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail501;
1421 0 : {
1422 0 : tree _r;
1423 0 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1424 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1425 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1426 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 409, __FILE__, __LINE__, true);
1427 : return _r;
1428 : }
1429 0 : next_after_fail501:;
1430 : }
1431 : else
1432 : {
1433 47 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail502;
1434 47 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail502;
1435 47 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail502;
1436 47 : {
1437 47 : tree res_op0;
1438 47 : res_op0 = captures[0];
1439 47 : tree res_op1;
1440 47 : res_op1 = wide_int_to_tree (TREE_TYPE (captures[0]), prod);
1441 47 : tree _r;
1442 47 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1443 47 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 410, __FILE__, __LINE__, true);
1444 : return _r;
1445 : }
1446 0 : next_after_fail502:;
1447 : }
1448 47 : }
1449 : }
1450 : }
1451 : }
1452 : return NULL_TREE;
1453 : }
1454 :
1455 : tree
1456 27485 : generic_simplify_288 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1457 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1458 : const enum tree_code ARG_UNUSED (cmp))
1459 : {
1460 27485 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1461 27485 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail526;
1462 27485 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail526;
1463 27485 : {
1464 27485 : tree res_op0;
1465 27485 : res_op0 = captures[0];
1466 27485 : tree res_op1;
1467 27485 : res_op1 = captures[1];
1468 27485 : tree _r;
1469 27485 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1470 27485 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 426, __FILE__, __LINE__, true);
1471 : return _r;
1472 : }
1473 27485 : next_after_fail526:;
1474 : return NULL_TREE;
1475 : }
1476 :
1477 : tree
1478 0 : generic_simplify_291 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1479 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1480 : const enum tree_code ARG_UNUSED (cmp))
1481 : {
1482 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1483 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
1484 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1485 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1486 0 : && TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (TREE_TYPE (captures[2]))
1487 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (TREE_TYPE (captures[1]))
1488 0 : && !wi::neg_p (wi::to_wide (captures[3]))
1489 : )
1490 : {
1491 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail529;
1492 0 : {
1493 0 : tree res_op0;
1494 0 : {
1495 0 : tree _o1[2], _r1;
1496 0 : _o1[0] = captures[2];
1497 0 : {
1498 0 : tree _o2[1], _r2;
1499 0 : {
1500 0 : tree _o3[1], _r3;
1501 0 : _o3[0] = captures[3];
1502 0 : _r3 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o3[0]), _o3[0]);
1503 0 : _o2[0] = _r3;
1504 : }
1505 0 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
1506 : {
1507 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
1508 : }
1509 : else
1510 : _r2 = _o2[0];
1511 0 : _o1[1] = _r2;
1512 : }
1513 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1514 0 : res_op0 = _r1;
1515 : }
1516 0 : tree res_op1;
1517 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[2]));
1518 0 : tree _r;
1519 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1520 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 429, __FILE__, __LINE__, true);
1521 : return _r;
1522 : }
1523 0 : next_after_fail529:;
1524 : }
1525 : return NULL_TREE;
1526 : }
1527 :
1528 : tree
1529 0 : generic_simplify_298 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1530 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1531 : const enum tree_code ARG_UNUSED (cmp),
1532 : const enum tree_code ARG_UNUSED (icmp))
1533 : {
1534 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1535 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail536;
1536 0 : {
1537 0 : tree res_op0;
1538 0 : {
1539 0 : tree _o1[2], _r1;
1540 0 : _o1[0] = captures[0];
1541 0 : _o1[1] = captures[1];
1542 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1543 0 : res_op0 = _r1;
1544 : }
1545 0 : tree res_op1;
1546 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
1547 0 : tree _r;
1548 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
1549 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 436, __FILE__, __LINE__, true);
1550 : return _r;
1551 : }
1552 0 : next_after_fail536:;
1553 0 : return NULL_TREE;
1554 : }
1555 :
1556 : tree
1557 834398 : generic_simplify_303 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1558 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1559 : const enum tree_code ARG_UNUSED (cmp),
1560 : const enum tree_code ARG_UNUSED (ncmp))
1561 : {
1562 834398 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1563 1604190 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1564 834398 : && type_has_mode_precision_p (TREE_TYPE (captures[1]))
1565 833101 : && element_precision (captures[0]) >= element_precision (captures[1])
1566 1668796 : && wi::only_sign_bit_p (wi::to_wide (captures[2]), element_precision (captures[1]))
1567 : )
1568 : {
1569 14820 : {
1570 14820 : tree stype = signed_type_for (TREE_TYPE (captures[1]));
1571 14820 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail541;
1572 14820 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail541;
1573 14820 : {
1574 14820 : tree res_op0;
1575 14820 : {
1576 14820 : tree _o1[1], _r1;
1577 14820 : _o1[0] = captures[1];
1578 14820 : if (TREE_TYPE (_o1[0]) != stype)
1579 : {
1580 14599 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
1581 : }
1582 : else
1583 : _r1 = _o1[0];
1584 14820 : res_op0 = _r1;
1585 : }
1586 14820 : tree res_op1;
1587 14820 : res_op1 = build_zero_cst (stype);
1588 14820 : tree _r;
1589 14820 : _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
1590 14820 : if (TREE_SIDE_EFFECTS (captures[2]))
1591 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1592 14820 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 439, __FILE__, __LINE__, true);
1593 : return _r;
1594 : }
1595 834398 : next_after_fail541:;
1596 : }
1597 : }
1598 : return NULL_TREE;
1599 : }
1600 :
1601 : tree
1602 8 : generic_simplify_310 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1603 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1604 : const enum tree_code ARG_UNUSED (cmp),
1605 : const enum tree_code ARG_UNUSED (out))
1606 : {
1607 8 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1608 16 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
1609 8 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1610 8 : && TYPE_UNSIGNED (TREE_TYPE (captures[2]))
1611 8 : && (TYPE_PRECISION (TREE_TYPE (captures[1]))
1612 8 : >= 2 * TYPE_PRECISION (TREE_TYPE (captures[2])))
1613 8 : && tree_fits_uhwi_p (captures[4])
1614 8 : && tree_to_uhwi (captures[4]) == TYPE_PRECISION (TREE_TYPE (captures[2]))
1615 8 : && types_match (captures[2], captures[3])
1616 16 : && TYPE_MAX_VALUE (TREE_TYPE (captures[2]))
1617 : )
1618 : {
1619 8 : {
1620 8 : tree utype = unsigned_type_for (TREE_TYPE (captures[1]));
1621 8 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail566;
1622 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail566;
1623 8 : {
1624 8 : tree res_op0;
1625 8 : {
1626 8 : tree _o1[2], _r1;
1627 8 : {
1628 8 : tree _o2[1], _r2;
1629 8 : _o2[0] = captures[2];
1630 8 : if (TREE_TYPE (_o2[0]) != utype)
1631 : {
1632 8 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
1633 : }
1634 : else
1635 : _r2 = _o2[0];
1636 8 : _o1[0] = _r2;
1637 : }
1638 8 : {
1639 8 : tree _o2[1], _r2;
1640 8 : _o2[0] = captures[3];
1641 8 : if (TREE_TYPE (_o2[0]) != utype)
1642 : {
1643 8 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
1644 : }
1645 : else
1646 : _r2 = _o2[0];
1647 8 : _o1[1] = _r2;
1648 : }
1649 8 : _r1 = fold_build2_loc (loc, MULT_EXPR, utype, _o1[0], _o1[1]);
1650 8 : res_op0 = _r1;
1651 : }
1652 8 : tree res_op1;
1653 8 : res_op1 = fold_convert (utype, TYPE_MAX_VALUE (TREE_TYPE (captures[2])));
1654 8 : tree _r;
1655 8 : _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
1656 8 : if (TREE_SIDE_EFFECTS (captures[4]))
1657 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
1658 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 456, __FILE__, __LINE__, true);
1659 : return _r;
1660 : }
1661 8 : next_after_fail566:;
1662 : }
1663 : }
1664 : return NULL_TREE;
1665 : }
1666 :
1667 : tree
1668 366 : generic_simplify_313 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1669 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1670 : const enum tree_code ARG_UNUSED (op),
1671 : const enum tree_code ARG_UNUSED (cmp),
1672 : const combined_fn ARG_UNUSED (clz))
1673 : {
1674 366 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1675 366 : if (!sanitize_flags_p (SANITIZE_BUILTIN)
1676 366 : || (cfun && (cfun->curr_properties & PROP_ssa) != 0)
1677 : )
1678 : {
1679 302 : if (integer_zerop (captures[2]) && single_use (captures[0])
1680 : )
1681 : {
1682 59 : {
1683 59 : tree stype = signed_type_for (TREE_TYPE (captures[1]));
1684 59 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail578;
1685 59 : {
1686 59 : tree res_op0;
1687 59 : {
1688 59 : tree _o1[1], _r1;
1689 59 : _o1[0] = captures[1];
1690 59 : if (TREE_TYPE (_o1[0]) != stype)
1691 : {
1692 59 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
1693 : }
1694 : else
1695 : _r1 = _o1[0];
1696 59 : res_op0 = _r1;
1697 : }
1698 59 : tree res_op1;
1699 59 : res_op1 = build_zero_cst (stype);
1700 59 : tree _r;
1701 59 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1702 59 : if (TREE_SIDE_EFFECTS (captures[2]))
1703 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1704 59 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 468, __FILE__, __LINE__, true);
1705 : return _r;
1706 : }
1707 0 : next_after_fail578:;
1708 : }
1709 : }
1710 : else
1711 : {
1712 243 : if (wi::to_wide (captures[2]) == TYPE_PRECISION (TREE_TYPE (captures[1])) - 1
1713 : )
1714 : {
1715 79 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail579;
1716 79 : {
1717 79 : tree res_op0;
1718 79 : res_op0 = captures[1];
1719 79 : tree res_op1;
1720 79 : res_op1 = build_one_cst (TREE_TYPE (captures[1]));
1721 79 : tree _r;
1722 79 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1723 79 : if (TREE_SIDE_EFFECTS (captures[2]))
1724 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1725 79 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 469, __FILE__, __LINE__, true);
1726 : return _r;
1727 : }
1728 0 : next_after_fail579:;
1729 : }
1730 : }
1731 : }
1732 : return NULL_TREE;
1733 : }
1734 :
1735 : tree
1736 29025 : generic_simplify_321 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1737 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1738 : const enum tree_code ARG_UNUSED (cmp),
1739 : const enum tree_code ARG_UNUSED (icmp),
1740 : const enum tree_code ARG_UNUSED (ncmp))
1741 : {
1742 29025 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1743 29025 : if (types_match (type, TREE_TYPE (captures[0]))
1744 : )
1745 : {
1746 28255 : {
1747 28255 : enum tree_code ic = invert_tree_comparison
1748 28255 : (cmp, HONOR_NANS (captures[1]));
1749 28255 : if (ic == icmp
1750 : )
1751 : {
1752 22031 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail592;
1753 22031 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail592;
1754 22031 : {
1755 22031 : tree res_op0;
1756 22031 : res_op0 = captures[1];
1757 22031 : tree res_op1;
1758 22031 : res_op1 = captures[2];
1759 22031 : tree _r;
1760 22031 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
1761 22031 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 482, __FILE__, __LINE__, true);
1762 : return _r;
1763 : }
1764 29025 : next_after_fail592:;
1765 : }
1766 : else
1767 : {
1768 6224 : if (ic == ncmp
1769 : )
1770 : {
1771 5 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail593;
1772 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail593;
1773 5 : {
1774 5 : tree res_op0;
1775 5 : res_op0 = captures[1];
1776 5 : tree res_op1;
1777 5 : res_op1 = captures[2];
1778 5 : tree _r;
1779 5 : _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
1780 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 483, __FILE__, __LINE__, true);
1781 : return _r;
1782 : }
1783 29025 : next_after_fail593:;
1784 : }
1785 : }
1786 : }
1787 : }
1788 : return NULL_TREE;
1789 : }
1790 :
1791 : tree
1792 2366 : generic_simplify_331 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1793 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1794 : const enum tree_code ARG_UNUSED (div))
1795 : {
1796 2366 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1797 2366 : if (!integer_zerop (captures[1])
1798 : )
1799 : {
1800 1737 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail605;
1801 1737 : {
1802 1737 : tree _r;
1803 1737 : _r = captures[0];
1804 1737 : if (TREE_SIDE_EFFECTS (captures[1]))
1805 59 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1806 1737 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 493, __FILE__, __LINE__, true);
1807 : return _r;
1808 : }
1809 0 : next_after_fail605:;
1810 : }
1811 : return NULL_TREE;
1812 : }
1813 :
1814 : tree
1815 9433 : generic_simplify_337 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1816 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1817 : const enum tree_code ARG_UNUSED (div))
1818 : {
1819 9433 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1820 9433 : {
1821 9433 : wi::overflow_type overflow;
1822 9433 : wide_int mul = wi::mul (wi::to_wide (captures[2]), wi::to_wide (captures[3]),
1823 18866 : TYPE_SIGN (type), &overflow);
1824 9433 : if (div == EXACT_DIV_EXPR
1825 9433 : || optimize_successive_divisions_p (captures[3], captures[0])
1826 : )
1827 : {
1828 0 : if (!overflow
1829 : )
1830 : {
1831 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail611;
1832 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail611;
1833 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail611;
1834 0 : {
1835 0 : tree res_op0;
1836 0 : res_op0 = captures[1];
1837 0 : tree res_op1;
1838 0 : res_op1 = wide_int_to_tree (type, mul);
1839 0 : tree _r;
1840 0 : _r = fold_build2_loc (loc, div, type, res_op0, res_op1);
1841 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 499, __FILE__, __LINE__, true);
1842 : return _r;
1843 : }
1844 9433 : next_after_fail611:;
1845 : }
1846 : else
1847 : {
1848 0 : if (TYPE_UNSIGNED (type)
1849 0 : || mul != wi::min_value (TYPE_PRECISION (type), SIGNED)
1850 : )
1851 : {
1852 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail612;
1853 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail612;
1854 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail612;
1855 0 : {
1856 0 : tree _r;
1857 0 : _r = build_zero_cst (type);
1858 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1859 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1860 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 500, __FILE__, __LINE__, true);
1861 : return _r;
1862 : }
1863 9433 : next_after_fail612:;
1864 : }
1865 : }
1866 : }
1867 0 : }
1868 9433 : return NULL_TREE;
1869 : }
1870 :
1871 : tree
1872 1598283 : generic_simplify_349 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1873 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1874 : const enum tree_code ARG_UNUSED (mod))
1875 : {
1876 1598283 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1877 1849395 : if ((TYPE_UNSIGNED (type) || tree_expr_nonnegative_p (captures[0]))
1878 1351823 : && INTEGRAL_TYPE_P (type)
1879 1351823 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1880 1351823 : && (TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (captures[1]))
1881 3 : || TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1882 1 : || !TYPE_UNSIGNED (type))
1883 2950106 : && integer_pow2p (captures[2]) && tree_int_cst_sgn (captures[2]) > 0
1884 : )
1885 : {
1886 990819 : {
1887 990819 : tree utype = TREE_TYPE (captures[1]);
1888 990819 : if (!TYPE_OVERFLOW_WRAPS (utype))
1889 303 : utype = unsigned_type_for (utype);
1890 990819 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail624;
1891 990819 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail624;
1892 990819 : {
1893 990819 : tree res_op0;
1894 990819 : res_op0 = captures[0];
1895 990819 : tree res_op1;
1896 990819 : {
1897 990819 : tree _o1[1], _r1;
1898 990819 : {
1899 990819 : tree _o2[2], _r2;
1900 990819 : {
1901 990819 : tree _o3[1], _r3;
1902 990819 : _o3[0] = captures[1];
1903 990819 : if (TREE_TYPE (_o3[0]) != utype)
1904 : {
1905 303 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
1906 : }
1907 : else
1908 : _r3 = _o3[0];
1909 990819 : _o2[0] = _r3;
1910 : }
1911 990819 : _o2[1] = build_one_cst (utype);
1912 990819 : _r2 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
1913 990819 : _o1[0] = _r2;
1914 : }
1915 990819 : if (TREE_TYPE (_o1[0]) != type)
1916 : {
1917 20256 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
1918 : }
1919 : else
1920 : _r1 = _o1[0];
1921 990819 : res_op1 = _r1;
1922 : }
1923 990819 : tree _r;
1924 990819 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
1925 990819 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 512, __FILE__, __LINE__, true);
1926 : return _r;
1927 : }
1928 1598283 : next_after_fail624:;
1929 : }
1930 : }
1931 : return NULL_TREE;
1932 : }
1933 :
1934 : tree
1935 0 : generic_simplify_367 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1936 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1937 : const enum tree_code ARG_UNUSED (cmp),
1938 : const enum tree_code ARG_UNUSED (minmax))
1939 : {
1940 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1941 0 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1942 0 : && TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1943 : )
1944 : {
1945 0 : {
1946 0 : tree_code code;
1947 0 : widest_int c1 = wi::mask<widest_int>(TYPE_PRECISION (type) - 1, 0);
1948 0 : tree_code ncmp = cmp == GE_EXPR ? LE_EXPR : GT_EXPR;
1949 0 : code = minmax_from_comparison (ncmp, captures[0], c1, wi::to_widest (captures[4]));
1950 0 : if (ncmp == LE_EXPR
1951 0 : && code == MIN_EXPR
1952 0 : && wi::le_p (wi::to_wide (captures[3]),
1953 0 : wi::to_wide (captures[4]),
1954 0 : TYPE_SIGN (type))
1955 : )
1956 : {
1957 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail649;
1958 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail649;
1959 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail649;
1960 0 : {
1961 0 : tree res_op0;
1962 0 : res_op0 = captures[2];
1963 0 : tree res_op1;
1964 0 : res_op1 = captures[4];
1965 0 : tree _r;
1966 0 : _r = fold_build2_loc (loc, MIN_EXPR, type, res_op0, res_op1);
1967 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1968 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1969 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 537, __FILE__, __LINE__, true);
1970 : return _r;
1971 : }
1972 0 : next_after_fail649:;
1973 : }
1974 : else
1975 : {
1976 0 : if (ncmp == GT_EXPR
1977 0 : && code == MAX_EXPR
1978 0 : && wi::ge_p (wi::to_wide (captures[3]),
1979 0 : wi::to_wide (captures[4]),
1980 0 : TYPE_SIGN (type))
1981 : )
1982 : {
1983 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail650;
1984 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail650;
1985 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail650;
1986 0 : {
1987 0 : tree res_op0;
1988 0 : res_op0 = captures[2];
1989 0 : tree res_op1;
1990 0 : res_op1 = captures[4];
1991 0 : tree _r;
1992 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
1993 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1994 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1995 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 538, __FILE__, __LINE__, true);
1996 : return _r;
1997 : }
1998 0 : next_after_fail650:;
1999 : }
2000 : }
2001 0 : }
2002 : }
2003 : return NULL_TREE;
2004 : }
2005 :
2006 : tree
2007 204 : generic_simplify_384 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2008 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
2009 : const enum tree_code ARG_UNUSED (op))
2010 : {
2011 204 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2012 204 : if (bitwise_equal_p (captures[0], captures[3])
2013 204 : && expr_no_side_effects_p (captures[2])
2014 : )
2015 : {
2016 1 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail671;
2017 1 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail671;
2018 1 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail671;
2019 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail671;
2020 1 : {
2021 1 : tree _r;
2022 1 : _r = captures[1];
2023 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 559, __FILE__, __LINE__, true);
2024 : return _r;
2025 : }
2026 204 : next_after_fail671:;
2027 : }
2028 : return NULL_TREE;
2029 : }
2030 :
2031 : tree
2032 9 : generic_simplify_391 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2033 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
2034 : const combined_fn ARG_UNUSED (func))
2035 : {
2036 9 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2037 9 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail679;
2038 9 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail679;
2039 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail679;
2040 9 : {
2041 9 : tree _r;
2042 9 : _r = captures[2];
2043 9 : if (TREE_SIDE_EFFECTS (captures[1]))
2044 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2045 9 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 567, __FILE__, __LINE__, true);
2046 : return _r;
2047 : }
2048 9 : next_after_fail679:;
2049 : return NULL_TREE;
2050 : }
2051 :
2052 : tree
2053 27 : generic_simplify_399 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2054 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2055 : const enum tree_code ARG_UNUSED (ltge),
2056 : const enum tree_code ARG_UNUSED (gelt))
2057 : {
2058 27 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2059 27 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail690;
2060 27 : {
2061 27 : tree res_op0;
2062 27 : res_op0 = captures[1];
2063 27 : tree res_op1;
2064 27 : res_op1 = build_zero_cst (TREE_TYPE (captures[1]));
2065 27 : tree _r;
2066 27 : _r = fold_build2_loc (loc, gelt, type, res_op0, res_op1);
2067 27 : if (TREE_SIDE_EFFECTS (captures[0]))
2068 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2069 27 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 576, __FILE__, __LINE__, true);
2070 : return _r;
2071 : }
2072 0 : next_after_fail690:;
2073 0 : return NULL_TREE;
2074 : }
2075 :
2076 : tree
2077 433 : generic_simplify_405 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2078 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2079 : const enum tree_code ARG_UNUSED (op))
2080 : {
2081 433 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2082 866 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2083 866 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
2084 : )
2085 : {
2086 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail697;
2087 0 : {
2088 0 : tree res_op0;
2089 0 : res_op0 = captures[2];
2090 0 : tree res_op1;
2091 0 : res_op1 = captures[1];
2092 0 : tree _r;
2093 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2094 0 : if (TREE_SIDE_EFFECTS (captures[0]))
2095 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2096 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 583, __FILE__, __LINE__, true);
2097 : return _r;
2098 : }
2099 0 : next_after_fail697:;
2100 : }
2101 : return NULL_TREE;
2102 : }
2103 :
2104 : tree
2105 64 : generic_simplify_410 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2106 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2107 : const enum tree_code ARG_UNUSED (minmax),
2108 : const enum tree_code ARG_UNUSED (cmp),
2109 : const enum tree_code ARG_UNUSED (comb))
2110 : {
2111 64 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2112 64 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail703;
2113 64 : {
2114 64 : if (! tree_invariant_p (captures[2])) goto next_after_fail703;
2115 64 : tree res_op0;
2116 64 : {
2117 64 : tree _o1[2], _r1;
2118 64 : _o1[0] = captures[0];
2119 64 : _o1[1] = unshare_expr (captures[2]);
2120 64 : _r1 = fold_build2_loc (loc, cmp, type, _o1[0], _o1[1]);
2121 64 : res_op0 = _r1;
2122 : }
2123 64 : tree res_op1;
2124 64 : {
2125 64 : tree _o1[2], _r1;
2126 64 : _o1[0] = captures[1];
2127 64 : _o1[1] = captures[2];
2128 64 : _r1 = fold_build2_loc (loc, cmp, type, _o1[0], _o1[1]);
2129 64 : res_op1 = _r1;
2130 : }
2131 64 : tree _r;
2132 64 : _r = fold_build2_loc (loc, comb, type, res_op0, res_op1);
2133 64 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 589, __FILE__, __LINE__, true);
2134 : return _r;
2135 : }
2136 64 : next_after_fail703:;
2137 : return NULL_TREE;
2138 : }
2139 :
2140 : tree
2141 2 : generic_simplify_422 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2142 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2143 : const enum tree_code ARG_UNUSED (cmp))
2144 : {
2145 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2146 4 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2147 4 : && TYPE_UNSIGNED (TREE_TYPE (captures[0]))
2148 : )
2149 : {
2150 2 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail747;
2151 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail747;
2152 2 : {
2153 2 : tree res_op0;
2154 2 : res_op0 = captures[1];
2155 2 : tree res_op1;
2156 2 : res_op1 = captures[0];
2157 2 : tree _r;
2158 2 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2159 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 616, __FILE__, __LINE__, true);
2160 : return _r;
2161 : }
2162 2 : next_after_fail747:;
2163 : }
2164 : return NULL_TREE;
2165 : }
2166 :
2167 : tree
2168 2502693 : generic_simplify_427 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2169 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2170 : const enum tree_code ARG_UNUSED (op),
2171 : const enum tree_code ARG_UNUSED (rop),
2172 : const enum tree_code ARG_UNUSED (cmp),
2173 : const enum tree_code ARG_UNUSED (rcmp))
2174 : {
2175 2502693 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2176 5005372 : if (!TREE_OVERFLOW (captures[2]) && !TREE_OVERFLOW (captures[3])
2177 5005360 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
2178 : )
2179 : {
2180 874743 : {
2181 874743 : tree res = int_const_binop (rop, captures[3], captures[2]);
2182 874743 : if (TREE_OVERFLOW (res)
2183 : )
2184 : {
2185 13182 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail753;
2186 13182 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail753;
2187 13182 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail753;
2188 13182 : {
2189 13182 : tree _r;
2190 13182 : bool less = cmp == LE_EXPR || cmp == LT_EXPR;
2191 13182 : bool ovf_high = wi::lt_p (wi::to_wide (captures[2]), 0,
2192 13182 : TYPE_SIGN (TREE_TYPE (captures[2])))
2193 13182 : != (op == MINUS_EXPR); _r =
2194 13182 : constant_boolean_node (less == ovf_high, type);
2195 13182 : if (TREE_SIDE_EFFECTS (captures[1]))
2196 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2197 13182 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 622, __FILE__, __LINE__, true);
2198 : return _r;
2199 : }
2200 2502693 : next_after_fail753:;
2201 : }
2202 : else
2203 : {
2204 861561 : if (single_use (captures[0])
2205 : )
2206 : {
2207 861561 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail754;
2208 861561 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail754;
2209 861561 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail754;
2210 861561 : {
2211 861561 : tree res_op0;
2212 861561 : res_op0 = captures[1];
2213 861561 : tree res_op1;
2214 861561 : res_op1 = res;
2215 861561 : tree _r;
2216 861561 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2217 861561 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 623, __FILE__, __LINE__, true);
2218 : return _r;
2219 : }
2220 2502693 : next_after_fail754:;
2221 : }
2222 : }
2223 : }
2224 : }
2225 : else
2226 : {
2227 1627950 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))
2228 : )
2229 : {
2230 1627825 : {
2231 1627825 : wide_int max = wi::max_value (TREE_TYPE (captures[1]));
2232 1627825 : wide_int min = wi::min_value (TREE_TYPE (captures[1]));
2233 1627825 : wide_int c2 = rop == PLUS_EXPR
2234 1627825 : ? wi::add (wi::to_wide (captures[3]), wi::to_wide (captures[2]))
2235 1627825 : : wi::sub (wi::to_wide (captures[3]), wi::to_wide (captures[2]));
2236 1556411 : if (((cmp == LE_EXPR || cmp == GT_EXPR) && wi::eq_p (c2, max))
2237 3168402 : || ((cmp == LT_EXPR || cmp == GE_EXPR) && wi::eq_p (c2, min))
2238 : )
2239 : {
2240 15992 : {
2241 15992 : wide_int c1 = rop == PLUS_EXPR
2242 15992 : ? wi::add (wi::bit_not (c2), wi::to_wide (captures[2]))
2243 31984 : : wi::sub (wi::bit_not (c2), wi::to_wide (captures[2]));
2244 15992 : tree c1_cst = wide_int_to_tree (TREE_TYPE (captures[1]), c1);
2245 15992 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail755;
2246 15992 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail755;
2247 15992 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail755;
2248 15992 : {
2249 15992 : tree res_op0;
2250 15992 : res_op0 = captures[1];
2251 15992 : tree res_op1;
2252 15992 : res_op1 = c1_cst;
2253 15992 : tree _r;
2254 15992 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
2255 15992 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 624, __FILE__, __LINE__, true);
2256 15992 : return _r;
2257 : }
2258 0 : next_after_fail755:;
2259 15992 : }
2260 : }
2261 1627827 : }
2262 : }
2263 : }
2264 : return NULL_TREE;
2265 : }
2266 :
2267 : tree
2268 1691521 : generic_simplify_444 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2269 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2270 : const enum tree_code ARG_UNUSED (shift))
2271 : {
2272 1691521 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2273 1691521 : if ((
2274 :
2275 1691521 : || !sanitize_flags_p (SANITIZE_SHIFT_EXPONENT))
2276 1689571 : && (TYPE_UNSIGNED (type)
2277 411081 : || shift == LSHIFT_EXPR
2278 212129 : || tree_expr_nonnegative_p (captures[0]))
2279 3177411 : && wi::ges_p (wi::to_wide (uniform_integer_cst_p (captures[1])),
2280 3176189 : element_precision (type))
2281 : )
2282 : {
2283 1222 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail780;
2284 1222 : {
2285 1222 : tree _r;
2286 1222 : _r = build_zero_cst (type);
2287 1222 : if (TREE_SIDE_EFFECTS (captures[0]))
2288 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2289 1222 : if (TREE_SIDE_EFFECTS (captures[1]))
2290 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2291 1222 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 645, __FILE__, __LINE__, true);
2292 : return _r;
2293 : }
2294 0 : next_after_fail780:;
2295 : }
2296 : return NULL_TREE;
2297 : }
2298 :
2299 : tree
2300 90 : generic_simplify_450 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2301 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2302 : const enum tree_code ARG_UNUSED (op))
2303 : {
2304 90 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2305 90 : {
2306 90 : unsigned int prec = element_precision (type);
2307 90 : if (wi::ge_p (wi::to_wide (captures[1]), 0, TYPE_SIGN (TREE_TYPE (captures[1])))
2308 90 : && wi::lt_p (wi::to_wide (captures[1]), prec, TYPE_SIGN (TREE_TYPE (captures[1])))
2309 90 : && wi::ge_p (wi::to_wide (captures[2]), 0, TYPE_SIGN (TREE_TYPE (captures[2])))
2310 180 : && wi::lt_p (wi::to_wide (captures[2]), prec, TYPE_SIGN (TREE_TYPE (captures[2])))
2311 : )
2312 : {
2313 90 : {
2314 90 : unsigned int low = (tree_to_uhwi (captures[1])
2315 90 : + tree_to_uhwi (captures[2]));
2316 90 : if (low >= prec
2317 : )
2318 : {
2319 25 : if (op == LROTATE_EXPR || op == RROTATE_EXPR
2320 : )
2321 : {
2322 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail786;
2323 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail786;
2324 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail786;
2325 0 : {
2326 0 : tree res_op0;
2327 0 : res_op0 = captures[0];
2328 0 : tree res_op1;
2329 0 : res_op1 = build_int_cst (TREE_TYPE (captures[1]), low % prec);
2330 0 : tree _r;
2331 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2332 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 650, __FILE__, __LINE__, true);
2333 90 : return _r;
2334 : }
2335 0 : next_after_fail786:;
2336 : }
2337 : else
2338 : {
2339 25 : if (TYPE_UNSIGNED (type) || op == LSHIFT_EXPR
2340 : )
2341 : {
2342 24 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail787;
2343 24 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail787;
2344 24 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail787;
2345 24 : {
2346 24 : tree _r;
2347 24 : _r = build_zero_cst (type);
2348 24 : if (TREE_SIDE_EFFECTS (captures[0]))
2349 14 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2350 24 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 651, __FILE__, __LINE__, true);
2351 : return _r;
2352 : }
2353 0 : next_after_fail787:;
2354 : }
2355 : else
2356 : {
2357 1 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail788;
2358 1 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail788;
2359 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail788;
2360 1 : {
2361 1 : tree res_op0;
2362 1 : res_op0 = captures[0];
2363 1 : tree res_op1;
2364 1 : res_op1 = build_int_cst (TREE_TYPE (captures[1]), prec - 1);
2365 1 : tree _r;
2366 1 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2367 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 652, __FILE__, __LINE__, true);
2368 : return _r;
2369 : }
2370 0 : next_after_fail788:;
2371 : }
2372 : }
2373 : }
2374 : else
2375 : {
2376 65 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail789;
2377 65 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail789;
2378 65 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail789;
2379 65 : {
2380 65 : tree res_op0;
2381 65 : res_op0 = captures[0];
2382 65 : tree res_op1;
2383 65 : res_op1 = build_int_cst (TREE_TYPE (captures[1]), low);
2384 65 : tree _r;
2385 65 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2386 65 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 653, __FILE__, __LINE__, true);
2387 : return _r;
2388 : }
2389 0 : next_after_fail789:;
2390 : }
2391 : }
2392 : }
2393 : }
2394 0 : return NULL_TREE;
2395 : }
2396 :
2397 : tree
2398 5016824 : generic_simplify_465 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2399 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2400 : {
2401 5016824 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2402 5016824 : if (INTEGRAL_TYPE_P (type)
2403 2794221 : && TYPE_PRECISION (type) == 1
2404 5030637 : && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[0]))
2405 : )
2406 : {
2407 13813 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail823;
2408 13813 : {
2409 13813 : tree res_op0;
2410 13813 : res_op0 = captures[0];
2411 13813 : tree _r;
2412 13813 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2413 13813 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 674, __FILE__, __LINE__, true);
2414 : return _r;
2415 : }
2416 0 : next_after_fail823:;
2417 : }
2418 : return NULL_TREE;
2419 : }
2420 :
2421 : tree
2422 0 : generic_simplify_468 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2423 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2424 : const combined_fn ARG_UNUSED (coshs),
2425 : const combined_fn ARG_UNUSED (atanhs),
2426 : const combined_fn ARG_UNUSED (sqrts))
2427 : {
2428 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2429 0 : if (!flag_errno_math
2430 : )
2431 : {
2432 0 : {
2433 0 : tree t_one = build_one_cst (type);
2434 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail826;
2435 0 : {
2436 0 : if (! tree_invariant_p (captures[1])) goto next_after_fail826;
2437 0 : tree res_op0;
2438 0 : res_op0 = t_one;
2439 0 : tree res_op1;
2440 0 : {
2441 0 : tree _o1[1], _r1;
2442 0 : {
2443 0 : tree _o2[2], _r2;
2444 0 : {
2445 0 : tree _o3[2], _r3;
2446 0 : _o3[0] = t_one;
2447 0 : _o3[1] = unshare_expr (captures[1]);
2448 0 : _r3 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
2449 0 : _o2[0] = _r3;
2450 : }
2451 0 : {
2452 0 : tree _o3[2], _r3;
2453 0 : _o3[0] = t_one;
2454 0 : _o3[1] = captures[1];
2455 0 : _r3 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
2456 0 : _o2[1] = _r3;
2457 : }
2458 0 : _r2 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
2459 0 : _o1[0] = _r2;
2460 : }
2461 0 : _r1 = maybe_build_call_expr_loc (loc, sqrts, TREE_TYPE (_o1[0]), 1, _o1[0]);
2462 0 : if (!_r1)
2463 0 : goto next_after_fail826;
2464 0 : res_op1 = _r1;
2465 : }
2466 0 : tree _r;
2467 0 : _r = fold_build2_loc (loc, RDIV_EXPR, type, res_op0, res_op1);
2468 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 677, __FILE__, __LINE__, true);
2469 : return _r;
2470 : }
2471 0 : next_after_fail826:;
2472 : }
2473 : }
2474 : return NULL_TREE;
2475 : }
2476 :
2477 : tree
2478 0 : generic_simplify_472 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2479 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2480 : const combined_fn ARG_UNUSED (POW))
2481 : {
2482 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2483 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail830;
2484 0 : {
2485 0 : tree _r;
2486 0 : _r = captures[0];
2487 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2488 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2489 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 681, __FILE__, __LINE__, true);
2490 : return _r;
2491 : }
2492 0 : next_after_fail830:;
2493 0 : return NULL_TREE;
2494 : }
2495 :
2496 : tree
2497 0 : generic_simplify_475 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2498 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2499 : const combined_fn ARG_UNUSED (copysigns),
2500 : const combined_fn ARG_UNUSED (hypots))
2501 : {
2502 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2503 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail833;
2504 0 : {
2505 0 : tree res_op0;
2506 0 : res_op0 = captures[0];
2507 0 : tree res_op1;
2508 0 : res_op1 = captures[1];
2509 0 : tree _r;
2510 0 : _r = maybe_build_call_expr_loc (loc, hypots, type, 2, res_op0, res_op1);
2511 0 : if (!_r)
2512 0 : goto next_after_fail833;
2513 0 : if (TREE_SIDE_EFFECTS (captures[2]))
2514 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2515 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 684, __FILE__, __LINE__, true);
2516 : return _r;
2517 : }
2518 0 : next_after_fail833:;
2519 : return NULL_TREE;
2520 : }
2521 :
2522 : tree
2523 0 : generic_simplify_481 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2524 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2525 : {
2526 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2527 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail839;
2528 0 : {
2529 0 : tree res_op0;
2530 0 : res_op0 = captures[0];
2531 0 : tree res_op1;
2532 0 : res_op1 = captures[1];
2533 0 : tree _r;
2534 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2535 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 690, __FILE__, __LINE__, true);
2536 : return _r;
2537 : }
2538 0 : next_after_fail839:;
2539 0 : return NULL_TREE;
2540 : }
2541 :
2542 : tree
2543 0 : generic_simplify_485 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2544 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2545 : {
2546 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2547 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail843;
2548 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail843;
2549 0 : {
2550 0 : tree res_op0;
2551 0 : res_op0 = captures[0];
2552 0 : tree res_op1;
2553 0 : {
2554 0 : tree _o1[1], _r1;
2555 0 : _o1[0] = captures[5];
2556 0 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2557 0 : res_op1 = _r1;
2558 : }
2559 0 : tree _r;
2560 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2561 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 693, __FILE__, __LINE__, true);
2562 : return _r;
2563 : }
2564 0 : next_after_fail843:;
2565 : return NULL_TREE;
2566 : }
2567 :
2568 : tree
2569 104 : generic_simplify_492 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2570 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2571 : {
2572 104 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2573 104 : {
2574 104 : bool wascmp;
2575 104 : if (bitwise_inverted_equal_p (captures[0], captures[2], wascmp)
2576 104 : && (!wascmp || element_precision (type) == 1)
2577 : )
2578 : {
2579 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail850;
2580 0 : {
2581 0 : tree res_op0;
2582 0 : res_op0 = captures[0];
2583 0 : tree res_op1;
2584 0 : res_op1 = captures[1];
2585 0 : tree _r;
2586 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2587 0 : if (TREE_SIDE_EFFECTS (captures[2]))
2588 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2589 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 700, __FILE__, __LINE__, true);
2590 0 : return _r;
2591 : }
2592 0 : next_after_fail850:;
2593 : }
2594 : }
2595 104 : return NULL_TREE;
2596 : }
2597 :
2598 : tree
2599 0 : generic_simplify_497 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2600 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2601 : const enum tree_code ARG_UNUSED (cmp))
2602 : {
2603 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2604 0 : if (fold_before_rtl_expansion_p ()
2605 : )
2606 : {
2607 0 : if (INTEGRAL_TYPE_P (type)
2608 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2609 : )
2610 : {
2611 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail855;
2612 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail855;
2613 0 : {
2614 0 : tree res_op0;
2615 0 : res_op0 = captures[0];
2616 0 : tree res_op1;
2617 0 : res_op1 = captures[3];
2618 0 : tree res_op2;
2619 0 : res_op2 = build_zero_cst (type);
2620 0 : tree _r;
2621 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
2622 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 704, __FILE__, __LINE__, true);
2623 : return _r;
2624 : }
2625 0 : next_after_fail855:;
2626 : }
2627 : }
2628 : return NULL_TREE;
2629 : }
2630 :
2631 : tree
2632 0 : generic_simplify_507 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2633 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2634 : {
2635 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2636 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail887;
2637 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail887;
2638 0 : {
2639 0 : tree _r;
2640 0 : _r = captures[2];
2641 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2642 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2643 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 725, __FILE__, __LINE__, true);
2644 : return _r;
2645 : }
2646 0 : next_after_fail887:;
2647 : return NULL_TREE;
2648 : }
2649 :
2650 : tree
2651 4 : generic_simplify_512 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2652 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2653 : {
2654 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2655 4 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail904;
2656 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail904;
2657 4 : {
2658 4 : tree _r;
2659 4 : _r = captures[2];
2660 4 : if (TREE_SIDE_EFFECTS (captures[1]))
2661 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2662 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 725, __FILE__, __LINE__, true);
2663 : return _r;
2664 : }
2665 4 : next_after_fail904:;
2666 : return NULL_TREE;
2667 : }
2668 :
2669 : tree
2670 67135 : generic_simplify_516 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2671 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2672 : const enum tree_code ARG_UNUSED (shift))
2673 : {
2674 67135 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2675 67135 : if (tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
2676 67135 : && TYPE_PRECISION (type) <= HOST_BITS_PER_WIDE_INT
2677 67019 : && tree_fits_uhwi_p (captures[4])
2678 66970 : && tree_to_uhwi (captures[4]) > 0
2679 134104 : && tree_to_uhwi (captures[4]) < TYPE_PRECISION (type)
2680 : )
2681 : {
2682 66969 : {
2683 66969 : unsigned int shiftc = tree_to_uhwi (captures[4]);
2684 66969 : unsigned HOST_WIDE_INT mask = TREE_INT_CST_LOW (captures[5]);
2685 66969 : unsigned HOST_WIDE_INT newmask, zerobits = 0;
2686 66969 : tree shift_type = TREE_TYPE (captures[2]);
2687 66969 : unsigned int prec;
2688 66969 : if (shift == LSHIFT_EXPR)
2689 28782 : zerobits = ((HOST_WIDE_INT_1U << shiftc) - 1);
2690 38187 : else if (shift == RSHIFT_EXPR
2691 38187 : && type_has_mode_precision_p (shift_type))
2692 : {
2693 38187 : prec = TYPE_PRECISION (TREE_TYPE (captures[2]));
2694 38187 : tree arg00 = captures[3];
2695 38187 : if (captures[2] != captures[3]
2696 38187 : && TYPE_UNSIGNED (TREE_TYPE (captures[3])))
2697 : {
2698 0 : tree inner_type = TREE_TYPE (captures[3]);
2699 0 : if (type_has_mode_precision_p (inner_type)
2700 0 : && TYPE_PRECISION (inner_type) < prec)
2701 : {
2702 0 : prec = TYPE_PRECISION (inner_type);
2703 0 : if (shiftc < prec)
2704 0 : shift_type = inner_type;
2705 : }
2706 : }
2707 38187 : zerobits = HOST_WIDE_INT_M1U;
2708 38187 : if (shiftc < prec)
2709 : {
2710 38187 : zerobits >>= HOST_BITS_PER_WIDE_INT - shiftc;
2711 38187 : zerobits <<= prec - shiftc;
2712 : }
2713 38187 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[2]))
2714 38187 : && prec == TYPE_PRECISION (TREE_TYPE (captures[2])))
2715 : {
2716 2897 : if ((mask & zerobits) == 0)
2717 2886 : shift_type = unsigned_type_for (TREE_TYPE (captures[2]));
2718 : else
2719 : zerobits = 0;
2720 : }
2721 : }
2722 66958 : if ((mask & zerobits) == mask
2723 : )
2724 : {
2725 3 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail910;
2726 3 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail910;
2727 3 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail910;
2728 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail910;
2729 3 : {
2730 3 : tree _r;
2731 3 : _r = build_int_cst (type, 0);
2732 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 728, __FILE__, __LINE__, true);
2733 67135 : return _r;
2734 : }
2735 67135 : next_after_fail910:;
2736 : }
2737 : else
2738 : {
2739 66966 : {
2740 66966 : newmask = mask | zerobits;
2741 66966 : if (newmask != mask && (newmask & (newmask + 1)) == 0
2742 : )
2743 : {
2744 : {
2745 18851 : for (prec = BITS_PER_UNIT;
2746 34821 : prec < HOST_BITS_PER_WIDE_INT; prec <<= 1)
2747 32574 : if (newmask == (HOST_WIDE_INT_1U << prec) - 1)
2748 : break;
2749 15970 : if (prec < HOST_BITS_PER_WIDE_INT
2750 2247 : || newmask == HOST_WIDE_INT_M1U
2751 : )
2752 : {
2753 13904 : {
2754 13904 : tree newmaskt = build_int_cst_type (TREE_TYPE (captures[5]), newmask);
2755 13904 : if (!tree_int_cst_equal (newmaskt, captures[5])
2756 : )
2757 : {
2758 13904 : if (shift_type != TREE_TYPE (captures[2])
2759 : )
2760 : {
2761 86 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail911;
2762 86 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail911;
2763 86 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail911;
2764 86 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail911;
2765 86 : {
2766 86 : tree res_op0;
2767 86 : {
2768 86 : tree _o1[1], _r1;
2769 86 : {
2770 86 : tree _o2[2], _r2;
2771 86 : {
2772 86 : tree _o3[1], _r3;
2773 86 : _o3[0] = captures[2];
2774 86 : if (TREE_TYPE (_o3[0]) != shift_type)
2775 : {
2776 86 : _r3 = fold_build1_loc (loc, NOP_EXPR, shift_type, _o3[0]);
2777 : }
2778 : else
2779 : _r3 = _o3[0];
2780 86 : _o2[0] = _r3;
2781 : }
2782 86 : _o2[1] = captures[4];
2783 86 : _r2 = fold_build2_loc (loc, shift, shift_type, _o2[0], _o2[1]);
2784 86 : _o1[0] = _r2;
2785 : }
2786 86 : if (TREE_TYPE (_o1[0]) != type)
2787 : {
2788 86 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2789 : }
2790 : else
2791 : _r1 = _o1[0];
2792 86 : res_op0 = _r1;
2793 : }
2794 86 : tree res_op1;
2795 86 : res_op1 = newmaskt;
2796 86 : tree _r;
2797 86 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2798 86 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 729, __FILE__, __LINE__, true);
2799 : return _r;
2800 : }
2801 67135 : next_after_fail911:;
2802 : }
2803 : else
2804 : {
2805 13818 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail912;
2806 12682 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail912;
2807 12682 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail912;
2808 12682 : {
2809 12682 : tree res_op0;
2810 12682 : res_op0 = captures[0];
2811 12682 : tree res_op1;
2812 12682 : res_op1 = newmaskt;
2813 12682 : tree _r;
2814 12682 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2815 12682 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 730, __FILE__, __LINE__, true);
2816 : return _r;
2817 : }
2818 67135 : next_after_fail912:;
2819 : }
2820 : }
2821 : }
2822 : }
2823 : }
2824 : }
2825 : }
2826 : }
2827 : }
2828 : }
2829 : return NULL_TREE;
2830 : }
2831 :
2832 : tree
2833 150 : generic_simplify_525 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2834 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2835 : const enum tree_code ARG_UNUSED (iop),
2836 : const enum tree_code ARG_UNUSED (res))
2837 : {
2838 150 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2839 150 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail927;
2840 150 : {
2841 150 : tree res_op0;
2842 150 : res_op0 = captures[1];
2843 150 : tree res_op1;
2844 150 : {
2845 150 : tree _o1[1], _r1;
2846 150 : _o1[0] = captures[2];
2847 150 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2848 150 : res_op1 = _r1;
2849 : }
2850 150 : tree _r;
2851 150 : _r = fold_build2_loc (loc, res, type, res_op0, res_op1);
2852 150 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 739, __FILE__, __LINE__, true);
2853 : return _r;
2854 : }
2855 0 : next_after_fail927:;
2856 0 : return NULL_TREE;
2857 : }
2858 :
2859 : tree
2860 145 : generic_simplify_530 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2861 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2862 : {
2863 145 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2864 145 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[0]))
2865 145 : || !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
2866 : )
2867 : {
2868 145 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail932;
2869 145 : {
2870 145 : tree res_op0;
2871 145 : {
2872 145 : tree _o1[2], _r1;
2873 145 : _o1[0] = captures[0];
2874 145 : _o1[1] = build_each_one_cst (TREE_TYPE (captures[0]));
2875 145 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2876 145 : res_op0 = _r1;
2877 : }
2878 145 : tree _r;
2879 145 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2880 145 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 744, __FILE__, __LINE__, true);
2881 : return _r;
2882 : }
2883 0 : next_after_fail932:;
2884 : }
2885 : return NULL_TREE;
2886 : }
2887 :
2888 : tree
2889 254 : generic_simplify_537 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2890 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2891 : const enum tree_code ARG_UNUSED (cmp),
2892 : const enum tree_code ARG_UNUSED (icmp),
2893 : const enum tree_code ARG_UNUSED (ncmp))
2894 : {
2895 254 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2896 254 : if (VECTOR_TYPE_P (type)
2897 254 : || (INTEGRAL_TYPE_P (type) && TYPE_PRECISION (type) == 1)
2898 : )
2899 : {
2900 51 : {
2901 51 : enum tree_code ic = invert_tree_comparison
2902 51 : (cmp, HONOR_NANS (captures[0]));
2903 51 : if (ic == icmp
2904 : )
2905 : {
2906 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail939;
2907 12 : {
2908 12 : tree res_op0;
2909 12 : res_op0 = captures[0];
2910 12 : tree res_op1;
2911 12 : res_op1 = captures[1];
2912 12 : tree _r;
2913 12 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
2914 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 749, __FILE__, __LINE__, true);
2915 : return _r;
2916 : }
2917 0 : next_after_fail939:;
2918 : }
2919 : else
2920 : {
2921 39 : if (ic == ncmp
2922 : )
2923 : {
2924 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail940;
2925 0 : {
2926 0 : tree res_op0;
2927 0 : res_op0 = captures[0];
2928 0 : tree res_op1;
2929 0 : res_op1 = captures[1];
2930 0 : tree _r;
2931 0 : _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
2932 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 750, __FILE__, __LINE__, true);
2933 : return _r;
2934 : }
2935 0 : next_after_fail940:;
2936 : }
2937 : }
2938 : }
2939 : }
2940 : return NULL_TREE;
2941 : }
2942 :
2943 : tree
2944 1 : generic_simplify_551 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2945 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2946 : const enum tree_code ARG_UNUSED (minmax))
2947 : {
2948 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2949 1 : if (INTEGRAL_TYPE_P (type)
2950 1 : && TYPE_OVERFLOW_UNDEFINED (type)
2951 2 : && !TYPE_OVERFLOW_SANITIZED (type)
2952 : )
2953 : {
2954 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail955;
2955 1 : {
2956 1 : tree res_op0;
2957 1 : {
2958 1 : tree _o1[2], _r1;
2959 1 : _o1[0] = captures[1];
2960 1 : _o1[1] = captures[4];
2961 1 : _r1 = fold_build2_loc (loc, minmax, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2962 1 : res_op0 = _r1;
2963 : }
2964 1 : tree res_op1;
2965 1 : res_op1 = captures[2];
2966 1 : tree _r;
2967 1 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
2968 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 764, __FILE__, __LINE__, true);
2969 : return _r;
2970 : }
2971 0 : next_after_fail955:;
2972 : }
2973 : return NULL_TREE;
2974 : }
2975 :
2976 : tree
2977 20 : generic_simplify_560 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2978 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2979 : const enum tree_code ARG_UNUSED (minmax),
2980 : const enum tree_code ARG_UNUSED (cmp))
2981 : {
2982 20 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2983 20 : {
2984 20 : poly_int64 off0, off1;
2985 20 : tree base0, base1;
2986 20 : int equal = address_compare (cmp, TREE_TYPE (captures[0]), captures[1], captures[3], base0, base1,
2987 : off0, off1,
2988 : 1
2989 : );
2990 20 : if (equal == 1
2991 : )
2992 : {
2993 0 : if (minmax == MIN_EXPR
2994 : )
2995 : {
2996 0 : if (known_le (off0, off1)
2997 : )
2998 : {
2999 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail975;
3000 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail975;
3001 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail975;
3002 0 : {
3003 0 : tree _r;
3004 0 : _r = captures[0];
3005 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 772, __FILE__, __LINE__, true);
3006 0 : return _r;
3007 : }
3008 20 : next_after_fail975:;
3009 : }
3010 : else
3011 : {
3012 0 : if (known_gt (off0, off1)
3013 : )
3014 : {
3015 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail976;
3016 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail976;
3017 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail976;
3018 0 : {
3019 0 : tree _r;
3020 0 : _r = captures[2];
3021 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 773, __FILE__, __LINE__, true);
3022 : return _r;
3023 : }
3024 20 : next_after_fail976:;
3025 : }
3026 : }
3027 : }
3028 : else
3029 : {
3030 0 : if (known_ge (off0, off1)
3031 : )
3032 : {
3033 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail977;
3034 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail977;
3035 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail977;
3036 0 : {
3037 0 : tree _r;
3038 0 : _r = captures[0];
3039 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 774, __FILE__, __LINE__, true);
3040 : return _r;
3041 : }
3042 20 : next_after_fail977:;
3043 : }
3044 : else
3045 : {
3046 0 : if (known_lt (off0, off1)
3047 : )
3048 : {
3049 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail978;
3050 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail978;
3051 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail978;
3052 0 : {
3053 0 : tree _r;
3054 0 : _r = captures[2];
3055 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 775, __FILE__, __LINE__, true);
3056 : return _r;
3057 : }
3058 20 : next_after_fail978:;
3059 : }
3060 : }
3061 : }
3062 : }
3063 : }
3064 20 : return NULL_TREE;
3065 : }
3066 :
3067 : tree
3068 0 : generic_simplify_582 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3069 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
3070 : const combined_fn ARG_UNUSED (cond_op))
3071 : {
3072 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3073 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1000;
3074 0 : {
3075 0 : tree res_op0;
3076 0 : {
3077 0 : tree _o1[2], _r1;
3078 0 : _o1[0] = captures[2];
3079 0 : _o1[1] = captures[0];
3080 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3081 0 : res_op0 = _r1;
3082 : }
3083 0 : tree res_op1;
3084 0 : res_op1 = captures[3];
3085 0 : tree res_op2;
3086 0 : res_op2 = captures[4];
3087 0 : tree res_op3;
3088 0 : res_op3 = captures[5];
3089 0 : tree _r;
3090 0 : _r = maybe_build_call_expr_loc (loc, cond_op, type, 4, res_op0, res_op1, res_op2, res_op3);
3091 0 : if (!_r)
3092 0 : goto next_after_fail1000;
3093 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 793, __FILE__, __LINE__, true);
3094 : return _r;
3095 : }
3096 0 : next_after_fail1000:;
3097 : return NULL_TREE;
3098 : }
3099 :
3100 : tree
3101 1 : generic_simplify_587 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3102 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
3103 : {
3104 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3105 1 : if (tree_nop_conversion_p (TREE_TYPE (captures[0]), type)
3106 : )
3107 : {
3108 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1008;
3109 1 : {
3110 1 : tree res_op0;
3111 1 : {
3112 1 : tree _o1[1], _r1;
3113 1 : _o1[0] = captures[0];
3114 1 : if (TREE_TYPE (_o1[0]) != type)
3115 : {
3116 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3117 : }
3118 : else
3119 : _r1 = _o1[0];
3120 1 : res_op0 = _r1;
3121 : }
3122 1 : tree _r;
3123 1 : _r = non_lvalue_loc (loc, res_op0);
3124 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 801, __FILE__, __LINE__, true);
3125 : return _r;
3126 : }
3127 0 : next_after_fail1008:;
3128 : }
3129 : return NULL_TREE;
3130 : }
3131 :
3132 : tree
3133 0 : generic_simplify_597 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3134 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3135 : const combined_fn ARG_UNUSED (logs))
3136 : {
3137 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3138 0 : if (flag_unsafe_math_optimizations
3139 : )
3140 : {
3141 0 : if (! HONOR_SIGN_DEPENDENT_ROUNDING (type)
3142 0 : && ! HONOR_NANS (type) && ! HONOR_INFINITIES (type)
3143 0 : && ! flag_trapping_math
3144 0 : && ! flag_errno_math
3145 : )
3146 : {
3147 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1018;
3148 0 : {
3149 0 : tree res_op0;
3150 0 : {
3151 0 : tree _o1[1], _r1;
3152 0 : _o1[0] = captures[1];
3153 0 : _r1 = maybe_build_call_expr_loc (loc, logs, TREE_TYPE (_o1[0]), 1, _o1[0]);
3154 0 : if (!_r1)
3155 0 : goto next_after_fail1018;
3156 0 : if (EXPR_P (_r1))
3157 0 : goto next_after_fail1018;
3158 0 : res_op0 = _r1;
3159 : }
3160 0 : tree res_op1;
3161 0 : {
3162 0 : tree _o1[1], _r1;
3163 0 : _o1[0] = captures[2];
3164 0 : _r1 = maybe_build_call_expr_loc (loc, logs, TREE_TYPE (_o1[0]), 1, _o1[0]);
3165 0 : if (!_r1)
3166 0 : goto next_after_fail1018;
3167 0 : res_op1 = _r1;
3168 : }
3169 0 : tree _r;
3170 0 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
3171 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 811, __FILE__, __LINE__, true);
3172 : return _r;
3173 : }
3174 0 : next_after_fail1018:;
3175 : }
3176 : }
3177 : return NULL_TREE;
3178 : }
3179 :
3180 : tree
3181 0 : generic_simplify_610 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3182 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3183 : const combined_fn ARG_UNUSED (froms),
3184 : const combined_fn ARG_UNUSED (tos))
3185 : {
3186 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3187 0 : if (optimize && canonicalize_math_p ()
3188 : )
3189 : {
3190 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1031;
3191 0 : {
3192 0 : tree res_op0;
3193 0 : res_op0 = captures[0];
3194 0 : tree _r;
3195 0 : _r = maybe_build_call_expr_loc (loc, tos, type, 1, res_op0);
3196 0 : if (!_r)
3197 0 : goto next_after_fail1031;
3198 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 824, __FILE__, __LINE__, true);
3199 : return _r;
3200 : }
3201 0 : next_after_fail1031:;
3202 : }
3203 : return NULL_TREE;
3204 : }
3205 :
3206 : tree
3207 0 : generic_simplify_618 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3208 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
3209 : const combined_fn ARG_UNUSED (fmas))
3210 : {
3211 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3212 0 : if (canonicalize_math_after_vectorization_p ()
3213 : )
3214 : {
3215 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1039;
3216 : {
3217 : tree res_op0;
3218 : res_op0 = captures[0];
3219 : tree res_op1;
3220 : res_op1 = captures[1];
3221 : tree res_op2;
3222 : res_op2 = captures[2];
3223 : tree _r;
3224 : _r = maybe_build_call_expr_loc (loc, CFN_FNMA, type, 3, res_op0, res_op1, res_op2);
3225 : if (!_r)
3226 : goto next_after_fail1039;
3227 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 832, __FILE__, __LINE__, true);
3228 : return _r;
3229 : }
3230 0 : next_after_fail1039:;
3231 : }
3232 0 : return NULL_TREE;
3233 : }
3234 :
3235 : tree
3236 0 : generic_simplify_628 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3237 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree ARG_UNUSED (_p3), tree ARG_UNUSED (_p4), tree *ARG_UNUSED (captures),
3238 : const combined_fn ARG_UNUSED (fmas))
3239 : {
3240 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3241 0 : if (canonicalize_math_after_vectorization_p ()
3242 : )
3243 : {
3244 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1049;
3245 : {
3246 : tree res_op0;
3247 : res_op0 = captures[0];
3248 : tree res_op1;
3249 : res_op1 = captures[1];
3250 : tree res_op2;
3251 : res_op2 = captures[2];
3252 : tree res_op3;
3253 : res_op3 = captures[3];
3254 : tree res_op4;
3255 : res_op4 = captures[4];
3256 : tree _r;
3257 : _r = maybe_build_call_expr_loc (loc, CFN_COND_FNMA, type, 5, res_op0, res_op1, res_op2, res_op3, res_op4);
3258 : if (!_r)
3259 : goto next_after_fail1049;
3260 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 842, __FILE__, __LINE__, true);
3261 : return _r;
3262 : }
3263 0 : next_after_fail1049:;
3264 : }
3265 0 : return NULL_TREE;
3266 : }
3267 :
3268 : tree
3269 0 : generic_simplify_637 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3270 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3271 : const combined_fn ARG_UNUSED (ctz))
3272 : {
3273 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3274 0 : {
3275 0 : tree t = TREE_TYPE (captures[0]);
3276 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1058;
3277 0 : {
3278 0 : tree res_op0;
3279 0 : {
3280 0 : tree _o1[1], _r1;
3281 0 : _o1[0] = captures[1];
3282 0 : if (TREE_TYPE (_o1[0]) != t)
3283 : {
3284 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, t, _o1[0]);
3285 : }
3286 : else
3287 : _r1 = _o1[0];
3288 0 : res_op0 = _r1;
3289 : }
3290 0 : tree _r;
3291 0 : _r = maybe_build_call_expr_loc (loc, ctz, type, 1, res_op0);
3292 0 : if (!_r)
3293 0 : goto next_after_fail1058;
3294 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 850, __FILE__, __LINE__, true);
3295 : return _r;
3296 : }
3297 0 : next_after_fail1058:;
3298 : }
3299 : return NULL_TREE;
3300 : }
3301 :
3302 : tree
3303 0 : generic_simplify_647 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3304 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3305 : const combined_fn ARG_UNUSED (bswap),
3306 : const combined_fn ARG_UNUSED (parity))
3307 : {
3308 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3309 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3310 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
3311 0 : && TYPE_PRECISION (TREE_TYPE (captures[0]))
3312 0 : >= TYPE_PRECISION (TREE_TYPE (captures[1]))
3313 : )
3314 : {
3315 0 : {
3316 0 : tree type0 = TREE_TYPE (captures[0]);
3317 0 : tree type1 = TREE_TYPE (captures[1]);
3318 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1070;
3319 0 : {
3320 0 : tree res_op0;
3321 0 : {
3322 0 : tree _o1[1], _r1;
3323 0 : {
3324 0 : tree _o2[1], _r2;
3325 0 : _o2[0] = captures[2];
3326 0 : if (TREE_TYPE (_o2[0]) != type1)
3327 : {
3328 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, type1, _o2[0]);
3329 : }
3330 : else
3331 : _r2 = _o2[0];
3332 0 : _o1[0] = _r2;
3333 : }
3334 0 : if (TREE_TYPE (_o1[0]) != type0)
3335 : {
3336 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type0, _o1[0]);
3337 : }
3338 : else
3339 : _r1 = _o1[0];
3340 0 : res_op0 = _r1;
3341 : }
3342 0 : tree _r;
3343 0 : _r = maybe_build_call_expr_loc (loc, parity, type, 1, res_op0);
3344 0 : if (!_r)
3345 0 : goto next_after_fail1070;
3346 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 858, __FILE__, __LINE__, true);
3347 : return _r;
3348 : }
3349 0 : next_after_fail1070:;
3350 : }
3351 : }
3352 : return NULL_TREE;
3353 : }
3354 :
3355 : tree
3356 900923812 : generic_simplify_CONVERT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0)
3357 : {
3358 900923812 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3359 900923812 : switch (TREE_CODE (_p0))
3360 : {
3361 781825 : case NEGATE_EXPR:
3362 781825 : {
3363 781825 : tree _q20 = TREE_OPERAND (_p0, 0);
3364 781825 : switch (TREE_CODE (_q20))
3365 : {
3366 454963 : CASE_CONVERT:
3367 454963 : {
3368 454963 : tree _q30 = TREE_OPERAND (_q20, 0);
3369 454963 : {
3370 454963 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q30 };
3371 909926 : if (INTEGRAL_TYPE_P (type)
3372 454662 : && tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
3373 450683 : && (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (captures[2]))
3374 449424 : || TYPE_OVERFLOW_WRAPS (type)
3375 887644 : || expr_not_equal_to (captures[1], wi::min_value (signed_type_for (type)),
3376 : gimple_match_ctx (captures[0])))
3377 472965 : && TREE_CODE (type) != BOOLEAN_TYPE
3378 : )
3379 : {
3380 18002 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1084;
3381 18002 : {
3382 18002 : tree res_op0;
3383 18002 : {
3384 18002 : tree _o1[1], _r1;
3385 18002 : _o1[0] = captures[2];
3386 18002 : if (TREE_TYPE (_o1[0]) != type)
3387 : {
3388 17889 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3389 : }
3390 : else
3391 : _r1 = _o1[0];
3392 18002 : res_op0 = _r1;
3393 : }
3394 18002 : tree _r;
3395 18002 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
3396 18002 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 870, __FILE__, __LINE__, true);
3397 : return _r;
3398 : }
3399 0 : next_after_fail1084:;
3400 : }
3401 : }
3402 : break;
3403 : }
3404 : default:;
3405 : }
3406 : break;
3407 : }
3408 1368735 : case BIT_AND_EXPR:
3409 1368735 : {
3410 1368735 : tree _q20 = TREE_OPERAND (_p0, 0);
3411 1368735 : tree _q21 = TREE_OPERAND (_p0, 1);
3412 1368735 : {
3413 1368735 : tree _q20_pops[1];
3414 1368735 : if (tree_nop_convert (_q20, _q20_pops))
3415 : {
3416 720962 : tree _q30 = _q20_pops[0];
3417 720962 : {
3418 720962 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3419 720962 : tree res = generic_simplify_457 (loc, type, _p0, captures, BIT_AND_EXPR);
3420 720962 : if (res) return res;
3421 : }
3422 : }
3423 : }
3424 1368735 : {
3425 1368735 : tree _q21_pops[1];
3426 1368735 : if (tree_nop_convert (_q21, _q21_pops))
3427 : {
3428 588616 : tree _q40 = _q21_pops[0];
3429 588616 : {
3430 588616 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3431 588616 : tree res = generic_simplify_457 (loc, type, _p0, captures, BIT_AND_EXPR);
3432 588616 : if (res) return res;
3433 : }
3434 : }
3435 : }
3436 1368735 : switch (TREE_CODE (_q20))
3437 : {
3438 797861 : CASE_CONVERT:
3439 797861 : {
3440 797861 : tree _q30 = TREE_OPERAND (_q20, 0);
3441 797861 : {
3442 797861 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3443 797861 : tree res = generic_simplify_458 (loc, type, _p0, captures, BIT_AND_EXPR);
3444 797861 : if (res) return res;
3445 : }
3446 797861 : break;
3447 : }
3448 1368735 : default:;
3449 : }
3450 1368735 : switch (TREE_CODE (_q21))
3451 : {
3452 589397 : CASE_CONVERT:
3453 589397 : {
3454 589397 : tree _q40 = TREE_OPERAND (_q21, 0);
3455 589397 : {
3456 589397 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3457 589397 : tree res = generic_simplify_458 (loc, type, _p0, captures, BIT_AND_EXPR);
3458 589397 : if (res) return res;
3459 : }
3460 589397 : break;
3461 : }
3462 : default:;
3463 : }
3464 : break;
3465 : }
3466 1204736 : case BIT_IOR_EXPR:
3467 1204736 : {
3468 1204736 : tree _q20 = TREE_OPERAND (_p0, 0);
3469 1204736 : tree _q21 = TREE_OPERAND (_p0, 1);
3470 1204736 : {
3471 1204736 : tree _q20_pops[1];
3472 1204736 : if (tree_nop_convert (_q20, _q20_pops))
3473 : {
3474 469584 : tree _q30 = _q20_pops[0];
3475 469584 : {
3476 469584 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3477 469584 : tree res = generic_simplify_457 (loc, type, _p0, captures, BIT_IOR_EXPR);
3478 469584 : if (res) return res;
3479 : }
3480 : }
3481 : }
3482 1204736 : {
3483 1204736 : tree _q21_pops[1];
3484 1204736 : if (tree_nop_convert (_q21, _q21_pops))
3485 : {
3486 1125056 : tree _q40 = _q21_pops[0];
3487 1125056 : {
3488 1125056 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3489 1125056 : tree res = generic_simplify_457 (loc, type, _p0, captures, BIT_IOR_EXPR);
3490 1125056 : if (res) return res;
3491 : }
3492 : }
3493 : }
3494 1204736 : switch (TREE_CODE (_q20))
3495 : {
3496 488416 : CASE_CONVERT:
3497 488416 : {
3498 488416 : tree _q30 = TREE_OPERAND (_q20, 0);
3499 488416 : {
3500 488416 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3501 488416 : tree res = generic_simplify_458 (loc, type, _p0, captures, BIT_IOR_EXPR);
3502 488416 : if (res) return res;
3503 : }
3504 488416 : break;
3505 : }
3506 1204736 : default:;
3507 : }
3508 1204736 : switch (TREE_CODE (_q21))
3509 : {
3510 1133408 : CASE_CONVERT:
3511 1133408 : {
3512 1133408 : tree _q40 = TREE_OPERAND (_q21, 0);
3513 1133408 : {
3514 1133408 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3515 1133408 : tree res = generic_simplify_458 (loc, type, _p0, captures, BIT_IOR_EXPR);
3516 1133408 : if (res) return res;
3517 : }
3518 1133408 : break;
3519 : }
3520 : default:;
3521 : }
3522 : break;
3523 : }
3524 649083 : case BIT_XOR_EXPR:
3525 649083 : {
3526 649083 : tree _q20 = TREE_OPERAND (_p0, 0);
3527 649083 : tree _q21 = TREE_OPERAND (_p0, 1);
3528 649083 : {
3529 649083 : tree _q20_pops[1];
3530 649083 : if (tree_nop_convert (_q20, _q20_pops))
3531 : {
3532 380294 : tree _q30 = _q20_pops[0];
3533 380294 : {
3534 380294 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3535 380294 : tree res = generic_simplify_457 (loc, type, _p0, captures, BIT_XOR_EXPR);
3536 380294 : if (res) return res;
3537 : }
3538 : }
3539 : }
3540 649083 : {
3541 649083 : tree _q21_pops[1];
3542 649083 : if (tree_nop_convert (_q21, _q21_pops))
3543 : {
3544 526279 : tree _q40 = _q21_pops[0];
3545 526279 : {
3546 526279 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3547 526279 : tree res = generic_simplify_457 (loc, type, _p0, captures, BIT_XOR_EXPR);
3548 526279 : if (res) return res;
3549 : }
3550 : }
3551 : }
3552 649083 : switch (TREE_CODE (_q20))
3553 : {
3554 423916 : CASE_CONVERT:
3555 423916 : {
3556 423916 : tree _q30 = TREE_OPERAND (_q20, 0);
3557 423916 : {
3558 423916 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3559 423916 : tree res = generic_simplify_458 (loc, type, _p0, captures, BIT_XOR_EXPR);
3560 423916 : if (res) return res;
3561 : }
3562 423916 : break;
3563 : }
3564 649083 : default:;
3565 : }
3566 649083 : switch (TREE_CODE (_q21))
3567 : {
3568 568894 : CASE_CONVERT:
3569 568894 : {
3570 568894 : tree _q40 = TREE_OPERAND (_q21, 0);
3571 568894 : {
3572 568894 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3573 568894 : tree res = generic_simplify_458 (loc, type, _p0, captures, BIT_XOR_EXPR);
3574 568894 : if (res) return res;
3575 : }
3576 568894 : break;
3577 : }
3578 : default:;
3579 : }
3580 : break;
3581 : }
3582 9527932 : case MULT_EXPR:
3583 9527932 : {
3584 9527932 : tree _q20 = TREE_OPERAND (_p0, 0);
3585 9527932 : tree _q21 = TREE_OPERAND (_p0, 1);
3586 9527932 : if (tree_zero_one_valued_p (_q20))
3587 : {
3588 57113 : switch (TREE_CODE (_q21))
3589 : {
3590 51636 : case INTEGER_CST:
3591 51636 : {
3592 51636 : {
3593 51636 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
3594 51636 : if (INTEGRAL_TYPE_P (type)
3595 51636 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3596 51636 : && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (captures[0]))
3597 51642 : && (TYPE_UNSIGNED (type) || TYPE_PRECISION (type) > 1)
3598 : )
3599 : {
3600 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1085;
3601 6 : {
3602 6 : tree res_op0;
3603 6 : {
3604 6 : tree _o1[1], _r1;
3605 6 : _o1[0] = captures[1];
3606 6 : if (TREE_TYPE (_o1[0]) != type)
3607 : {
3608 6 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3609 : }
3610 : else
3611 : _r1 = _o1[0];
3612 6 : res_op0 = _r1;
3613 : }
3614 6 : tree res_op1;
3615 6 : {
3616 6 : tree _o1[1], _r1;
3617 6 : _o1[0] = captures[2];
3618 6 : if (TREE_TYPE (_o1[0]) != type)
3619 : {
3620 6 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3621 : }
3622 : else
3623 : _r1 = _o1[0];
3624 6 : res_op1 = _r1;
3625 : }
3626 6 : tree _r;
3627 6 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
3628 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 871, __FILE__, __LINE__, true);
3629 : return _r;
3630 : }
3631 0 : next_after_fail1085:;
3632 : }
3633 : }
3634 : break;
3635 : }
3636 : default:;
3637 : }
3638 : }
3639 : break;
3640 : }
3641 1217490 : case POINTER_DIFF_EXPR:
3642 1217490 : {
3643 1217490 : tree _q20 = TREE_OPERAND (_p0, 0);
3644 1217490 : tree _q21 = TREE_OPERAND (_p0, 1);
3645 1217490 : switch (TREE_CODE (_q21))
3646 : {
3647 200 : case INTEGER_CST:
3648 200 : {
3649 200 : {
3650 200 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3651 200 : if (POINTER_TYPE_P (type)
3652 : )
3653 : {
3654 18 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1086;
3655 18 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1086;
3656 18 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1086;
3657 18 : {
3658 18 : tree _r;
3659 18 : _r = build_fold_addr_expr_with_type
3660 : (build2 (MEM_REF, char_type_node, captures[0],
3661 : wide_int_to_tree (ptr_type_node, wi::neg (wi::to_wide (captures[1])))),
3662 : type);
3663 18 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
3664 : return _r;
3665 : }
3666 900764402 : next_after_fail1086:;
3667 : }
3668 : }
3669 : break;
3670 : }
3671 : default:;
3672 : }
3673 : break;
3674 : }
3675 218222 : case EQ_EXPR:
3676 218222 : {
3677 218222 : tree _q20 = TREE_OPERAND (_p0, 0);
3678 218222 : tree _q21 = TREE_OPERAND (_p0, 1);
3679 218222 : if (tree_zero_one_valued_p (_q20))
3680 : {
3681 1757 : switch (TREE_CODE (_q21))
3682 : {
3683 823 : case INTEGER_CST:
3684 823 : {
3685 823 : {
3686 823 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3687 823 : tree res = generic_simplify_459 (loc, type, _p0, captures, EQ_EXPR);
3688 823 : if (res) return res;
3689 : }
3690 775 : break;
3691 : }
3692 : default:;
3693 : }
3694 : }
3695 : break;
3696 : }
3697 270723 : case NE_EXPR:
3698 270723 : {
3699 270723 : tree _q20 = TREE_OPERAND (_p0, 0);
3700 270723 : tree _q21 = TREE_OPERAND (_p0, 1);
3701 270723 : if (tree_zero_one_valued_p (_q20))
3702 : {
3703 1907 : switch (TREE_CODE (_q21))
3704 : {
3705 1573 : case INTEGER_CST:
3706 1573 : {
3707 1573 : {
3708 1573 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3709 1573 : tree res = generic_simplify_459 (loc, type, _p0, captures, NE_EXPR);
3710 1573 : if (res) return res;
3711 : }
3712 9 : break;
3713 : }
3714 : default:;
3715 : }
3716 : }
3717 : break;
3718 : }
3719 2001 : case MIN_EXPR:
3720 2001 : {
3721 2001 : tree _q20 = TREE_OPERAND (_p0, 0);
3722 2001 : tree _q21 = TREE_OPERAND (_p0, 1);
3723 2001 : switch (TREE_CODE (_q20))
3724 : {
3725 733 : CASE_CONVERT:
3726 733 : {
3727 733 : tree _q30 = TREE_OPERAND (_q20, 0);
3728 733 : switch (TREE_CODE (_q21))
3729 : {
3730 659 : case INTEGER_CST:
3731 659 : {
3732 659 : {
3733 659 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q21 };
3734 659 : tree res = generic_simplify_460 (loc, type, _p0, captures, MIN_EXPR);
3735 659 : if (res) return res;
3736 : }
3737 659 : break;
3738 : }
3739 : default:;
3740 : }
3741 : break;
3742 : }
3743 : default:;
3744 : }
3745 : break;
3746 : }
3747 277244 : case MAX_EXPR:
3748 277244 : {
3749 277244 : tree _q20 = TREE_OPERAND (_p0, 0);
3750 277244 : tree _q21 = TREE_OPERAND (_p0, 1);
3751 277244 : switch (TREE_CODE (_q20))
3752 : {
3753 7485 : CASE_CONVERT:
3754 7485 : {
3755 7485 : tree _q30 = TREE_OPERAND (_q20, 0);
3756 7485 : switch (TREE_CODE (_q21))
3757 : {
3758 7445 : case INTEGER_CST:
3759 7445 : {
3760 7445 : {
3761 7445 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q21 };
3762 7445 : tree res = generic_simplify_460 (loc, type, _p0, captures, MAX_EXPR);
3763 7445 : if (res) return res;
3764 : }
3765 7445 : break;
3766 : }
3767 : default:;
3768 : }
3769 : break;
3770 : }
3771 : default:;
3772 : }
3773 : break;
3774 : }
3775 470565 : case LSHIFT_EXPR:
3776 470565 : {
3777 470565 : tree _q20 = TREE_OPERAND (_p0, 0);
3778 470565 : tree _q21 = TREE_OPERAND (_p0, 1);
3779 470565 : switch (TREE_CODE (_q21))
3780 : {
3781 141907 : case INTEGER_CST:
3782 141907 : {
3783 141907 : {
3784 141907 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
3785 141907 : if (INTEGRAL_TYPE_P (type)
3786 141880 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3787 141880 : && !integer_zerop (captures[2])
3788 283014 : && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (captures[0]))
3789 : )
3790 : {
3791 139821 : if (TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (captures[0]))
3792 139821 : || wi::ltu_p (wi::to_wide (captures[2]), TYPE_PRECISION (type))
3793 : )
3794 : {
3795 139493 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1087;
3796 139493 : {
3797 139493 : tree res_op0;
3798 139493 : {
3799 139493 : tree _o1[1], _r1;
3800 139493 : _o1[0] = captures[1];
3801 139493 : if (TREE_TYPE (_o1[0]) != type)
3802 : {
3803 130419 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3804 : }
3805 : else
3806 : _r1 = _o1[0];
3807 139493 : res_op0 = _r1;
3808 : }
3809 139493 : tree res_op1;
3810 139493 : res_op1 = captures[2];
3811 139493 : tree _r;
3812 139493 : _r = fold_build2_loc (loc, LSHIFT_EXPR, type, res_op0, res_op1);
3813 139493 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 873, __FILE__, __LINE__, true);
3814 : return _r;
3815 : }
3816 0 : next_after_fail1087:;
3817 : }
3818 : else
3819 : {
3820 328 : if (wi::ltu_p (wi::to_wide (captures[2]), TYPE_PRECISION (TREE_TYPE (captures[0])))
3821 : )
3822 : {
3823 279 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1088;
3824 279 : {
3825 279 : tree _r;
3826 279 : _r = build_zero_cst (type);
3827 279 : if (TREE_SIDE_EFFECTS (captures[1]))
3828 14 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3829 279 : if (TREE_SIDE_EFFECTS (captures[2]))
3830 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
3831 279 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 874, __FILE__, __LINE__, true);
3832 : return _r;
3833 : }
3834 0 : next_after_fail1088:;
3835 : }
3836 : }
3837 : }
3838 : }
3839 : break;
3840 : }
3841 : default:;
3842 : }
3843 : break;
3844 : }
3845 900764402 : default:;
3846 : }
3847 900764402 : {
3848 900764402 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3849 1801528804 : if ((
3850 :
3851 : && useless_type_conversion_p (type, TREE_TYPE (captures[0])))
3852 : || (
3853 : 1
3854 900764402 : && type == TREE_TYPE (captures[0]))
3855 : )
3856 : {
3857 51658822 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1089;
3858 51658822 : {
3859 51658822 : tree _r;
3860 51658822 : _r = captures[0];
3861 51658822 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 875, __FILE__, __LINE__, true);
3862 900923812 : return _r;
3863 : }
3864 0 : next_after_fail1089:;
3865 : }
3866 : }
3867 849105580 : switch (TREE_CODE (_p0))
3868 : {
3869 142329275 : CASE_CONVERT:
3870 142329275 : {
3871 142329275 : tree _q20 = TREE_OPERAND (_p0, 0);
3872 142329275 : {
3873 142329275 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3874 142329275 : {
3875 142329275 : tree inside_type = TREE_TYPE (captures[1]);
3876 142329275 : tree inter_type = TREE_TYPE (captures[0]);
3877 142329275 : int inside_int = ANY_INTEGRAL_TYPE_P (inside_type);
3878 142329275 : int inside_ptr = POINTER_TYPE_P (inside_type);
3879 142329275 : int inside_float = FLOAT_TYPE_P (inside_type);
3880 142329275 : unsigned int inside_prec = element_precision (inside_type);
3881 142329275 : int inside_unsignedp = TYPE_UNSIGNED (inside_type);
3882 142329275 : int inter_int = ANY_INTEGRAL_TYPE_P (inter_type);
3883 142329275 : int inter_ptr = POINTER_TYPE_P (inter_type);
3884 142329275 : int inter_float = FLOAT_TYPE_P (inter_type);
3885 142329275 : unsigned int inter_prec = element_precision (inter_type);
3886 142329275 : int inter_unsignedp = TYPE_UNSIGNED (inter_type);
3887 142329275 : int final_int = ANY_INTEGRAL_TYPE_P (type);
3888 142329275 : int final_ptr = POINTER_TYPE_P (type);
3889 142329275 : int final_float = FLOAT_TYPE_P (type);
3890 142329275 : unsigned int final_prec = element_precision (type);
3891 142329275 : int final_unsignedp = TYPE_UNSIGNED (type);
3892 142329275 : int is_vec = VECTOR_TYPE_P (type);
3893 142329275 : gcc_checking_assert (is_vec == VECTOR_TYPE_P (inside_type)
3894 : && is_vec == VECTOR_TYPE_P (inter_type));
3895 142329275 : if (((
3896 :
3897 : && useless_type_conversion_p (type, inside_type))
3898 : || (
3899 : 1
3900 142329275 : && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
3901 23603161 : && (((inter_int || inter_ptr) && final_int)
3902 17773183 : || (inter_float && final_float))
3903 5916457 : && inter_prec >= final_prec
3904 147708815 : && (! is_vec
3905 0 : || supportable_convert_operation (CONVERT_EXPR, type, TREE_TYPE (captures[1])))
3906 : )
3907 : {
3908 5379540 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1090;
3909 5379540 : {
3910 5379540 : tree res_op0;
3911 5379540 : res_op0 = captures[1];
3912 5379540 : tree _r;
3913 5379540 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3914 5379540 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
3915 : return _r;
3916 : }
3917 0 : next_after_fail1090:;
3918 : }
3919 : else
3920 : {
3921 123973998 : if (((inter_int && inside_int) || (inter_float && inside_float))
3922 13086449 : && (final_int || final_float)
3923 12954679 : && inter_prec >= inside_prec
3924 11640452 : && (inter_float || inter_unsignedp == inside_unsignedp)
3925 145024862 : && (! is_vec
3926 0 : || supportable_convert_operation (CONVERT_EXPR, type, TREE_TYPE (captures[1])))
3927 : )
3928 : {
3929 8075127 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1091;
3930 8075127 : {
3931 8075127 : tree res_op0;
3932 8075127 : res_op0 = captures[1];
3933 8075127 : tree _r;
3934 8075127 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3935 8075127 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
3936 : return _r;
3937 : }
3938 0 : next_after_fail1091:;
3939 : }
3940 : else
3941 : {
3942 5004617 : if (inside_int && inter_int && final_int
3943 4872851 : && ((inside_prec < inter_prec && inter_prec < final_prec
3944 184593 : && inside_unsignedp && !inter_unsignedp)
3945 4715066 : || final_prec == inter_prec
3946 2349012 : || (inside_prec < inter_prec && inter_prec > final_prec
3947 152030 : && !inside_unsignedp && inter_unsignedp))
3948 131462716 : && (! is_vec
3949 0 : || supportable_convert_operation (CONVERT_EXPR, type, TREE_TYPE (captures[1])))
3950 : )
3951 : {
3952 2588108 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1092;
3953 2588108 : {
3954 2588108 : tree res_op0;
3955 2588108 : res_op0 = captures[1];
3956 2588108 : tree _r;
3957 2588108 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3958 2588108 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
3959 : return _r;
3960 : }
3961 0 : next_after_fail1092:;
3962 : }
3963 : else
3964 : {
3965 126286500 : if (! inside_float && ! inter_float && ! final_float
3966 : && ! is_vec
3967 126279795 : && (inter_prec >= inside_prec || inter_prec >= final_prec)
3968 125524161 : && ! (inside_int && inter_int
3969 1660875 : && inter_unsignedp != inside_unsignedp
3970 1660875 : && inter_prec < final_prec)
3971 124170829 : && ((inter_unsignedp && inter_prec > inside_prec)
3972 124170829 : == (final_unsignedp && final_prec > inter_prec))
3973 124147078 : && ! (inside_ptr && inter_prec != final_prec)
3974 123643777 : && ! (final_ptr && inside_prec != inter_prec)
3975 : )
3976 : {
3977 123622871 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1093;
3978 123622871 : {
3979 123622871 : tree res_op0;
3980 123622871 : res_op0 = captures[1];
3981 123622871 : tree _r;
3982 123622871 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3983 123622871 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 879, __FILE__, __LINE__, true);
3984 : return _r;
3985 : }
3986 0 : next_after_fail1093:;
3987 0 : }
3988 : else
3989 : {
3990 2663629 : if (inside_int && inter_int && final_int
3991 2138741 : && final_prec <= inside_prec
3992 694853 : && inter_prec >= inside_prec
3993 2663629 : && (! is_vec
3994 0 : || supportable_convert_operation (CONVERT_EXPR, type, TREE_TYPE (captures[1])))
3995 : )
3996 : {
3997 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1094;
3998 0 : {
3999 0 : tree res_op0;
4000 0 : res_op0 = captures[1];
4001 0 : tree _r;
4002 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4003 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 880, __FILE__, __LINE__, true);
4004 : return _r;
4005 : }
4006 0 : next_after_fail1094:;
4007 : }
4008 : else
4009 : {
4010 : if (0
4011 : && final_int && inter_int && inside_int
4012 : && ! is_vec
4013 : && final_prec >= inside_prec
4014 : && inside_prec > inter_prec
4015 : && inter_unsignedp
4016 : )
4017 : {
4018 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1095;
4019 : {
4020 : tree res_op0;
4021 : {
4022 : tree _o1[2], _r1;
4023 : _o1[0] = captures[1];
4024 : _o1[1] = wide_int_to_tree
4025 : (inside_type,
4026 : wi::mask (inter_prec, false,
4027 : TYPE_PRECISION (inside_type)));
4028 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4029 : res_op0 = _r1;
4030 : }
4031 : tree _r;
4032 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4033 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 881, __FILE__, __LINE__, true);
4034 : return _r;
4035 : }
4036 : next_after_fail1095:;
4037 : }
4038 : else
4039 : {
4040 : if (0
4041 : && inside_int && inter_float && final_int
4042 : && ! is_vec
4043 : && ((unsigned) significand_size (TYPE_MODE (inter_type))
4044 : >= inside_prec - !inside_unsignedp)
4045 : )
4046 : {
4047 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1096;
4048 : {
4049 : tree res_op0;
4050 : res_op0 = captures[1];
4051 : tree _r;
4052 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4053 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 882, __FILE__, __LINE__, true);
4054 : return _r;
4055 : }
4056 : next_after_fail1096:;
4057 : }
4058 : }
4059 : }
4060 : }
4061 : }
4062 : }
4063 : }
4064 : }
4065 : }
4066 : break;
4067 : }
4068 3067 : case FLOAT_EXPR:
4069 3067 : {
4070 3067 : tree _q20 = TREE_OPERAND (_p0, 0);
4071 3067 : {
4072 3067 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
4073 3067 : {
4074 3067 : tree inside_type = TREE_TYPE (captures[1]);
4075 3067 : tree inter_type = TREE_TYPE (captures[0]);
4076 3067 : int inside_int = ANY_INTEGRAL_TYPE_P (inside_type);
4077 3067 : int inside_ptr = POINTER_TYPE_P (inside_type);
4078 3067 : int inside_float = FLOAT_TYPE_P (inside_type);
4079 3067 : unsigned int inside_prec = element_precision (inside_type);
4080 3067 : int inside_unsignedp = TYPE_UNSIGNED (inside_type);
4081 3067 : int inter_int = ANY_INTEGRAL_TYPE_P (inter_type);
4082 3067 : int inter_ptr = POINTER_TYPE_P (inter_type);
4083 3067 : int inter_float = FLOAT_TYPE_P (inter_type);
4084 3067 : unsigned int inter_prec = element_precision (inter_type);
4085 3067 : int inter_unsignedp = TYPE_UNSIGNED (inter_type);
4086 3067 : int final_int = ANY_INTEGRAL_TYPE_P (type);
4087 3067 : int final_ptr = POINTER_TYPE_P (type);
4088 3067 : int final_float = FLOAT_TYPE_P (type);
4089 3067 : unsigned int final_prec = element_precision (type);
4090 3067 : int final_unsignedp = TYPE_UNSIGNED (type);
4091 3067 : int is_vec = VECTOR_TYPE_P (type);
4092 3067 : gcc_checking_assert (is_vec == VECTOR_TYPE_P (inside_type)
4093 : && is_vec == VECTOR_TYPE_P (inter_type));
4094 3067 : if (((
4095 :
4096 : && useless_type_conversion_p (type, inside_type))
4097 : || (
4098 : 1
4099 3067 : && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
4100 0 : && (((inter_int || inter_ptr) && final_int)
4101 0 : || (inter_float && final_float))
4102 0 : && inter_prec >= final_prec
4103 3067 : && (! is_vec
4104 0 : || supportable_convert_operation (CONVERT_EXPR, type, TREE_TYPE (captures[1])))
4105 : )
4106 : {
4107 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1097;
4108 0 : {
4109 0 : tree res_op0;
4110 0 : res_op0 = captures[1];
4111 0 : tree _r;
4112 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4113 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
4114 : return _r;
4115 : }
4116 0 : next_after_fail1097:;
4117 : }
4118 : else
4119 : {
4120 3067 : if (((inter_int && inside_int) || (inter_float && inside_float))
4121 0 : && (final_int || final_float)
4122 0 : && inter_prec >= inside_prec
4123 0 : && (inter_float || inter_unsignedp == inside_unsignedp)
4124 3067 : && (! is_vec
4125 0 : || supportable_convert_operation (CONVERT_EXPR, type, TREE_TYPE (captures[1])))
4126 : )
4127 : {
4128 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1098;
4129 0 : {
4130 0 : tree res_op0;
4131 0 : res_op0 = captures[1];
4132 0 : tree _r;
4133 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4134 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
4135 : return _r;
4136 : }
4137 0 : next_after_fail1098:;
4138 : }
4139 : else
4140 : {
4141 0 : if (inside_int && inter_int && final_int
4142 0 : && ((inside_prec < inter_prec && inter_prec < final_prec
4143 0 : && inside_unsignedp && !inter_unsignedp)
4144 0 : || final_prec == inter_prec
4145 0 : || (inside_prec < inter_prec && inter_prec > final_prec
4146 0 : && !inside_unsignedp && inter_unsignedp))
4147 3067 : && (! is_vec
4148 0 : || supportable_convert_operation (CONVERT_EXPR, type, TREE_TYPE (captures[1])))
4149 : )
4150 : {
4151 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1099;
4152 0 : {
4153 0 : tree res_op0;
4154 0 : res_op0 = captures[1];
4155 0 : tree _r;
4156 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4157 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
4158 : return _r;
4159 : }
4160 0 : next_after_fail1099:;
4161 : }
4162 : else
4163 : {
4164 3067 : if (! inside_float && ! inter_float && ! final_float
4165 : && ! is_vec
4166 0 : && (inter_prec >= inside_prec || inter_prec >= final_prec)
4167 0 : && ! (inside_int && inter_int
4168 0 : && inter_unsignedp != inside_unsignedp
4169 0 : && inter_prec < final_prec)
4170 0 : && ((inter_unsignedp && inter_prec > inside_prec)
4171 0 : == (final_unsignedp && final_prec > inter_prec))
4172 0 : && ! (inside_ptr && inter_prec != final_prec)
4173 0 : && ! (final_ptr && inside_prec != inter_prec)
4174 : )
4175 : {
4176 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1100;
4177 0 : {
4178 0 : tree res_op0;
4179 0 : res_op0 = captures[1];
4180 0 : tree _r;
4181 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4182 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 879, __FILE__, __LINE__, true);
4183 : return _r;
4184 : }
4185 0 : next_after_fail1100:;
4186 0 : }
4187 : else
4188 : {
4189 3067 : if (inside_int && inter_int && final_int
4190 0 : && final_prec <= inside_prec
4191 0 : && inter_prec >= inside_prec
4192 3067 : && (! is_vec
4193 0 : || supportable_convert_operation (CONVERT_EXPR, type, TREE_TYPE (captures[1])))
4194 : )
4195 : {
4196 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1101;
4197 0 : {
4198 0 : tree res_op0;
4199 0 : res_op0 = captures[1];
4200 0 : tree _r;
4201 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4202 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 880, __FILE__, __LINE__, true);
4203 : return _r;
4204 : }
4205 0 : next_after_fail1101:;
4206 : }
4207 : else
4208 : {
4209 : if (0
4210 : && final_int && inter_int && inside_int
4211 : && ! is_vec
4212 : && final_prec >= inside_prec
4213 : && inside_prec > inter_prec
4214 : && inter_unsignedp
4215 : )
4216 : {
4217 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1102;
4218 : {
4219 : tree res_op0;
4220 : {
4221 : tree _o1[2], _r1;
4222 : _o1[0] = captures[1];
4223 : _o1[1] = wide_int_to_tree
4224 : (inside_type,
4225 : wi::mask (inter_prec, false,
4226 : TYPE_PRECISION (inside_type)));
4227 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4228 : res_op0 = _r1;
4229 : }
4230 : tree _r;
4231 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4232 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 881, __FILE__, __LINE__, true);
4233 : return _r;
4234 : }
4235 : next_after_fail1102:;
4236 : }
4237 : else
4238 : {
4239 : if (0
4240 : && inside_int && inter_float && final_int
4241 : && ! is_vec
4242 : && ((unsigned) significand_size (TYPE_MODE (inter_type))
4243 : >= inside_prec - !inside_unsignedp)
4244 : )
4245 : {
4246 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1103;
4247 : {
4248 : tree res_op0;
4249 : res_op0 = captures[1];
4250 : tree _r;
4251 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4252 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 882, __FILE__, __LINE__, true);
4253 : return _r;
4254 : }
4255 : next_after_fail1103:;
4256 : }
4257 : }
4258 : }
4259 : }
4260 : }
4261 : }
4262 : }
4263 : }
4264 : }
4265 : break;
4266 : }
4267 999949 : case BIT_AND_EXPR:
4268 999949 : {
4269 999949 : tree _q20 = TREE_OPERAND (_p0, 0);
4270 999949 : tree _q21 = TREE_OPERAND (_p0, 1);
4271 999949 : switch (TREE_CODE (_q21))
4272 : {
4273 294420 : case INTEGER_CST:
4274 294420 : {
4275 294420 : {
4276 294420 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4277 294420 : if (INTEGRAL_TYPE_P (type)
4278 293912 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4279 293912 : && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (captures[0]))
4280 506396 : && operand_equal_p (captures[1], build_low_bits_mask (TREE_TYPE (captures[1]),
4281 211976 : TYPE_PRECISION (type)), 0)
4282 : )
4283 : {
4284 13402 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1104;
4285 13402 : {
4286 13402 : tree res_op0;
4287 13402 : res_op0 = captures[0];
4288 13402 : tree _r;
4289 13402 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4290 13402 : if (TREE_SIDE_EFFECTS (captures[1]))
4291 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4292 13402 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 883, __FILE__, __LINE__, true);
4293 : return _r;
4294 : }
4295 0 : next_after_fail1104:;
4296 : }
4297 : }
4298 : break;
4299 : }
4300 : default:;
4301 : }
4302 : break;
4303 : }
4304 5 : case VEC_COND_EXPR:
4305 5 : {
4306 5 : tree _q20 = TREE_OPERAND (_p0, 0);
4307 5 : tree _q21 = TREE_OPERAND (_p0, 1);
4308 5 : tree _q22 = TREE_OPERAND (_p0, 2);
4309 5 : {
4310 5 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
4311 5 : if (VECTOR_TYPE_P (type)
4312 0 : && types_match (TREE_TYPE (captures[1]), truth_type_for (type))
4313 5 : && (expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
4314 0 : || !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1])))
4315 : )
4316 : {
4317 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1105;
4318 0 : {
4319 0 : tree res_op0;
4320 0 : res_op0 = captures[1];
4321 0 : tree res_op1;
4322 0 : {
4323 0 : tree _o1[1], _r1;
4324 0 : _o1[0] = captures[2];
4325 0 : if (TREE_TYPE (_o1[0]) != type)
4326 : {
4327 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4328 0 : if (EXPR_P (_r1))
4329 0 : goto next_after_fail1105;
4330 : }
4331 : else
4332 : _r1 = _o1[0];
4333 0 : res_op1 = _r1;
4334 : }
4335 0 : tree res_op2;
4336 0 : {
4337 0 : tree _o1[1], _r1;
4338 0 : _o1[0] = captures[3];
4339 0 : if (TREE_TYPE (_o1[0]) != type)
4340 : {
4341 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4342 0 : if (EXPR_P (_r1))
4343 0 : goto next_after_fail1105;
4344 : }
4345 : else
4346 : _r1 = _o1[0];
4347 0 : res_op2 = _r1;
4348 : }
4349 0 : tree _r;
4350 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4351 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 884, __FILE__, __LINE__, true);
4352 : return _r;
4353 : }
4354 900923812 : next_after_fail1105:;
4355 : }
4356 : }
4357 : break;
4358 : }
4359 666039 : case COND_EXPR:
4360 666039 : {
4361 666039 : tree _q20 = TREE_OPERAND (_p0, 0);
4362 666039 : tree _q21 = TREE_OPERAND (_p0, 1);
4363 666039 : tree _q22 = TREE_OPERAND (_p0, 2);
4364 666039 : switch (TREE_CODE (_q21))
4365 : {
4366 186053 : case INTEGER_CST:
4367 186053 : {
4368 186053 : switch (TREE_CODE (_q22))
4369 : {
4370 118112 : case INTEGER_CST:
4371 118112 : {
4372 118112 : {
4373 118112 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
4374 118112 : if (INTEGRAL_TYPE_P (type)
4375 118112 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4376 : )
4377 : {
4378 118112 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1106;
4379 118112 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1106;
4380 118112 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1106;
4381 118112 : {
4382 118112 : tree res_op0;
4383 118112 : res_op0 = captures[1];
4384 118112 : tree res_op1;
4385 118112 : {
4386 118112 : tree _o1[1], _r1;
4387 118112 : _o1[0] = captures[2];
4388 118112 : if (TREE_TYPE (_o1[0]) != type)
4389 : {
4390 118112 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4391 : }
4392 : else
4393 : _r1 = _o1[0];
4394 118112 : res_op1 = _r1;
4395 : }
4396 118112 : tree res_op2;
4397 118112 : {
4398 118112 : tree _o1[1], _r1;
4399 118112 : _o1[0] = captures[3];
4400 118112 : if (TREE_TYPE (_o1[0]) != type)
4401 : {
4402 118112 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4403 : }
4404 : else
4405 : _r1 = _o1[0];
4406 118112 : res_op2 = _r1;
4407 : }
4408 118112 : tree _r;
4409 118112 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
4410 118112 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 885, __FILE__, __LINE__, true);
4411 : return _r;
4412 : }
4413 900923812 : next_after_fail1106:;
4414 : }
4415 : }
4416 : break;
4417 : }
4418 : default:;
4419 : }
4420 : break;
4421 : }
4422 : default:;
4423 : }
4424 : break;
4425 : }
4426 12022252 : case PLUS_EXPR:
4427 12022252 : {
4428 12022252 : tree _q20 = TREE_OPERAND (_p0, 0);
4429 12022252 : tree _q21 = TREE_OPERAND (_p0, 1);
4430 12022252 : switch (TREE_CODE (_q20))
4431 : {
4432 4629801 : CASE_CONVERT:
4433 4629801 : {
4434 4629801 : tree _q30 = TREE_OPERAND (_q20, 0);
4435 4629801 : switch (TREE_CODE (_q21))
4436 : {
4437 361338 : CASE_CONVERT:
4438 361338 : {
4439 361338 : tree _q50 = TREE_OPERAND (_q21, 0);
4440 361338 : {
4441 361338 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4442 361338 : tree res = generic_simplify_461 (loc, type, _p0, captures, PLUS_EXPR);
4443 361338 : if (res) return res;
4444 : }
4445 361282 : break;
4446 : }
4447 4629745 : default:;
4448 : }
4449 4629745 : {
4450 4629745 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4451 4629745 : tree res = generic_simplify_462 (loc, type, _p0, captures, PLUS_EXPR);
4452 4629745 : if (res) return res;
4453 : }
4454 4617255 : break;
4455 : }
4456 12009706 : default:;
4457 : }
4458 12009706 : switch (TREE_CODE (_q21))
4459 : {
4460 1631623 : CASE_CONVERT:
4461 1631623 : {
4462 1631623 : tree _q40 = TREE_OPERAND (_q21, 0);
4463 1631623 : {
4464 1631623 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4465 1631623 : tree res = generic_simplify_463 (loc, type, _p0, captures, PLUS_EXPR);
4466 1631623 : if (res) return res;
4467 : }
4468 1631623 : break;
4469 : }
4470 12009706 : default:;
4471 : }
4472 12009706 : {
4473 12009706 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4474 12009706 : tree res = generic_simplify_464 (loc, type, _p0, captures, PLUS_EXPR);
4475 12009706 : if (res) return res;
4476 : }
4477 12009672 : break;
4478 : }
4479 1021027 : case MINUS_EXPR:
4480 1021027 : {
4481 1021027 : tree _q20 = TREE_OPERAND (_p0, 0);
4482 1021027 : tree _q21 = TREE_OPERAND (_p0, 1);
4483 1021027 : switch (TREE_CODE (_q20))
4484 : {
4485 429521 : CASE_CONVERT:
4486 429521 : {
4487 429521 : tree _q30 = TREE_OPERAND (_q20, 0);
4488 429521 : switch (TREE_CODE (_q21))
4489 : {
4490 273370 : CASE_CONVERT:
4491 273370 : {
4492 273370 : tree _q50 = TREE_OPERAND (_q21, 0);
4493 273370 : {
4494 273370 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4495 273370 : tree res = generic_simplify_461 (loc, type, _p0, captures, MINUS_EXPR);
4496 273370 : if (res) return res;
4497 : }
4498 273341 : break;
4499 : }
4500 429492 : default:;
4501 : }
4502 429492 : {
4503 429492 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4504 429492 : tree res = generic_simplify_462 (loc, type, _p0, captures, MINUS_EXPR);
4505 429492 : if (res) return res;
4506 : }
4507 428372 : break;
4508 : }
4509 1019878 : default:;
4510 : }
4511 1019878 : switch (TREE_CODE (_q21))
4512 : {
4513 337156 : CASE_CONVERT:
4514 337156 : {
4515 337156 : tree _q40 = TREE_OPERAND (_q21, 0);
4516 337156 : {
4517 337156 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4518 337156 : tree res = generic_simplify_463 (loc, type, _p0, captures, MINUS_EXPR);
4519 337156 : if (res) return res;
4520 : }
4521 337146 : break;
4522 : }
4523 1019868 : default:;
4524 : }
4525 1019868 : {
4526 1019868 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4527 1019868 : tree res = generic_simplify_464 (loc, type, _p0, captures, MINUS_EXPR);
4528 1019868 : if (res) return res;
4529 : }
4530 1019836 : break;
4531 : }
4532 9301302 : case MULT_EXPR:
4533 9301302 : {
4534 9301302 : tree _q20 = TREE_OPERAND (_p0, 0);
4535 9301302 : tree _q21 = TREE_OPERAND (_p0, 1);
4536 9301302 : switch (TREE_CODE (_q20))
4537 : {
4538 4163739 : CASE_CONVERT:
4539 4163739 : {
4540 4163739 : tree _q30 = TREE_OPERAND (_q20, 0);
4541 4163739 : switch (TREE_CODE (_q21))
4542 : {
4543 359707 : CASE_CONVERT:
4544 359707 : {
4545 359707 : tree _q50 = TREE_OPERAND (_q21, 0);
4546 359707 : {
4547 359707 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4548 359707 : tree res = generic_simplify_461 (loc, type, _p0, captures, MULT_EXPR);
4549 359707 : if (res) return res;
4550 : }
4551 359707 : break;
4552 : }
4553 4163739 : default:;
4554 : }
4555 4163739 : {
4556 4163739 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4557 4163739 : tree res = generic_simplify_462 (loc, type, _p0, captures, MULT_EXPR);
4558 4163739 : if (res) return res;
4559 : }
4560 4163612 : break;
4561 : }
4562 9301175 : default:;
4563 : }
4564 9301175 : switch (TREE_CODE (_q21))
4565 : {
4566 800535 : CASE_CONVERT:
4567 800535 : {
4568 800535 : tree _q40 = TREE_OPERAND (_q21, 0);
4569 800535 : {
4570 800535 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4571 800535 : tree res = generic_simplify_463 (loc, type, _p0, captures, MULT_EXPR);
4572 800535 : if (res) return res;
4573 : }
4574 800535 : break;
4575 : }
4576 9301175 : default:;
4577 : }
4578 9301175 : {
4579 9301175 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4580 9301175 : tree res = generic_simplify_464 (loc, type, _p0, captures, MULT_EXPR);
4581 9301175 : if (res) return res;
4582 : }
4583 9301142 : break;
4584 : }
4585 3121 : case RDIV_EXPR:
4586 3121 : {
4587 3121 : tree _q20 = TREE_OPERAND (_p0, 0);
4588 3121 : tree _q21 = TREE_OPERAND (_p0, 1);
4589 3121 : switch (TREE_CODE (_q20))
4590 : {
4591 1005 : CASE_CONVERT:
4592 1005 : {
4593 1005 : tree _q30 = TREE_OPERAND (_q20, 0);
4594 1005 : switch (TREE_CODE (_q21))
4595 : {
4596 691 : CASE_CONVERT:
4597 691 : {
4598 691 : tree _q50 = TREE_OPERAND (_q21, 0);
4599 691 : {
4600 691 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4601 691 : tree res = generic_simplify_461 (loc, type, _p0, captures, RDIV_EXPR);
4602 691 : if (res) return res;
4603 : }
4604 690 : break;
4605 : }
4606 1004 : default:;
4607 : }
4608 1004 : {
4609 1004 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4610 1004 : tree res = generic_simplify_462 (loc, type, _p0, captures, RDIV_EXPR);
4611 1004 : if (res) return res;
4612 : }
4613 1002 : break;
4614 : }
4615 3118 : default:;
4616 : }
4617 3118 : switch (TREE_CODE (_q21))
4618 : {
4619 1690 : CASE_CONVERT:
4620 1690 : {
4621 1690 : tree _q40 = TREE_OPERAND (_q21, 0);
4622 1690 : {
4623 1690 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4624 1690 : tree res = generic_simplify_463 (loc, type, _p0, captures, RDIV_EXPR);
4625 1690 : if (res) return res;
4626 : }
4627 1045 : break;
4628 : }
4629 2473 : default:;
4630 : }
4631 2473 : {
4632 2473 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4633 2473 : tree res = generic_simplify_464 (loc, type, _p0, captures, RDIV_EXPR);
4634 2473 : if (res) return res;
4635 : }
4636 2431 : break;
4637 : }
4638 748726 : case NEGATE_EXPR:
4639 748726 : {
4640 748726 : tree _q20 = TREE_OPERAND (_p0, 0);
4641 748726 : {
4642 748726 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4643 748726 : tree res = generic_simplify_465 (loc, type, _p0, captures);
4644 748726 : if (res) return res;
4645 : }
4646 748704 : break;
4647 : }
4648 : default:;
4649 : }
4650 : return NULL_TREE;
4651 : }
4652 :
4653 : tree
4654 2138147 : generic_simplify_FLOOR_DIV_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
4655 : {
4656 2138147 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4657 2138147 : if (integer_onep (_p1))
4658 : {
4659 775900 : {
4660 775900 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4661 775900 : tree res = generic_simplify_196 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR);
4662 775900 : if (res) return res;
4663 : }
4664 : }
4665 1362247 : if (integer_zerop (_p0))
4666 : {
4667 4 : {
4668 4 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4669 4 : tree res = generic_simplify_331 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR);
4670 4 : if (res) return res;
4671 : }
4672 : }
4673 1362243 : switch (TREE_CODE (_p1))
4674 : {
4675 981 : case SSA_NAME:
4676 981 : {
4677 981 : {
4678 981 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4679 981 : tree res = generic_simplify_333 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR);
4680 981 : if (res) return res;
4681 : }
4682 981 : break;
4683 : }
4684 1362243 : default:;
4685 : }
4686 1362243 : if (integer_minus_onep (_p1))
4687 : {
4688 229 : {
4689 229 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4690 229 : tree res = generic_simplify_332 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR);
4691 229 : if (res) return res;
4692 : }
4693 : }
4694 1362182 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
4695 : {
4696 0 : {
4697 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4698 0 : tree res = generic_simplify_334 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR);
4699 0 : if (res) return res;
4700 : }
4701 : }
4702 1362182 : switch (TREE_CODE (_p1))
4703 : {
4704 0 : case ABS_EXPR:
4705 0 : {
4706 0 : tree _q30 = TREE_OPERAND (_p1, 0);
4707 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
4708 : {
4709 0 : {
4710 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4711 0 : tree res = generic_simplify_335 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR);
4712 0 : if (res) return res;
4713 : }
4714 : }
4715 : break;
4716 : }
4717 1362182 : default:;
4718 : }
4719 1362182 : switch (TREE_CODE (_p0))
4720 : {
4721 0 : case ABS_EXPR:
4722 0 : {
4723 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4724 0 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4725 : {
4726 0 : {
4727 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4728 0 : tree res = generic_simplify_335 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR);
4729 0 : if (res) return res;
4730 : }
4731 : }
4732 : break;
4733 : }
4734 1362182 : default:;
4735 : }
4736 1362182 : switch (TREE_CODE (_p1))
4737 : {
4738 0 : case NEGATE_EXPR:
4739 0 : {
4740 0 : tree _q30 = TREE_OPERAND (_p1, 0);
4741 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
4742 : {
4743 0 : {
4744 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4745 0 : tree res = generic_simplify_336 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR);
4746 0 : if (res) return res;
4747 : }
4748 : }
4749 : break;
4750 : }
4751 1362182 : default:;
4752 : }
4753 1362182 : switch (TREE_CODE (_p0))
4754 : {
4755 364 : case NEGATE_EXPR:
4756 364 : {
4757 364 : tree _q20 = TREE_OPERAND (_p0, 0);
4758 364 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4759 : {
4760 0 : {
4761 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4762 0 : tree res = generic_simplify_336 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR);
4763 0 : if (res) return res;
4764 : }
4765 : }
4766 : break;
4767 : }
4768 1362182 : default:;
4769 : }
4770 1362182 : {
4771 1362182 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4772 1362182 : tree res = generic_simplify_342 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR, TRUNC_DIV_EXPR);
4773 1362182 : if (res) return res;
4774 : }
4775 5580 : switch (TREE_CODE (_p0))
4776 : {
4777 388 : CASE_CONVERT:
4778 388 : {
4779 388 : tree _q20 = TREE_OPERAND (_p0, 0);
4780 388 : switch (TREE_CODE (_q20))
4781 : {
4782 0 : case BIT_AND_EXPR:
4783 0 : {
4784 0 : tree _q30 = TREE_OPERAND (_q20, 0);
4785 0 : tree _q31 = TREE_OPERAND (_q20, 1);
4786 0 : switch (TREE_CODE (_q31))
4787 : {
4788 0 : case INTEGER_CST:
4789 0 : {
4790 0 : switch (TREE_CODE (_p1))
4791 : {
4792 0 : case INTEGER_CST:
4793 0 : {
4794 0 : {
4795 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
4796 0 : tree res = generic_simplify_338 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR);
4797 0 : if (res) return res;
4798 : }
4799 0 : break;
4800 : }
4801 : default:;
4802 : }
4803 : break;
4804 : }
4805 : default:;
4806 : }
4807 : break;
4808 : }
4809 : default:;
4810 : }
4811 : break;
4812 : }
4813 0 : case BIT_AND_EXPR:
4814 0 : {
4815 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4816 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4817 0 : switch (TREE_CODE (_q21))
4818 : {
4819 0 : case INTEGER_CST:
4820 0 : {
4821 0 : switch (TREE_CODE (_p1))
4822 : {
4823 0 : case INTEGER_CST:
4824 0 : {
4825 0 : {
4826 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4827 0 : tree res = generic_simplify_338 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR);
4828 0 : if (res) return res;
4829 : }
4830 0 : break;
4831 : }
4832 : default:;
4833 : }
4834 : break;
4835 : }
4836 : default:;
4837 : }
4838 : break;
4839 : }
4840 0 : case MULT_EXPR:
4841 0 : {
4842 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4843 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4844 0 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
4845 : {
4846 0 : {
4847 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
4848 0 : tree res = generic_simplify_340 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR);
4849 0 : if (res) return res;
4850 : }
4851 : }
4852 0 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4853 : {
4854 0 : {
4855 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
4856 0 : tree res = generic_simplify_340 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR);
4857 0 : if (res) return res;
4858 : }
4859 : }
4860 0 : switch (TREE_CODE (_q21))
4861 : {
4862 0 : case INTEGER_CST:
4863 0 : {
4864 0 : switch (TREE_CODE (_p1))
4865 : {
4866 0 : case MULT_EXPR:
4867 0 : {
4868 0 : tree _q50 = TREE_OPERAND (_p1, 0);
4869 0 : tree _q51 = TREE_OPERAND (_p1, 1);
4870 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4871 : {
4872 0 : switch (TREE_CODE (_q51))
4873 : {
4874 0 : case INTEGER_CST:
4875 0 : {
4876 0 : {
4877 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
4878 0 : tree res = generic_simplify_341 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR);
4879 0 : if (res) return res;
4880 : }
4881 0 : break;
4882 : }
4883 : default:;
4884 : }
4885 : }
4886 : break;
4887 : }
4888 : default:;
4889 : }
4890 : break;
4891 : }
4892 : default:;
4893 : }
4894 : break;
4895 : }
4896 0 : case VEC_COND_EXPR:
4897 0 : {
4898 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4899 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4900 0 : tree _q22 = TREE_OPERAND (_p0, 2);
4901 0 : switch (TREE_CODE (_p1))
4902 : {
4903 0 : case VEC_COND_EXPR:
4904 0 : {
4905 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4906 0 : tree _q61 = TREE_OPERAND (_p1, 1);
4907 0 : tree _q62 = TREE_OPERAND (_p1, 2);
4908 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4909 : {
4910 0 : {
4911 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
4912 0 : if (VECTOR_TYPE_P (type)
4913 : && (TREE_CODE_CLASS (FLOOR_DIV_EXPR) != tcc_comparison
4914 : || types_match (type, TREE_TYPE (captures[2]))
4915 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
4916 : || (optimize_vectors_before_lowering_p ()
4917 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
4918 : )
4919 : {
4920 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1662;
4921 0 : {
4922 0 : tree res_op0;
4923 0 : res_op0 = captures[1];
4924 0 : tree res_op1;
4925 0 : {
4926 0 : tree _o1[2], _r1;
4927 0 : _o1[0] = captures[2];
4928 0 : _o1[1] = captures[5];
4929 0 : _r1 = fold_build2_loc (loc, FLOOR_DIV_EXPR, type, _o1[0], _o1[1]);
4930 0 : if (EXPR_P (_r1))
4931 0 : goto next_after_fail1662;
4932 0 : res_op1 = _r1;
4933 : }
4934 0 : tree res_op2;
4935 0 : {
4936 0 : tree _o1[2], _r1;
4937 0 : _o1[0] = captures[3];
4938 0 : _o1[1] = captures[6];
4939 0 : _r1 = fold_build2_loc (loc, FLOOR_DIV_EXPR, type, _o1[0], _o1[1]);
4940 0 : if (EXPR_P (_r1))
4941 0 : goto next_after_fail1662;
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", 938, __FILE__, __LINE__, true);
4947 : return _r;
4948 : }
4949 0 : next_after_fail1662:;
4950 : }
4951 : }
4952 : }
4953 : break;
4954 : }
4955 0 : default:;
4956 : }
4957 0 : {
4958 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
4959 0 : if (VECTOR_TYPE_P (type)
4960 : && (TREE_CODE_CLASS (FLOOR_DIV_EXPR) != tcc_comparison
4961 : || types_match (type, TREE_TYPE (captures[2]))
4962 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
4963 : || (optimize_vectors_before_lowering_p ()
4964 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
4965 : )
4966 : {
4967 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1663;
4968 0 : {
4969 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1663;
4970 0 : tree res_op0;
4971 0 : res_op0 = captures[1];
4972 0 : tree res_op1;
4973 0 : {
4974 0 : tree _o1[2], _r1;
4975 0 : _o1[0] = captures[2];
4976 0 : _o1[1] = unshare_expr (captures[4]);
4977 0 : _r1 = fold_build2_loc (loc, FLOOR_DIV_EXPR, type, _o1[0], _o1[1]);
4978 0 : if (EXPR_P (_r1))
4979 0 : goto next_after_fail1663;
4980 0 : res_op1 = _r1;
4981 : }
4982 0 : tree res_op2;
4983 0 : {
4984 0 : tree _o1[2], _r1;
4985 0 : _o1[0] = captures[3];
4986 0 : _o1[1] = captures[4];
4987 0 : _r1 = fold_build2_loc (loc, FLOOR_DIV_EXPR, type, _o1[0], _o1[1]);
4988 0 : if (EXPR_P (_r1))
4989 0 : goto next_after_fail1663;
4990 0 : res_op2 = _r1;
4991 : }
4992 0 : tree _r;
4993 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4994 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 940, __FILE__, __LINE__, true);
4995 : return _r;
4996 : }
4997 5580 : next_after_fail1663:;
4998 : }
4999 : }
5000 : break;
5001 : }
5002 5580 : default:;
5003 : }
5004 5580 : switch (TREE_CODE (_p1))
5005 : {
5006 0 : case VEC_COND_EXPR:
5007 0 : {
5008 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5009 0 : tree _q31 = TREE_OPERAND (_p1, 1);
5010 0 : tree _q32 = TREE_OPERAND (_p1, 2);
5011 0 : {
5012 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
5013 0 : if (VECTOR_TYPE_P (type)
5014 : && (TREE_CODE_CLASS (FLOOR_DIV_EXPR) != tcc_comparison
5015 : || types_match (type, TREE_TYPE (captures[3]))
5016 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
5017 : || (optimize_vectors_before_lowering_p ()
5018 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
5019 : )
5020 : {
5021 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1664;
5022 0 : {
5023 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1664;
5024 0 : tree res_op0;
5025 0 : res_op0 = captures[2];
5026 0 : tree res_op1;
5027 0 : {
5028 0 : tree _o1[2], _r1;
5029 0 : _o1[0] = unshare_expr (captures[0]);
5030 0 : _o1[1] = captures[3];
5031 0 : _r1 = fold_build2_loc (loc, FLOOR_DIV_EXPR, type, _o1[0], _o1[1]);
5032 0 : if (EXPR_P (_r1))
5033 0 : goto next_after_fail1664;
5034 0 : res_op1 = _r1;
5035 : }
5036 0 : tree res_op2;
5037 0 : {
5038 0 : tree _o1[2], _r1;
5039 0 : _o1[0] = captures[0];
5040 0 : _o1[1] = captures[4];
5041 0 : _r1 = fold_build2_loc (loc, FLOOR_DIV_EXPR, type, _o1[0], _o1[1]);
5042 0 : if (EXPR_P (_r1))
5043 0 : goto next_after_fail1664;
5044 0 : res_op2 = _r1;
5045 : }
5046 0 : tree _r;
5047 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
5048 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 941, __FILE__, __LINE__, true);
5049 : return _r;
5050 : }
5051 2138147 : next_after_fail1664:;
5052 : }
5053 : }
5054 : break;
5055 : }
5056 : default:;
5057 : }
5058 : return NULL_TREE;
5059 : }
5060 :
5061 : tree
5062 889686 : generic_simplify_FLOOR_MOD_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
5063 : {
5064 889686 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
5065 889686 : {
5066 889686 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
5067 889686 : tree res = generic_simplify_342 (loc, type, _p0, _p1, captures, FLOOR_MOD_EXPR, TRUNC_MOD_EXPR);
5068 889686 : if (res) return res;
5069 : }
5070 3552 : if (integer_zerop (_p0))
5071 : {
5072 0 : {
5073 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
5074 0 : tree res = generic_simplify_343 (loc, type, _p0, _p1, captures, FLOOR_MOD_EXPR);
5075 0 : if (res) return res;
5076 : }
5077 : }
5078 3552 : if (integer_onep (_p1))
5079 : {
5080 0 : {
5081 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
5082 0 : tree res = generic_simplify_344 (loc, type, _p0, _p1, captures, FLOOR_MOD_EXPR);
5083 0 : if (res) return res;
5084 : }
5085 : }
5086 3552 : if (integer_minus_onep (_p1))
5087 : {
5088 0 : {
5089 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
5090 0 : tree res = generic_simplify_345 (loc, type, _p0, _p1, captures, FLOOR_MOD_EXPR);
5091 0 : if (res) return res;
5092 : }
5093 : }
5094 3552 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
5095 : {
5096 0 : {
5097 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
5098 0 : tree res = generic_simplify_346 (loc, type, _p0, _p1, captures, FLOOR_MOD_EXPR);
5099 0 : if (res) return res;
5100 : }
5101 : }
5102 3552 : switch (TREE_CODE (_p0))
5103 : {
5104 0 : case FLOOR_MOD_EXPR:
5105 0 : {
5106 0 : tree _q20 = TREE_OPERAND (_p0, 0);
5107 0 : tree _q21 = TREE_OPERAND (_p0, 1);
5108 0 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5109 : {
5110 0 : {
5111 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
5112 0 : tree res = generic_simplify_347 (loc, type, _p0, _p1, captures, FLOOR_MOD_EXPR);
5113 0 : if (res) return res;
5114 : }
5115 : }
5116 : break;
5117 : }
5118 4 : case MULT_EXPR:
5119 4 : {
5120 4 : tree _q20 = TREE_OPERAND (_p0, 0);
5121 4 : tree _q21 = TREE_OPERAND (_p0, 1);
5122 4 : switch (TREE_CODE (_q21))
5123 : {
5124 4 : case INTEGER_CST:
5125 4 : {
5126 4 : switch (TREE_CODE (_p1))
5127 : {
5128 4 : case INTEGER_CST:
5129 4 : {
5130 4 : {
5131 4 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5132 4 : tree res = generic_simplify_348 (loc, type, _p0, _p1, captures, FLOOR_MOD_EXPR);
5133 4 : if (res) return res;
5134 : }
5135 4 : break;
5136 : }
5137 : default:;
5138 : }
5139 : break;
5140 : }
5141 : default:;
5142 : }
5143 : break;
5144 : }
5145 3552 : default:;
5146 : }
5147 3552 : switch (TREE_CODE (_p1))
5148 : {
5149 1 : CASE_CONVERT:
5150 1 : {
5151 1 : tree _q30 = TREE_OPERAND (_p1, 0);
5152 1 : {
5153 1 : tree _q30_pops[1];
5154 1 : if (tree_power_of_two_cand (_q30, _q30_pops))
5155 : {
5156 0 : tree _q40 = _q30_pops[0];
5157 0 : {
5158 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q40 };
5159 0 : tree res = generic_simplify_349 (loc, type, _p0, _p1, captures, FLOOR_MOD_EXPR);
5160 0 : if (res) return res;
5161 : }
5162 : }
5163 : }
5164 1 : break;
5165 : }
5166 3552 : default:;
5167 : }
5168 3552 : {
5169 3552 : tree _p1_pops[1];
5170 3552 : if (tree_power_of_two_cand (_p1, _p1_pops))
5171 : {
5172 1769 : tree _q30 = _p1_pops[0];
5173 1769 : {
5174 1769 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q30 };
5175 1769 : tree res = generic_simplify_349 (loc, type, _p0, _p1, captures, FLOOR_MOD_EXPR);
5176 1769 : if (res) return res;
5177 : }
5178 : }
5179 : }
5180 3512 : switch (TREE_CODE (_p0))
5181 : {
5182 4 : case MULT_EXPR:
5183 4 : {
5184 4 : tree _q20 = TREE_OPERAND (_p0, 0);
5185 4 : tree _q21 = TREE_OPERAND (_p0, 1);
5186 4 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5187 : {
5188 0 : {
5189 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
5190 0 : tree res = generic_simplify_350 (loc, type, _p0, _p1, captures, FLOOR_MOD_EXPR);
5191 0 : if (res) return res;
5192 : }
5193 : }
5194 4 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5195 : {
5196 0 : {
5197 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
5198 0 : tree res = generic_simplify_350 (loc, type, _p0, _p1, captures, FLOOR_MOD_EXPR);
5199 0 : if (res) return res;
5200 : }
5201 : }
5202 : break;
5203 : }
5204 0 : case VEC_COND_EXPR:
5205 0 : {
5206 0 : tree _q20 = TREE_OPERAND (_p0, 0);
5207 0 : tree _q21 = TREE_OPERAND (_p0, 1);
5208 0 : tree _q22 = TREE_OPERAND (_p0, 2);
5209 0 : switch (TREE_CODE (_p1))
5210 : {
5211 0 : case VEC_COND_EXPR:
5212 0 : {
5213 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5214 0 : tree _q61 = TREE_OPERAND (_p1, 1);
5215 0 : tree _q62 = TREE_OPERAND (_p1, 2);
5216 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
5217 : {
5218 0 : {
5219 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
5220 0 : if (VECTOR_TYPE_P (type)
5221 : && (TREE_CODE_CLASS (FLOOR_MOD_EXPR) != tcc_comparison
5222 : || types_match (type, TREE_TYPE (captures[2]))
5223 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
5224 : || (optimize_vectors_before_lowering_p ()
5225 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
5226 : )
5227 : {
5228 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1671;
5229 0 : {
5230 0 : tree res_op0;
5231 0 : res_op0 = captures[1];
5232 0 : tree res_op1;
5233 0 : {
5234 0 : tree _o1[2], _r1;
5235 0 : _o1[0] = captures[2];
5236 0 : _o1[1] = captures[5];
5237 0 : _r1 = fold_build2_loc (loc, FLOOR_MOD_EXPR, type, _o1[0], _o1[1]);
5238 0 : if (EXPR_P (_r1))
5239 0 : goto next_after_fail1671;
5240 0 : res_op1 = _r1;
5241 : }
5242 0 : tree res_op2;
5243 0 : {
5244 0 : tree _o1[2], _r1;
5245 0 : _o1[0] = captures[3];
5246 0 : _o1[1] = captures[6];
5247 0 : _r1 = fold_build2_loc (loc, FLOOR_MOD_EXPR, type, _o1[0], _o1[1]);
5248 0 : if (EXPR_P (_r1))
5249 0 : goto next_after_fail1671;
5250 0 : res_op2 = _r1;
5251 : }
5252 0 : tree _r;
5253 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
5254 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 938, __FILE__, __LINE__, true);
5255 : return _r;
5256 : }
5257 0 : next_after_fail1671:;
5258 : }
5259 : }
5260 : }
5261 : break;
5262 : }
5263 0 : default:;
5264 : }
5265 0 : {
5266 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
5267 0 : if (VECTOR_TYPE_P (type)
5268 : && (TREE_CODE_CLASS (FLOOR_MOD_EXPR) != tcc_comparison
5269 : || types_match (type, TREE_TYPE (captures[2]))
5270 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
5271 : || (optimize_vectors_before_lowering_p ()
5272 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
5273 : )
5274 : {
5275 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1672;
5276 0 : {
5277 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1672;
5278 0 : tree res_op0;
5279 0 : res_op0 = captures[1];
5280 0 : tree res_op1;
5281 0 : {
5282 0 : tree _o1[2], _r1;
5283 0 : _o1[0] = captures[2];
5284 0 : _o1[1] = unshare_expr (captures[4]);
5285 0 : _r1 = fold_build2_loc (loc, FLOOR_MOD_EXPR, type, _o1[0], _o1[1]);
5286 0 : if (EXPR_P (_r1))
5287 0 : goto next_after_fail1672;
5288 0 : res_op1 = _r1;
5289 : }
5290 0 : tree res_op2;
5291 0 : {
5292 0 : tree _o1[2], _r1;
5293 0 : _o1[0] = captures[3];
5294 0 : _o1[1] = captures[4];
5295 0 : _r1 = fold_build2_loc (loc, FLOOR_MOD_EXPR, type, _o1[0], _o1[1]);
5296 0 : if (EXPR_P (_r1))
5297 0 : goto next_after_fail1672;
5298 0 : res_op2 = _r1;
5299 : }
5300 0 : tree _r;
5301 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
5302 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 940, __FILE__, __LINE__, true);
5303 : return _r;
5304 : }
5305 3512 : next_after_fail1672:;
5306 : }
5307 : }
5308 : break;
5309 : }
5310 3512 : default:;
5311 : }
5312 3512 : switch (TREE_CODE (_p1))
5313 : {
5314 0 : case VEC_COND_EXPR:
5315 0 : {
5316 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5317 0 : tree _q31 = TREE_OPERAND (_p1, 1);
5318 0 : tree _q32 = TREE_OPERAND (_p1, 2);
5319 0 : {
5320 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
5321 0 : if (VECTOR_TYPE_P (type)
5322 : && (TREE_CODE_CLASS (FLOOR_MOD_EXPR) != tcc_comparison
5323 : || types_match (type, TREE_TYPE (captures[3]))
5324 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
5325 : || (optimize_vectors_before_lowering_p ()
5326 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
5327 : )
5328 : {
5329 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1673;
5330 0 : {
5331 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1673;
5332 0 : tree res_op0;
5333 0 : res_op0 = captures[2];
5334 0 : tree res_op1;
5335 0 : {
5336 0 : tree _o1[2], _r1;
5337 0 : _o1[0] = unshare_expr (captures[0]);
5338 0 : _o1[1] = captures[3];
5339 0 : _r1 = fold_build2_loc (loc, FLOOR_MOD_EXPR, type, _o1[0], _o1[1]);
5340 0 : if (EXPR_P (_r1))
5341 0 : goto next_after_fail1673;
5342 0 : res_op1 = _r1;
5343 : }
5344 0 : tree res_op2;
5345 0 : {
5346 0 : tree _o1[2], _r1;
5347 0 : _o1[0] = captures[0];
5348 0 : _o1[1] = captures[4];
5349 0 : _r1 = fold_build2_loc (loc, FLOOR_MOD_EXPR, type, _o1[0], _o1[1]);
5350 0 : if (EXPR_P (_r1))
5351 0 : goto next_after_fail1673;
5352 0 : res_op2 = _r1;
5353 : }
5354 0 : tree _r;
5355 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
5356 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 941, __FILE__, __LINE__, true);
5357 : return _r;
5358 : }
5359 889686 : next_after_fail1673:;
5360 : }
5361 : }
5362 : break;
5363 : }
5364 : default:;
5365 : }
5366 : return NULL_TREE;
5367 : }
5368 :
5369 : tree
5370 17939535 : generic_simplify_LT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
5371 : {
5372 17939535 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
5373 17939535 : switch (TREE_CODE (_p0))
5374 : {
5375 2218 : case RDIV_EXPR:
5376 2218 : {
5377 2218 : tree _q20 = TREE_OPERAND (_p0, 0);
5378 2218 : tree _q21 = TREE_OPERAND (_p0, 1);
5379 2218 : switch (TREE_CODE (_q20))
5380 : {
5381 717 : case REAL_CST:
5382 717 : {
5383 717 : if (real_zerop (_p1))
5384 : {
5385 440 : {
5386 440 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5387 440 : tree res = generic_simplify_398 (loc, type, _p0, _p1, captures, LT_EXPR, GT_EXPR);
5388 440 : if (res) return res;
5389 : }
5390 : }
5391 : break;
5392 : }
5393 : default:;
5394 : }
5395 : break;
5396 : }
5397 2862 : case TRUNC_MOD_EXPR:
5398 2862 : {
5399 2862 : tree _q20 = TREE_OPERAND (_p0, 0);
5400 2862 : tree _q21 = TREE_OPERAND (_p0, 1);
5401 2862 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5402 : {
5403 11 : {
5404 11 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5405 11 : tree res = generic_simplify_399 (loc, type, _p0, _p1, captures, LT_EXPR, GE_EXPR);
5406 11 : if (res) return res;
5407 : }
5408 : }
5409 : break;
5410 : }
5411 143234 : case MULT_EXPR:
5412 143234 : {
5413 143234 : tree _q20 = TREE_OPERAND (_p0, 0);
5414 143234 : tree _q21 = TREE_OPERAND (_p0, 1);
5415 143234 : switch (TREE_CODE (_p1))
5416 : {
5417 52310 : case MULT_EXPR:
5418 52310 : {
5419 52310 : tree _q50 = TREE_OPERAND (_p1, 0);
5420 52310 : tree _q51 = TREE_OPERAND (_p1, 1);
5421 52310 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5422 : {
5423 10353 : {
5424 10353 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5425 10353 : tree res = generic_simplify_400 (loc, type, _p0, _p1, captures, LT_EXPR);
5426 10353 : if (res) return res;
5427 : }
5428 : }
5429 43946 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5430 : {
5431 0 : {
5432 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5433 0 : tree res = generic_simplify_400 (loc, type, _p0, _p1, captures, LT_EXPR);
5434 0 : if (res) return res;
5435 : }
5436 : }
5437 43946 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5438 : {
5439 0 : {
5440 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
5441 0 : tree res = generic_simplify_400 (loc, type, _p0, _p1, captures, LT_EXPR);
5442 0 : if (res) return res;
5443 : }
5444 : }
5445 43946 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5446 : {
5447 1405 : {
5448 1405 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
5449 1405 : tree res = generic_simplify_400 (loc, type, _p0, _p1, captures, LT_EXPR);
5450 1405 : if (res) return res;
5451 : }
5452 : }
5453 : break;
5454 : }
5455 : default:;
5456 : }
5457 : break;
5458 : }
5459 3265693 : CASE_CONVERT:
5460 3265693 : {
5461 3265693 : tree _q20 = TREE_OPERAND (_p0, 0);
5462 3265693 : switch (TREE_CODE (_q20))
5463 : {
5464 125 : case EXACT_DIV_EXPR:
5465 125 : {
5466 125 : tree _q30 = TREE_OPERAND (_q20, 0);
5467 125 : tree _q31 = TREE_OPERAND (_q20, 1);
5468 125 : switch (TREE_CODE (_q31))
5469 : {
5470 125 : case INTEGER_CST:
5471 125 : {
5472 125 : switch (TREE_CODE (_p1))
5473 : {
5474 41 : CASE_CONVERT:
5475 41 : {
5476 41 : tree _q60 = TREE_OPERAND (_p1, 0);
5477 41 : switch (TREE_CODE (_q60))
5478 : {
5479 0 : case EXACT_DIV_EXPR:
5480 0 : {
5481 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5482 0 : tree _q71 = TREE_OPERAND (_q60, 1);
5483 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
5484 : {
5485 0 : {
5486 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q70 };
5487 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, LT_EXPR);
5488 0 : if (res) return res;
5489 : }
5490 : }
5491 : break;
5492 : }
5493 : default:;
5494 : }
5495 : break;
5496 : }
5497 : default:;
5498 : }
5499 : break;
5500 : }
5501 : default:;
5502 : }
5503 : break;
5504 : }
5505 : default:;
5506 : }
5507 : break;
5508 : }
5509 929 : case EXACT_DIV_EXPR:
5510 929 : {
5511 929 : tree _q20 = TREE_OPERAND (_p0, 0);
5512 929 : tree _q21 = TREE_OPERAND (_p0, 1);
5513 929 : switch (TREE_CODE (_q21))
5514 : {
5515 929 : case INTEGER_CST:
5516 929 : {
5517 929 : switch (TREE_CODE (_p1))
5518 : {
5519 2 : case EXACT_DIV_EXPR:
5520 2 : {
5521 2 : tree _q50 = TREE_OPERAND (_p1, 0);
5522 2 : tree _q51 = TREE_OPERAND (_p1, 1);
5523 2 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5524 : {
5525 0 : {
5526 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
5527 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, LT_EXPR);
5528 0 : if (res) return res;
5529 : }
5530 : }
5531 : break;
5532 : }
5533 : default:;
5534 : }
5535 : break;
5536 : }
5537 : default:;
5538 : }
5539 : break;
5540 : }
5541 12652 : case TRUNC_DIV_EXPR:
5542 12652 : {
5543 12652 : tree _q20 = TREE_OPERAND (_p0, 0);
5544 12652 : tree _q21 = TREE_OPERAND (_p0, 1);
5545 12652 : switch (TREE_CODE (_q21))
5546 : {
5547 3504 : case INTEGER_CST:
5548 3504 : {
5549 3504 : switch (TREE_CODE (_p1))
5550 : {
5551 1460 : case INTEGER_CST:
5552 1460 : {
5553 1460 : {
5554 1460 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
5555 1460 : tree res = generic_simplify_231 (loc, type, _p0, _p1, captures, LT_EXPR);
5556 1460 : if (res) return res;
5557 : }
5558 704 : break;
5559 : }
5560 : default:;
5561 : }
5562 : break;
5563 : }
5564 : default:;
5565 : }
5566 : break;
5567 : }
5568 2374155 : case PLUS_EXPR:
5569 2374155 : {
5570 2374155 : tree _q20 = TREE_OPERAND (_p0, 0);
5571 2374155 : tree _q21 = TREE_OPERAND (_p0, 1);
5572 2374155 : switch (TREE_CODE (_p1))
5573 : {
5574 338379 : case PLUS_EXPR:
5575 338379 : {
5576 338379 : tree _q50 = TREE_OPERAND (_p1, 0);
5577 338379 : tree _q51 = TREE_OPERAND (_p1, 1);
5578 338379 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5579 : {
5580 139009 : {
5581 139009 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5582 139009 : tree res = generic_simplify_401 (loc, type, _p0, _p1, captures, LT_EXPR);
5583 139009 : if (res) return res;
5584 : }
5585 : }
5586 277611 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5587 : {
5588 26 : {
5589 26 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5590 26 : tree res = generic_simplify_401 (loc, type, _p0, _p1, captures, LT_EXPR);
5591 26 : if (res) return res;
5592 : }
5593 : }
5594 277595 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5595 : {
5596 48 : {
5597 48 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
5598 48 : tree res = generic_simplify_401 (loc, type, _p0, _p1, captures, LT_EXPR);
5599 48 : if (res) return res;
5600 : }
5601 : }
5602 277579 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5603 : {
5604 1779 : {
5605 1779 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
5606 1779 : tree res = generic_simplify_401 (loc, type, _p0, _p1, captures, LT_EXPR);
5607 1779 : if (res) return res;
5608 : }
5609 : }
5610 : break;
5611 : }
5612 2312978 : default:;
5613 : }
5614 2312978 : switch (TREE_CODE (_q21))
5615 : {
5616 1768924 : case INTEGER_CST:
5617 1768924 : {
5618 1768924 : switch (TREE_CODE (_p1))
5619 : {
5620 271931 : case PLUS_EXPR:
5621 271931 : {
5622 271931 : tree _q50 = TREE_OPERAND (_p1, 0);
5623 271931 : tree _q51 = TREE_OPERAND (_p1, 1);
5624 271931 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5625 : {
5626 78241 : {
5627 78241 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5628 78241 : tree res = generic_simplify_402 (loc, type, _p0, _p1, captures, LT_EXPR);
5629 78241 : if (res) return res;
5630 : }
5631 : }
5632 : break;
5633 : }
5634 : default:;
5635 : }
5636 : break;
5637 : }
5638 2312973 : default:;
5639 : }
5640 2312973 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5641 : {
5642 208882 : {
5643 208882 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
5644 208882 : tree res = generic_simplify_403 (loc, type, _p0, _p1, captures, LT_EXPR);
5645 208882 : if (res) return res;
5646 : }
5647 : }
5648 2129934 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5649 : {
5650 56421 : {
5651 56421 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
5652 56421 : tree res = generic_simplify_403 (loc, type, _p0, _p1, captures, LT_EXPR);
5653 56421 : if (res) return res;
5654 : }
5655 : }
5656 : break;
5657 : }
5658 195263 : case MINUS_EXPR:
5659 195263 : {
5660 195263 : tree _q20 = TREE_OPERAND (_p0, 0);
5661 195263 : tree _q21 = TREE_OPERAND (_p0, 1);
5662 195263 : switch (TREE_CODE (_p1))
5663 : {
5664 5330 : case MINUS_EXPR:
5665 5330 : {
5666 5330 : tree _q50 = TREE_OPERAND (_p1, 0);
5667 5330 : tree _q51 = TREE_OPERAND (_p1, 1);
5668 5330 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5669 : {
5670 4 : {
5671 4 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5672 4 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, LT_EXPR);
5673 4 : if (res) return res;
5674 : }
5675 : }
5676 5330 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5677 : {
5678 215 : {
5679 215 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5680 215 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, LT_EXPR);
5681 215 : if (res) return res;
5682 : }
5683 : }
5684 : break;
5685 : }
5686 : default:;
5687 : }
5688 : break;
5689 : }
5690 102754 : case POINTER_DIFF_EXPR:
5691 102754 : {
5692 102754 : tree _q20 = TREE_OPERAND (_p0, 0);
5693 102754 : tree _q21 = TREE_OPERAND (_p0, 1);
5694 102754 : switch (TREE_CODE (_p1))
5695 : {
5696 463 : case POINTER_DIFF_EXPR:
5697 463 : {
5698 463 : tree _q50 = TREE_OPERAND (_p1, 0);
5699 463 : tree _q51 = TREE_OPERAND (_p1, 1);
5700 463 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5701 : {
5702 0 : {
5703 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
5704 0 : tree res = generic_simplify_234 (loc, type, _p0, _p1, captures, LT_EXPR);
5705 0 : if (res) return res;
5706 : }
5707 : }
5708 463 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5709 : {
5710 0 : {
5711 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
5712 0 : tree res = generic_simplify_235 (loc, type, _p0, _p1, captures, LT_EXPR);
5713 0 : if (res) return res;
5714 : }
5715 : }
5716 : break;
5717 : }
5718 : default:;
5719 : }
5720 : break;
5721 : }
5722 17685771 : default:;
5723 : }
5724 17685771 : switch (TREE_CODE (_p1))
5725 : {
5726 347999 : case PLUS_EXPR:
5727 347999 : {
5728 347999 : tree _q30 = TREE_OPERAND (_p1, 0);
5729 347999 : tree _q31 = TREE_OPERAND (_p1, 1);
5730 347999 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5731 : {
5732 120 : {
5733 120 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
5734 120 : tree res = generic_simplify_403 (loc, type, _p0, _p1, captures, GT_EXPR);
5735 120 : if (res) return res;
5736 : }
5737 : }
5738 347879 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5739 : {
5740 81 : {
5741 81 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q31, _p0 };
5742 81 : tree res = generic_simplify_403 (loc, type, _p0, _p1, captures, GT_EXPR);
5743 81 : if (res) return res;
5744 : }
5745 : }
5746 : break;
5747 : }
5748 23854 : case MINUS_EXPR:
5749 23854 : {
5750 23854 : tree _q30 = TREE_OPERAND (_p1, 0);
5751 23854 : tree _q31 = TREE_OPERAND (_p1, 1);
5752 23854 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5753 : {
5754 0 : {
5755 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
5756 0 : tree res = generic_simplify_239 (loc, type, _p0, _p1, captures, LT_EXPR);
5757 0 : if (res) return res;
5758 : }
5759 : }
5760 : break;
5761 : }
5762 17685651 : default:;
5763 : }
5764 17685651 : switch (TREE_CODE (_p0))
5765 : {
5766 195263 : case MINUS_EXPR:
5767 195263 : {
5768 195263 : tree _q20 = TREE_OPERAND (_p0, 0);
5769 195263 : tree _q21 = TREE_OPERAND (_p0, 1);
5770 195263 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5771 : {
5772 3367 : {
5773 3367 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
5774 3367 : tree res = generic_simplify_239 (loc, type, _p0, _p1, captures, GT_EXPR);
5775 3367 : if (res) return res;
5776 : }
5777 : }
5778 : break;
5779 : }
5780 1178 : case BIT_IOR_EXPR:
5781 1178 : {
5782 1178 : tree _q20 = TREE_OPERAND (_p0, 0);
5783 1178 : tree _q21 = TREE_OPERAND (_p0, 1);
5784 1178 : if (tree_expr_nonnegative_p (_q20))
5785 : {
5786 418 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5787 : {
5788 0 : {
5789 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5790 0 : tree res = generic_simplify_406 (loc, type, _p0, _p1, captures, LT_EXPR, BIT_IOR_EXPR);
5791 0 : if (res) return res;
5792 : }
5793 : }
5794 : }
5795 1178 : if (tree_expr_nonnegative_p (_q21))
5796 : {
5797 823 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5798 : {
5799 0 : {
5800 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
5801 0 : tree res = generic_simplify_406 (loc, type, _p0, _p1, captures, LT_EXPR, BIT_IOR_EXPR);
5802 0 : if (res) return res;
5803 : }
5804 : }
5805 : }
5806 : break;
5807 : }
5808 17683227 : default:;
5809 : }
5810 17683227 : switch (TREE_CODE (_p1))
5811 : {
5812 487 : case BIT_AND_EXPR:
5813 487 : {
5814 487 : tree _q30 = TREE_OPERAND (_p1, 0);
5815 487 : tree _q31 = TREE_OPERAND (_p1, 1);
5816 487 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5817 : {
5818 0 : if (tree_expr_nonnegative_p (_q30))
5819 : {
5820 0 : {
5821 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
5822 0 : tree res = generic_simplify_406 (loc, type, _p0, _p1, captures, GT_EXPR, BIT_AND_EXPR);
5823 0 : if (res) return res;
5824 : }
5825 : }
5826 : }
5827 487 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5828 : {
5829 0 : if (tree_expr_nonnegative_p (_q31))
5830 : {
5831 0 : {
5832 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
5833 0 : tree res = generic_simplify_406 (loc, type, _p0, _p1, captures, GT_EXPR, BIT_AND_EXPR);
5834 0 : if (res) return res;
5835 : }
5836 : }
5837 : }
5838 : break;
5839 : }
5840 17683227 : default:;
5841 : }
5842 17683227 : switch (TREE_CODE (_p0))
5843 : {
5844 9873 : case MAX_EXPR:
5845 9873 : {
5846 9873 : tree _q20 = TREE_OPERAND (_p0, 0);
5847 9873 : tree _q21 = TREE_OPERAND (_p0, 1);
5848 9873 : switch (TREE_CODE (_p1))
5849 : {
5850 8 : case MIN_EXPR:
5851 8 : {
5852 8 : tree _q50 = TREE_OPERAND (_p1, 0);
5853 8 : tree _q51 = TREE_OPERAND (_p1, 1);
5854 8 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5855 : {
5856 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5857 : {
5858 0 : {
5859 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5860 0 : tree res = generic_simplify_407 (loc, type, _p0, _p1, captures, GT_EXPR);
5861 0 : if (res) return res;
5862 : }
5863 : }
5864 : }
5865 : break;
5866 : }
5867 : default:;
5868 : }
5869 : break;
5870 : }
5871 9934 : case MIN_EXPR:
5872 9934 : {
5873 9934 : tree _q20 = TREE_OPERAND (_p0, 0);
5874 9934 : tree _q21 = TREE_OPERAND (_p0, 1);
5875 9934 : switch (TREE_CODE (_p1))
5876 : {
5877 16 : case MAX_EXPR:
5878 16 : {
5879 16 : tree _q50 = TREE_OPERAND (_p1, 0);
5880 16 : tree _q51 = TREE_OPERAND (_p1, 1);
5881 16 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5882 : {
5883 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5884 : {
5885 0 : {
5886 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5887 0 : tree res = generic_simplify_408 (loc, type, _p0, _p1, captures, LT_EXPR, NE_EXPR);
5888 0 : if (res) return res;
5889 : }
5890 : }
5891 : }
5892 : break;
5893 : }
5894 9934 : default:;
5895 : }
5896 9934 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5897 : {
5898 1 : {
5899 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5900 1 : tree res = generic_simplify_246 (loc, type, _p0, _p1, captures, MIN_EXPR, LT_EXPR, GT_EXPR);
5901 1 : if (res) return res;
5902 : }
5903 : }
5904 9933 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5905 : {
5906 5 : {
5907 5 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
5908 5 : tree res = generic_simplify_246 (loc, type, _p0, _p1, captures, MIN_EXPR, LT_EXPR, GT_EXPR);
5909 5 : if (res) return res;
5910 : }
5911 : }
5912 : break;
5913 : }
5914 17683224 : default:;
5915 : }
5916 17683224 : switch (TREE_CODE (_p1))
5917 : {
5918 1703 : case MAX_EXPR:
5919 1703 : {
5920 1703 : tree _q30 = TREE_OPERAND (_p1, 0);
5921 1703 : tree _q31 = TREE_OPERAND (_p1, 1);
5922 1703 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5923 : {
5924 0 : {
5925 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
5926 0 : tree res = generic_simplify_246 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR, LT_EXPR);
5927 0 : if (res) return res;
5928 : }
5929 : }
5930 1703 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5931 : {
5932 0 : {
5933 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
5934 0 : tree res = generic_simplify_246 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR, LT_EXPR);
5935 0 : if (res) return res;
5936 : }
5937 : }
5938 : break;
5939 : }
5940 907 : case MIN_EXPR:
5941 907 : {
5942 907 : tree _q30 = TREE_OPERAND (_p1, 0);
5943 907 : tree _q31 = TREE_OPERAND (_p1, 1);
5944 907 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5945 : {
5946 0 : {
5947 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
5948 0 : tree res = generic_simplify_409 (loc, type, _p0, _p1, captures, MIN_EXPR, LT_EXPR);
5949 0 : if (res) return res;
5950 : }
5951 : }
5952 907 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5953 : {
5954 0 : {
5955 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
5956 0 : tree res = generic_simplify_409 (loc, type, _p0, _p1, captures, MIN_EXPR, LT_EXPR);
5957 0 : if (res) return res;
5958 : }
5959 : }
5960 : break;
5961 : }
5962 17683224 : default:;
5963 : }
5964 17683224 : switch (TREE_CODE (_p0))
5965 : {
5966 9873 : case MAX_EXPR:
5967 9873 : {
5968 9873 : tree _q20 = TREE_OPERAND (_p0, 0);
5969 9873 : tree _q21 = TREE_OPERAND (_p0, 1);
5970 9873 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5971 : {
5972 1 : {
5973 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5974 1 : tree res = generic_simplify_409 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR);
5975 1 : if (res) return res;
5976 : }
5977 : }
5978 9872 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5979 : {
5980 1 : {
5981 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
5982 1 : tree res = generic_simplify_409 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR);
5983 1 : if (res) return res;
5984 : }
5985 : }
5986 9871 : switch (TREE_CODE (_q21))
5987 : {
5988 9356 : case INTEGER_CST:
5989 9356 : {
5990 9356 : switch (TREE_CODE (_p1))
5991 : {
5992 1 : case INTEGER_CST:
5993 1 : {
5994 1 : {
5995 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5996 1 : tree res = generic_simplify_410 (loc, type, _p0, _p1, captures, MAX_EXPR, LT_EXPR, BIT_AND_EXPR);
5997 1 : if (res) return res;
5998 : }
5999 0 : break;
6000 : }
6001 : default:;
6002 : }
6003 : break;
6004 : }
6005 : default:;
6006 : }
6007 : break;
6008 : }
6009 9931 : case MIN_EXPR:
6010 9931 : {
6011 9931 : tree _q20 = TREE_OPERAND (_p0, 0);
6012 9931 : tree _q21 = TREE_OPERAND (_p0, 1);
6013 9931 : switch (TREE_CODE (_q21))
6014 : {
6015 779 : case INTEGER_CST:
6016 779 : {
6017 779 : switch (TREE_CODE (_p1))
6018 : {
6019 2 : case INTEGER_CST:
6020 2 : {
6021 2 : {
6022 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6023 2 : tree res = generic_simplify_410 (loc, type, _p0, _p1, captures, MIN_EXPR, LT_EXPR, BIT_IOR_EXPR);
6024 2 : if (res) return res;
6025 : }
6026 0 : break;
6027 : }
6028 : default:;
6029 : }
6030 : break;
6031 : }
6032 9929 : default:;
6033 : }
6034 9929 : if (tree_expr_nonnegative_p (_q21))
6035 : {
6036 1118 : if (integer_zerop (_p1))
6037 : {
6038 0 : {
6039 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6040 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, LT_EXPR, MIN_EXPR);
6041 0 : if (res) return res;
6042 : }
6043 : }
6044 : }
6045 9929 : if (tree_expr_nonnegative_p (_q20))
6046 : {
6047 459 : if (integer_zerop (_p1))
6048 : {
6049 0 : {
6050 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _p1 };
6051 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, LT_EXPR, MIN_EXPR);
6052 0 : if (res) return res;
6053 : }
6054 : }
6055 : }
6056 : break;
6057 : }
6058 1178 : case BIT_IOR_EXPR:
6059 1178 : {
6060 1178 : tree _q20 = TREE_OPERAND (_p0, 0);
6061 1178 : tree _q21 = TREE_OPERAND (_p0, 1);
6062 1178 : if (tree_expr_nonnegative_p (_q21))
6063 : {
6064 823 : if (integer_zerop (_p1))
6065 : {
6066 8 : {
6067 8 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6068 8 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, LT_EXPR, BIT_IOR_EXPR);
6069 8 : if (res) return res;
6070 : }
6071 : }
6072 : }
6073 1170 : if (tree_expr_nonnegative_p (_q20))
6074 : {
6075 418 : if (integer_zerop (_p1))
6076 : {
6077 0 : {
6078 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _p1 };
6079 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, LT_EXPR, BIT_IOR_EXPR);
6080 0 : if (res) return res;
6081 : }
6082 : }
6083 : }
6084 : break;
6085 : }
6086 3265573 : CASE_CONVERT:
6087 3265573 : {
6088 3265573 : tree _q20 = TREE_OPERAND (_p0, 0);
6089 3265573 : switch (TREE_CODE (_q20))
6090 : {
6091 0 : case GE_EXPR:
6092 0 : {
6093 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6094 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6095 0 : if (tree_zero_one_valued_p (_q30))
6096 : {
6097 0 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
6098 : {
6099 0 : {
6100 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
6101 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, LT_EXPR);
6102 0 : if (res) return res;
6103 : }
6104 : }
6105 : }
6106 : break;
6107 : }
6108 : default:;
6109 : }
6110 : break;
6111 : }
6112 15 : case GE_EXPR:
6113 15 : {
6114 15 : tree _q20 = TREE_OPERAND (_p0, 0);
6115 15 : tree _q21 = TREE_OPERAND (_p0, 1);
6116 15 : if (tree_zero_one_valued_p (_q20))
6117 : {
6118 3 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
6119 : {
6120 3 : {
6121 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6122 3 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, LT_EXPR);
6123 3 : if (res) return res;
6124 : }
6125 : }
6126 : }
6127 : break;
6128 : }
6129 904 : case VEC_COND_EXPR:
6130 904 : {
6131 904 : tree _q20 = TREE_OPERAND (_p0, 0);
6132 904 : tree _q21 = TREE_OPERAND (_p0, 1);
6133 904 : tree _q22 = TREE_OPERAND (_p0, 2);
6134 904 : switch (TREE_CODE (_p1))
6135 : {
6136 0 : case VEC_COND_EXPR:
6137 0 : {
6138 0 : tree _q60 = TREE_OPERAND (_p1, 0);
6139 0 : tree _q61 = TREE_OPERAND (_p1, 1);
6140 0 : tree _q62 = TREE_OPERAND (_p1, 2);
6141 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6142 : {
6143 0 : {
6144 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
6145 0 : if (VECTOR_TYPE_P (type)
6146 0 : && (TREE_CODE_CLASS (LT_EXPR) != tcc_comparison
6147 0 : || types_match (type, TREE_TYPE (captures[2]))
6148 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
6149 : || (optimize_vectors_before_lowering_p ()
6150 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
6151 : )
6152 : {
6153 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1712;
6154 0 : {
6155 0 : tree res_op0;
6156 0 : res_op0 = captures[1];
6157 0 : tree res_op1;
6158 0 : {
6159 0 : tree _o1[2], _r1;
6160 0 : _o1[0] = captures[2];
6161 0 : _o1[1] = captures[5];
6162 0 : _r1 = fold_build2_loc (loc, LT_EXPR, type, _o1[0], _o1[1]);
6163 0 : if (EXPR_P (_r1))
6164 0 : goto next_after_fail1712;
6165 0 : res_op1 = _r1;
6166 : }
6167 0 : tree res_op2;
6168 0 : {
6169 0 : tree _o1[2], _r1;
6170 0 : _o1[0] = captures[3];
6171 0 : _o1[1] = captures[6];
6172 0 : _r1 = fold_build2_loc (loc, LT_EXPR, type, _o1[0], _o1[1]);
6173 0 : if (EXPR_P (_r1))
6174 0 : goto next_after_fail1712;
6175 0 : res_op2 = _r1;
6176 : }
6177 0 : tree _r;
6178 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
6179 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 938, __FILE__, __LINE__, true);
6180 : return _r;
6181 : }
6182 904 : next_after_fail1712:;
6183 : }
6184 : }
6185 : }
6186 : break;
6187 : }
6188 904 : default:;
6189 : }
6190 904 : {
6191 904 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
6192 904 : if (VECTOR_TYPE_P (type)
6193 1808 : && (TREE_CODE_CLASS (LT_EXPR) != tcc_comparison
6194 904 : || types_match (type, TREE_TYPE (captures[2]))
6195 904 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
6196 : || (optimize_vectors_before_lowering_p ()
6197 1 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
6198 : )
6199 : {
6200 904 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1713;
6201 904 : {
6202 904 : if (! tree_invariant_p (captures[4])) goto next_after_fail1713;
6203 36 : tree res_op0;
6204 36 : res_op0 = captures[1];
6205 36 : tree res_op1;
6206 36 : {
6207 36 : tree _o1[2], _r1;
6208 36 : _o1[0] = captures[2];
6209 36 : _o1[1] = unshare_expr (captures[4]);
6210 36 : _r1 = fold_build2_loc (loc, LT_EXPR, type, _o1[0], _o1[1]);
6211 36 : if (EXPR_P (_r1))
6212 35 : goto next_after_fail1713;
6213 1 : res_op1 = _r1;
6214 : }
6215 1 : tree res_op2;
6216 1 : {
6217 1 : tree _o1[2], _r1;
6218 1 : _o1[0] = captures[3];
6219 1 : _o1[1] = captures[4];
6220 1 : _r1 = fold_build2_loc (loc, LT_EXPR, type, _o1[0], _o1[1]);
6221 1 : if (EXPR_P (_r1))
6222 0 : goto next_after_fail1713;
6223 1 : res_op2 = _r1;
6224 : }
6225 1 : tree _r;
6226 1 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
6227 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 940, __FILE__, __LINE__, true);
6228 : return _r;
6229 : }
6230 17683207 : next_after_fail1713:;
6231 : }
6232 : }
6233 : break;
6234 : }
6235 17683207 : default:;
6236 : }
6237 17683207 : switch (TREE_CODE (_p1))
6238 : {
6239 78 : case VEC_COND_EXPR:
6240 78 : {
6241 78 : tree _q30 = TREE_OPERAND (_p1, 0);
6242 78 : tree _q31 = TREE_OPERAND (_p1, 1);
6243 78 : tree _q32 = TREE_OPERAND (_p1, 2);
6244 78 : {
6245 78 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
6246 78 : if (VECTOR_TYPE_P (type)
6247 156 : && (TREE_CODE_CLASS (LT_EXPR) != tcc_comparison
6248 78 : || types_match (type, TREE_TYPE (captures[3]))
6249 78 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
6250 : || (optimize_vectors_before_lowering_p ()
6251 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
6252 : )
6253 : {
6254 78 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1714;
6255 78 : {
6256 78 : if (! tree_invariant_p (captures[0])) goto next_after_fail1714;
6257 0 : tree res_op0;
6258 0 : res_op0 = captures[2];
6259 0 : tree res_op1;
6260 0 : {
6261 0 : tree _o1[2], _r1;
6262 0 : _o1[0] = unshare_expr (captures[0]);
6263 0 : _o1[1] = captures[3];
6264 0 : _r1 = fold_build2_loc (loc, LT_EXPR, type, _o1[0], _o1[1]);
6265 0 : if (EXPR_P (_r1))
6266 0 : goto next_after_fail1714;
6267 0 : res_op1 = _r1;
6268 : }
6269 0 : tree res_op2;
6270 0 : {
6271 0 : tree _o1[2], _r1;
6272 0 : _o1[0] = captures[0];
6273 0 : _o1[1] = captures[4];
6274 0 : _r1 = fold_build2_loc (loc, LT_EXPR, type, _o1[0], _o1[1]);
6275 0 : if (EXPR_P (_r1))
6276 0 : goto next_after_fail1714;
6277 0 : res_op2 = _r1;
6278 : }
6279 0 : tree _r;
6280 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
6281 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 941, __FILE__, __LINE__, true);
6282 : return _r;
6283 : }
6284 17683207 : next_after_fail1714:;
6285 : }
6286 : }
6287 : break;
6288 : }
6289 17683207 : default:;
6290 : }
6291 17683207 : if (uniform_integer_cst_p (_p1))
6292 : {
6293 6313775 : {
6294 6313775 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
6295 6313775 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, LT_EXPR, LE_EXPR);
6296 6313775 : if (res) return res;
6297 : }
6298 : }
6299 15239178 : switch (TREE_CODE (_p0))
6300 : {
6301 185561 : case MINUS_EXPR:
6302 185561 : {
6303 185561 : tree _q20 = TREE_OPERAND (_p0, 0);
6304 185561 : tree _q21 = TREE_OPERAND (_p0, 1);
6305 185561 : switch (TREE_CODE (_q20))
6306 : {
6307 4236 : CASE_CONVERT:
6308 4236 : {
6309 4236 : tree _q30 = TREE_OPERAND (_q20, 0);
6310 4236 : switch (TREE_CODE (_q30))
6311 : {
6312 0 : case GT_EXPR:
6313 0 : {
6314 0 : tree _q40 = TREE_OPERAND (_q30, 0);
6315 0 : tree _q41 = TREE_OPERAND (_q30, 1);
6316 0 : switch (TREE_CODE (_q21))
6317 : {
6318 0 : CASE_CONVERT:
6319 0 : {
6320 0 : tree _q70 = TREE_OPERAND (_q21, 0);
6321 0 : switch (TREE_CODE (_q70))
6322 : {
6323 0 : case LT_EXPR:
6324 0 : {
6325 0 : tree _q80 = TREE_OPERAND (_q70, 0);
6326 0 : tree _q81 = TREE_OPERAND (_q70, 1);
6327 0 : if ((_q80 == _q40 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q40, 0) && types_match (_q80, _q40)))
6328 : {
6329 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
6330 : {
6331 0 : if (integer_zerop (_p1))
6332 : {
6333 0 : {
6334 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q41 };
6335 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GT_EXPR, LT_EXPR, LT_EXPR);
6336 0 : if (res) return res;
6337 : }
6338 : }
6339 : }
6340 : }
6341 : break;
6342 : }
6343 0 : case GT_EXPR:
6344 0 : {
6345 0 : tree _q80 = TREE_OPERAND (_q70, 0);
6346 0 : tree _q81 = TREE_OPERAND (_q70, 1);
6347 0 : if ((_q80 == _q41 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q41, 0) && types_match (_q80, _q41)))
6348 : {
6349 0 : if ((_q81 == _q40 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q40, 0) && types_match (_q81, _q40)))
6350 : {
6351 0 : if (integer_zerop (_p1))
6352 : {
6353 0 : {
6354 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q41 };
6355 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GT_EXPR, LT_EXPR, LT_EXPR);
6356 0 : if (res) return res;
6357 : }
6358 : }
6359 : }
6360 : }
6361 : break;
6362 : }
6363 : default:;
6364 : }
6365 : break;
6366 : }
6367 : default:;
6368 : }
6369 : break;
6370 : }
6371 0 : case GE_EXPR:
6372 0 : {
6373 0 : tree _q40 = TREE_OPERAND (_q30, 0);
6374 0 : tree _q41 = TREE_OPERAND (_q30, 1);
6375 0 : switch (TREE_CODE (_q21))
6376 : {
6377 0 : CASE_CONVERT:
6378 0 : {
6379 0 : tree _q70 = TREE_OPERAND (_q21, 0);
6380 0 : switch (TREE_CODE (_q70))
6381 : {
6382 0 : case LE_EXPR:
6383 0 : {
6384 0 : tree _q80 = TREE_OPERAND (_q70, 0);
6385 0 : tree _q81 = TREE_OPERAND (_q70, 1);
6386 0 : if ((_q80 == _q40 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q40, 0) && types_match (_q80, _q40)))
6387 : {
6388 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
6389 : {
6390 0 : if (integer_zerop (_p1))
6391 : {
6392 0 : {
6393 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q41 };
6394 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR, LT_EXPR);
6395 0 : if (res) return res;
6396 : }
6397 : }
6398 : }
6399 : }
6400 : break;
6401 : }
6402 0 : case GE_EXPR:
6403 0 : {
6404 0 : tree _q80 = TREE_OPERAND (_q70, 0);
6405 0 : tree _q81 = TREE_OPERAND (_q70, 1);
6406 0 : if ((_q80 == _q41 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q41, 0) && types_match (_q80, _q41)))
6407 : {
6408 0 : if ((_q81 == _q40 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q40, 0) && types_match (_q81, _q40)))
6409 : {
6410 0 : if (integer_zerop (_p1))
6411 : {
6412 0 : {
6413 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q41 };
6414 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR, LT_EXPR);
6415 0 : if (res) return res;
6416 : }
6417 : }
6418 : }
6419 : }
6420 : break;
6421 : }
6422 : default:;
6423 : }
6424 : break;
6425 : }
6426 : default:;
6427 : }
6428 : break;
6429 : }
6430 0 : case LT_EXPR:
6431 0 : {
6432 0 : tree _q40 = TREE_OPERAND (_q30, 0);
6433 0 : tree _q41 = TREE_OPERAND (_q30, 1);
6434 0 : switch (TREE_CODE (_q21))
6435 : {
6436 0 : CASE_CONVERT:
6437 0 : {
6438 0 : tree _q70 = TREE_OPERAND (_q21, 0);
6439 0 : switch (TREE_CODE (_q70))
6440 : {
6441 0 : case LT_EXPR:
6442 0 : {
6443 0 : tree _q80 = TREE_OPERAND (_q70, 0);
6444 0 : tree _q81 = TREE_OPERAND (_q70, 1);
6445 0 : if ((_q80 == _q41 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q41, 0) && types_match (_q80, _q41)))
6446 : {
6447 0 : if ((_q81 == _q40 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q40, 0) && types_match (_q81, _q40)))
6448 : {
6449 0 : if (integer_zerop (_p1))
6450 : {
6451 0 : {
6452 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q40 };
6453 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GT_EXPR, LT_EXPR, LT_EXPR);
6454 0 : if (res) return res;
6455 : }
6456 : }
6457 : }
6458 : }
6459 : break;
6460 : }
6461 0 : case GT_EXPR:
6462 0 : {
6463 0 : tree _q80 = TREE_OPERAND (_q70, 0);
6464 0 : tree _q81 = TREE_OPERAND (_q70, 1);
6465 0 : if ((_q80 == _q40 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q40, 0) && types_match (_q80, _q40)))
6466 : {
6467 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
6468 : {
6469 0 : if (integer_zerop (_p1))
6470 : {
6471 0 : {
6472 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q40 };
6473 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GT_EXPR, LT_EXPR, LT_EXPR);
6474 0 : if (res) return res;
6475 : }
6476 : }
6477 : }
6478 : }
6479 : break;
6480 : }
6481 : default:;
6482 : }
6483 : break;
6484 : }
6485 : default:;
6486 : }
6487 : break;
6488 : }
6489 0 : case LE_EXPR:
6490 0 : {
6491 0 : tree _q40 = TREE_OPERAND (_q30, 0);
6492 0 : tree _q41 = TREE_OPERAND (_q30, 1);
6493 0 : switch (TREE_CODE (_q21))
6494 : {
6495 0 : CASE_CONVERT:
6496 0 : {
6497 0 : tree _q70 = TREE_OPERAND (_q21, 0);
6498 0 : switch (TREE_CODE (_q70))
6499 : {
6500 0 : case LE_EXPR:
6501 0 : {
6502 0 : tree _q80 = TREE_OPERAND (_q70, 0);
6503 0 : tree _q81 = TREE_OPERAND (_q70, 1);
6504 0 : if ((_q80 == _q41 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q41, 0) && types_match (_q80, _q41)))
6505 : {
6506 0 : if ((_q81 == _q40 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q40, 0) && types_match (_q81, _q40)))
6507 : {
6508 0 : if (integer_zerop (_p1))
6509 : {
6510 0 : {
6511 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q40 };
6512 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR, LT_EXPR);
6513 0 : if (res) return res;
6514 : }
6515 : }
6516 : }
6517 : }
6518 : break;
6519 : }
6520 0 : case GE_EXPR:
6521 0 : {
6522 0 : tree _q80 = TREE_OPERAND (_q70, 0);
6523 0 : tree _q81 = TREE_OPERAND (_q70, 1);
6524 0 : if ((_q80 == _q40 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q40, 0) && types_match (_q80, _q40)))
6525 : {
6526 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
6527 : {
6528 0 : if (integer_zerop (_p1))
6529 : {
6530 0 : {
6531 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q40 };
6532 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR, LT_EXPR);
6533 0 : if (res) return res;
6534 : }
6535 : }
6536 : }
6537 : }
6538 : break;
6539 : }
6540 : default:;
6541 : }
6542 : break;
6543 : }
6544 : default:;
6545 : }
6546 : break;
6547 : }
6548 : default:;
6549 : }
6550 : break;
6551 : }
6552 0 : case GT_EXPR:
6553 0 : {
6554 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6555 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6556 0 : switch (TREE_CODE (_q21))
6557 : {
6558 0 : case LT_EXPR:
6559 0 : {
6560 0 : tree _q60 = TREE_OPERAND (_q21, 0);
6561 0 : tree _q61 = TREE_OPERAND (_q21, 1);
6562 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
6563 : {
6564 0 : if ((_q61 == _q31 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q31, 0) && types_match (_q61, _q31)))
6565 : {
6566 0 : if (integer_zerop (_p1))
6567 : {
6568 0 : {
6569 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q31 };
6570 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GT_EXPR, LT_EXPR, LT_EXPR);
6571 0 : if (res) return res;
6572 : }
6573 : }
6574 : }
6575 : }
6576 : break;
6577 : }
6578 0 : case GT_EXPR:
6579 0 : {
6580 0 : tree _q60 = TREE_OPERAND (_q21, 0);
6581 0 : tree _q61 = TREE_OPERAND (_q21, 1);
6582 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
6583 : {
6584 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
6585 : {
6586 0 : if (integer_zerop (_p1))
6587 : {
6588 0 : {
6589 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q31 };
6590 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GT_EXPR, LT_EXPR, LT_EXPR);
6591 0 : if (res) return res;
6592 : }
6593 : }
6594 : }
6595 : }
6596 : break;
6597 : }
6598 : default:;
6599 : }
6600 : break;
6601 : }
6602 0 : case GE_EXPR:
6603 0 : {
6604 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6605 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6606 0 : switch (TREE_CODE (_q21))
6607 : {
6608 0 : case LE_EXPR:
6609 0 : {
6610 0 : tree _q60 = TREE_OPERAND (_q21, 0);
6611 0 : tree _q61 = TREE_OPERAND (_q21, 1);
6612 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
6613 : {
6614 0 : if ((_q61 == _q31 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q31, 0) && types_match (_q61, _q31)))
6615 : {
6616 0 : if (integer_zerop (_p1))
6617 : {
6618 0 : {
6619 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q31 };
6620 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR, LT_EXPR);
6621 0 : if (res) return res;
6622 : }
6623 : }
6624 : }
6625 : }
6626 : break;
6627 : }
6628 0 : case GE_EXPR:
6629 0 : {
6630 0 : tree _q60 = TREE_OPERAND (_q21, 0);
6631 0 : tree _q61 = TREE_OPERAND (_q21, 1);
6632 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
6633 : {
6634 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
6635 : {
6636 0 : if (integer_zerop (_p1))
6637 : {
6638 0 : {
6639 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q31 };
6640 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR, LT_EXPR);
6641 0 : if (res) return res;
6642 : }
6643 : }
6644 : }
6645 : }
6646 : break;
6647 : }
6648 : default:;
6649 : }
6650 : break;
6651 : }
6652 0 : case LT_EXPR:
6653 0 : {
6654 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6655 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6656 0 : switch (TREE_CODE (_q21))
6657 : {
6658 0 : case LT_EXPR:
6659 0 : {
6660 0 : tree _q60 = TREE_OPERAND (_q21, 0);
6661 0 : tree _q61 = TREE_OPERAND (_q21, 1);
6662 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
6663 : {
6664 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
6665 : {
6666 0 : if (integer_zerop (_p1))
6667 : {
6668 0 : {
6669 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q31, _q30 };
6670 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GT_EXPR, LT_EXPR, LT_EXPR);
6671 0 : if (res) return res;
6672 : }
6673 : }
6674 : }
6675 : }
6676 : break;
6677 : }
6678 0 : case GT_EXPR:
6679 0 : {
6680 0 : tree _q60 = TREE_OPERAND (_q21, 0);
6681 0 : tree _q61 = TREE_OPERAND (_q21, 1);
6682 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
6683 : {
6684 0 : if ((_q61 == _q31 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q31, 0) && types_match (_q61, _q31)))
6685 : {
6686 0 : if (integer_zerop (_p1))
6687 : {
6688 0 : {
6689 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q31, _q30 };
6690 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GT_EXPR, LT_EXPR, LT_EXPR);
6691 0 : if (res) return res;
6692 : }
6693 : }
6694 : }
6695 : }
6696 : break;
6697 : }
6698 : default:;
6699 : }
6700 : break;
6701 : }
6702 0 : case LE_EXPR:
6703 0 : {
6704 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6705 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6706 0 : switch (TREE_CODE (_q21))
6707 : {
6708 0 : case LE_EXPR:
6709 0 : {
6710 0 : tree _q60 = TREE_OPERAND (_q21, 0);
6711 0 : tree _q61 = TREE_OPERAND (_q21, 1);
6712 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
6713 : {
6714 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
6715 : {
6716 0 : if (integer_zerop (_p1))
6717 : {
6718 0 : {
6719 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q31, _q30 };
6720 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR, LT_EXPR);
6721 0 : if (res) return res;
6722 : }
6723 : }
6724 : }
6725 : }
6726 : break;
6727 : }
6728 0 : case GE_EXPR:
6729 0 : {
6730 0 : tree _q60 = TREE_OPERAND (_q21, 0);
6731 0 : tree _q61 = TREE_OPERAND (_q21, 1);
6732 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
6733 : {
6734 0 : if ((_q61 == _q31 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q31, 0) && types_match (_q61, _q31)))
6735 : {
6736 0 : if (integer_zerop (_p1))
6737 : {
6738 0 : {
6739 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q31, _q30 };
6740 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR, LT_EXPR);
6741 0 : if (res) return res;
6742 : }
6743 : }
6744 : }
6745 : }
6746 : break;
6747 : }
6748 : default:;
6749 : }
6750 : break;
6751 : }
6752 : default:;
6753 : }
6754 : break;
6755 : }
6756 127185 : case MULT_EXPR:
6757 127185 : {
6758 127185 : tree _q20 = TREE_OPERAND (_p0, 0);
6759 127185 : tree _q21 = TREE_OPERAND (_p0, 1);
6760 127185 : switch (TREE_CODE (_q21))
6761 : {
6762 67935 : case INTEGER_CST:
6763 67935 : {
6764 67935 : if (integer_zerop (_p1))
6765 : {
6766 3968 : {
6767 3968 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
6768 3968 : tree res = generic_simplify_267 (loc, type, _p0, _p1, captures, LT_EXPR, GT_EXPR);
6769 3968 : if (res) return res;
6770 : }
6771 : }
6772 : break;
6773 : }
6774 : default:;
6775 : }
6776 : break;
6777 : }
6778 15236564 : default:;
6779 : }
6780 15236564 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
6781 : {
6782 7515 : {
6783 7515 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
6784 7515 : tree res = generic_simplify_322 (loc, type, _p0, _p1, captures, LT_EXPR);
6785 7515 : if (res) return res;
6786 : }
6787 : }
6788 15229049 : switch (TREE_CODE (_p0))
6789 : {
6790 2497 : case BIT_NOT_EXPR:
6791 2497 : {
6792 2497 : tree _q20 = TREE_OPERAND (_p0, 0);
6793 2497 : switch (TREE_CODE (_p1))
6794 : {
6795 11 : case BIT_NOT_EXPR:
6796 11 : {
6797 11 : tree _q40 = TREE_OPERAND (_p1, 0);
6798 11 : {
6799 11 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _p1, _q40 };
6800 11 : tree res = generic_simplify_273 (loc, type, _p0, _p1, captures, LT_EXPR);
6801 11 : if (res) return res;
6802 : }
6803 0 : break;
6804 : }
6805 2486 : default:;
6806 : }
6807 2486 : {
6808 2486 : tree _p1_pops[1];
6809 2486 : if (tree_nop_convert (_p1, _p1_pops))
6810 : {
6811 24 : tree _q40 = _p1_pops[0];
6812 24 : switch (TREE_CODE (_q40))
6813 : {
6814 0 : case BIT_NOT_EXPR:
6815 0 : {
6816 0 : tree _q50 = TREE_OPERAND (_q40, 0);
6817 0 : {
6818 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40, _q50 };
6819 0 : tree res = generic_simplify_273 (loc, type, _p0, _p1, captures, LT_EXPR);
6820 0 : if (res) return res;
6821 : }
6822 0 : break;
6823 : }
6824 : default:;
6825 : }
6826 : }
6827 : }
6828 2486 : if (CONSTANT_CLASS_P (_p1))
6829 : {
6830 21 : {
6831 21 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
6832 21 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, LT_EXPR, GT_EXPR);
6833 21 : if (res) return res;
6834 : }
6835 : }
6836 : break;
6837 : }
6838 15229017 : default:;
6839 : }
6840 15229017 : {
6841 15229017 : tree _p0_pops[1];
6842 15229017 : if (tree_nop_convert (_p0, _p0_pops))
6843 : {
6844 1825990 : tree _q20 = _p0_pops[0];
6845 1825990 : switch (TREE_CODE (_q20))
6846 : {
6847 0 : case BIT_NOT_EXPR:
6848 0 : {
6849 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6850 0 : switch (TREE_CODE (_p1))
6851 : {
6852 0 : case BIT_NOT_EXPR:
6853 0 : {
6854 0 : tree _q50 = TREE_OPERAND (_p1, 0);
6855 0 : {
6856 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _p1, _q50 };
6857 0 : tree res = generic_simplify_271 (loc, type, _p0, _p1, captures, LT_EXPR);
6858 0 : if (res) return res;
6859 : }
6860 0 : break;
6861 : }
6862 0 : default:;
6863 : }
6864 0 : {
6865 0 : tree _p1_pops[1];
6866 0 : if (tree_nop_convert (_p1, _p1_pops))
6867 : {
6868 0 : tree _q50 = _p1_pops[0];
6869 0 : switch (TREE_CODE (_q50))
6870 : {
6871 0 : case BIT_NOT_EXPR:
6872 0 : {
6873 0 : tree _q60 = TREE_OPERAND (_q50, 0);
6874 0 : {
6875 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50, _q60 };
6876 0 : tree res = generic_simplify_271 (loc, type, _p0, _p1, captures, LT_EXPR);
6877 0 : if (res) return res;
6878 : }
6879 0 : break;
6880 : }
6881 : default:;
6882 : }
6883 : }
6884 : }
6885 0 : if (CONSTANT_CLASS_P (_p1))
6886 : {
6887 0 : {
6888 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
6889 0 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, LT_EXPR, GT_EXPR);
6890 0 : if (res) return res;
6891 : }
6892 : }
6893 : break;
6894 : }
6895 : default:;
6896 : }
6897 : }
6898 : }
6899 15229017 : switch (TREE_CODE (_p1))
6900 : {
6901 3057145 : case REAL_CST:
6902 3057145 : {
6903 3057145 : {
6904 3057145 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
6905 3057145 : tree res = generic_simplify_274 (loc, type, _p0, _p1, captures, LT_EXPR);
6906 3057145 : if (res) return res;
6907 : }
6908 3057042 : break;
6909 : }
6910 15228914 : default:;
6911 : }
6912 15228914 : switch (TREE_CODE (_p0))
6913 : {
6914 2003929 : case PLUS_EXPR:
6915 2003929 : {
6916 2003929 : tree _q20 = TREE_OPERAND (_p0, 0);
6917 2003929 : tree _q21 = TREE_OPERAND (_p0, 1);
6918 2003929 : switch (TREE_CODE (_q21))
6919 : {
6920 538 : case REAL_CST:
6921 538 : {
6922 538 : switch (TREE_CODE (_p1))
6923 : {
6924 236 : case REAL_CST:
6925 236 : {
6926 236 : {
6927 236 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6928 236 : tree res = generic_simplify_275 (loc, type, _p0, _p1, captures, PLUS_EXPR, LT_EXPR);
6929 236 : if (res) return res;
6930 : }
6931 234 : break;
6932 : }
6933 : default:;
6934 : }
6935 : break;
6936 : }
6937 1476343 : case INTEGER_CST:
6938 1476343 : {
6939 1476343 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
6940 : {
6941 18078 : {
6942 18078 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q20, _q21 };
6943 18078 : tree res = generic_simplify_415 (loc, type, _p0, _p1, captures, LT_EXPR, GT_EXPR);
6944 18078 : if (res) return res;
6945 : }
6946 : }
6947 : break;
6948 : }
6949 : default:;
6950 : }
6951 : break;
6952 : }
6953 185561 : case MINUS_EXPR:
6954 185561 : {
6955 185561 : tree _q20 = TREE_OPERAND (_p0, 0);
6956 185561 : tree _q21 = TREE_OPERAND (_p0, 1);
6957 185561 : switch (TREE_CODE (_q21))
6958 : {
6959 210 : case REAL_CST:
6960 210 : {
6961 210 : switch (TREE_CODE (_p1))
6962 : {
6963 195 : case REAL_CST:
6964 195 : {
6965 195 : {
6966 195 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6967 195 : tree res = generic_simplify_275 (loc, type, _p0, _p1, captures, MINUS_EXPR, LT_EXPR);
6968 195 : if (res) return res;
6969 : }
6970 195 : break;
6971 : }
6972 : default:;
6973 : }
6974 : break;
6975 : }
6976 185561 : default:;
6977 : }
6978 185561 : switch (TREE_CODE (_q20))
6979 : {
6980 19663 : case REAL_CST:
6981 19663 : {
6982 19663 : switch (TREE_CODE (_p1))
6983 : {
6984 19442 : case REAL_CST:
6985 19442 : {
6986 19442 : {
6987 19442 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6988 19442 : tree res = generic_simplify_276 (loc, type, _p0, _p1, captures, LT_EXPR);
6989 19442 : if (res) return res;
6990 : }
6991 19432 : break;
6992 : }
6993 : default:;
6994 : }
6995 : break;
6996 : }
6997 : default:;
6998 : }
6999 : break;
7000 : }
7001 51212 : case FLOAT_EXPR:
7002 51212 : {
7003 51212 : tree _q20 = TREE_OPERAND (_p0, 0);
7004 51212 : switch (TREE_CODE (_p1))
7005 : {
7006 105 : case FLOAT_EXPR:
7007 105 : {
7008 105 : tree _q40 = TREE_OPERAND (_p1, 0);
7009 105 : {
7010 105 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
7011 105 : tree res = generic_simplify_279 (loc, type, _p0, _p1, captures, LT_EXPR, LT_EXPR);
7012 105 : if (res) return res;
7013 : }
7014 74 : break;
7015 : }
7016 804 : case REAL_CST:
7017 804 : {
7018 804 : {
7019 804 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7020 804 : tree res = generic_simplify_280 (loc, type, _p0, _p1, captures, LT_EXPR, LE_EXPR);
7021 804 : if (res) return res;
7022 : }
7023 597 : break;
7024 : }
7025 : default:;
7026 : }
7027 : break;
7028 : }
7029 525 : case EXACT_DIV_EXPR:
7030 525 : {
7031 525 : tree _q20 = TREE_OPERAND (_p0, 0);
7032 525 : tree _q21 = TREE_OPERAND (_p0, 1);
7033 525 : switch (TREE_CODE (_q21))
7034 : {
7035 525 : case INTEGER_CST:
7036 525 : {
7037 525 : switch (TREE_CODE (_p1))
7038 : {
7039 19 : case INTEGER_CST:
7040 19 : {
7041 19 : {
7042 19 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7043 19 : tree res = generic_simplify_416 (loc, type, _p0, _p1, captures, LT_EXPR);
7044 19 : if (res) return res;
7045 : }
7046 0 : break;
7047 : }
7048 : default:;
7049 : }
7050 : break;
7051 : }
7052 : default:;
7053 : }
7054 : break;
7055 : }
7056 2819075 : CASE_CONVERT:
7057 2819075 : {
7058 2819075 : tree _q20 = TREE_OPERAND (_p0, 0);
7059 2819075 : switch (TREE_CODE (_q20))
7060 : {
7061 125 : case EXACT_DIV_EXPR:
7062 125 : {
7063 125 : tree _q30 = TREE_OPERAND (_q20, 0);
7064 125 : tree _q31 = TREE_OPERAND (_q20, 1);
7065 125 : switch (TREE_CODE (_q31))
7066 : {
7067 125 : case INTEGER_CST:
7068 125 : {
7069 125 : switch (TREE_CODE (_p1))
7070 : {
7071 0 : case INTEGER_CST:
7072 0 : {
7073 0 : {
7074 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
7075 0 : tree res = generic_simplify_417 (loc, type, _p0, _p1, captures, LT_EXPR, GE_EXPR);
7076 0 : if (res) return res;
7077 : }
7078 0 : break;
7079 : }
7080 : default:;
7081 : }
7082 : break;
7083 : }
7084 : default:;
7085 : }
7086 : break;
7087 : }
7088 2819075 : default:;
7089 : }
7090 2819075 : switch (TREE_CODE (_p1))
7091 : {
7092 1510168 : CASE_CONVERT:
7093 1510168 : {
7094 1510168 : tree _q40 = TREE_OPERAND (_p1, 0);
7095 1510168 : {
7096 1510168 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
7097 1510168 : tree res = generic_simplify_284 (loc, type, _p0, _p1, captures, LT_EXPR);
7098 1510168 : if (res) return res;
7099 : }
7100 1231912 : break;
7101 : }
7102 2540819 : default:;
7103 : }
7104 2540819 : {
7105 2540819 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
7106 2540819 : tree res = generic_simplify_285 (loc, type, _p0, _p1, captures, LT_EXPR);
7107 2540819 : if (res) return res;
7108 : }
7109 2143804 : switch (TREE_CODE (_q20))
7110 : {
7111 67437 : case ADDR_EXPR:
7112 67437 : {
7113 67437 : switch (TREE_CODE (_p1))
7114 : {
7115 66865 : CASE_CONVERT:
7116 66865 : {
7117 66865 : tree _q40 = TREE_OPERAND (_p1, 0);
7118 66865 : switch (TREE_CODE (_q40))
7119 : {
7120 66865 : case ADDR_EXPR:
7121 66865 : {
7122 66865 : {
7123 66865 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7124 66865 : tree res = generic_simplify_305 (loc, type, _p0, _p1, captures, LT_EXPR);
7125 66865 : if (res) return res;
7126 : }
7127 314 : break;
7128 : }
7129 : default:;
7130 : }
7131 : break;
7132 : }
7133 475 : case ADDR_EXPR:
7134 475 : {
7135 475 : {
7136 475 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7137 475 : tree res = generic_simplify_305 (loc, type, _p0, _p1, captures, LT_EXPR);
7138 475 : if (res) return res;
7139 : }
7140 0 : break;
7141 : }
7142 : default:;
7143 : }
7144 : break;
7145 : }
7146 2076778 : default:;
7147 : }
7148 2076778 : if (uniform_integer_cst_p (_p1))
7149 : {
7150 315088 : {
7151 315088 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7152 315088 : tree res = generic_simplify_418 (loc, type, _p0, _p1, captures, LT_EXPR);
7153 315088 : if (res) return res;
7154 : }
7155 : }
7156 : break;
7157 : }
7158 2256 : case NEGATE_EXPR:
7159 2256 : {
7160 2256 : tree _q20 = TREE_OPERAND (_p0, 0);
7161 2256 : switch (TREE_CODE (_p1))
7162 : {
7163 0 : case NEGATE_EXPR:
7164 0 : {
7165 0 : tree _q40 = TREE_OPERAND (_p1, 0);
7166 0 : {
7167 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
7168 0 : tree res = generic_simplify_282 (loc, type, _p0, _p1, captures, LT_EXPR, GT_EXPR);
7169 0 : if (res) return res;
7170 : }
7171 0 : break;
7172 : }
7173 2256 : default:;
7174 : }
7175 2256 : if (CONSTANT_CLASS_P (_p1))
7176 : {
7177 167 : {
7178 167 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7179 167 : tree res = generic_simplify_283 (loc, type, _p0, _p1, captures, LT_EXPR, GT_EXPR);
7180 167 : if (res) return res;
7181 : }
7182 : }
7183 : break;
7184 : }
7185 30234 : case ADDR_EXPR:
7186 30234 : {
7187 30234 : switch (TREE_CODE (_p1))
7188 : {
7189 0 : CASE_CONVERT:
7190 0 : {
7191 0 : tree _q30 = TREE_OPERAND (_p1, 0);
7192 0 : switch (TREE_CODE (_q30))
7193 : {
7194 0 : case ADDR_EXPR:
7195 0 : {
7196 0 : {
7197 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q30 };
7198 0 : tree res = generic_simplify_306 (loc, type, _p0, _p1, captures, LT_EXPR);
7199 0 : if (res) return res;
7200 : }
7201 0 : break;
7202 : }
7203 : default:;
7204 : }
7205 : break;
7206 : }
7207 29769 : case ADDR_EXPR:
7208 29769 : {
7209 29769 : {
7210 29769 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
7211 29769 : tree res = generic_simplify_306 (loc, type, _p0, _p1, captures, LT_EXPR);
7212 29769 : if (res) return res;
7213 : }
7214 628 : break;
7215 : }
7216 : default:;
7217 : }
7218 : break;
7219 : }
7220 1455088 : case CALL_EXPR:
7221 1455088 : switch (get_call_combined_fn (_p0))
7222 : {
7223 5 : case CFN_BUILT_IN_SQRTF:
7224 5 : if (call_expr_nargs (_p0) == 1)
7225 : {
7226 5 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7227 5 : switch (TREE_CODE (_p1))
7228 : {
7229 5 : case REAL_CST:
7230 5 : {
7231 5 : {
7232 5 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7233 5 : tree res = generic_simplify_277 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, LT_EXPR);
7234 5 : if (res) return res;
7235 : }
7236 0 : break;
7237 : }
7238 0 : case CALL_EXPR:
7239 0 : switch (get_call_combined_fn (_p1))
7240 : {
7241 0 : case CFN_BUILT_IN_SQRTF:
7242 0 : if (call_expr_nargs (_p1) == 1)
7243 : {
7244 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7245 0 : {
7246 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
7247 0 : tree res = generic_simplify_278 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, LT_EXPR);
7248 0 : if (res) return res;
7249 : }
7250 : }
7251 : break;
7252 : default:;
7253 : }
7254 : break;
7255 : default:;
7256 : }
7257 : }
7258 : break;
7259 0 : case CFN_BUILT_IN_SQRTL:
7260 0 : if (call_expr_nargs (_p0) == 1)
7261 : {
7262 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7263 0 : switch (TREE_CODE (_p1))
7264 : {
7265 0 : case REAL_CST:
7266 0 : {
7267 0 : {
7268 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7269 0 : tree res = generic_simplify_277 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, LT_EXPR);
7270 0 : if (res) return res;
7271 : }
7272 0 : break;
7273 : }
7274 0 : case CALL_EXPR:
7275 0 : switch (get_call_combined_fn (_p1))
7276 : {
7277 0 : case CFN_BUILT_IN_SQRTL:
7278 0 : if (call_expr_nargs (_p1) == 1)
7279 : {
7280 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7281 0 : {
7282 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
7283 0 : tree res = generic_simplify_278 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, LT_EXPR);
7284 0 : if (res) return res;
7285 : }
7286 : }
7287 : break;
7288 : default:;
7289 : }
7290 : break;
7291 : default:;
7292 : }
7293 : }
7294 : break;
7295 4 : case CFN_BUILT_IN_SQRT:
7296 4 : if (call_expr_nargs (_p0) == 1)
7297 : {
7298 4 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7299 4 : switch (TREE_CODE (_p1))
7300 : {
7301 4 : case REAL_CST:
7302 4 : {
7303 4 : {
7304 4 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7305 4 : tree res = generic_simplify_277 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, LT_EXPR);
7306 4 : if (res) return res;
7307 : }
7308 1 : break;
7309 : }
7310 0 : case CALL_EXPR:
7311 0 : switch (get_call_combined_fn (_p1))
7312 : {
7313 0 : case CFN_BUILT_IN_SQRT:
7314 0 : if (call_expr_nargs (_p1) == 1)
7315 : {
7316 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7317 0 : {
7318 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
7319 0 : tree res = generic_simplify_278 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, LT_EXPR);
7320 0 : if (res) return res;
7321 : }
7322 : }
7323 : break;
7324 : default:;
7325 : }
7326 : break;
7327 : default:;
7328 : }
7329 : }
7330 : break;
7331 0 : case CFN_SQRT:
7332 0 : if (call_expr_nargs (_p0) == 1)
7333 : {
7334 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7335 0 : switch (TREE_CODE (_p1))
7336 : {
7337 0 : case REAL_CST:
7338 0 : {
7339 0 : {
7340 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7341 0 : tree res = generic_simplify_277 (loc, type, _p0, _p1, captures, CFN_SQRT, LT_EXPR);
7342 0 : if (res) return res;
7343 : }
7344 0 : break;
7345 : }
7346 0 : case CALL_EXPR:
7347 0 : switch (get_call_combined_fn (_p1))
7348 : {
7349 0 : case CFN_SQRT:
7350 0 : if (call_expr_nargs (_p1) == 1)
7351 : {
7352 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7353 0 : {
7354 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
7355 0 : tree res = generic_simplify_278 (loc, type, _p0, _p1, captures, CFN_SQRT, LT_EXPR);
7356 0 : if (res) return res;
7357 : }
7358 : }
7359 : break;
7360 : default:;
7361 : }
7362 : break;
7363 : default:;
7364 : }
7365 : }
7366 : break;
7367 : default:;
7368 : }
7369 : break;
7370 14436192 : default:;
7371 : }
7372 14436192 : switch (TREE_CODE (_p1))
7373 : {
7374 2020146 : CASE_CONVERT:
7375 2020146 : {
7376 2020146 : tree _q30 = TREE_OPERAND (_p1, 0);
7377 2020146 : switch (TREE_CODE (_q30))
7378 : {
7379 0 : case NE_EXPR:
7380 0 : {
7381 0 : tree _q40 = TREE_OPERAND (_q30, 0);
7382 0 : tree _q41 = TREE_OPERAND (_q30, 1);
7383 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
7384 : {
7385 0 : if (tree_expr_nonnegative_p (_q40))
7386 : {
7387 0 : if (integer_zerop (_q41))
7388 : {
7389 0 : {
7390 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
7391 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1715;
7392 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1715;
7393 0 : {
7394 0 : tree _r;
7395 0 : _r = constant_boolean_node (false, type);
7396 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1045, __FILE__, __LINE__, true);
7397 : return _r;
7398 : }
7399 14436192 : next_after_fail1715:;
7400 : }
7401 : }
7402 : }
7403 : }
7404 : break;
7405 : }
7406 : default:;
7407 : }
7408 : break;
7409 : }
7410 14436192 : default:;
7411 : }
7412 14436192 : if (uniform_integer_cst_p (_p1))
7413 : {
7414 3467629 : {
7415 3467629 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
7416 3467629 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, LT_EXPR);
7417 3467629 : if (res) return res;
7418 : }
7419 : }
7420 13982157 : switch (TREE_CODE (_p0))
7421 : {
7422 2073108 : CASE_CONVERT:
7423 2073108 : {
7424 2073108 : tree _q20 = TREE_OPERAND (_p0, 0);
7425 2073108 : switch (TREE_CODE (_q20))
7426 : {
7427 77048 : case PLUS_EXPR:
7428 77048 : {
7429 77048 : tree _q30 = TREE_OPERAND (_q20, 0);
7430 77048 : tree _q31 = TREE_OPERAND (_q20, 1);
7431 77048 : switch (TREE_CODE (_q30))
7432 : {
7433 50464 : CASE_CONVERT:
7434 50464 : {
7435 50464 : tree _q40 = TREE_OPERAND (_q30, 0);
7436 50464 : switch (TREE_CODE (_q31))
7437 : {
7438 50441 : case INTEGER_CST:
7439 50441 : {
7440 50441 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
7441 : {
7442 27 : {
7443 27 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q40, _q31 };
7444 27 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, LT_EXPR, GT_EXPR);
7445 27 : if (res) return res;
7446 : }
7447 : }
7448 : break;
7449 : }
7450 : default:;
7451 : }
7452 : break;
7453 : }
7454 : default:;
7455 : }
7456 : break;
7457 : }
7458 : default:;
7459 : }
7460 : break;
7461 : }
7462 13982130 : default:;
7463 : }
7464 13982130 : switch (TREE_CODE (_p1))
7465 : {
7466 2020146 : CASE_CONVERT:
7467 2020146 : {
7468 2020146 : tree _q30 = TREE_OPERAND (_p1, 0);
7469 2020146 : switch (TREE_CODE (_q30))
7470 : {
7471 23261 : case PLUS_EXPR:
7472 23261 : {
7473 23261 : tree _q40 = TREE_OPERAND (_q30, 0);
7474 23261 : tree _q41 = TREE_OPERAND (_q30, 1);
7475 23261 : switch (TREE_CODE (_q40))
7476 : {
7477 20895 : CASE_CONVERT:
7478 20895 : {
7479 20895 : tree _q50 = TREE_OPERAND (_q40, 0);
7480 20895 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
7481 : {
7482 0 : switch (TREE_CODE (_q41))
7483 : {
7484 0 : case INTEGER_CST:
7485 0 : {
7486 0 : {
7487 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0, _q41 };
7488 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, GT_EXPR, LE_EXPR);
7489 0 : if (res) return res;
7490 : }
7491 0 : break;
7492 : }
7493 : default:;
7494 : }
7495 : }
7496 : break;
7497 : }
7498 : default:;
7499 : }
7500 : break;
7501 : }
7502 : default:;
7503 : }
7504 : break;
7505 : }
7506 347879 : case PLUS_EXPR:
7507 347879 : {
7508 347879 : tree _q30 = TREE_OPERAND (_p1, 0);
7509 347879 : tree _q31 = TREE_OPERAND (_p1, 1);
7510 347879 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
7511 : {
7512 81 : switch (TREE_CODE (_q31))
7513 : {
7514 65 : case INTEGER_CST:
7515 65 : {
7516 65 : {
7517 65 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0, _q31 };
7518 65 : tree res = generic_simplify_415 (loc, type, _p0, _p1, captures, GT_EXPR, LE_EXPR);
7519 65 : if (res) return res;
7520 : }
7521 0 : break;
7522 : }
7523 : default:;
7524 : }
7525 : }
7526 : break;
7527 : }
7528 23854 : case MINUS_EXPR:
7529 23854 : {
7530 23854 : tree _q30 = TREE_OPERAND (_p1, 0);
7531 23854 : tree _q31 = TREE_OPERAND (_p1, 1);
7532 23854 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
7533 : {
7534 0 : {
7535 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q31 };
7536 0 : tree res = generic_simplify_421 (loc, type, _p0, _p1, captures, GT_EXPR);
7537 0 : if (res) return res;
7538 : }
7539 : }
7540 : break;
7541 : }
7542 13982065 : default:;
7543 : }
7544 13982065 : switch (TREE_CODE (_p0))
7545 : {
7546 1964743 : case PLUS_EXPR:
7547 1964743 : {
7548 1964743 : tree _q20 = TREE_OPERAND (_p0, 0);
7549 1964743 : tree _q21 = TREE_OPERAND (_p0, 1);
7550 1964743 : switch (TREE_CODE (_q20))
7551 : {
7552 1348 : case MINUS_EXPR:
7553 1348 : {
7554 1348 : tree _q30 = TREE_OPERAND (_q20, 0);
7555 1348 : tree _q31 = TREE_OPERAND (_q20, 1);
7556 1348 : if (integer_minus_onep (_q21))
7557 : {
7558 49 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
7559 : {
7560 1 : {
7561 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
7562 1 : tree res = generic_simplify_422 (loc, type, _p0, _p1, captures, LT_EXPR);
7563 1 : if (res) return res;
7564 : }
7565 : }
7566 : }
7567 : break;
7568 : }
7569 : default:;
7570 : }
7571 : break;
7572 : }
7573 13982064 : default:;
7574 : }
7575 13982064 : switch (TREE_CODE (_p1))
7576 : {
7577 0 : case REALPART_EXPR:
7578 0 : {
7579 0 : tree _q30 = TREE_OPERAND (_p1, 0);
7580 0 : switch (TREE_CODE (_q30))
7581 : {
7582 0 : case CALL_EXPR:
7583 0 : switch (get_call_combined_fn (_q30))
7584 : {
7585 0 : case CFN_SUB_OVERFLOW:
7586 0 : if (call_expr_nargs (_q30) == 2)
7587 : {
7588 0 : tree _q40 = CALL_EXPR_ARG (_q30, 0);
7589 0 : tree _q41 = CALL_EXPR_ARG (_q30, 1);
7590 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
7591 : {
7592 0 : {
7593 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p0, _q41 };
7594 0 : tree res = generic_simplify_423 (loc, type, _p0, _p1, captures, GT_EXPR, NE_EXPR);
7595 0 : if (res) return res;
7596 : }
7597 : }
7598 : }
7599 : break;
7600 : default:;
7601 : }
7602 : break;
7603 : default:;
7604 : }
7605 : break;
7606 : }
7607 13982064 : default:;
7608 : }
7609 13982064 : switch (TREE_CODE (_p0))
7610 : {
7611 20 : case REALPART_EXPR:
7612 20 : {
7613 20 : tree _q20 = TREE_OPERAND (_p0, 0);
7614 20 : switch (TREE_CODE (_q20))
7615 : {
7616 0 : case CALL_EXPR:
7617 0 : switch (get_call_combined_fn (_q20))
7618 : {
7619 0 : case CFN_ADD_OVERFLOW:
7620 0 : if (call_expr_nargs (_q20) == 2)
7621 : {
7622 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
7623 0 : tree _q31 = CALL_EXPR_ARG (_q20, 1);
7624 0 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
7625 : {
7626 0 : {
7627 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7628 0 : tree res = generic_simplify_424 (loc, type, _p0, _p1, captures, LT_EXPR, NE_EXPR);
7629 0 : if (res) return res;
7630 : }
7631 : }
7632 0 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
7633 : {
7634 0 : {
7635 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q31, _q30 };
7636 0 : tree res = generic_simplify_424 (loc, type, _p0, _p1, captures, LT_EXPR, NE_EXPR);
7637 0 : if (res) return res;
7638 : }
7639 : }
7640 : }
7641 : break;
7642 : default:;
7643 : }
7644 : break;
7645 : default:;
7646 : }
7647 : break;
7648 : }
7649 7393 : case TRUNC_DIV_EXPR:
7650 7393 : {
7651 7393 : tree _q20 = TREE_OPERAND (_p0, 0);
7652 7393 : tree _q21 = TREE_OPERAND (_p0, 1);
7653 7393 : if (integer_all_onesp (_q20))
7654 : {
7655 1098 : {
7656 1098 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _p1 };
7657 1098 : tree res = generic_simplify_425 (loc, type, _p0, _p1, captures, LT_EXPR, NE_EXPR);
7658 1098 : if (res) return res;
7659 : }
7660 : }
7661 : break;
7662 : }
7663 121225 : case MULT_EXPR:
7664 121225 : {
7665 121225 : tree _q20 = TREE_OPERAND (_p0, 0);
7666 121225 : tree _q21 = TREE_OPERAND (_p0, 1);
7667 121225 : switch (TREE_CODE (_q21))
7668 : {
7669 12347 : case REAL_CST:
7670 12347 : {
7671 12347 : switch (TREE_CODE (_p1))
7672 : {
7673 1076 : case REAL_CST:
7674 1076 : {
7675 1076 : {
7676 1076 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7677 1076 : tree res = generic_simplify_426 (loc, type, _p0, _p1, captures, LT_EXPR, GT_EXPR);
7678 1076 : if (res) return res;
7679 : }
7680 1076 : break;
7681 : }
7682 : default:;
7683 : }
7684 : break;
7685 : }
7686 : default:;
7687 : }
7688 : break;
7689 : }
7690 1964742 : case PLUS_EXPR:
7691 1964742 : {
7692 1964742 : tree _q20 = TREE_OPERAND (_p0, 0);
7693 1964742 : tree _q21 = TREE_OPERAND (_p0, 1);
7694 1964742 : switch (TREE_CODE (_q21))
7695 : {
7696 1457882 : case INTEGER_CST:
7697 1457882 : {
7698 1457882 : switch (TREE_CODE (_p1))
7699 : {
7700 226955 : case INTEGER_CST:
7701 226955 : {
7702 226955 : {
7703 226955 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
7704 226955 : tree res = generic_simplify_427 (loc, type, _p0, _p1, captures, PLUS_EXPR, MINUS_EXPR, LT_EXPR, GT_EXPR);
7705 226955 : if (res) return res;
7706 : }
7707 15196 : break;
7708 : }
7709 : default:;
7710 : }
7711 : break;
7712 : }
7713 : default:;
7714 : }
7715 : break;
7716 : }
7717 185372 : case MINUS_EXPR:
7718 185372 : {
7719 185372 : tree _q20 = TREE_OPERAND (_p0, 0);
7720 185372 : tree _q21 = TREE_OPERAND (_p0, 1);
7721 185372 : switch (TREE_CODE (_q21))
7722 : {
7723 2 : case INTEGER_CST:
7724 2 : {
7725 2 : switch (TREE_CODE (_p1))
7726 : {
7727 0 : case INTEGER_CST:
7728 0 : {
7729 0 : {
7730 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
7731 0 : tree res = generic_simplify_427 (loc, type, _p0, _p1, captures, MINUS_EXPR, PLUS_EXPR, LT_EXPR, GT_EXPR);
7732 0 : if (res) return res;
7733 : }
7734 0 : break;
7735 : }
7736 : default:;
7737 : }
7738 : break;
7739 : }
7740 185372 : default:;
7741 : }
7742 185372 : switch (TREE_CODE (_q20))
7743 : {
7744 43879 : case INTEGER_CST:
7745 43879 : {
7746 43879 : switch (TREE_CODE (_p1))
7747 : {
7748 268 : case INTEGER_CST:
7749 268 : {
7750 268 : {
7751 268 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7752 268 : tree res = generic_simplify_312 (loc, type, _p0, _p1, captures, LT_EXPR, GT_EXPR);
7753 268 : if (res) return res;
7754 : }
7755 0 : break;
7756 : }
7757 : default:;
7758 : }
7759 : break;
7760 : }
7761 : default:;
7762 : }
7763 : break;
7764 : }
7765 1455063 : case CALL_EXPR:
7766 1455063 : switch (get_call_combined_fn (_p0))
7767 : {
7768 4 : case CFN_BUILT_IN_CTZ:
7769 4 : if (call_expr_nargs (_p0) == 1)
7770 : {
7771 4 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7772 4 : switch (TREE_CODE (_p1))
7773 : {
7774 3 : case INTEGER_CST:
7775 3 : {
7776 3 : {
7777 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7778 3 : tree res = generic_simplify_428 (loc, type, _p0, _p1, captures, LT_EXPR, NE_EXPR, CFN_BUILT_IN_CTZ);
7779 3 : if (res) return res;
7780 : }
7781 0 : break;
7782 : }
7783 : default:;
7784 : }
7785 : }
7786 : break;
7787 2 : case CFN_BUILT_IN_CTZL:
7788 2 : if (call_expr_nargs (_p0) == 1)
7789 : {
7790 2 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7791 2 : switch (TREE_CODE (_p1))
7792 : {
7793 2 : case INTEGER_CST:
7794 2 : {
7795 2 : {
7796 2 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7797 2 : tree res = generic_simplify_428 (loc, type, _p0, _p1, captures, LT_EXPR, NE_EXPR, CFN_BUILT_IN_CTZL);
7798 2 : if (res) return res;
7799 : }
7800 0 : break;
7801 : }
7802 : default:;
7803 : }
7804 : }
7805 : break;
7806 0 : case CFN_BUILT_IN_CTZIMAX:
7807 0 : if (call_expr_nargs (_p0) == 1)
7808 : {
7809 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7810 0 : switch (TREE_CODE (_p1))
7811 : {
7812 0 : case INTEGER_CST:
7813 0 : {
7814 0 : {
7815 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7816 0 : tree res = generic_simplify_428 (loc, type, _p0, _p1, captures, LT_EXPR, NE_EXPR, CFN_BUILT_IN_CTZIMAX);
7817 0 : if (res) return res;
7818 : }
7819 0 : break;
7820 : }
7821 : default:;
7822 : }
7823 : }
7824 : break;
7825 1 : case CFN_CTZ:
7826 1 : if (call_expr_nargs (_p0) == 1)
7827 : {
7828 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7829 0 : switch (TREE_CODE (_p1))
7830 : {
7831 0 : case INTEGER_CST:
7832 0 : {
7833 0 : {
7834 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7835 0 : tree res = generic_simplify_428 (loc, type, _p0, _p1, captures, LT_EXPR, NE_EXPR, CFN_CTZ);
7836 0 : if (res) return res;
7837 : }
7838 0 : break;
7839 : }
7840 : default:;
7841 : }
7842 : }
7843 1 : if (call_expr_nargs (_p0) == 2)
7844 : {
7845 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7846 1 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
7847 1 : switch (TREE_CODE (_p1))
7848 : {
7849 0 : case INTEGER_CST:
7850 0 : {
7851 0 : {
7852 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
7853 0 : tree res = generic_simplify_429 (loc, type, _p0, _p1, captures, LT_EXPR, NE_EXPR);
7854 0 : if (res) return res;
7855 : }
7856 0 : break;
7857 : }
7858 : default:;
7859 : }
7860 : }
7861 : break;
7862 2 : case CFN_BUILT_IN_CTZLL:
7863 2 : if (call_expr_nargs (_p0) == 1)
7864 : {
7865 2 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7866 2 : switch (TREE_CODE (_p1))
7867 : {
7868 2 : case INTEGER_CST:
7869 2 : {
7870 2 : {
7871 2 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7872 2 : tree res = generic_simplify_428 (loc, type, _p0, _p1, captures, LT_EXPR, NE_EXPR, CFN_BUILT_IN_CTZLL);
7873 2 : if (res) return res;
7874 : }
7875 0 : break;
7876 : }
7877 : default:;
7878 : }
7879 : }
7880 : break;
7881 : default:;
7882 : }
7883 : break;
7884 : default:;
7885 : }
7886 : return NULL_TREE;
7887 : }
7888 :
7889 : tree
7890 6882650 : generic_simplify_GE_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
7891 : {
7892 6882650 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7893 6882650 : switch (TREE_CODE (_p0))
7894 : {
7895 2001 : case RDIV_EXPR:
7896 2001 : {
7897 2001 : tree _q20 = TREE_OPERAND (_p0, 0);
7898 2001 : tree _q21 = TREE_OPERAND (_p0, 1);
7899 2001 : switch (TREE_CODE (_q20))
7900 : {
7901 46 : case REAL_CST:
7902 46 : {
7903 46 : if (real_zerop (_p1))
7904 : {
7905 2 : {
7906 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7907 2 : tree res = generic_simplify_398 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR);
7908 2 : if (res) return res;
7909 : }
7910 : }
7911 : break;
7912 : }
7913 : default:;
7914 : }
7915 : break;
7916 : }
7917 1167 : case TRUNC_MOD_EXPR:
7918 1167 : {
7919 1167 : tree _q20 = TREE_OPERAND (_p0, 0);
7920 1167 : tree _q21 = TREE_OPERAND (_p0, 1);
7921 1167 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
7922 : {
7923 16 : {
7924 16 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7925 16 : tree res = generic_simplify_399 (loc, type, _p0, _p1, captures, GE_EXPR, LT_EXPR);
7926 16 : if (res) return res;
7927 : }
7928 : }
7929 : break;
7930 : }
7931 31948 : case MULT_EXPR:
7932 31948 : {
7933 31948 : tree _q20 = TREE_OPERAND (_p0, 0);
7934 31948 : tree _q21 = TREE_OPERAND (_p0, 1);
7935 31948 : switch (TREE_CODE (_p1))
7936 : {
7937 7222 : case MULT_EXPR:
7938 7222 : {
7939 7222 : tree _q50 = TREE_OPERAND (_p1, 0);
7940 7222 : tree _q51 = TREE_OPERAND (_p1, 1);
7941 7222 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7942 : {
7943 4833 : {
7944 4833 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
7945 4833 : tree res = generic_simplify_400 (loc, type, _p0, _p1, captures, GE_EXPR);
7946 4833 : if (res) return res;
7947 : }
7948 : }
7949 2937 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7950 : {
7951 0 : {
7952 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
7953 0 : tree res = generic_simplify_400 (loc, type, _p0, _p1, captures, GE_EXPR);
7954 0 : if (res) return res;
7955 : }
7956 : }
7957 2937 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7958 : {
7959 0 : {
7960 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
7961 0 : tree res = generic_simplify_400 (loc, type, _p0, _p1, captures, GE_EXPR);
7962 0 : if (res) return res;
7963 : }
7964 : }
7965 2937 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7966 : {
7967 3 : {
7968 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
7969 3 : tree res = generic_simplify_400 (loc, type, _p0, _p1, captures, GE_EXPR);
7970 3 : if (res) return res;
7971 : }
7972 : }
7973 : break;
7974 : }
7975 : default:;
7976 : }
7977 : break;
7978 : }
7979 1067494 : CASE_CONVERT:
7980 1067494 : {
7981 1067494 : tree _q20 = TREE_OPERAND (_p0, 0);
7982 1067494 : switch (TREE_CODE (_q20))
7983 : {
7984 161 : case EXACT_DIV_EXPR:
7985 161 : {
7986 161 : tree _q30 = TREE_OPERAND (_q20, 0);
7987 161 : tree _q31 = TREE_OPERAND (_q20, 1);
7988 161 : switch (TREE_CODE (_q31))
7989 : {
7990 161 : case INTEGER_CST:
7991 161 : {
7992 161 : switch (TREE_CODE (_p1))
7993 : {
7994 47 : CASE_CONVERT:
7995 47 : {
7996 47 : tree _q60 = TREE_OPERAND (_p1, 0);
7997 47 : switch (TREE_CODE (_q60))
7998 : {
7999 0 : case EXACT_DIV_EXPR:
8000 0 : {
8001 0 : tree _q70 = TREE_OPERAND (_q60, 0);
8002 0 : tree _q71 = TREE_OPERAND (_q60, 1);
8003 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
8004 : {
8005 0 : {
8006 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q70 };
8007 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, GE_EXPR);
8008 0 : if (res) return res;
8009 : }
8010 : }
8011 : break;
8012 : }
8013 : default:;
8014 : }
8015 : break;
8016 : }
8017 : default:;
8018 : }
8019 : break;
8020 : }
8021 : default:;
8022 : }
8023 : break;
8024 : }
8025 : default:;
8026 : }
8027 : break;
8028 : }
8029 8014 : case EXACT_DIV_EXPR:
8030 8014 : {
8031 8014 : tree _q20 = TREE_OPERAND (_p0, 0);
8032 8014 : tree _q21 = TREE_OPERAND (_p0, 1);
8033 8014 : switch (TREE_CODE (_q21))
8034 : {
8035 8014 : case INTEGER_CST:
8036 8014 : {
8037 8014 : switch (TREE_CODE (_p1))
8038 : {
8039 0 : case EXACT_DIV_EXPR:
8040 0 : {
8041 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8042 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8043 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8044 : {
8045 0 : {
8046 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
8047 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, GE_EXPR);
8048 0 : if (res) return res;
8049 : }
8050 : }
8051 : break;
8052 : }
8053 : default:;
8054 : }
8055 : break;
8056 : }
8057 : default:;
8058 : }
8059 : break;
8060 : }
8061 42526 : case TRUNC_DIV_EXPR:
8062 42526 : {
8063 42526 : tree _q20 = TREE_OPERAND (_p0, 0);
8064 42526 : tree _q21 = TREE_OPERAND (_p0, 1);
8065 42526 : switch (TREE_CODE (_q21))
8066 : {
8067 42003 : case INTEGER_CST:
8068 42003 : {
8069 42003 : switch (TREE_CODE (_p1))
8070 : {
8071 41064 : case INTEGER_CST:
8072 41064 : {
8073 41064 : {
8074 41064 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
8075 41064 : tree res = generic_simplify_231 (loc, type, _p0, _p1, captures, GE_EXPR);
8076 41064 : if (res) return res;
8077 : }
8078 0 : break;
8079 : }
8080 : default:;
8081 : }
8082 : break;
8083 : }
8084 : default:;
8085 : }
8086 : break;
8087 : }
8088 799656 : case PLUS_EXPR:
8089 799656 : {
8090 799656 : tree _q20 = TREE_OPERAND (_p0, 0);
8091 799656 : tree _q21 = TREE_OPERAND (_p0, 1);
8092 799656 : switch (TREE_CODE (_p1))
8093 : {
8094 52213 : case PLUS_EXPR:
8095 52213 : {
8096 52213 : tree _q50 = TREE_OPERAND (_p1, 0);
8097 52213 : tree _q51 = TREE_OPERAND (_p1, 1);
8098 52213 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8099 : {
8100 1457 : {
8101 1457 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
8102 1457 : tree res = generic_simplify_401 (loc, type, _p0, _p1, captures, GE_EXPR);
8103 1457 : if (res) return res;
8104 : }
8105 : }
8106 52213 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8107 : {
8108 21 : {
8109 21 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
8110 21 : tree res = generic_simplify_401 (loc, type, _p0, _p1, captures, GE_EXPR);
8111 21 : if (res) return res;
8112 : }
8113 : }
8114 52213 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8115 : {
8116 13 : {
8117 13 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
8118 13 : tree res = generic_simplify_401 (loc, type, _p0, _p1, captures, GE_EXPR);
8119 13 : if (res) return res;
8120 : }
8121 : }
8122 52213 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8123 : {
8124 988 : {
8125 988 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
8126 988 : tree res = generic_simplify_401 (loc, type, _p0, _p1, captures, GE_EXPR);
8127 988 : if (res) return res;
8128 : }
8129 : }
8130 : break;
8131 : }
8132 799603 : default:;
8133 : }
8134 799603 : switch (TREE_CODE (_q21))
8135 : {
8136 689955 : case INTEGER_CST:
8137 689955 : {
8138 689955 : switch (TREE_CODE (_p1))
8139 : {
8140 15177 : case PLUS_EXPR:
8141 15177 : {
8142 15177 : tree _q50 = TREE_OPERAND (_p1, 0);
8143 15177 : tree _q51 = TREE_OPERAND (_p1, 1);
8144 15177 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8145 : {
8146 1453 : {
8147 1453 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
8148 1453 : tree res = generic_simplify_402 (loc, type, _p0, _p1, captures, GE_EXPR);
8149 1453 : if (res) return res;
8150 : }
8151 : }
8152 : break;
8153 : }
8154 : default:;
8155 : }
8156 : break;
8157 : }
8158 799603 : default:;
8159 : }
8160 799603 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8161 : {
8162 59235 : {
8163 59235 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8164 59235 : tree res = generic_simplify_403 (loc, type, _p0, _p1, captures, GE_EXPR);
8165 59235 : if (res) return res;
8166 : }
8167 : }
8168 763305 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
8169 : {
8170 24539 : {
8171 24539 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
8172 24539 : tree res = generic_simplify_403 (loc, type, _p0, _p1, captures, GE_EXPR);
8173 24539 : if (res) return res;
8174 : }
8175 : }
8176 : break;
8177 : }
8178 129813 : case MINUS_EXPR:
8179 129813 : {
8180 129813 : tree _q20 = TREE_OPERAND (_p0, 0);
8181 129813 : tree _q21 = TREE_OPERAND (_p0, 1);
8182 129813 : switch (TREE_CODE (_p1))
8183 : {
8184 1521 : case MINUS_EXPR:
8185 1521 : {
8186 1521 : tree _q50 = TREE_OPERAND (_p1, 0);
8187 1521 : tree _q51 = TREE_OPERAND (_p1, 1);
8188 1521 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8189 : {
8190 14 : {
8191 14 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
8192 14 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, GE_EXPR);
8193 14 : if (res) return res;
8194 : }
8195 : }
8196 1521 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8197 : {
8198 22 : {
8199 22 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
8200 22 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, GE_EXPR);
8201 22 : if (res) return res;
8202 : }
8203 : }
8204 : break;
8205 : }
8206 : default:;
8207 : }
8208 : break;
8209 : }
8210 2487 : case POINTER_DIFF_EXPR:
8211 2487 : {
8212 2487 : tree _q20 = TREE_OPERAND (_p0, 0);
8213 2487 : tree _q21 = TREE_OPERAND (_p0, 1);
8214 2487 : switch (TREE_CODE (_p1))
8215 : {
8216 32 : case POINTER_DIFF_EXPR:
8217 32 : {
8218 32 : tree _q50 = TREE_OPERAND (_p1, 0);
8219 32 : tree _q51 = TREE_OPERAND (_p1, 1);
8220 32 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8221 : {
8222 0 : {
8223 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
8224 0 : tree res = generic_simplify_234 (loc, type, _p0, _p1, captures, GE_EXPR);
8225 0 : if (res) return res;
8226 : }
8227 : }
8228 32 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8229 : {
8230 0 : {
8231 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
8232 0 : tree res = generic_simplify_235 (loc, type, _p0, _p1, captures, GE_EXPR);
8233 0 : if (res) return res;
8234 : }
8235 : }
8236 : break;
8237 : }
8238 : default:;
8239 : }
8240 : break;
8241 : }
8242 6797355 : default:;
8243 : }
8244 6797355 : switch (TREE_CODE (_p1))
8245 : {
8246 58978 : case PLUS_EXPR:
8247 58978 : {
8248 58978 : tree _q30 = TREE_OPERAND (_p1, 0);
8249 58978 : tree _q31 = TREE_OPERAND (_p1, 1);
8250 58978 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
8251 : {
8252 0 : {
8253 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
8254 0 : tree res = generic_simplify_403 (loc, type, _p0, _p1, captures, LE_EXPR);
8255 0 : if (res) return res;
8256 : }
8257 : }
8258 58978 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
8259 : {
8260 0 : {
8261 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q31, _p0 };
8262 0 : tree res = generic_simplify_403 (loc, type, _p0, _p1, captures, LE_EXPR);
8263 0 : if (res) return res;
8264 : }
8265 : }
8266 : break;
8267 : }
8268 2568 : case MINUS_EXPR:
8269 2568 : {
8270 2568 : tree _q30 = TREE_OPERAND (_p1, 0);
8271 2568 : tree _q31 = TREE_OPERAND (_p1, 1);
8272 2568 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
8273 : {
8274 0 : {
8275 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
8276 0 : tree res = generic_simplify_239 (loc, type, _p0, _p1, captures, GE_EXPR);
8277 0 : if (res) return res;
8278 : }
8279 : }
8280 : break;
8281 : }
8282 6797355 : default:;
8283 : }
8284 6797355 : switch (TREE_CODE (_p0))
8285 : {
8286 129813 : case MINUS_EXPR:
8287 129813 : {
8288 129813 : tree _q20 = TREE_OPERAND (_p0, 0);
8289 129813 : tree _q21 = TREE_OPERAND (_p0, 1);
8290 129813 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
8291 : {
8292 2377 : {
8293 2377 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
8294 2377 : tree res = generic_simplify_239 (loc, type, _p0, _p1, captures, LE_EXPR);
8295 2377 : if (res) return res;
8296 : }
8297 : }
8298 : break;
8299 : }
8300 889 : case BIT_IOR_EXPR:
8301 889 : {
8302 889 : tree _q20 = TREE_OPERAND (_p0, 0);
8303 889 : tree _q21 = TREE_OPERAND (_p0, 1);
8304 889 : if (tree_expr_nonnegative_p (_q20))
8305 : {
8306 82 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
8307 : {
8308 0 : {
8309 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8310 0 : tree res = generic_simplify_406 (loc, type, _p0, _p1, captures, GE_EXPR, BIT_IOR_EXPR);
8311 0 : if (res) return res;
8312 : }
8313 : }
8314 : }
8315 889 : if (tree_expr_nonnegative_p (_q21))
8316 : {
8317 264 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8318 : {
8319 0 : {
8320 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8321 0 : tree res = generic_simplify_406 (loc, type, _p0, _p1, captures, GE_EXPR, BIT_IOR_EXPR);
8322 0 : if (res) return res;
8323 : }
8324 : }
8325 : }
8326 : break;
8327 : }
8328 6797354 : default:;
8329 : }
8330 6797354 : switch (TREE_CODE (_p1))
8331 : {
8332 199 : case BIT_AND_EXPR:
8333 199 : {
8334 199 : tree _q30 = TREE_OPERAND (_p1, 0);
8335 199 : tree _q31 = TREE_OPERAND (_p1, 1);
8336 199 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
8337 : {
8338 0 : if (tree_expr_nonnegative_p (_q30))
8339 : {
8340 0 : {
8341 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
8342 0 : tree res = generic_simplify_406 (loc, type, _p0, _p1, captures, LE_EXPR, BIT_AND_EXPR);
8343 0 : if (res) return res;
8344 : }
8345 : }
8346 : }
8347 199 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
8348 : {
8349 0 : if (tree_expr_nonnegative_p (_q31))
8350 : {
8351 0 : {
8352 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
8353 0 : tree res = generic_simplify_406 (loc, type, _p0, _p1, captures, LE_EXPR, BIT_AND_EXPR);
8354 0 : if (res) return res;
8355 : }
8356 : }
8357 : }
8358 : break;
8359 : }
8360 6797354 : default:;
8361 : }
8362 6797354 : switch (TREE_CODE (_p0))
8363 : {
8364 875 : case MAX_EXPR:
8365 875 : {
8366 875 : tree _q20 = TREE_OPERAND (_p0, 0);
8367 875 : tree _q21 = TREE_OPERAND (_p0, 1);
8368 875 : switch (TREE_CODE (_p1))
8369 : {
8370 0 : case MIN_EXPR:
8371 0 : {
8372 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8373 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8374 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8375 : {
8376 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8377 : {
8378 0 : {
8379 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8380 0 : tree res = generic_simplify_407 (loc, type, _p0, _p1, captures, LE_EXPR);
8381 0 : if (res) return res;
8382 : }
8383 : }
8384 : }
8385 : break;
8386 : }
8387 : default:;
8388 : }
8389 : break;
8390 : }
8391 2698 : case MIN_EXPR:
8392 2698 : {
8393 2698 : tree _q20 = TREE_OPERAND (_p0, 0);
8394 2698 : tree _q21 = TREE_OPERAND (_p0, 1);
8395 2698 : switch (TREE_CODE (_p1))
8396 : {
8397 27 : case MAX_EXPR:
8398 27 : {
8399 27 : tree _q50 = TREE_OPERAND (_p1, 0);
8400 27 : tree _q51 = TREE_OPERAND (_p1, 1);
8401 27 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8402 : {
8403 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8404 : {
8405 0 : {
8406 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8407 0 : tree res = generic_simplify_408 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
8408 0 : if (res) return res;
8409 : }
8410 : }
8411 : }
8412 : break;
8413 : }
8414 2698 : default:;
8415 : }
8416 2698 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
8417 : {
8418 0 : {
8419 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8420 0 : tree res = generic_simplify_246 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR, LE_EXPR);
8421 0 : if (res) return res;
8422 : }
8423 : }
8424 2698 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8425 : {
8426 1 : {
8427 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8428 1 : tree res = generic_simplify_246 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR, LE_EXPR);
8429 1 : if (res) return res;
8430 : }
8431 : }
8432 : break;
8433 : }
8434 6797353 : default:;
8435 : }
8436 6797353 : switch (TREE_CODE (_p1))
8437 : {
8438 214 : case MAX_EXPR:
8439 214 : {
8440 214 : tree _q30 = TREE_OPERAND (_p1, 0);
8441 214 : tree _q31 = TREE_OPERAND (_p1, 1);
8442 214 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
8443 : {
8444 0 : {
8445 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
8446 0 : tree res = generic_simplify_246 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR, GE_EXPR);
8447 0 : if (res) return res;
8448 : }
8449 : }
8450 214 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
8451 : {
8452 0 : {
8453 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
8454 0 : tree res = generic_simplify_246 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR, GE_EXPR);
8455 0 : if (res) return res;
8456 : }
8457 : }
8458 : break;
8459 : }
8460 1728 : case MIN_EXPR:
8461 1728 : {
8462 1728 : tree _q30 = TREE_OPERAND (_p1, 0);
8463 1728 : tree _q31 = TREE_OPERAND (_p1, 1);
8464 1728 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
8465 : {
8466 0 : {
8467 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
8468 0 : tree res = generic_simplify_409 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR);
8469 0 : if (res) return res;
8470 : }
8471 : }
8472 1728 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
8473 : {
8474 0 : {
8475 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
8476 0 : tree res = generic_simplify_409 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR);
8477 0 : if (res) return res;
8478 : }
8479 : }
8480 : break;
8481 : }
8482 6797353 : default:;
8483 : }
8484 6797353 : switch (TREE_CODE (_p0))
8485 : {
8486 875 : case MAX_EXPR:
8487 875 : {
8488 875 : tree _q20 = TREE_OPERAND (_p0, 0);
8489 875 : tree _q21 = TREE_OPERAND (_p0, 1);
8490 875 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
8491 : {
8492 0 : {
8493 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8494 0 : tree res = generic_simplify_409 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR);
8495 0 : if (res) return res;
8496 : }
8497 : }
8498 875 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8499 : {
8500 2 : {
8501 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8502 2 : tree res = generic_simplify_409 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR);
8503 2 : if (res) return res;
8504 : }
8505 : }
8506 873 : switch (TREE_CODE (_q21))
8507 : {
8508 689 : case INTEGER_CST:
8509 689 : {
8510 689 : switch (TREE_CODE (_p1))
8511 : {
8512 0 : case INTEGER_CST:
8513 0 : {
8514 0 : {
8515 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8516 0 : tree res = generic_simplify_410 (loc, type, _p0, _p1, captures, MAX_EXPR, GE_EXPR, BIT_IOR_EXPR);
8517 0 : if (res) return res;
8518 : }
8519 0 : break;
8520 : }
8521 : default:;
8522 : }
8523 : break;
8524 : }
8525 : default:;
8526 : }
8527 : break;
8528 : }
8529 2697 : case MIN_EXPR:
8530 2697 : {
8531 2697 : tree _q20 = TREE_OPERAND (_p0, 0);
8532 2697 : tree _q21 = TREE_OPERAND (_p0, 1);
8533 2697 : switch (TREE_CODE (_q21))
8534 : {
8535 1005 : case INTEGER_CST:
8536 1005 : {
8537 1005 : switch (TREE_CODE (_p1))
8538 : {
8539 0 : case INTEGER_CST:
8540 0 : {
8541 0 : {
8542 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8543 0 : tree res = generic_simplify_410 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR, BIT_AND_EXPR);
8544 0 : if (res) return res;
8545 : }
8546 0 : break;
8547 : }
8548 : default:;
8549 : }
8550 : break;
8551 : }
8552 2697 : default:;
8553 : }
8554 2697 : if (tree_expr_nonnegative_p (_q21))
8555 : {
8556 1080 : if (integer_zerop (_p1))
8557 : {
8558 0 : {
8559 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8560 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, GE_EXPR, MIN_EXPR);
8561 0 : if (res) return res;
8562 : }
8563 : }
8564 : }
8565 2697 : if (tree_expr_nonnegative_p (_q20))
8566 : {
8567 505 : if (integer_zerop (_p1))
8568 : {
8569 2 : {
8570 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _p1 };
8571 2 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, GE_EXPR, MIN_EXPR);
8572 2 : if (res) return res;
8573 : }
8574 : }
8575 : }
8576 : break;
8577 : }
8578 889 : case BIT_IOR_EXPR:
8579 889 : {
8580 889 : tree _q20 = TREE_OPERAND (_p0, 0);
8581 889 : tree _q21 = TREE_OPERAND (_p0, 1);
8582 889 : if (tree_expr_nonnegative_p (_q21))
8583 : {
8584 264 : if (integer_zerop (_p1))
8585 : {
8586 0 : {
8587 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8588 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, GE_EXPR, BIT_IOR_EXPR);
8589 0 : if (res) return res;
8590 : }
8591 : }
8592 : }
8593 889 : if (tree_expr_nonnegative_p (_q20))
8594 : {
8595 82 : if (integer_zerop (_p1))
8596 : {
8597 0 : {
8598 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _p1 };
8599 0 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, GE_EXPR, BIT_IOR_EXPR);
8600 0 : if (res) return res;
8601 : }
8602 : }
8603 : }
8604 : break;
8605 : }
8606 1067494 : CASE_CONVERT:
8607 1067494 : {
8608 1067494 : tree _q20 = TREE_OPERAND (_p0, 0);
8609 1067494 : switch (TREE_CODE (_q20))
8610 : {
8611 0 : case GE_EXPR:
8612 0 : {
8613 0 : tree _q30 = TREE_OPERAND (_q20, 0);
8614 0 : tree _q31 = TREE_OPERAND (_q20, 1);
8615 0 : if (tree_zero_one_valued_p (_q30))
8616 : {
8617 0 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
8618 : {
8619 0 : {
8620 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
8621 0 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, GE_EXPR);
8622 0 : if (res) return res;
8623 : }
8624 : }
8625 : }
8626 : break;
8627 : }
8628 : default:;
8629 : }
8630 : break;
8631 : }
8632 41 : case GE_EXPR:
8633 41 : {
8634 41 : tree _q20 = TREE_OPERAND (_p0, 0);
8635 41 : tree _q21 = TREE_OPERAND (_p0, 1);
8636 41 : if (tree_zero_one_valued_p (_q20))
8637 : {
8638 15 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8639 : {
8640 3 : {
8641 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8642 3 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, GE_EXPR);
8643 3 : if (res) return res;
8644 : }
8645 : }
8646 : }
8647 : break;
8648 : }
8649 6 : case VEC_COND_EXPR:
8650 6 : {
8651 6 : tree _q20 = TREE_OPERAND (_p0, 0);
8652 6 : tree _q21 = TREE_OPERAND (_p0, 1);
8653 6 : tree _q22 = TREE_OPERAND (_p0, 2);
8654 6 : switch (TREE_CODE (_p1))
8655 : {
8656 0 : case VEC_COND_EXPR:
8657 0 : {
8658 0 : tree _q60 = TREE_OPERAND (_p1, 0);
8659 0 : tree _q61 = TREE_OPERAND (_p1, 1);
8660 0 : tree _q62 = TREE_OPERAND (_p1, 2);
8661 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
8662 : {
8663 0 : {
8664 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
8665 0 : if (VECTOR_TYPE_P (type)
8666 0 : && (TREE_CODE_CLASS (GE_EXPR) != tcc_comparison
8667 0 : || types_match (type, TREE_TYPE (captures[2]))
8668 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8669 : || (optimize_vectors_before_lowering_p ()
8670 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8671 : )
8672 : {
8673 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1723;
8674 0 : {
8675 0 : tree res_op0;
8676 0 : res_op0 = captures[1];
8677 0 : tree res_op1;
8678 0 : {
8679 0 : tree _o1[2], _r1;
8680 0 : _o1[0] = captures[2];
8681 0 : _o1[1] = captures[5];
8682 0 : _r1 = fold_build2_loc (loc, GE_EXPR, type, _o1[0], _o1[1]);
8683 0 : if (EXPR_P (_r1))
8684 0 : goto next_after_fail1723;
8685 0 : res_op1 = _r1;
8686 : }
8687 0 : tree res_op2;
8688 0 : {
8689 0 : tree _o1[2], _r1;
8690 0 : _o1[0] = captures[3];
8691 0 : _o1[1] = captures[6];
8692 0 : _r1 = fold_build2_loc (loc, GE_EXPR, type, _o1[0], _o1[1]);
8693 0 : if (EXPR_P (_r1))
8694 0 : goto next_after_fail1723;
8695 0 : res_op2 = _r1;
8696 : }
8697 0 : tree _r;
8698 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8699 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 938, __FILE__, __LINE__, true);
8700 : return _r;
8701 : }
8702 6 : next_after_fail1723:;
8703 : }
8704 : }
8705 : }
8706 : break;
8707 : }
8708 6 : default:;
8709 : }
8710 6 : {
8711 6 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
8712 6 : if (VECTOR_TYPE_P (type)
8713 12 : && (TREE_CODE_CLASS (GE_EXPR) != tcc_comparison
8714 6 : || types_match (type, TREE_TYPE (captures[2]))
8715 6 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8716 : || (optimize_vectors_before_lowering_p ()
8717 2 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8718 : )
8719 : {
8720 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1724;
8721 6 : {
8722 6 : if (! tree_invariant_p (captures[4])) goto next_after_fail1724;
8723 5 : tree res_op0;
8724 5 : res_op0 = captures[1];
8725 5 : tree res_op1;
8726 5 : {
8727 5 : tree _o1[2], _r1;
8728 5 : _o1[0] = captures[2];
8729 5 : _o1[1] = unshare_expr (captures[4]);
8730 5 : _r1 = fold_build2_loc (loc, GE_EXPR, type, _o1[0], _o1[1]);
8731 5 : if (EXPR_P (_r1))
8732 1 : goto next_after_fail1724;
8733 4 : res_op1 = _r1;
8734 : }
8735 4 : tree res_op2;
8736 4 : {
8737 4 : tree _o1[2], _r1;
8738 4 : _o1[0] = captures[3];
8739 4 : _o1[1] = captures[4];
8740 4 : _r1 = fold_build2_loc (loc, GE_EXPR, type, _o1[0], _o1[1]);
8741 4 : if (EXPR_P (_r1))
8742 0 : goto next_after_fail1724;
8743 4 : res_op2 = _r1;
8744 : }
8745 4 : tree _r;
8746 4 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8747 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 940, __FILE__, __LINE__, true);
8748 : return _r;
8749 : }
8750 6797342 : next_after_fail1724:;
8751 : }
8752 : }
8753 : break;
8754 : }
8755 6797342 : default:;
8756 : }
8757 6797342 : switch (TREE_CODE (_p1))
8758 : {
8759 0 : case VEC_COND_EXPR:
8760 0 : {
8761 0 : tree _q30 = TREE_OPERAND (_p1, 0);
8762 0 : tree _q31 = TREE_OPERAND (_p1, 1);
8763 0 : tree _q32 = TREE_OPERAND (_p1, 2);
8764 0 : {
8765 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
8766 0 : if (VECTOR_TYPE_P (type)
8767 0 : && (TREE_CODE_CLASS (GE_EXPR) != tcc_comparison
8768 0 : || types_match (type, TREE_TYPE (captures[3]))
8769 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
8770 : || (optimize_vectors_before_lowering_p ()
8771 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
8772 : )
8773 : {
8774 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1725;
8775 0 : {
8776 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1725;
8777 0 : tree res_op0;
8778 0 : res_op0 = captures[2];
8779 0 : tree res_op1;
8780 0 : {
8781 0 : tree _o1[2], _r1;
8782 0 : _o1[0] = unshare_expr (captures[0]);
8783 0 : _o1[1] = captures[3];
8784 0 : _r1 = fold_build2_loc (loc, GE_EXPR, type, _o1[0], _o1[1]);
8785 0 : if (EXPR_P (_r1))
8786 0 : goto next_after_fail1725;
8787 0 : res_op1 = _r1;
8788 : }
8789 0 : tree res_op2;
8790 0 : {
8791 0 : tree _o1[2], _r1;
8792 0 : _o1[0] = captures[0];
8793 0 : _o1[1] = captures[4];
8794 0 : _r1 = fold_build2_loc (loc, GE_EXPR, type, _o1[0], _o1[1]);
8795 0 : if (EXPR_P (_r1))
8796 0 : goto next_after_fail1725;
8797 0 : res_op2 = _r1;
8798 : }
8799 0 : tree _r;
8800 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8801 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 941, __FILE__, __LINE__, true);
8802 : return _r;
8803 : }
8804 6797342 : next_after_fail1725:;
8805 : }
8806 : }
8807 : break;
8808 : }
8809 6797342 : default:;
8810 : }
8811 6797342 : if (uniform_integer_cst_p (_p1))
8812 : {
8813 3442263 : {
8814 3442263 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8815 3442263 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, GE_EXPR, GT_EXPR);
8816 3442263 : if (res) return res;
8817 : }
8818 : }
8819 5239336 : switch (TREE_CODE (_p0))
8820 : {
8821 58681 : case MINUS_EXPR:
8822 58681 : {
8823 58681 : tree _q20 = TREE_OPERAND (_p0, 0);
8824 58681 : tree _q21 = TREE_OPERAND (_p0, 1);
8825 58681 : switch (TREE_CODE (_q20))
8826 : {
8827 434 : CASE_CONVERT:
8828 434 : {
8829 434 : tree _q30 = TREE_OPERAND (_q20, 0);
8830 434 : switch (TREE_CODE (_q30))
8831 : {
8832 0 : case GT_EXPR:
8833 0 : {
8834 0 : tree _q40 = TREE_OPERAND (_q30, 0);
8835 0 : tree _q41 = TREE_OPERAND (_q30, 1);
8836 0 : switch (TREE_CODE (_q21))
8837 : {
8838 0 : CASE_CONVERT:
8839 0 : {
8840 0 : tree _q70 = TREE_OPERAND (_q21, 0);
8841 0 : switch (TREE_CODE (_q70))
8842 : {
8843 0 : case LT_EXPR:
8844 0 : {
8845 0 : tree _q80 = TREE_OPERAND (_q70, 0);
8846 0 : tree _q81 = TREE_OPERAND (_q70, 1);
8847 0 : if ((_q80 == _q40 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q40, 0) && types_match (_q80, _q40)))
8848 : {
8849 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
8850 : {
8851 0 : if (integer_zerop (_p1))
8852 : {
8853 0 : {
8854 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q41 };
8855 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GT_EXPR, LT_EXPR, GE_EXPR);
8856 0 : if (res) return res;
8857 : }
8858 : }
8859 : }
8860 : }
8861 : break;
8862 : }
8863 0 : case GT_EXPR:
8864 0 : {
8865 0 : tree _q80 = TREE_OPERAND (_q70, 0);
8866 0 : tree _q81 = TREE_OPERAND (_q70, 1);
8867 0 : if ((_q80 == _q41 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q41, 0) && types_match (_q80, _q41)))
8868 : {
8869 0 : if ((_q81 == _q40 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q40, 0) && types_match (_q81, _q40)))
8870 : {
8871 0 : if (integer_zerop (_p1))
8872 : {
8873 0 : {
8874 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q41 };
8875 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GT_EXPR, LT_EXPR, GE_EXPR);
8876 0 : if (res) return res;
8877 : }
8878 : }
8879 : }
8880 : }
8881 : break;
8882 : }
8883 : default:;
8884 : }
8885 : break;
8886 : }
8887 : default:;
8888 : }
8889 : break;
8890 : }
8891 0 : case GE_EXPR:
8892 0 : {
8893 0 : tree _q40 = TREE_OPERAND (_q30, 0);
8894 0 : tree _q41 = TREE_OPERAND (_q30, 1);
8895 0 : switch (TREE_CODE (_q21))
8896 : {
8897 0 : CASE_CONVERT:
8898 0 : {
8899 0 : tree _q70 = TREE_OPERAND (_q21, 0);
8900 0 : switch (TREE_CODE (_q70))
8901 : {
8902 0 : case LE_EXPR:
8903 0 : {
8904 0 : tree _q80 = TREE_OPERAND (_q70, 0);
8905 0 : tree _q81 = TREE_OPERAND (_q70, 1);
8906 0 : if ((_q80 == _q40 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q40, 0) && types_match (_q80, _q40)))
8907 : {
8908 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
8909 : {
8910 0 : if (integer_zerop (_p1))
8911 : {
8912 0 : {
8913 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q41 };
8914 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR, GE_EXPR);
8915 0 : if (res) return res;
8916 : }
8917 : }
8918 : }
8919 : }
8920 : break;
8921 : }
8922 0 : case GE_EXPR:
8923 0 : {
8924 0 : tree _q80 = TREE_OPERAND (_q70, 0);
8925 0 : tree _q81 = TREE_OPERAND (_q70, 1);
8926 0 : if ((_q80 == _q41 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q41, 0) && types_match (_q80, _q41)))
8927 : {
8928 0 : if ((_q81 == _q40 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q40, 0) && types_match (_q81, _q40)))
8929 : {
8930 0 : if (integer_zerop (_p1))
8931 : {
8932 0 : {
8933 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q41 };
8934 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR, GE_EXPR);
8935 0 : if (res) return res;
8936 : }
8937 : }
8938 : }
8939 : }
8940 : break;
8941 : }
8942 : default:;
8943 : }
8944 : break;
8945 : }
8946 : default:;
8947 : }
8948 : break;
8949 : }
8950 0 : case LT_EXPR:
8951 0 : {
8952 0 : tree _q40 = TREE_OPERAND (_q30, 0);
8953 0 : tree _q41 = TREE_OPERAND (_q30, 1);
8954 0 : switch (TREE_CODE (_q21))
8955 : {
8956 0 : CASE_CONVERT:
8957 0 : {
8958 0 : tree _q70 = TREE_OPERAND (_q21, 0);
8959 0 : switch (TREE_CODE (_q70))
8960 : {
8961 0 : case LT_EXPR:
8962 0 : {
8963 0 : tree _q80 = TREE_OPERAND (_q70, 0);
8964 0 : tree _q81 = TREE_OPERAND (_q70, 1);
8965 0 : if ((_q80 == _q41 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q41, 0) && types_match (_q80, _q41)))
8966 : {
8967 0 : if ((_q81 == _q40 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q40, 0) && types_match (_q81, _q40)))
8968 : {
8969 0 : if (integer_zerop (_p1))
8970 : {
8971 0 : {
8972 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q40 };
8973 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GT_EXPR, LT_EXPR, GE_EXPR);
8974 0 : if (res) return res;
8975 : }
8976 : }
8977 : }
8978 : }
8979 : break;
8980 : }
8981 0 : case GT_EXPR:
8982 0 : {
8983 0 : tree _q80 = TREE_OPERAND (_q70, 0);
8984 0 : tree _q81 = TREE_OPERAND (_q70, 1);
8985 0 : if ((_q80 == _q40 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q40, 0) && types_match (_q80, _q40)))
8986 : {
8987 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
8988 : {
8989 0 : if (integer_zerop (_p1))
8990 : {
8991 0 : {
8992 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q40 };
8993 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GT_EXPR, LT_EXPR, GE_EXPR);
8994 0 : if (res) return res;
8995 : }
8996 : }
8997 : }
8998 : }
8999 : break;
9000 : }
9001 : default:;
9002 : }
9003 : break;
9004 : }
9005 : default:;
9006 : }
9007 : break;
9008 : }
9009 0 : case LE_EXPR:
9010 0 : {
9011 0 : tree _q40 = TREE_OPERAND (_q30, 0);
9012 0 : tree _q41 = TREE_OPERAND (_q30, 1);
9013 0 : switch (TREE_CODE (_q21))
9014 : {
9015 0 : CASE_CONVERT:
9016 0 : {
9017 0 : tree _q70 = TREE_OPERAND (_q21, 0);
9018 0 : switch (TREE_CODE (_q70))
9019 : {
9020 0 : case LE_EXPR:
9021 0 : {
9022 0 : tree _q80 = TREE_OPERAND (_q70, 0);
9023 0 : tree _q81 = TREE_OPERAND (_q70, 1);
9024 0 : if ((_q80 == _q41 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q41, 0) && types_match (_q80, _q41)))
9025 : {
9026 0 : if ((_q81 == _q40 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q40, 0) && types_match (_q81, _q40)))
9027 : {
9028 0 : if (integer_zerop (_p1))
9029 : {
9030 0 : {
9031 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q40 };
9032 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR, GE_EXPR);
9033 0 : if (res) return res;
9034 : }
9035 : }
9036 : }
9037 : }
9038 : break;
9039 : }
9040 0 : case GE_EXPR:
9041 0 : {
9042 0 : tree _q80 = TREE_OPERAND (_q70, 0);
9043 0 : tree _q81 = TREE_OPERAND (_q70, 1);
9044 0 : if ((_q80 == _q40 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q40, 0) && types_match (_q80, _q40)))
9045 : {
9046 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
9047 : {
9048 0 : if (integer_zerop (_p1))
9049 : {
9050 0 : {
9051 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q40 };
9052 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR, GE_EXPR);
9053 0 : if (res) return res;
9054 : }
9055 : }
9056 : }
9057 : }
9058 : break;
9059 : }
9060 : default:;
9061 : }
9062 : break;
9063 : }
9064 : default:;
9065 : }
9066 : break;
9067 : }
9068 : default:;
9069 : }
9070 : break;
9071 : }
9072 0 : case GT_EXPR:
9073 0 : {
9074 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9075 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9076 0 : switch (TREE_CODE (_q21))
9077 : {
9078 0 : case LT_EXPR:
9079 0 : {
9080 0 : tree _q60 = TREE_OPERAND (_q21, 0);
9081 0 : tree _q61 = TREE_OPERAND (_q21, 1);
9082 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
9083 : {
9084 0 : if ((_q61 == _q31 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q31, 0) && types_match (_q61, _q31)))
9085 : {
9086 0 : if (integer_zerop (_p1))
9087 : {
9088 0 : {
9089 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q31 };
9090 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GT_EXPR, LT_EXPR, GE_EXPR);
9091 0 : if (res) return res;
9092 : }
9093 : }
9094 : }
9095 : }
9096 : break;
9097 : }
9098 0 : case GT_EXPR:
9099 0 : {
9100 0 : tree _q60 = TREE_OPERAND (_q21, 0);
9101 0 : tree _q61 = TREE_OPERAND (_q21, 1);
9102 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
9103 : {
9104 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
9105 : {
9106 0 : if (integer_zerop (_p1))
9107 : {
9108 0 : {
9109 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q31 };
9110 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GT_EXPR, LT_EXPR, GE_EXPR);
9111 0 : if (res) return res;
9112 : }
9113 : }
9114 : }
9115 : }
9116 : break;
9117 : }
9118 : default:;
9119 : }
9120 : break;
9121 : }
9122 0 : case GE_EXPR:
9123 0 : {
9124 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9125 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9126 0 : switch (TREE_CODE (_q21))
9127 : {
9128 0 : case LE_EXPR:
9129 0 : {
9130 0 : tree _q60 = TREE_OPERAND (_q21, 0);
9131 0 : tree _q61 = TREE_OPERAND (_q21, 1);
9132 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
9133 : {
9134 0 : if ((_q61 == _q31 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q31, 0) && types_match (_q61, _q31)))
9135 : {
9136 0 : if (integer_zerop (_p1))
9137 : {
9138 0 : {
9139 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q31 };
9140 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR, GE_EXPR);
9141 0 : if (res) return res;
9142 : }
9143 : }
9144 : }
9145 : }
9146 : break;
9147 : }
9148 0 : case GE_EXPR:
9149 0 : {
9150 0 : tree _q60 = TREE_OPERAND (_q21, 0);
9151 0 : tree _q61 = TREE_OPERAND (_q21, 1);
9152 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
9153 : {
9154 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
9155 : {
9156 0 : if (integer_zerop (_p1))
9157 : {
9158 0 : {
9159 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q31 };
9160 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR, GE_EXPR);
9161 0 : if (res) return res;
9162 : }
9163 : }
9164 : }
9165 : }
9166 : break;
9167 : }
9168 : default:;
9169 : }
9170 : break;
9171 : }
9172 0 : case LT_EXPR:
9173 0 : {
9174 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9175 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9176 0 : switch (TREE_CODE (_q21))
9177 : {
9178 0 : case LT_EXPR:
9179 0 : {
9180 0 : tree _q60 = TREE_OPERAND (_q21, 0);
9181 0 : tree _q61 = TREE_OPERAND (_q21, 1);
9182 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
9183 : {
9184 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
9185 : {
9186 0 : if (integer_zerop (_p1))
9187 : {
9188 0 : {
9189 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q31, _q30 };
9190 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GT_EXPR, LT_EXPR, GE_EXPR);
9191 0 : if (res) return res;
9192 : }
9193 : }
9194 : }
9195 : }
9196 : break;
9197 : }
9198 0 : case GT_EXPR:
9199 0 : {
9200 0 : tree _q60 = TREE_OPERAND (_q21, 0);
9201 0 : tree _q61 = TREE_OPERAND (_q21, 1);
9202 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
9203 : {
9204 0 : if ((_q61 == _q31 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q31, 0) && types_match (_q61, _q31)))
9205 : {
9206 0 : if (integer_zerop (_p1))
9207 : {
9208 0 : {
9209 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q31, _q30 };
9210 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GT_EXPR, LT_EXPR, GE_EXPR);
9211 0 : if (res) return res;
9212 : }
9213 : }
9214 : }
9215 : }
9216 : break;
9217 : }
9218 : default:;
9219 : }
9220 : break;
9221 : }
9222 0 : case LE_EXPR:
9223 0 : {
9224 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9225 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9226 0 : switch (TREE_CODE (_q21))
9227 : {
9228 0 : case LE_EXPR:
9229 0 : {
9230 0 : tree _q60 = TREE_OPERAND (_q21, 0);
9231 0 : tree _q61 = TREE_OPERAND (_q21, 1);
9232 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
9233 : {
9234 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
9235 : {
9236 0 : if (integer_zerop (_p1))
9237 : {
9238 0 : {
9239 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q31, _q30 };
9240 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR, GE_EXPR);
9241 0 : if (res) return res;
9242 : }
9243 : }
9244 : }
9245 : }
9246 : break;
9247 : }
9248 0 : case GE_EXPR:
9249 0 : {
9250 0 : tree _q60 = TREE_OPERAND (_q21, 0);
9251 0 : tree _q61 = TREE_OPERAND (_q21, 1);
9252 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
9253 : {
9254 0 : if ((_q61 == _q31 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q31, 0) && types_match (_q61, _q31)))
9255 : {
9256 0 : if (integer_zerop (_p1))
9257 : {
9258 0 : {
9259 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q31, _q30 };
9260 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR, GE_EXPR);
9261 0 : if (res) return res;
9262 : }
9263 : }
9264 : }
9265 : }
9266 : break;
9267 : }
9268 : default:;
9269 : }
9270 : break;
9271 : }
9272 : default:;
9273 : }
9274 : break;
9275 : }
9276 23954 : case MULT_EXPR:
9277 23954 : {
9278 23954 : tree _q20 = TREE_OPERAND (_p0, 0);
9279 23954 : tree _q21 = TREE_OPERAND (_p0, 1);
9280 23954 : switch (TREE_CODE (_q21))
9281 : {
9282 20033 : case INTEGER_CST:
9283 20033 : {
9284 20033 : if (integer_zerop (_p1))
9285 : {
9286 2754 : {
9287 2754 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
9288 2754 : tree res = generic_simplify_267 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR);
9289 2754 : if (res) return res;
9290 : }
9291 : }
9292 : break;
9293 : }
9294 : default:;
9295 : }
9296 : break;
9297 : }
9298 5239040 : default:;
9299 : }
9300 5239040 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
9301 : {
9302 47023 : {
9303 47023 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
9304 47023 : tree res = generic_simplify_269 (loc, type, _p0, _p1, captures, GE_EXPR);
9305 47023 : if (res) return res;
9306 : }
9307 : }
9308 5192059 : switch (TREE_CODE (_p0))
9309 : {
9310 420 : case BIT_NOT_EXPR:
9311 420 : {
9312 420 : tree _q20 = TREE_OPERAND (_p0, 0);
9313 420 : switch (TREE_CODE (_p1))
9314 : {
9315 1 : case BIT_NOT_EXPR:
9316 1 : {
9317 1 : tree _q40 = TREE_OPERAND (_p1, 0);
9318 1 : {
9319 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _p1, _q40 };
9320 1 : tree res = generic_simplify_273 (loc, type, _p0, _p1, captures, GE_EXPR);
9321 1 : if (res) return res;
9322 : }
9323 0 : break;
9324 : }
9325 419 : default:;
9326 : }
9327 419 : {
9328 419 : tree _p1_pops[1];
9329 419 : if (tree_nop_convert (_p1, _p1_pops))
9330 : {
9331 50 : tree _q40 = _p1_pops[0];
9332 50 : switch (TREE_CODE (_q40))
9333 : {
9334 0 : case BIT_NOT_EXPR:
9335 0 : {
9336 0 : tree _q50 = TREE_OPERAND (_q40, 0);
9337 0 : {
9338 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40, _q50 };
9339 0 : tree res = generic_simplify_273 (loc, type, _p0, _p1, captures, GE_EXPR);
9340 0 : if (res) return res;
9341 : }
9342 0 : break;
9343 : }
9344 : default:;
9345 : }
9346 : }
9347 : }
9348 419 : if (CONSTANT_CLASS_P (_p1))
9349 : {
9350 96 : {
9351 96 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9352 96 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR);
9353 96 : if (res) return res;
9354 : }
9355 : }
9356 : break;
9357 : }
9358 5191962 : default:;
9359 : }
9360 5191962 : {
9361 5191962 : tree _p0_pops[1];
9362 5191962 : if (tree_nop_convert (_p0, _p0_pops))
9363 : {
9364 246414 : tree _q20 = _p0_pops[0];
9365 246414 : switch (TREE_CODE (_q20))
9366 : {
9367 4 : case BIT_NOT_EXPR:
9368 4 : {
9369 4 : tree _q30 = TREE_OPERAND (_q20, 0);
9370 4 : switch (TREE_CODE (_p1))
9371 : {
9372 0 : case BIT_NOT_EXPR:
9373 0 : {
9374 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9375 0 : {
9376 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _p1, _q50 };
9377 0 : tree res = generic_simplify_271 (loc, type, _p0, _p1, captures, GE_EXPR);
9378 0 : if (res) return res;
9379 : }
9380 0 : break;
9381 : }
9382 4 : default:;
9383 : }
9384 4 : {
9385 4 : tree _p1_pops[1];
9386 4 : if (tree_nop_convert (_p1, _p1_pops))
9387 : {
9388 0 : tree _q50 = _p1_pops[0];
9389 0 : switch (TREE_CODE (_q50))
9390 : {
9391 0 : case BIT_NOT_EXPR:
9392 0 : {
9393 0 : tree _q60 = TREE_OPERAND (_q50, 0);
9394 0 : {
9395 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50, _q60 };
9396 0 : tree res = generic_simplify_271 (loc, type, _p0, _p1, captures, GE_EXPR);
9397 0 : if (res) return res;
9398 : }
9399 0 : break;
9400 : }
9401 : default:;
9402 : }
9403 : }
9404 : }
9405 4 : if (CONSTANT_CLASS_P (_p1))
9406 : {
9407 0 : {
9408 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9409 0 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR);
9410 0 : if (res) return res;
9411 : }
9412 : }
9413 : break;
9414 : }
9415 : default:;
9416 : }
9417 : }
9418 : }
9419 5191962 : switch (TREE_CODE (_p1))
9420 : {
9421 659403 : case REAL_CST:
9422 659403 : {
9423 659403 : {
9424 659403 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9425 659403 : tree res = generic_simplify_274 (loc, type, _p0, _p1, captures, GE_EXPR);
9426 659403 : if (res) return res;
9427 : }
9428 659313 : break;
9429 : }
9430 5191872 : default:;
9431 : }
9432 5191872 : switch (TREE_CODE (_p0))
9433 : {
9434 675682 : case PLUS_EXPR:
9435 675682 : {
9436 675682 : tree _q20 = TREE_OPERAND (_p0, 0);
9437 675682 : tree _q21 = TREE_OPERAND (_p0, 1);
9438 675682 : switch (TREE_CODE (_q21))
9439 : {
9440 168 : case REAL_CST:
9441 168 : {
9442 168 : switch (TREE_CODE (_p1))
9443 : {
9444 20 : case REAL_CST:
9445 20 : {
9446 20 : {
9447 20 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
9448 20 : tree res = generic_simplify_275 (loc, type, _p0, _p1, captures, PLUS_EXPR, GE_EXPR);
9449 20 : if (res) return res;
9450 : }
9451 20 : break;
9452 : }
9453 : default:;
9454 : }
9455 : break;
9456 : }
9457 566139 : case INTEGER_CST:
9458 566139 : {
9459 566139 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9460 : {
9461 16012 : {
9462 16012 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q20, _q21 };
9463 16012 : tree res = generic_simplify_415 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR);
9464 16012 : if (res) return res;
9465 : }
9466 : }
9467 : break;
9468 : }
9469 : default:;
9470 : }
9471 : break;
9472 : }
9473 58681 : case MINUS_EXPR:
9474 58681 : {
9475 58681 : tree _q20 = TREE_OPERAND (_p0, 0);
9476 58681 : tree _q21 = TREE_OPERAND (_p0, 1);
9477 58681 : switch (TREE_CODE (_q21))
9478 : {
9479 31 : case REAL_CST:
9480 31 : {
9481 31 : switch (TREE_CODE (_p1))
9482 : {
9483 31 : case REAL_CST:
9484 31 : {
9485 31 : {
9486 31 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
9487 31 : tree res = generic_simplify_275 (loc, type, _p0, _p1, captures, MINUS_EXPR, GE_EXPR);
9488 31 : if (res) return res;
9489 : }
9490 31 : break;
9491 : }
9492 : default:;
9493 : }
9494 : break;
9495 : }
9496 58681 : default:;
9497 : }
9498 58681 : switch (TREE_CODE (_q20))
9499 : {
9500 24 : case REAL_CST:
9501 24 : {
9502 24 : switch (TREE_CODE (_p1))
9503 : {
9504 0 : case REAL_CST:
9505 0 : {
9506 0 : {
9507 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
9508 0 : tree res = generic_simplify_276 (loc, type, _p0, _p1, captures, GE_EXPR);
9509 0 : if (res) return res;
9510 : }
9511 0 : break;
9512 : }
9513 : default:;
9514 : }
9515 : break;
9516 : }
9517 : default:;
9518 : }
9519 : break;
9520 : }
9521 40747 : case FLOAT_EXPR:
9522 40747 : {
9523 40747 : tree _q20 = TREE_OPERAND (_p0, 0);
9524 40747 : switch (TREE_CODE (_p1))
9525 : {
9526 8 : case FLOAT_EXPR:
9527 8 : {
9528 8 : tree _q40 = TREE_OPERAND (_p1, 0);
9529 8 : {
9530 8 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
9531 8 : tree res = generic_simplify_279 (loc, type, _p0, _p1, captures, GE_EXPR, GE_EXPR);
9532 8 : if (res) return res;
9533 : }
9534 1 : break;
9535 : }
9536 39267 : case REAL_CST:
9537 39267 : {
9538 39267 : {
9539 39267 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9540 39267 : tree res = generic_simplify_280 (loc, type, _p0, _p1, captures, GE_EXPR, GE_EXPR);
9541 39267 : if (res) return res;
9542 : }
9543 19641 : break;
9544 : }
9545 : default:;
9546 : }
9547 : break;
9548 : }
9549 7970 : case EXACT_DIV_EXPR:
9550 7970 : {
9551 7970 : tree _q20 = TREE_OPERAND (_p0, 0);
9552 7970 : tree _q21 = TREE_OPERAND (_p0, 1);
9553 7970 : switch (TREE_CODE (_q21))
9554 : {
9555 7970 : case INTEGER_CST:
9556 7970 : {
9557 7970 : switch (TREE_CODE (_p1))
9558 : {
9559 0 : case INTEGER_CST:
9560 0 : {
9561 0 : {
9562 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
9563 0 : tree res = generic_simplify_416 (loc, type, _p0, _p1, captures, GE_EXPR);
9564 0 : if (res) return res;
9565 : }
9566 0 : break;
9567 : }
9568 : default:;
9569 : }
9570 : break;
9571 : }
9572 : default:;
9573 : }
9574 : break;
9575 : }
9576 641117 : CASE_CONVERT:
9577 641117 : {
9578 641117 : tree _q20 = TREE_OPERAND (_p0, 0);
9579 641117 : switch (TREE_CODE (_q20))
9580 : {
9581 161 : case EXACT_DIV_EXPR:
9582 161 : {
9583 161 : tree _q30 = TREE_OPERAND (_q20, 0);
9584 161 : tree _q31 = TREE_OPERAND (_q20, 1);
9585 161 : switch (TREE_CODE (_q31))
9586 : {
9587 161 : case INTEGER_CST:
9588 161 : {
9589 161 : switch (TREE_CODE (_p1))
9590 : {
9591 0 : case INTEGER_CST:
9592 0 : {
9593 0 : {
9594 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
9595 0 : tree res = generic_simplify_417 (loc, type, _p0, _p1, captures, GE_EXPR, LT_EXPR);
9596 0 : if (res) return res;
9597 : }
9598 0 : break;
9599 : }
9600 : default:;
9601 : }
9602 : break;
9603 : }
9604 : default:;
9605 : }
9606 : break;
9607 : }
9608 641117 : default:;
9609 : }
9610 641117 : switch (TREE_CODE (_p1))
9611 : {
9612 100978 : CASE_CONVERT:
9613 100978 : {
9614 100978 : tree _q40 = TREE_OPERAND (_p1, 0);
9615 100978 : {
9616 100978 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
9617 100978 : tree res = generic_simplify_284 (loc, type, _p0, _p1, captures, GE_EXPR);
9618 100978 : if (res) return res;
9619 : }
9620 62034 : break;
9621 : }
9622 602173 : default:;
9623 : }
9624 602173 : {
9625 602173 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
9626 602173 : tree res = generic_simplify_285 (loc, type, _p0, _p1, captures, GE_EXPR);
9627 602173 : if (res) return res;
9628 : }
9629 329150 : switch (TREE_CODE (_q20))
9630 : {
9631 3883 : case ADDR_EXPR:
9632 3883 : {
9633 3883 : switch (TREE_CODE (_p1))
9634 : {
9635 3812 : CASE_CONVERT:
9636 3812 : {
9637 3812 : tree _q40 = TREE_OPERAND (_p1, 0);
9638 3812 : switch (TREE_CODE (_q40))
9639 : {
9640 3812 : case ADDR_EXPR:
9641 3812 : {
9642 3812 : {
9643 3812 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
9644 3812 : tree res = generic_simplify_305 (loc, type, _p0, _p1, captures, GE_EXPR);
9645 3812 : if (res) return res;
9646 : }
9647 257 : break;
9648 : }
9649 : default:;
9650 : }
9651 : break;
9652 : }
9653 7 : case ADDR_EXPR:
9654 7 : {
9655 7 : {
9656 7 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9657 7 : tree res = generic_simplify_305 (loc, type, _p0, _p1, captures, GE_EXPR);
9658 7 : if (res) return res;
9659 : }
9660 0 : break;
9661 : }
9662 : default:;
9663 : }
9664 : break;
9665 : }
9666 325588 : default:;
9667 : }
9668 325588 : if (uniform_integer_cst_p (_p1))
9669 : {
9670 102211 : {
9671 102211 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9672 102211 : tree res = generic_simplify_418 (loc, type, _p0, _p1, captures, GE_EXPR);
9673 102211 : if (res) return res;
9674 : }
9675 : }
9676 : break;
9677 : }
9678 787 : case NEGATE_EXPR:
9679 787 : {
9680 787 : tree _q20 = TREE_OPERAND (_p0, 0);
9681 787 : switch (TREE_CODE (_p1))
9682 : {
9683 0 : case NEGATE_EXPR:
9684 0 : {
9685 0 : tree _q40 = TREE_OPERAND (_p1, 0);
9686 0 : {
9687 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9688 0 : tree res = generic_simplify_282 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR);
9689 0 : if (res) return res;
9690 : }
9691 0 : break;
9692 : }
9693 787 : default:;
9694 : }
9695 787 : if (CONSTANT_CLASS_P (_p1))
9696 : {
9697 254 : {
9698 254 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9699 254 : tree res = generic_simplify_283 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR);
9700 254 : if (res) return res;
9701 : }
9702 : }
9703 : break;
9704 : }
9705 7665 : case ADDR_EXPR:
9706 7665 : {
9707 7665 : switch (TREE_CODE (_p1))
9708 : {
9709 0 : CASE_CONVERT:
9710 0 : {
9711 0 : tree _q30 = TREE_OPERAND (_p1, 0);
9712 0 : switch (TREE_CODE (_q30))
9713 : {
9714 0 : case ADDR_EXPR:
9715 0 : {
9716 0 : {
9717 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q30 };
9718 0 : tree res = generic_simplify_306 (loc, type, _p0, _p1, captures, GE_EXPR);
9719 0 : if (res) return res;
9720 : }
9721 0 : break;
9722 : }
9723 : default:;
9724 : }
9725 : break;
9726 : }
9727 7267 : case ADDR_EXPR:
9728 7267 : {
9729 7267 : {
9730 7267 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
9731 7267 : tree res = generic_simplify_306 (loc, type, _p0, _p1, captures, GE_EXPR);
9732 7267 : if (res) return res;
9733 : }
9734 116 : break;
9735 : }
9736 : default:;
9737 : }
9738 : break;
9739 : }
9740 245533 : case CALL_EXPR:
9741 245533 : switch (get_call_combined_fn (_p0))
9742 : {
9743 2 : case CFN_BUILT_IN_SQRTF:
9744 2 : if (call_expr_nargs (_p0) == 1)
9745 : {
9746 2 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9747 2 : switch (TREE_CODE (_p1))
9748 : {
9749 2 : case REAL_CST:
9750 2 : {
9751 2 : {
9752 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9753 2 : tree res = generic_simplify_277 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, GE_EXPR);
9754 2 : if (res) return res;
9755 : }
9756 0 : break;
9757 : }
9758 0 : case CALL_EXPR:
9759 0 : switch (get_call_combined_fn (_p1))
9760 : {
9761 0 : case CFN_BUILT_IN_SQRTF:
9762 0 : if (call_expr_nargs (_p1) == 1)
9763 : {
9764 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9765 0 : {
9766 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9767 0 : tree res = generic_simplify_278 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, GE_EXPR);
9768 0 : if (res) return res;
9769 : }
9770 : }
9771 : break;
9772 : default:;
9773 : }
9774 : break;
9775 : default:;
9776 : }
9777 : }
9778 : break;
9779 0 : case CFN_BUILT_IN_SQRTL:
9780 0 : if (call_expr_nargs (_p0) == 1)
9781 : {
9782 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9783 0 : switch (TREE_CODE (_p1))
9784 : {
9785 0 : case REAL_CST:
9786 0 : {
9787 0 : {
9788 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9789 0 : tree res = generic_simplify_277 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, GE_EXPR);
9790 0 : if (res) return res;
9791 : }
9792 0 : break;
9793 : }
9794 0 : case CALL_EXPR:
9795 0 : switch (get_call_combined_fn (_p1))
9796 : {
9797 0 : case CFN_BUILT_IN_SQRTL:
9798 0 : if (call_expr_nargs (_p1) == 1)
9799 : {
9800 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9801 0 : {
9802 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9803 0 : tree res = generic_simplify_278 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, GE_EXPR);
9804 0 : if (res) return res;
9805 : }
9806 : }
9807 : break;
9808 : default:;
9809 : }
9810 : break;
9811 : default:;
9812 : }
9813 : }
9814 : break;
9815 1 : case CFN_BUILT_IN_SQRT:
9816 1 : if (call_expr_nargs (_p0) == 1)
9817 : {
9818 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9819 1 : switch (TREE_CODE (_p1))
9820 : {
9821 1 : case REAL_CST:
9822 1 : {
9823 1 : {
9824 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9825 1 : tree res = generic_simplify_277 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, GE_EXPR);
9826 1 : if (res) return res;
9827 : }
9828 1 : break;
9829 : }
9830 0 : case CALL_EXPR:
9831 0 : switch (get_call_combined_fn (_p1))
9832 : {
9833 0 : case CFN_BUILT_IN_SQRT:
9834 0 : if (call_expr_nargs (_p1) == 1)
9835 : {
9836 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9837 0 : {
9838 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9839 0 : tree res = generic_simplify_278 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, GE_EXPR);
9840 0 : if (res) return res;
9841 : }
9842 : }
9843 : break;
9844 : default:;
9845 : }
9846 : break;
9847 : default:;
9848 : }
9849 : }
9850 : break;
9851 0 : case CFN_SQRT:
9852 0 : if (call_expr_nargs (_p0) == 1)
9853 : {
9854 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9855 0 : switch (TREE_CODE (_p1))
9856 : {
9857 0 : case REAL_CST:
9858 0 : {
9859 0 : {
9860 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9861 0 : tree res = generic_simplify_277 (loc, type, _p0, _p1, captures, CFN_SQRT, GE_EXPR);
9862 0 : if (res) return res;
9863 : }
9864 0 : break;
9865 : }
9866 0 : case CALL_EXPR:
9867 0 : switch (get_call_combined_fn (_p1))
9868 : {
9869 0 : case CFN_SQRT:
9870 0 : if (call_expr_nargs (_p1) == 1)
9871 : {
9872 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9873 0 : {
9874 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9875 0 : tree res = generic_simplify_278 (loc, type, _p0, _p1, captures, CFN_SQRT, GE_EXPR);
9876 0 : if (res) return res;
9877 : }
9878 : }
9879 : break;
9880 : default:;
9881 : }
9882 : break;
9883 : default:;
9884 : }
9885 : }
9886 : break;
9887 : default:;
9888 : }
9889 : break;
9890 4822933 : default:;
9891 : }
9892 4822933 : if (uniform_integer_cst_p (_p1))
9893 : {
9894 1600428 : {
9895 1600428 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
9896 1600428 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, GE_EXPR);
9897 1600428 : if (res) return res;
9898 : }
9899 : }
9900 4514820 : switch (TREE_CODE (_p0))
9901 : {
9902 314231 : CASE_CONVERT:
9903 314231 : {
9904 314231 : tree _q20 = TREE_OPERAND (_p0, 0);
9905 314231 : switch (TREE_CODE (_q20))
9906 : {
9907 30329 : case PLUS_EXPR:
9908 30329 : {
9909 30329 : tree _q30 = TREE_OPERAND (_q20, 0);
9910 30329 : tree _q31 = TREE_OPERAND (_q20, 1);
9911 30329 : switch (TREE_CODE (_q30))
9912 : {
9913 21537 : CASE_CONVERT:
9914 21537 : {
9915 21537 : tree _q40 = TREE_OPERAND (_q30, 0);
9916 21537 : switch (TREE_CODE (_q31))
9917 : {
9918 21536 : case INTEGER_CST:
9919 21536 : {
9920 21536 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
9921 : {
9922 154 : {
9923 154 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q40, _q31 };
9924 154 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR);
9925 154 : if (res) return res;
9926 : }
9927 : }
9928 : break;
9929 : }
9930 : default:;
9931 : }
9932 : break;
9933 : }
9934 : default:;
9935 : }
9936 : break;
9937 : }
9938 : default:;
9939 : }
9940 : break;
9941 : }
9942 4514748 : default:;
9943 : }
9944 4514748 : switch (TREE_CODE (_p1))
9945 : {
9946 227725 : CASE_CONVERT:
9947 227725 : {
9948 227725 : tree _q30 = TREE_OPERAND (_p1, 0);
9949 227725 : switch (TREE_CODE (_q30))
9950 : {
9951 315 : case PLUS_EXPR:
9952 315 : {
9953 315 : tree _q40 = TREE_OPERAND (_q30, 0);
9954 315 : tree _q41 = TREE_OPERAND (_q30, 1);
9955 315 : switch (TREE_CODE (_q40))
9956 : {
9957 219 : CASE_CONVERT:
9958 219 : {
9959 219 : tree _q50 = TREE_OPERAND (_q40, 0);
9960 219 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
9961 : {
9962 0 : switch (TREE_CODE (_q41))
9963 : {
9964 0 : case INTEGER_CST:
9965 0 : {
9966 0 : {
9967 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0, _q41 };
9968 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR);
9969 0 : if (res) return res;
9970 : }
9971 0 : break;
9972 : }
9973 : default:;
9974 : }
9975 : }
9976 : break;
9977 : }
9978 : default:;
9979 : }
9980 : break;
9981 : }
9982 : default:;
9983 : }
9984 : break;
9985 : }
9986 58978 : case PLUS_EXPR:
9987 58978 : {
9988 58978 : tree _q30 = TREE_OPERAND (_p1, 0);
9989 58978 : tree _q31 = TREE_OPERAND (_p1, 1);
9990 58978 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9991 : {
9992 0 : switch (TREE_CODE (_q31))
9993 : {
9994 0 : case INTEGER_CST:
9995 0 : {
9996 0 : {
9997 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0, _q31 };
9998 0 : tree res = generic_simplify_415 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR);
9999 0 : if (res) return res;
10000 : }
10001 0 : break;
10002 : }
10003 : default:;
10004 : }
10005 : }
10006 : break;
10007 : }
10008 2568 : case MINUS_EXPR:
10009 2568 : {
10010 2568 : tree _q30 = TREE_OPERAND (_p1, 0);
10011 2568 : tree _q31 = TREE_OPERAND (_p1, 1);
10012 2568 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10013 : {
10014 0 : {
10015 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q31 };
10016 0 : tree res = generic_simplify_421 (loc, type, _p0, _p1, captures, LE_EXPR);
10017 0 : if (res) return res;
10018 : }
10019 : }
10020 : break;
10021 : }
10022 4514748 : default:;
10023 : }
10024 4514748 : switch (TREE_CODE (_p0))
10025 : {
10026 585696 : case PLUS_EXPR:
10027 585696 : {
10028 585696 : tree _q20 = TREE_OPERAND (_p0, 0);
10029 585696 : tree _q21 = TREE_OPERAND (_p0, 1);
10030 585696 : switch (TREE_CODE (_q20))
10031 : {
10032 141 : case MINUS_EXPR:
10033 141 : {
10034 141 : tree _q30 = TREE_OPERAND (_q20, 0);
10035 141 : tree _q31 = TREE_OPERAND (_q20, 1);
10036 141 : if (integer_minus_onep (_q21))
10037 : {
10038 1 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
10039 : {
10040 1 : {
10041 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
10042 1 : tree res = generic_simplify_422 (loc, type, _p0, _p1, captures, GE_EXPR);
10043 1 : if (res) return res;
10044 : }
10045 : }
10046 : }
10047 : break;
10048 : }
10049 : default:;
10050 : }
10051 : break;
10052 : }
10053 4514747 : default:;
10054 : }
10055 4514747 : switch (TREE_CODE (_p1))
10056 : {
10057 0 : case REALPART_EXPR:
10058 0 : {
10059 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10060 0 : switch (TREE_CODE (_q30))
10061 : {
10062 0 : case CALL_EXPR:
10063 0 : switch (get_call_combined_fn (_q30))
10064 : {
10065 0 : case CFN_SUB_OVERFLOW:
10066 0 : if (call_expr_nargs (_q30) == 2)
10067 : {
10068 0 : tree _q40 = CALL_EXPR_ARG (_q30, 0);
10069 0 : tree _q41 = CALL_EXPR_ARG (_q30, 1);
10070 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
10071 : {
10072 0 : {
10073 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p0, _q41 };
10074 0 : tree res = generic_simplify_423 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR);
10075 0 : if (res) return res;
10076 : }
10077 : }
10078 : }
10079 : break;
10080 : default:;
10081 : }
10082 : break;
10083 : default:;
10084 : }
10085 : break;
10086 : }
10087 4514747 : default:;
10088 : }
10089 4514747 : switch (TREE_CODE (_p0))
10090 : {
10091 0 : case REALPART_EXPR:
10092 0 : {
10093 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10094 0 : switch (TREE_CODE (_q20))
10095 : {
10096 0 : case CALL_EXPR:
10097 0 : switch (get_call_combined_fn (_q20))
10098 : {
10099 0 : case CFN_ADD_OVERFLOW:
10100 0 : if (call_expr_nargs (_q20) == 2)
10101 : {
10102 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
10103 0 : tree _q31 = CALL_EXPR_ARG (_q20, 1);
10104 0 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
10105 : {
10106 0 : {
10107 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
10108 0 : tree res = generic_simplify_424 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
10109 0 : if (res) return res;
10110 : }
10111 : }
10112 0 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
10113 : {
10114 0 : {
10115 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q31, _q30 };
10116 0 : tree res = generic_simplify_424 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
10117 0 : if (res) return res;
10118 : }
10119 : }
10120 : }
10121 : break;
10122 : default:;
10123 : }
10124 : break;
10125 : default:;
10126 : }
10127 : break;
10128 : }
10129 1455 : case TRUNC_DIV_EXPR:
10130 1455 : {
10131 1455 : tree _q20 = TREE_OPERAND (_p0, 0);
10132 1455 : tree _q21 = TREE_OPERAND (_p0, 1);
10133 1455 : if (integer_all_onesp (_q20))
10134 : {
10135 33 : {
10136 33 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _p1 };
10137 33 : tree res = generic_simplify_425 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
10138 33 : if (res) return res;
10139 : }
10140 : }
10141 : break;
10142 : }
10143 22178 : case MULT_EXPR:
10144 22178 : {
10145 22178 : tree _q20 = TREE_OPERAND (_p0, 0);
10146 22178 : tree _q21 = TREE_OPERAND (_p0, 1);
10147 22178 : switch (TREE_CODE (_q21))
10148 : {
10149 305 : case REAL_CST:
10150 305 : {
10151 305 : switch (TREE_CODE (_p1))
10152 : {
10153 43 : case REAL_CST:
10154 43 : {
10155 43 : {
10156 43 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
10157 43 : tree res = generic_simplify_426 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR);
10158 43 : if (res) return res;
10159 : }
10160 43 : break;
10161 : }
10162 : default:;
10163 : }
10164 : break;
10165 : }
10166 : default:;
10167 : }
10168 : break;
10169 : }
10170 151 : case REAL_CST:
10171 151 : {
10172 151 : switch (TREE_CODE (_p1))
10173 : {
10174 0 : case CALL_EXPR:
10175 0 : switch (get_call_combined_fn (_p1))
10176 : {
10177 0 : case CFN_BUILT_IN_EXP:
10178 0 : if (call_expr_nargs (_p1) == 1)
10179 : {
10180 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10181 0 : {
10182 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10183 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, LE_EXPR);
10184 0 : if (res) return res;
10185 : }
10186 : }
10187 : break;
10188 0 : case CFN_BUILT_IN_LOG:
10189 0 : if (call_expr_nargs (_p1) == 1)
10190 : {
10191 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10192 0 : {
10193 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10194 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, LE_EXPR);
10195 0 : if (res) return res;
10196 : }
10197 : }
10198 : break;
10199 0 : case CFN_BUILT_IN_EXP10F:
10200 0 : if (call_expr_nargs (_p1) == 1)
10201 : {
10202 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10203 0 : {
10204 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10205 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, LE_EXPR);
10206 0 : if (res) return res;
10207 : }
10208 : }
10209 : break;
10210 0 : case CFN_BUILT_IN_EXP10L:
10211 0 : if (call_expr_nargs (_p1) == 1)
10212 : {
10213 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10214 0 : {
10215 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10216 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, LE_EXPR);
10217 0 : if (res) return res;
10218 : }
10219 : }
10220 : break;
10221 0 : case CFN_BUILT_IN_EXP2:
10222 0 : if (call_expr_nargs (_p1) == 1)
10223 : {
10224 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10225 0 : {
10226 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10227 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, LE_EXPR);
10228 0 : if (res) return res;
10229 : }
10230 : }
10231 : break;
10232 0 : case CFN_BUILT_IN_EXPF:
10233 0 : if (call_expr_nargs (_p1) == 1)
10234 : {
10235 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10236 0 : {
10237 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10238 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, LE_EXPR);
10239 0 : if (res) return res;
10240 : }
10241 : }
10242 : break;
10243 0 : case CFN_BUILT_IN_EXPL:
10244 0 : if (call_expr_nargs (_p1) == 1)
10245 : {
10246 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10247 0 : {
10248 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10249 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, LE_EXPR);
10250 0 : if (res) return res;
10251 : }
10252 : }
10253 : break;
10254 0 : case CFN_BUILT_IN_LOG2:
10255 0 : if (call_expr_nargs (_p1) == 1)
10256 : {
10257 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10258 0 : {
10259 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10260 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, LE_EXPR);
10261 0 : if (res) return res;
10262 : }
10263 : }
10264 : break;
10265 0 : case CFN_BUILT_IN_LOGF:
10266 0 : if (call_expr_nargs (_p1) == 1)
10267 : {
10268 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10269 0 : {
10270 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10271 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, LE_EXPR);
10272 0 : if (res) return res;
10273 : }
10274 : }
10275 : break;
10276 0 : case CFN_BUILT_IN_LOGL:
10277 0 : if (call_expr_nargs (_p1) == 1)
10278 : {
10279 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10280 0 : {
10281 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10282 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, LE_EXPR);
10283 0 : if (res) return res;
10284 : }
10285 : }
10286 : break;
10287 0 : case CFN_BUILT_IN_LOG10F:
10288 0 : if (call_expr_nargs (_p1) == 1)
10289 : {
10290 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10291 0 : {
10292 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10293 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, LE_EXPR);
10294 0 : if (res) return res;
10295 : }
10296 : }
10297 : break;
10298 0 : case CFN_BUILT_IN_LOG10L:
10299 0 : if (call_expr_nargs (_p1) == 1)
10300 : {
10301 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10302 0 : {
10303 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10304 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, LE_EXPR);
10305 0 : if (res) return res;
10306 : }
10307 : }
10308 : break;
10309 0 : case CFN_EXP:
10310 0 : if (call_expr_nargs (_p1) == 1)
10311 : {
10312 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10313 0 : {
10314 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10315 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, LE_EXPR);
10316 0 : if (res) return res;
10317 : }
10318 : }
10319 : break;
10320 0 : case CFN_LOG:
10321 0 : if (call_expr_nargs (_p1) == 1)
10322 : {
10323 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10324 0 : {
10325 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10326 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, LE_EXPR);
10327 0 : if (res) return res;
10328 : }
10329 : }
10330 : break;
10331 0 : case CFN_EXP2:
10332 0 : if (call_expr_nargs (_p1) == 1)
10333 : {
10334 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10335 0 : {
10336 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10337 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, LE_EXPR);
10338 0 : if (res) return res;
10339 : }
10340 : }
10341 : break;
10342 0 : case CFN_LOG2:
10343 0 : if (call_expr_nargs (_p1) == 1)
10344 : {
10345 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10346 0 : {
10347 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10348 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, LE_EXPR);
10349 0 : if (res) return res;
10350 : }
10351 : }
10352 : break;
10353 0 : case CFN_EXP10:
10354 0 : if (call_expr_nargs (_p1) == 1)
10355 : {
10356 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10357 0 : {
10358 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10359 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, LE_EXPR);
10360 0 : if (res) return res;
10361 : }
10362 : }
10363 : break;
10364 0 : case CFN_LOG10:
10365 0 : if (call_expr_nargs (_p1) == 1)
10366 : {
10367 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10368 0 : {
10369 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10370 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, LE_EXPR);
10371 0 : if (res) return res;
10372 : }
10373 : }
10374 : break;
10375 0 : case CFN_BUILT_IN_EXP10:
10376 0 : if (call_expr_nargs (_p1) == 1)
10377 : {
10378 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10379 0 : {
10380 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10381 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, LE_EXPR);
10382 0 : if (res) return res;
10383 : }
10384 : }
10385 : break;
10386 0 : case CFN_BUILT_IN_EXP2F:
10387 0 : if (call_expr_nargs (_p1) == 1)
10388 : {
10389 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10390 0 : {
10391 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10392 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, LE_EXPR);
10393 0 : if (res) return res;
10394 : }
10395 : }
10396 : break;
10397 0 : case CFN_BUILT_IN_EXP2L:
10398 0 : if (call_expr_nargs (_p1) == 1)
10399 : {
10400 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10401 0 : {
10402 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10403 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, LE_EXPR);
10404 0 : if (res) return res;
10405 : }
10406 : }
10407 : break;
10408 0 : case CFN_BUILT_IN_LOG10:
10409 0 : if (call_expr_nargs (_p1) == 1)
10410 : {
10411 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10412 0 : {
10413 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10414 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, LE_EXPR);
10415 0 : if (res) return res;
10416 : }
10417 : }
10418 : break;
10419 0 : case CFN_BUILT_IN_LOG2F:
10420 0 : if (call_expr_nargs (_p1) == 1)
10421 : {
10422 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10423 0 : {
10424 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10425 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, LE_EXPR);
10426 0 : if (res) return res;
10427 : }
10428 : }
10429 : break;
10430 0 : case CFN_BUILT_IN_LOG2L:
10431 0 : if (call_expr_nargs (_p1) == 1)
10432 : {
10433 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
10434 0 : {
10435 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
10436 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, LE_EXPR);
10437 0 : if (res) return res;
10438 : }
10439 : }
10440 : break;
10441 : default:;
10442 : }
10443 : break;
10444 : default:;
10445 : }
10446 : break;
10447 : }
10448 585695 : case PLUS_EXPR:
10449 585695 : {
10450 585695 : tree _q20 = TREE_OPERAND (_p0, 0);
10451 585695 : tree _q21 = TREE_OPERAND (_p0, 1);
10452 585695 : switch (TREE_CODE (_q21))
10453 : {
10454 476152 : case INTEGER_CST:
10455 476152 : {
10456 476152 : switch (TREE_CODE (_p1))
10457 : {
10458 118494 : case INTEGER_CST:
10459 118494 : {
10460 118494 : {
10461 118494 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
10462 118494 : tree res = generic_simplify_427 (loc, type, _p0, _p1, captures, PLUS_EXPR, MINUS_EXPR, GE_EXPR, LE_EXPR);
10463 118494 : if (res) return res;
10464 : }
10465 56085 : break;
10466 : }
10467 : default:;
10468 : }
10469 : break;
10470 : }
10471 : default:;
10472 : }
10473 : break;
10474 : }
10475 58237 : case MINUS_EXPR:
10476 58237 : {
10477 58237 : tree _q20 = TREE_OPERAND (_p0, 0);
10478 58237 : tree _q21 = TREE_OPERAND (_p0, 1);
10479 58237 : switch (TREE_CODE (_q21))
10480 : {
10481 7 : case INTEGER_CST:
10482 7 : {
10483 7 : switch (TREE_CODE (_p1))
10484 : {
10485 7 : case INTEGER_CST:
10486 7 : {
10487 7 : {
10488 7 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
10489 7 : tree res = generic_simplify_427 (loc, type, _p0, _p1, captures, MINUS_EXPR, PLUS_EXPR, GE_EXPR, LE_EXPR);
10490 7 : if (res) return res;
10491 : }
10492 0 : break;
10493 : }
10494 : default:;
10495 : }
10496 : break;
10497 : }
10498 58230 : default:;
10499 : }
10500 58230 : switch (TREE_CODE (_q20))
10501 : {
10502 1580 : case INTEGER_CST:
10503 1580 : {
10504 1580 : switch (TREE_CODE (_p1))
10505 : {
10506 543 : case INTEGER_CST:
10507 543 : {
10508 543 : {
10509 543 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
10510 543 : tree res = generic_simplify_312 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR);
10511 543 : if (res) return res;
10512 : }
10513 0 : break;
10514 : }
10515 : default:;
10516 : }
10517 : break;
10518 : }
10519 : default:;
10520 : }
10521 : break;
10522 : }
10523 245143 : case CALL_EXPR:
10524 245143 : switch (get_call_combined_fn (_p0))
10525 : {
10526 1 : case CFN_BUILT_IN_CTZ:
10527 1 : if (call_expr_nargs (_p0) == 1)
10528 : {
10529 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10530 1 : switch (TREE_CODE (_p1))
10531 : {
10532 1 : case INTEGER_CST:
10533 1 : {
10534 1 : {
10535 1 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10536 1 : tree res = generic_simplify_428 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR, CFN_BUILT_IN_CTZ);
10537 1 : if (res) return res;
10538 : }
10539 0 : break;
10540 : }
10541 : default:;
10542 : }
10543 : }
10544 : break;
10545 1 : case CFN_BUILT_IN_EXP:
10546 1 : if (call_expr_nargs (_p0) == 1)
10547 : {
10548 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10549 1 : switch (TREE_CODE (_p1))
10550 : {
10551 1 : case REAL_CST:
10552 1 : {
10553 1 : {
10554 1 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10555 1 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, GE_EXPR);
10556 1 : if (res) return res;
10557 : }
10558 1 : break;
10559 : }
10560 : default:;
10561 : }
10562 : }
10563 : break;
10564 1 : case CFN_BUILT_IN_LOG:
10565 1 : if (call_expr_nargs (_p0) == 1)
10566 : {
10567 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10568 1 : switch (TREE_CODE (_p1))
10569 : {
10570 0 : case REAL_CST:
10571 0 : {
10572 0 : {
10573 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10574 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, GE_EXPR);
10575 0 : if (res) return res;
10576 : }
10577 0 : break;
10578 : }
10579 : default:;
10580 : }
10581 : }
10582 : break;
10583 0 : case CFN_BUILT_IN_EXP10F:
10584 0 : if (call_expr_nargs (_p0) == 1)
10585 : {
10586 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10587 0 : switch (TREE_CODE (_p1))
10588 : {
10589 0 : case REAL_CST:
10590 0 : {
10591 0 : {
10592 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10593 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, GE_EXPR);
10594 0 : if (res) return res;
10595 : }
10596 0 : break;
10597 : }
10598 : default:;
10599 : }
10600 : }
10601 : break;
10602 0 : case CFN_BUILT_IN_EXP10L:
10603 0 : if (call_expr_nargs (_p0) == 1)
10604 : {
10605 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10606 0 : switch (TREE_CODE (_p1))
10607 : {
10608 0 : case REAL_CST:
10609 0 : {
10610 0 : {
10611 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10612 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, GE_EXPR);
10613 0 : if (res) return res;
10614 : }
10615 0 : break;
10616 : }
10617 : default:;
10618 : }
10619 : }
10620 : break;
10621 0 : case CFN_BUILT_IN_CTZL:
10622 0 : if (call_expr_nargs (_p0) == 1)
10623 : {
10624 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10625 0 : switch (TREE_CODE (_p1))
10626 : {
10627 0 : case INTEGER_CST:
10628 0 : {
10629 0 : {
10630 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10631 0 : tree res = generic_simplify_428 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR, CFN_BUILT_IN_CTZL);
10632 0 : if (res) return res;
10633 : }
10634 0 : break;
10635 : }
10636 : default:;
10637 : }
10638 : }
10639 : break;
10640 0 : case CFN_BUILT_IN_EXP2:
10641 0 : if (call_expr_nargs (_p0) == 1)
10642 : {
10643 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10644 0 : switch (TREE_CODE (_p1))
10645 : {
10646 0 : case REAL_CST:
10647 0 : {
10648 0 : {
10649 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10650 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, GE_EXPR);
10651 0 : if (res) return res;
10652 : }
10653 0 : break;
10654 : }
10655 : default:;
10656 : }
10657 : }
10658 : break;
10659 0 : case CFN_BUILT_IN_EXPF:
10660 0 : if (call_expr_nargs (_p0) == 1)
10661 : {
10662 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10663 0 : switch (TREE_CODE (_p1))
10664 : {
10665 0 : case REAL_CST:
10666 0 : {
10667 0 : {
10668 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10669 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, GE_EXPR);
10670 0 : if (res) return res;
10671 : }
10672 0 : break;
10673 : }
10674 : default:;
10675 : }
10676 : }
10677 : break;
10678 0 : case CFN_BUILT_IN_EXPL:
10679 0 : if (call_expr_nargs (_p0) == 1)
10680 : {
10681 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10682 0 : switch (TREE_CODE (_p1))
10683 : {
10684 0 : case REAL_CST:
10685 0 : {
10686 0 : {
10687 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10688 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, GE_EXPR);
10689 0 : if (res) return res;
10690 : }
10691 0 : break;
10692 : }
10693 : default:;
10694 : }
10695 : }
10696 : break;
10697 0 : case CFN_BUILT_IN_LOG2:
10698 0 : if (call_expr_nargs (_p0) == 1)
10699 : {
10700 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10701 0 : switch (TREE_CODE (_p1))
10702 : {
10703 0 : case REAL_CST:
10704 0 : {
10705 0 : {
10706 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10707 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, GE_EXPR);
10708 0 : if (res) return res;
10709 : }
10710 0 : break;
10711 : }
10712 : default:;
10713 : }
10714 : }
10715 : break;
10716 0 : case CFN_BUILT_IN_LOGF:
10717 0 : if (call_expr_nargs (_p0) == 1)
10718 : {
10719 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10720 0 : switch (TREE_CODE (_p1))
10721 : {
10722 0 : case REAL_CST:
10723 0 : {
10724 0 : {
10725 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10726 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, GE_EXPR);
10727 0 : if (res) return res;
10728 : }
10729 0 : break;
10730 : }
10731 : default:;
10732 : }
10733 : }
10734 : break;
10735 0 : case CFN_BUILT_IN_LOGL:
10736 0 : if (call_expr_nargs (_p0) == 1)
10737 : {
10738 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10739 0 : switch (TREE_CODE (_p1))
10740 : {
10741 0 : case REAL_CST:
10742 0 : {
10743 0 : {
10744 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10745 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, GE_EXPR);
10746 0 : if (res) return res;
10747 : }
10748 0 : break;
10749 : }
10750 : default:;
10751 : }
10752 : }
10753 : break;
10754 0 : case CFN_BUILT_IN_LOG10F:
10755 0 : if (call_expr_nargs (_p0) == 1)
10756 : {
10757 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10758 0 : switch (TREE_CODE (_p1))
10759 : {
10760 0 : case REAL_CST:
10761 0 : {
10762 0 : {
10763 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10764 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, GE_EXPR);
10765 0 : if (res) return res;
10766 : }
10767 0 : break;
10768 : }
10769 : default:;
10770 : }
10771 : }
10772 : break;
10773 0 : case CFN_BUILT_IN_LOG10L:
10774 0 : if (call_expr_nargs (_p0) == 1)
10775 : {
10776 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10777 0 : switch (TREE_CODE (_p1))
10778 : {
10779 0 : case REAL_CST:
10780 0 : {
10781 0 : {
10782 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10783 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, GE_EXPR);
10784 0 : if (res) return res;
10785 : }
10786 0 : break;
10787 : }
10788 : default:;
10789 : }
10790 : }
10791 : break;
10792 0 : case CFN_BUILT_IN_CTZIMAX:
10793 0 : if (call_expr_nargs (_p0) == 1)
10794 : {
10795 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10796 0 : switch (TREE_CODE (_p1))
10797 : {
10798 0 : case INTEGER_CST:
10799 0 : {
10800 0 : {
10801 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10802 0 : tree res = generic_simplify_428 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR, CFN_BUILT_IN_CTZIMAX);
10803 0 : if (res) return res;
10804 : }
10805 0 : break;
10806 : }
10807 : default:;
10808 : }
10809 : }
10810 : break;
10811 0 : case CFN_CTZ:
10812 0 : if (call_expr_nargs (_p0) == 2)
10813 : {
10814 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10815 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
10816 0 : switch (TREE_CODE (_p1))
10817 : {
10818 0 : case INTEGER_CST:
10819 0 : {
10820 0 : {
10821 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
10822 0 : tree res = generic_simplify_429 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
10823 0 : if (res) return res;
10824 : }
10825 0 : break;
10826 : }
10827 : default:;
10828 : }
10829 : }
10830 0 : if (call_expr_nargs (_p0) == 1)
10831 : {
10832 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10833 0 : switch (TREE_CODE (_p1))
10834 : {
10835 0 : case INTEGER_CST:
10836 0 : {
10837 0 : {
10838 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10839 0 : tree res = generic_simplify_428 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR, CFN_CTZ);
10840 0 : if (res) return res;
10841 : }
10842 0 : break;
10843 : }
10844 : default:;
10845 : }
10846 : }
10847 : break;
10848 0 : case CFN_EXP:
10849 0 : if (call_expr_nargs (_p0) == 1)
10850 : {
10851 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10852 0 : switch (TREE_CODE (_p1))
10853 : {
10854 0 : case REAL_CST:
10855 0 : {
10856 0 : {
10857 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10858 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, GE_EXPR);
10859 0 : if (res) return res;
10860 : }
10861 0 : break;
10862 : }
10863 : default:;
10864 : }
10865 : }
10866 : break;
10867 0 : case CFN_LOG:
10868 0 : if (call_expr_nargs (_p0) == 1)
10869 : {
10870 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10871 0 : switch (TREE_CODE (_p1))
10872 : {
10873 0 : case REAL_CST:
10874 0 : {
10875 0 : {
10876 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10877 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, GE_EXPR);
10878 0 : if (res) return res;
10879 : }
10880 0 : break;
10881 : }
10882 : default:;
10883 : }
10884 : }
10885 : break;
10886 0 : case CFN_EXP2:
10887 0 : if (call_expr_nargs (_p0) == 1)
10888 : {
10889 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10890 0 : switch (TREE_CODE (_p1))
10891 : {
10892 0 : case REAL_CST:
10893 0 : {
10894 0 : {
10895 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10896 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, GE_EXPR);
10897 0 : if (res) return res;
10898 : }
10899 0 : break;
10900 : }
10901 : default:;
10902 : }
10903 : }
10904 : break;
10905 0 : case CFN_LOG2:
10906 0 : if (call_expr_nargs (_p0) == 1)
10907 : {
10908 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10909 0 : switch (TREE_CODE (_p1))
10910 : {
10911 0 : case REAL_CST:
10912 0 : {
10913 0 : {
10914 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10915 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, GE_EXPR);
10916 0 : if (res) return res;
10917 : }
10918 0 : break;
10919 : }
10920 : default:;
10921 : }
10922 : }
10923 : break;
10924 0 : case CFN_EXP10:
10925 0 : if (call_expr_nargs (_p0) == 1)
10926 : {
10927 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10928 0 : switch (TREE_CODE (_p1))
10929 : {
10930 0 : case REAL_CST:
10931 0 : {
10932 0 : {
10933 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10934 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, GE_EXPR);
10935 0 : if (res) return res;
10936 : }
10937 0 : break;
10938 : }
10939 : default:;
10940 : }
10941 : }
10942 : break;
10943 0 : case CFN_BUILT_IN_CTZLL:
10944 0 : if (call_expr_nargs (_p0) == 1)
10945 : {
10946 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10947 0 : switch (TREE_CODE (_p1))
10948 : {
10949 0 : case INTEGER_CST:
10950 0 : {
10951 0 : {
10952 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10953 0 : tree res = generic_simplify_428 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR, CFN_BUILT_IN_CTZLL);
10954 0 : if (res) return res;
10955 : }
10956 0 : break;
10957 : }
10958 : default:;
10959 : }
10960 : }
10961 : break;
10962 0 : case CFN_LOG10:
10963 0 : if (call_expr_nargs (_p0) == 1)
10964 : {
10965 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10966 0 : switch (TREE_CODE (_p1))
10967 : {
10968 0 : case REAL_CST:
10969 0 : {
10970 0 : {
10971 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10972 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, GE_EXPR);
10973 0 : if (res) return res;
10974 : }
10975 0 : break;
10976 : }
10977 : default:;
10978 : }
10979 : }
10980 : break;
10981 0 : case CFN_BUILT_IN_EXP10:
10982 0 : if (call_expr_nargs (_p0) == 1)
10983 : {
10984 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10985 0 : switch (TREE_CODE (_p1))
10986 : {
10987 0 : case REAL_CST:
10988 0 : {
10989 0 : {
10990 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10991 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, GE_EXPR);
10992 0 : if (res) return res;
10993 : }
10994 0 : break;
10995 : }
10996 : default:;
10997 : }
10998 : }
10999 : break;
11000 0 : case CFN_BUILT_IN_EXP2F:
11001 0 : if (call_expr_nargs (_p0) == 1)
11002 : {
11003 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11004 0 : switch (TREE_CODE (_p1))
11005 : {
11006 0 : case REAL_CST:
11007 0 : {
11008 0 : {
11009 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11010 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, GE_EXPR);
11011 0 : if (res) return res;
11012 : }
11013 0 : break;
11014 : }
11015 : default:;
11016 : }
11017 : }
11018 : break;
11019 0 : case CFN_BUILT_IN_EXP2L:
11020 0 : if (call_expr_nargs (_p0) == 1)
11021 : {
11022 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11023 0 : switch (TREE_CODE (_p1))
11024 : {
11025 0 : case REAL_CST:
11026 0 : {
11027 0 : {
11028 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11029 0 : tree res = generic_simplify_440 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, GE_EXPR);
11030 0 : if (res) return res;
11031 : }
11032 0 : break;
11033 : }
11034 : default:;
11035 : }
11036 : }
11037 : break;
11038 0 : case CFN_BUILT_IN_LOG10:
11039 0 : if (call_expr_nargs (_p0) == 1)
11040 : {
11041 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11042 0 : switch (TREE_CODE (_p1))
11043 : {
11044 0 : case REAL_CST:
11045 0 : {
11046 0 : {
11047 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11048 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, GE_EXPR);
11049 0 : if (res) return res;
11050 : }
11051 0 : break;
11052 : }
11053 : default:;
11054 : }
11055 : }
11056 : break;
11057 0 : case CFN_BUILT_IN_LOG2F:
11058 0 : if (call_expr_nargs (_p0) == 1)
11059 : {
11060 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11061 0 : switch (TREE_CODE (_p1))
11062 : {
11063 0 : case REAL_CST:
11064 0 : {
11065 0 : {
11066 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11067 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, GE_EXPR);
11068 0 : if (res) return res;
11069 : }
11070 0 : break;
11071 : }
11072 : default:;
11073 : }
11074 : }
11075 : break;
11076 0 : case CFN_BUILT_IN_LOG2L:
11077 0 : if (call_expr_nargs (_p0) == 1)
11078 : {
11079 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11080 0 : switch (TREE_CODE (_p1))
11081 : {
11082 0 : case REAL_CST:
11083 0 : {
11084 0 : {
11085 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11086 0 : tree res = generic_simplify_439 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, GE_EXPR);
11087 0 : if (res) return res;
11088 : }
11089 0 : break;
11090 : }
11091 : default:;
11092 : }
11093 : }
11094 : break;
11095 : default:;
11096 : }
11097 : break;
11098 : default:;
11099 : }
11100 : return NULL_TREE;
11101 : }
11102 :
11103 : tree
11104 393609 : generic_simplify_MAX_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
11105 : {
11106 393609 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
11107 393609 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
11108 : {
11109 0 : {
11110 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
11111 0 : tree res = generic_simplify_546 (loc, type, _p0, _p1, captures, MAX_EXPR, MIN_EXPR);
11112 0 : if (res) return res;
11113 : }
11114 : }
11115 393609 : switch (TREE_CODE (_p0))
11116 : {
11117 112 : case MAX_EXPR:
11118 112 : {
11119 112 : tree _q20 = TREE_OPERAND (_p0, 0);
11120 112 : tree _q21 = TREE_OPERAND (_p0, 1);
11121 112 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
11122 : {
11123 0 : {
11124 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
11125 0 : tree res = generic_simplify_547 (loc, type, _p0, _p1, captures, MAX_EXPR, MIN_EXPR);
11126 0 : if (res) return res;
11127 : }
11128 : }
11129 112 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
11130 : {
11131 0 : {
11132 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
11133 0 : tree res = generic_simplify_547 (loc, type, _p0, _p1, captures, MAX_EXPR, MIN_EXPR);
11134 0 : if (res) return res;
11135 : }
11136 : }
11137 : break;
11138 : }
11139 393609 : default:;
11140 : }
11141 393609 : switch (TREE_CODE (_p1))
11142 : {
11143 0 : case MAX_EXPR:
11144 0 : {
11145 0 : tree _q30 = TREE_OPERAND (_p1, 0);
11146 0 : tree _q31 = TREE_OPERAND (_p1, 1);
11147 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
11148 : {
11149 0 : {
11150 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q31 };
11151 0 : tree res = generic_simplify_548 (loc, type, _p0, _p1, captures, MAX_EXPR, MIN_EXPR);
11152 0 : if (res) return res;
11153 : }
11154 : }
11155 0 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
11156 : {
11157 0 : {
11158 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q30 };
11159 0 : tree res = generic_simplify_548 (loc, type, _p0, _p1, captures, MAX_EXPR, MIN_EXPR);
11160 0 : if (res) return res;
11161 : }
11162 : }
11163 : break;
11164 : }
11165 393609 : default:;
11166 : }
11167 393609 : switch (TREE_CODE (_p0))
11168 : {
11169 3553 : case MIN_EXPR:
11170 3553 : {
11171 3553 : tree _q20 = TREE_OPERAND (_p0, 0);
11172 3553 : tree _q21 = TREE_OPERAND (_p0, 1);
11173 3553 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
11174 : {
11175 1 : {
11176 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11177 1 : tree res = generic_simplify_549 (loc, type, _p0, _p1, captures, MAX_EXPR, MIN_EXPR);
11178 1 : if (res) return res;
11179 : }
11180 : }
11181 3552 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
11182 : {
11183 1 : {
11184 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11185 1 : tree res = generic_simplify_549 (loc, type, _p0, _p1, captures, MAX_EXPR, MIN_EXPR);
11186 1 : if (res) return res;
11187 : }
11188 : }
11189 : break;
11190 : }
11191 393607 : default:;
11192 : }
11193 393607 : switch (TREE_CODE (_p1))
11194 : {
11195 0 : case MIN_EXPR:
11196 0 : {
11197 0 : tree _q30 = TREE_OPERAND (_p1, 0);
11198 0 : tree _q31 = TREE_OPERAND (_p1, 1);
11199 0 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
11200 : {
11201 0 : {
11202 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
11203 0 : tree res = generic_simplify_549 (loc, type, _p0, _p1, captures, MAX_EXPR, MIN_EXPR);
11204 0 : if (res) return res;
11205 : }
11206 : }
11207 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
11208 : {
11209 0 : {
11210 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _p0 };
11211 0 : tree res = generic_simplify_549 (loc, type, _p0, _p1, captures, MAX_EXPR, MIN_EXPR);
11212 0 : if (res) return res;
11213 : }
11214 : }
11215 : break;
11216 : }
11217 0 : case NEGATE_EXPR:
11218 0 : {
11219 0 : tree _q30 = TREE_OPERAND (_p1, 0);
11220 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
11221 : {
11222 0 : {
11223 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
11224 0 : tree res = generic_simplify_565 (loc, type, _p0, _p1, captures);
11225 0 : if (res) return res;
11226 : }
11227 : }
11228 : break;
11229 : }
11230 393607 : default:;
11231 : }
11232 393607 : switch (TREE_CODE (_p0))
11233 : {
11234 76 : case NEGATE_EXPR:
11235 76 : {
11236 76 : tree _q20 = TREE_OPERAND (_p0, 0);
11237 76 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
11238 : {
11239 2 : {
11240 2 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
11241 2 : tree res = generic_simplify_565 (loc, type, _p0, _p1, captures);
11242 2 : if (res) return res;
11243 : }
11244 : }
11245 : break;
11246 : }
11247 393605 : default:;
11248 : }
11249 393605 : {
11250 393605 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
11251 393605 : if (INTEGRAL_TYPE_P (type)
11252 391649 : && TYPE_MAX_VALUE (type)
11253 785254 : && operand_equal_p (captures[1], TYPE_MAX_VALUE (type), OEP_ONLY_CONST)
11254 : )
11255 : {
11256 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1850;
11257 0 : {
11258 0 : tree _r;
11259 0 : _r = captures[1];
11260 0 : if (TREE_SIDE_EFFECTS (captures[0]))
11261 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
11262 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1071, __FILE__, __LINE__, true);
11263 : return _r;
11264 : }
11265 0 : next_after_fail1850:;
11266 : }
11267 : else
11268 : {
11269 393605 : if (INTEGRAL_TYPE_P (type)
11270 391649 : && TYPE_MIN_VALUE (type)
11271 785254 : && operand_equal_p (captures[1], TYPE_MIN_VALUE (type), OEP_ONLY_CONST)
11272 : )
11273 : {
11274 31734 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1851;
11275 31734 : {
11276 31734 : tree _r;
11277 31734 : _r = captures[0];
11278 31734 : if (TREE_SIDE_EFFECTS (captures[1]))
11279 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11280 31734 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1072, __FILE__, __LINE__, true);
11281 : return _r;
11282 : }
11283 0 : next_after_fail1851:;
11284 : }
11285 : }
11286 : }
11287 361871 : switch (TREE_CODE (_p0))
11288 : {
11289 23611 : case PLUS_EXPR:
11290 23611 : {
11291 23611 : tree _q20 = TREE_OPERAND (_p0, 0);
11292 23611 : tree _q21 = TREE_OPERAND (_p0, 1);
11293 23611 : switch (TREE_CODE (_p1))
11294 : {
11295 14 : case PLUS_EXPR:
11296 14 : {
11297 14 : tree _q50 = TREE_OPERAND (_p1, 0);
11298 14 : tree _q51 = TREE_OPERAND (_p1, 1);
11299 14 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11300 : {
11301 0 : {
11302 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
11303 0 : tree res = generic_simplify_551 (loc, type, _p0, _p1, captures, MAX_EXPR);
11304 0 : if (res) return res;
11305 : }
11306 0 : {
11307 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q50, _q21, _p0, _q20 };
11308 0 : tree res = generic_simplify_551 (loc, type, _p0, _p1, captures, MAX_EXPR);
11309 0 : if (res) return res;
11310 : }
11311 : }
11312 14 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
11313 : {
11314 0 : {
11315 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q50 };
11316 0 : tree res = generic_simplify_551 (loc, type, _p0, _p1, captures, MAX_EXPR);
11317 0 : if (res) return res;
11318 : }
11319 : }
11320 14 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
11321 : {
11322 0 : {
11323 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q51, _q21, _p0, _q20 };
11324 0 : tree res = generic_simplify_551 (loc, type, _p0, _p1, captures, MAX_EXPR);
11325 0 : if (res) return res;
11326 : }
11327 : }
11328 : break;
11329 : }
11330 23611 : default:;
11331 : }
11332 23611 : switch (TREE_CODE (_q21))
11333 : {
11334 23573 : case INTEGER_CST:
11335 23573 : {
11336 23573 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
11337 : {
11338 11 : {
11339 11 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
11340 11 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
11341 : )
11342 : {
11343 0 : if (tree_int_cst_sgn (captures[2]) > 0
11344 : )
11345 : {
11346 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1852;
11347 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1852;
11348 0 : {
11349 0 : tree _r;
11350 0 : _r = captures[1];
11351 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1073, __FILE__, __LINE__, true);
11352 : return _r;
11353 : }
11354 361871 : next_after_fail1852:;
11355 : }
11356 : else
11357 : {
11358 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1853;
11359 0 : {
11360 0 : tree _r;
11361 0 : _r = captures[0];
11362 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11363 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11364 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1074, __FILE__, __LINE__, true);
11365 : return _r;
11366 : }
11367 0 : next_after_fail1853:;
11368 : }
11369 : }
11370 : }
11371 : }
11372 : break;
11373 : }
11374 : default:;
11375 : }
11376 : break;
11377 : }
11378 8248 : case MINUS_EXPR:
11379 8248 : {
11380 8248 : tree _q20 = TREE_OPERAND (_p0, 0);
11381 8248 : tree _q21 = TREE_OPERAND (_p0, 1);
11382 8248 : switch (TREE_CODE (_p1))
11383 : {
11384 0 : case MINUS_EXPR:
11385 0 : {
11386 0 : tree _q50 = TREE_OPERAND (_p1, 0);
11387 0 : tree _q51 = TREE_OPERAND (_p1, 1);
11388 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11389 : {
11390 0 : {
11391 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
11392 0 : tree res = generic_simplify_552 (loc, type, _p0, _p1, captures, MAX_EXPR);
11393 0 : if (res) return res;
11394 : }
11395 0 : {
11396 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q50, _q21, _p0, _q20 };
11397 0 : tree res = generic_simplify_552 (loc, type, _p0, _p1, captures, MAX_EXPR);
11398 0 : if (res) return res;
11399 : }
11400 : }
11401 : break;
11402 : }
11403 : default:;
11404 : }
11405 : break;
11406 : }
11407 34675 : CASE_CONVERT:
11408 34675 : {
11409 34675 : tree _q20 = TREE_OPERAND (_p0, 0);
11410 34675 : switch (TREE_CODE (_p1))
11411 : {
11412 0 : CASE_CONVERT:
11413 0 : {
11414 0 : tree _q40 = TREE_OPERAND (_p1, 0);
11415 0 : {
11416 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
11417 0 : tree res = generic_simplify_553 (loc, type, _p0, _p1, captures, MAX_EXPR, MAX_EXPR);
11418 0 : if (res) return res;
11419 : }
11420 0 : break;
11421 : }
11422 : default:;
11423 : }
11424 : break;
11425 : }
11426 361871 : default:;
11427 : }
11428 361871 : switch (TREE_CODE (_p1))
11429 : {
11430 110 : case PLUS_EXPR:
11431 110 : {
11432 110 : tree _q30 = TREE_OPERAND (_p1, 0);
11433 110 : tree _q31 = TREE_OPERAND (_p1, 1);
11434 110 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
11435 : {
11436 0 : switch (TREE_CODE (_q31))
11437 : {
11438 0 : case INTEGER_CST:
11439 0 : {
11440 0 : {
11441 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
11442 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
11443 : )
11444 : {
11445 0 : if (tree_int_cst_sgn (captures[2]) > 0
11446 : )
11447 : {
11448 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1854;
11449 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1854;
11450 0 : {
11451 0 : tree _r;
11452 0 : _r = captures[1];
11453 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1073, __FILE__, __LINE__, true);
11454 : return _r;
11455 : }
11456 361871 : next_after_fail1854:;
11457 : }
11458 : else
11459 : {
11460 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1855;
11461 0 : {
11462 0 : tree _r;
11463 0 : _r = captures[0];
11464 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11465 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11466 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1074, __FILE__, __LINE__, true);
11467 : return _r;
11468 : }
11469 0 : next_after_fail1855:;
11470 : }
11471 : }
11472 : }
11473 : break;
11474 : }
11475 : default:;
11476 : }
11477 : }
11478 : break;
11479 : }
11480 361871 : default:;
11481 : }
11482 361871 : switch (TREE_CODE (_p0))
11483 : {
11484 3551 : case MIN_EXPR:
11485 3551 : {
11486 3551 : tree _q20 = TREE_OPERAND (_p0, 0);
11487 3551 : tree _q21 = TREE_OPERAND (_p0, 1);
11488 3551 : switch (TREE_CODE (_q21))
11489 : {
11490 0 : case PLUS_EXPR:
11491 0 : {
11492 0 : tree _q40 = TREE_OPERAND (_q21, 0);
11493 0 : tree _q41 = TREE_OPERAND (_q21, 1);
11494 0 : switch (TREE_CODE (_q41))
11495 : {
11496 0 : case INTEGER_CST:
11497 0 : {
11498 0 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
11499 : {
11500 0 : {
11501 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q40, _q41 };
11502 0 : tree res = generic_simplify_554 (loc, type, _p0, _p1, captures, MAX_EXPR, MIN_EXPR);
11503 0 : if (res) return res;
11504 : }
11505 : }
11506 : break;
11507 : }
11508 : default:;
11509 : }
11510 : break;
11511 : }
11512 3551 : default:;
11513 : }
11514 3551 : switch (TREE_CODE (_q20))
11515 : {
11516 0 : case PLUS_EXPR:
11517 0 : {
11518 0 : tree _q30 = TREE_OPERAND (_q20, 0);
11519 0 : tree _q31 = TREE_OPERAND (_q20, 1);
11520 0 : switch (TREE_CODE (_q31))
11521 : {
11522 0 : case INTEGER_CST:
11523 0 : {
11524 0 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
11525 : {
11526 0 : {
11527 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q30, _q31 };
11528 0 : tree res = generic_simplify_554 (loc, type, _p0, _p1, captures, MAX_EXPR, MIN_EXPR);
11529 0 : if (res) return res;
11530 : }
11531 : }
11532 : break;
11533 : }
11534 : default:;
11535 : }
11536 : break;
11537 : }
11538 3551 : default:;
11539 : }
11540 3551 : switch (TREE_CODE (_p1))
11541 : {
11542 0 : case MAX_EXPR:
11543 0 : {
11544 0 : tree _q50 = TREE_OPERAND (_p1, 0);
11545 0 : tree _q51 = TREE_OPERAND (_p1, 1);
11546 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
11547 : {
11548 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11549 : {
11550 0 : {
11551 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11552 0 : if (!HONOR_NANS (captures[0])
11553 : )
11554 : {
11555 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1856;
11556 0 : {
11557 0 : tree res_op0;
11558 0 : res_op0 = captures[0];
11559 0 : tree res_op1;
11560 0 : res_op1 = captures[1];
11561 0 : tree _r;
11562 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
11563 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 937, __FILE__, __LINE__, true);
11564 : return _r;
11565 : }
11566 0 : next_after_fail1856:;
11567 : }
11568 : }
11569 : }
11570 : }
11571 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
11572 : {
11573 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
11574 : {
11575 0 : {
11576 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11577 0 : if (!HONOR_NANS (captures[0])
11578 : )
11579 : {
11580 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1857;
11581 0 : {
11582 0 : tree res_op0;
11583 0 : res_op0 = captures[0];
11584 0 : tree res_op1;
11585 0 : res_op1 = captures[1];
11586 0 : tree _r;
11587 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
11588 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 937, __FILE__, __LINE__, true);
11589 : return _r;
11590 : }
11591 0 : next_after_fail1857:;
11592 : }
11593 : }
11594 : }
11595 : }
11596 : break;
11597 : }
11598 : default:;
11599 : }
11600 : break;
11601 : }
11602 361871 : default:;
11603 : }
11604 361871 : switch (TREE_CODE (_p1))
11605 : {
11606 0 : case MIN_EXPR:
11607 0 : {
11608 0 : tree _q30 = TREE_OPERAND (_p1, 0);
11609 0 : tree _q31 = TREE_OPERAND (_p1, 1);
11610 0 : switch (TREE_CODE (_q31))
11611 : {
11612 0 : case PLUS_EXPR:
11613 0 : {
11614 0 : tree _q50 = TREE_OPERAND (_q31, 0);
11615 0 : tree _q51 = TREE_OPERAND (_q31, 1);
11616 0 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
11617 : {
11618 0 : switch (TREE_CODE (_q51))
11619 : {
11620 0 : case INTEGER_CST:
11621 0 : {
11622 0 : {
11623 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p0, _q51 };
11624 0 : tree res = generic_simplify_554 (loc, type, _p0, _p1, captures, MAX_EXPR, MIN_EXPR);
11625 0 : if (res) return res;
11626 : }
11627 0 : break;
11628 : }
11629 : default:;
11630 : }
11631 : }
11632 : break;
11633 : }
11634 0 : default:;
11635 : }
11636 0 : switch (TREE_CODE (_q30))
11637 : {
11638 0 : case PLUS_EXPR:
11639 0 : {
11640 0 : tree _q40 = TREE_OPERAND (_q30, 0);
11641 0 : tree _q41 = TREE_OPERAND (_q30, 1);
11642 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
11643 : {
11644 0 : switch (TREE_CODE (_q41))
11645 : {
11646 0 : case INTEGER_CST:
11647 0 : {
11648 0 : {
11649 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _p0, _q41 };
11650 0 : tree res = generic_simplify_554 (loc, type, _p0, _p1, captures, MAX_EXPR, MIN_EXPR);
11651 0 : if (res) return res;
11652 : }
11653 0 : break;
11654 : }
11655 : default:;
11656 : }
11657 : }
11658 : break;
11659 : }
11660 : default:;
11661 : }
11662 : break;
11663 : }
11664 361871 : default:;
11665 : }
11666 361871 : switch (TREE_CODE (_p0))
11667 : {
11668 112 : case MAX_EXPR:
11669 112 : {
11670 112 : tree _q20 = TREE_OPERAND (_p0, 0);
11671 112 : tree _q21 = TREE_OPERAND (_p0, 1);
11672 112 : switch (TREE_CODE (_p1))
11673 : {
11674 0 : case MIN_EXPR:
11675 0 : {
11676 0 : tree _q50 = TREE_OPERAND (_p1, 0);
11677 0 : tree _q51 = TREE_OPERAND (_p1, 1);
11678 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
11679 : {
11680 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11681 : {
11682 0 : {
11683 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11684 0 : if (!HONOR_NANS (captures[0])
11685 : )
11686 : {
11687 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1858;
11688 0 : {
11689 0 : tree res_op0;
11690 0 : res_op0 = captures[0];
11691 0 : tree res_op1;
11692 0 : res_op1 = captures[1];
11693 0 : tree _r;
11694 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
11695 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 937, __FILE__, __LINE__, true);
11696 : return _r;
11697 : }
11698 0 : next_after_fail1858:;
11699 : }
11700 : }
11701 : }
11702 : }
11703 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
11704 : {
11705 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
11706 : {
11707 0 : {
11708 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11709 0 : if (!HONOR_NANS (captures[0])
11710 : )
11711 : {
11712 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1859;
11713 0 : {
11714 0 : tree res_op0;
11715 0 : res_op0 = captures[0];
11716 0 : tree res_op1;
11717 0 : res_op1 = captures[1];
11718 0 : tree _r;
11719 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
11720 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 937, __FILE__, __LINE__, true);
11721 : return _r;
11722 : }
11723 0 : next_after_fail1859:;
11724 : }
11725 : }
11726 : }
11727 : }
11728 : break;
11729 : }
11730 : default:;
11731 : }
11732 : break;
11733 : }
11734 0 : case BIT_AND_EXPR:
11735 0 : {
11736 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11737 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11738 0 : switch (TREE_CODE (_q21))
11739 : {
11740 0 : case INTEGER_CST:
11741 0 : {
11742 0 : switch (TREE_CODE (_p1))
11743 : {
11744 0 : case BIT_AND_EXPR:
11745 0 : {
11746 0 : tree _q50 = TREE_OPERAND (_p1, 0);
11747 0 : tree _q51 = TREE_OPERAND (_p1, 1);
11748 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
11749 : {
11750 0 : switch (TREE_CODE (_q51))
11751 : {
11752 0 : case INTEGER_CST:
11753 0 : {
11754 0 : {
11755 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
11756 0 : tree res = generic_simplify_555 (loc, type, _p0, _p1, captures, MAX_EXPR);
11757 0 : if (res) return res;
11758 : }
11759 0 : break;
11760 : }
11761 : default:;
11762 : }
11763 : }
11764 : break;
11765 : }
11766 : default:;
11767 : }
11768 : break;
11769 : }
11770 : default:;
11771 : }
11772 : break;
11773 : }
11774 361871 : default:;
11775 : }
11776 361871 : switch (TREE_CODE (_p1))
11777 : {
11778 0 : case BIT_AND_EXPR:
11779 0 : {
11780 0 : tree _q30 = TREE_OPERAND (_p1, 0);
11781 0 : tree _q31 = TREE_OPERAND (_p1, 1);
11782 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
11783 : {
11784 0 : switch (TREE_CODE (_q31))
11785 : {
11786 0 : case INTEGER_CST:
11787 0 : {
11788 0 : {
11789 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
11790 0 : tree res = generic_simplify_556 (loc, type, _p0, _p1, captures, MAX_EXPR);
11791 0 : if (res) return res;
11792 : }
11793 0 : break;
11794 : }
11795 : default:;
11796 : }
11797 : }
11798 : break;
11799 : }
11800 361871 : default:;
11801 : }
11802 361871 : switch (TREE_CODE (_p0))
11803 : {
11804 34675 : CASE_CONVERT:
11805 34675 : {
11806 34675 : tree _q20 = TREE_OPERAND (_p0, 0);
11807 34675 : switch (TREE_CODE (_q20))
11808 : {
11809 30 : case ADDR_EXPR:
11810 30 : {
11811 30 : switch (TREE_CODE (_p1))
11812 : {
11813 0 : CASE_CONVERT:
11814 0 : {
11815 0 : tree _q40 = TREE_OPERAND (_p1, 0);
11816 0 : switch (TREE_CODE (_q40))
11817 : {
11818 0 : case ADDR_EXPR:
11819 0 : {
11820 0 : {
11821 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11822 0 : tree res = generic_simplify_557 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR);
11823 0 : if (res) return res;
11824 : }
11825 0 : break;
11826 : }
11827 : default:;
11828 : }
11829 : break;
11830 : }
11831 0 : case ADDR_EXPR:
11832 0 : {
11833 0 : {
11834 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
11835 0 : tree res = generic_simplify_558 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR);
11836 0 : if (res) return res;
11837 : }
11838 0 : break;
11839 : }
11840 : default:;
11841 : }
11842 : break;
11843 : }
11844 : default:;
11845 : }
11846 : break;
11847 : }
11848 10 : case ADDR_EXPR:
11849 10 : {
11850 10 : switch (TREE_CODE (_p1))
11851 : {
11852 0 : CASE_CONVERT:
11853 0 : {
11854 0 : tree _q30 = TREE_OPERAND (_p1, 0);
11855 0 : switch (TREE_CODE (_q30))
11856 : {
11857 0 : case ADDR_EXPR:
11858 0 : {
11859 0 : {
11860 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _p1, _q30 };
11861 0 : tree res = generic_simplify_559 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR);
11862 0 : if (res) return res;
11863 : }
11864 0 : break;
11865 : }
11866 : default:;
11867 : }
11868 : break;
11869 : }
11870 10 : case ADDR_EXPR:
11871 10 : {
11872 10 : {
11873 10 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _p1, _p1 };
11874 10 : tree res = generic_simplify_560 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR);
11875 10 : if (res) return res;
11876 : }
11877 10 : break;
11878 : }
11879 : default:;
11880 : }
11881 : break;
11882 : }
11883 74 : case NEGATE_EXPR:
11884 74 : {
11885 74 : tree _q20 = TREE_OPERAND (_p0, 0);
11886 74 : switch (TREE_CODE (_p1))
11887 : {
11888 0 : case NEGATE_EXPR:
11889 0 : {
11890 0 : tree _q40 = TREE_OPERAND (_p1, 0);
11891 0 : {
11892 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11893 0 : if (FLOAT_TYPE_P (TREE_TYPE (captures[1]))
11894 0 : || (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
11895 0 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1])))
11896 : )
11897 : {
11898 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1860;
11899 0 : {
11900 0 : tree res_op0;
11901 0 : {
11902 0 : tree _o1[2], _r1;
11903 0 : _o1[0] = captures[1];
11904 0 : _o1[1] = captures[3];
11905 0 : _r1 = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
11906 0 : res_op0 = _r1;
11907 : }
11908 0 : tree _r;
11909 0 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
11910 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1070, __FILE__, __LINE__, true);
11911 : return _r;
11912 : }
11913 0 : next_after_fail1860:;
11914 : }
11915 : }
11916 : break;
11917 : }
11918 : default:;
11919 : }
11920 : break;
11921 : }
11922 0 : case BIT_NOT_EXPR:
11923 0 : {
11924 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11925 0 : switch (TREE_CODE (_p1))
11926 : {
11927 0 : case BIT_NOT_EXPR:
11928 0 : {
11929 0 : tree _q40 = TREE_OPERAND (_p1, 0);
11930 0 : {
11931 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11932 0 : tree res = generic_simplify_561 (loc, type, _p0, _p1, captures, MAX_EXPR, MIN_EXPR);
11933 0 : if (res) return res;
11934 : }
11935 0 : break;
11936 : }
11937 : default:;
11938 : }
11939 : break;
11940 : }
11941 0 : case VEC_COND_EXPR:
11942 0 : {
11943 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11944 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11945 0 : tree _q22 = TREE_OPERAND (_p0, 2);
11946 0 : switch (TREE_CODE (_p1))
11947 : {
11948 0 : case VEC_COND_EXPR:
11949 0 : {
11950 0 : tree _q60 = TREE_OPERAND (_p1, 0);
11951 0 : tree _q61 = TREE_OPERAND (_p1, 1);
11952 0 : tree _q62 = TREE_OPERAND (_p1, 2);
11953 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
11954 : {
11955 0 : {
11956 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
11957 0 : if (VECTOR_TYPE_P (type)
11958 : && (TREE_CODE_CLASS (MAX_EXPR) != tcc_comparison
11959 : || types_match (type, TREE_TYPE (captures[2]))
11960 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
11961 : || (optimize_vectors_before_lowering_p ()
11962 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
11963 : )
11964 : {
11965 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1861;
11966 0 : {
11967 0 : tree res_op0;
11968 0 : res_op0 = captures[1];
11969 0 : tree res_op1;
11970 0 : {
11971 0 : tree _o1[2], _r1;
11972 0 : _o1[0] = captures[2];
11973 0 : _o1[1] = captures[5];
11974 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
11975 0 : if (EXPR_P (_r1))
11976 0 : goto next_after_fail1861;
11977 0 : res_op1 = _r1;
11978 : }
11979 0 : tree res_op2;
11980 0 : {
11981 0 : tree _o1[2], _r1;
11982 0 : _o1[0] = captures[3];
11983 0 : _o1[1] = captures[6];
11984 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
11985 0 : if (EXPR_P (_r1))
11986 0 : goto next_after_fail1861;
11987 0 : res_op2 = _r1;
11988 : }
11989 0 : tree _r;
11990 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11991 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 938, __FILE__, __LINE__, true);
11992 : return _r;
11993 : }
11994 0 : next_after_fail1861:;
11995 : }
11996 : }
11997 : }
11998 : break;
11999 : }
12000 0 : default:;
12001 : }
12002 0 : {
12003 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
12004 0 : if (VECTOR_TYPE_P (type)
12005 : && (TREE_CODE_CLASS (MAX_EXPR) != tcc_comparison
12006 : || types_match (type, TREE_TYPE (captures[2]))
12007 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
12008 : || (optimize_vectors_before_lowering_p ()
12009 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
12010 : )
12011 : {
12012 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1862;
12013 0 : {
12014 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1862;
12015 0 : tree res_op0;
12016 0 : res_op0 = captures[1];
12017 0 : tree res_op1;
12018 0 : {
12019 0 : tree _o1[2], _r1;
12020 0 : _o1[0] = captures[2];
12021 0 : _o1[1] = unshare_expr (captures[4]);
12022 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
12023 0 : if (EXPR_P (_r1))
12024 0 : goto next_after_fail1862;
12025 0 : res_op1 = _r1;
12026 : }
12027 0 : tree res_op2;
12028 0 : {
12029 0 : tree _o1[2], _r1;
12030 0 : _o1[0] = captures[3];
12031 0 : _o1[1] = captures[4];
12032 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
12033 0 : if (EXPR_P (_r1))
12034 0 : goto next_after_fail1862;
12035 0 : res_op2 = _r1;
12036 : }
12037 0 : tree _r;
12038 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
12039 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 940, __FILE__, __LINE__, true);
12040 : return _r;
12041 : }
12042 361871 : next_after_fail1862:;
12043 : }
12044 : }
12045 : break;
12046 : }
12047 361871 : default:;
12048 : }
12049 361871 : switch (TREE_CODE (_p1))
12050 : {
12051 0 : case VEC_COND_EXPR:
12052 0 : {
12053 0 : tree _q30 = TREE_OPERAND (_p1, 0);
12054 0 : tree _q31 = TREE_OPERAND (_p1, 1);
12055 0 : tree _q32 = TREE_OPERAND (_p1, 2);
12056 0 : {
12057 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
12058 0 : if (VECTOR_TYPE_P (type)
12059 : && (TREE_CODE_CLASS (MAX_EXPR) != tcc_comparison
12060 : || types_match (type, TREE_TYPE (captures[3]))
12061 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
12062 : || (optimize_vectors_before_lowering_p ()
12063 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
12064 : )
12065 : {
12066 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1863;
12067 0 : {
12068 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1863;
12069 0 : tree res_op0;
12070 0 : res_op0 = captures[2];
12071 0 : tree res_op1;
12072 0 : {
12073 0 : tree _o1[2], _r1;
12074 0 : _o1[0] = unshare_expr (captures[0]);
12075 0 : _o1[1] = captures[3];
12076 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
12077 0 : if (EXPR_P (_r1))
12078 0 : goto next_after_fail1863;
12079 0 : res_op1 = _r1;
12080 : }
12081 0 : tree res_op2;
12082 0 : {
12083 0 : tree _o1[2], _r1;
12084 0 : _o1[0] = captures[0];
12085 0 : _o1[1] = captures[4];
12086 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
12087 0 : if (EXPR_P (_r1))
12088 0 : goto next_after_fail1863;
12089 0 : res_op2 = _r1;
12090 : }
12091 0 : tree _r;
12092 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
12093 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 941, __FILE__, __LINE__, true);
12094 : return _r;
12095 : }
12096 361871 : next_after_fail1863:;
12097 : }
12098 : }
12099 : break;
12100 : }
12101 361871 : default:;
12102 : }
12103 361871 : switch (TREE_CODE (_p0))
12104 : {
12105 0 : case CALL_EXPR:
12106 0 : switch (get_call_combined_fn (_p0))
12107 : {
12108 0 : case CFN_REDUC_MAX:
12109 0 : if (call_expr_nargs (_p0) == 1)
12110 : {
12111 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
12112 0 : switch (TREE_CODE (_p1))
12113 : {
12114 0 : case CALL_EXPR:
12115 0 : switch (get_call_combined_fn (_p1))
12116 : {
12117 0 : case CFN_REDUC_MAX:
12118 0 : if (call_expr_nargs (_p1) == 1)
12119 : {
12120 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
12121 0 : {
12122 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
12123 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, CFN_REDUC_MAX, MAX_EXPR);
12124 0 : if (res) return res;
12125 : }
12126 : }
12127 : break;
12128 : default:;
12129 : }
12130 : break;
12131 : default:;
12132 : }
12133 : }
12134 : break;
12135 : default:;
12136 : }
12137 : break;
12138 361871 : default:;
12139 : }
12140 361871 : if (tree_zero_one_valued_p (_p0))
12141 : {
12142 10 : if (tree_zero_one_valued_p (_p1))
12143 : {
12144 0 : {
12145 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
12146 0 : tree res = generic_simplify_562 (loc, type, _p0, _p1, captures, MAX_EXPR, BIT_IOR_EXPR);
12147 0 : if (res) return res;
12148 : }
12149 : }
12150 : }
12151 : return NULL_TREE;
12152 : }
12153 :
12154 : tree
12155 1650331 : generic_simplify_UNLE_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
12156 : {
12157 1650331 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
12158 1650331 : switch (TREE_CODE (_p0))
12159 : {
12160 0 : case VEC_COND_EXPR:
12161 0 : {
12162 0 : tree _q20 = TREE_OPERAND (_p0, 0);
12163 0 : tree _q21 = TREE_OPERAND (_p0, 1);
12164 0 : tree _q22 = TREE_OPERAND (_p0, 2);
12165 0 : switch (TREE_CODE (_p1))
12166 : {
12167 0 : case VEC_COND_EXPR:
12168 0 : {
12169 0 : tree _q60 = TREE_OPERAND (_p1, 0);
12170 0 : tree _q61 = TREE_OPERAND (_p1, 1);
12171 0 : tree _q62 = TREE_OPERAND (_p1, 2);
12172 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
12173 : {
12174 0 : {
12175 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
12176 0 : if (VECTOR_TYPE_P (type)
12177 0 : && (TREE_CODE_CLASS (UNLE_EXPR) != tcc_comparison
12178 0 : || types_match (type, TREE_TYPE (captures[2]))
12179 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
12180 : || (optimize_vectors_before_lowering_p ()
12181 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
12182 : )
12183 : {
12184 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1879;
12185 0 : {
12186 0 : tree res_op0;
12187 0 : res_op0 = captures[1];
12188 0 : tree res_op1;
12189 0 : {
12190 0 : tree _o1[2], _r1;
12191 0 : _o1[0] = captures[2];
12192 0 : _o1[1] = captures[5];
12193 0 : _r1 = fold_build2_loc (loc, UNLE_EXPR, type, _o1[0], _o1[1]);
12194 0 : if (EXPR_P (_r1))
12195 0 : goto next_after_fail1879;
12196 0 : res_op1 = _r1;
12197 : }
12198 0 : tree res_op2;
12199 0 : {
12200 0 : tree _o1[2], _r1;
12201 0 : _o1[0] = captures[3];
12202 0 : _o1[1] = captures[6];
12203 0 : _r1 = fold_build2_loc (loc, UNLE_EXPR, type, _o1[0], _o1[1]);
12204 0 : if (EXPR_P (_r1))
12205 0 : goto next_after_fail1879;
12206 0 : res_op2 = _r1;
12207 : }
12208 0 : tree _r;
12209 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
12210 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 938, __FILE__, __LINE__, true);
12211 : return _r;
12212 : }
12213 0 : next_after_fail1879:;
12214 : }
12215 : }
12216 : }
12217 : break;
12218 : }
12219 0 : default:;
12220 : }
12221 0 : {
12222 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
12223 0 : if (VECTOR_TYPE_P (type)
12224 0 : && (TREE_CODE_CLASS (UNLE_EXPR) != tcc_comparison
12225 0 : || types_match (type, TREE_TYPE (captures[2]))
12226 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
12227 : || (optimize_vectors_before_lowering_p ()
12228 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
12229 : )
12230 : {
12231 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1880;
12232 0 : {
12233 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1880;
12234 0 : tree res_op0;
12235 0 : res_op0 = captures[1];
12236 0 : tree res_op1;
12237 0 : {
12238 0 : tree _o1[2], _r1;
12239 0 : _o1[0] = captures[2];
12240 0 : _o1[1] = unshare_expr (captures[4]);
12241 0 : _r1 = fold_build2_loc (loc, UNLE_EXPR, type, _o1[0], _o1[1]);
12242 0 : if (EXPR_P (_r1))
12243 0 : goto next_after_fail1880;
12244 0 : res_op1 = _r1;
12245 : }
12246 0 : tree res_op2;
12247 0 : {
12248 0 : tree _o1[2], _r1;
12249 0 : _o1[0] = captures[3];
12250 0 : _o1[1] = captures[4];
12251 0 : _r1 = fold_build2_loc (loc, UNLE_EXPR, type, _o1[0], _o1[1]);
12252 0 : if (EXPR_P (_r1))
12253 0 : goto next_after_fail1880;
12254 0 : res_op2 = _r1;
12255 : }
12256 0 : tree _r;
12257 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
12258 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 940, __FILE__, __LINE__, true);
12259 : return _r;
12260 : }
12261 1650331 : next_after_fail1880:;
12262 : }
12263 : }
12264 : break;
12265 : }
12266 1650331 : default:;
12267 : }
12268 1650331 : switch (TREE_CODE (_p1))
12269 : {
12270 0 : case VEC_COND_EXPR:
12271 0 : {
12272 0 : tree _q30 = TREE_OPERAND (_p1, 0);
12273 0 : tree _q31 = TREE_OPERAND (_p1, 1);
12274 0 : tree _q32 = TREE_OPERAND (_p1, 2);
12275 0 : {
12276 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
12277 0 : if (VECTOR_TYPE_P (type)
12278 0 : && (TREE_CODE_CLASS (UNLE_EXPR) != tcc_comparison
12279 0 : || types_match (type, TREE_TYPE (captures[3]))
12280 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
12281 : || (optimize_vectors_before_lowering_p ()
12282 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
12283 : )
12284 : {
12285 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1881;
12286 0 : {
12287 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1881;
12288 0 : tree res_op0;
12289 0 : res_op0 = captures[2];
12290 0 : tree res_op1;
12291 0 : {
12292 0 : tree _o1[2], _r1;
12293 0 : _o1[0] = unshare_expr (captures[0]);
12294 0 : _o1[1] = captures[3];
12295 0 : _r1 = fold_build2_loc (loc, UNLE_EXPR, type, _o1[0], _o1[1]);
12296 0 : if (EXPR_P (_r1))
12297 0 : goto next_after_fail1881;
12298 0 : res_op1 = _r1;
12299 : }
12300 0 : tree res_op2;
12301 0 : {
12302 0 : tree _o1[2], _r1;
12303 0 : _o1[0] = captures[0];
12304 0 : _o1[1] = captures[4];
12305 0 : _r1 = fold_build2_loc (loc, UNLE_EXPR, type, _o1[0], _o1[1]);
12306 0 : if (EXPR_P (_r1))
12307 0 : goto next_after_fail1881;
12308 0 : res_op2 = _r1;
12309 : }
12310 0 : tree _r;
12311 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
12312 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 941, __FILE__, __LINE__, true);
12313 : return _r;
12314 : }
12315 1650331 : next_after_fail1881:;
12316 : }
12317 : }
12318 : break;
12319 : }
12320 1650331 : default:;
12321 : }
12322 1650331 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
12323 : {
12324 30 : {
12325 30 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
12326 30 : tree res = generic_simplify_593 (loc, type, _p0, _p1, captures, UNLE_EXPR);
12327 30 : if (res) return res;
12328 : }
12329 : }
12330 1650301 : switch (TREE_CODE (_p0))
12331 : {
12332 96 : case FLOAT_EXPR:
12333 96 : {
12334 96 : tree _q20 = TREE_OPERAND (_p0, 0);
12335 96 : switch (TREE_CODE (_p1))
12336 : {
12337 0 : case FLOAT_EXPR:
12338 0 : {
12339 0 : tree _q40 = TREE_OPERAND (_p1, 0);
12340 0 : {
12341 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
12342 0 : tree res = generic_simplify_279 (loc, type, _p0, _p1, captures, UNLE_EXPR, LE_EXPR);
12343 0 : if (res) return res;
12344 : }
12345 0 : break;
12346 : }
12347 : default:;
12348 : }
12349 : break;
12350 : }
12351 112 : case NEGATE_EXPR:
12352 112 : {
12353 112 : tree _q20 = TREE_OPERAND (_p0, 0);
12354 112 : switch (TREE_CODE (_p1))
12355 : {
12356 0 : case NEGATE_EXPR:
12357 0 : {
12358 0 : tree _q40 = TREE_OPERAND (_p1, 0);
12359 0 : {
12360 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
12361 0 : tree res = generic_simplify_282 (loc, type, _p0, _p1, captures, UNLE_EXPR, UNGE_EXPR);
12362 0 : if (res) return res;
12363 : }
12364 0 : break;
12365 : }
12366 112 : default:;
12367 : }
12368 112 : if (CONSTANT_CLASS_P (_p1))
12369 : {
12370 112 : {
12371 112 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
12372 112 : tree res = generic_simplify_283 (loc, type, _p0, _p1, captures, UNLE_EXPR, UNGE_EXPR);
12373 112 : if (res) return res;
12374 : }
12375 : }
12376 : break;
12377 : }
12378 1650189 : default:;
12379 : }
12380 1650189 : switch (TREE_CODE (_p1))
12381 : {
12382 1269938 : case REAL_CST:
12383 1269938 : {
12384 1269938 : {
12385 1269938 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
12386 1269938 : tree res = generic_simplify_591 (loc, type, _p0, _p1, captures, UNLE_EXPR);
12387 1269938 : if (res) return res;
12388 : }
12389 1269936 : break;
12390 : }
12391 : default:;
12392 : }
12393 : return NULL_TREE;
12394 : }
12395 :
12396 : tree
12397 3531561 : generic_simplify_TRUTH_ORIF_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
12398 : {
12399 3531561 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
12400 3531561 : switch (TREE_CODE (_p0))
12401 : {
12402 368180 : case LE_EXPR:
12403 368180 : {
12404 368180 : tree _q20 = TREE_OPERAND (_p0, 0);
12405 368180 : tree _q21 = TREE_OPERAND (_p0, 1);
12406 368180 : switch (TREE_CODE (_q20))
12407 : {
12408 90 : case POINTER_PLUS_EXPR:
12409 90 : {
12410 90 : tree _q30 = TREE_OPERAND (_q20, 0);
12411 90 : tree _q31 = TREE_OPERAND (_q20, 1);
12412 90 : switch (TREE_CODE (_q31))
12413 : {
12414 2 : case INTEGER_CST:
12415 2 : {
12416 2 : switch (TREE_CODE (_p1))
12417 : {
12418 2 : case LE_EXPR:
12419 2 : {
12420 2 : tree _q70 = TREE_OPERAND (_p1, 0);
12421 2 : tree _q71 = TREE_OPERAND (_p1, 1);
12422 2 : switch (TREE_CODE (_q70))
12423 : {
12424 2 : case POINTER_PLUS_EXPR:
12425 2 : {
12426 2 : tree _q80 = TREE_OPERAND (_q70, 0);
12427 2 : tree _q81 = TREE_OPERAND (_q70, 1);
12428 2 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
12429 : {
12430 2 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
12431 : {
12432 2 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
12433 : {
12434 2 : {
12435 2 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70 };
12436 2 : const enum tree_code cmp = LE_EXPR;
12437 2 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
12438 1 : && TYPE_OVERFLOW_WRAPS (sizetype)
12439 3 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
12440 : )
12441 : {
12442 1 : {
12443 1 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
12444 1 : offset_int rhs = off * 2;
12445 1 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
12446 : )
12447 : {
12448 1 : {
12449 1 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
12450 1 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
12451 1 : if (cmp == LT_EXPR
12452 : )
12453 : {
12454 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1895;
12455 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1895;
12456 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1895;
12457 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1895;
12458 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1895;
12459 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1895;
12460 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1895;
12461 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1895;
12462 : {
12463 : tree res_op0;
12464 : {
12465 : tree _o1[1], _r1;
12466 : {
12467 : tree _o2[2], _r2;
12468 : _o2[0] = swap_p ? captures[6] : captures[1];
12469 : _o2[1] = swap_p ? captures[2] : captures[4];
12470 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12471 : _o1[0] = _r2;
12472 : }
12473 : if (TREE_TYPE (_o1[0]) != sizetype)
12474 : {
12475 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12476 : }
12477 : else
12478 : _r1 = _o1[0];
12479 : res_op0 = _r1;
12480 : }
12481 : tree res_op1;
12482 : res_op1 = rhs_tree;
12483 : tree _r;
12484 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12485 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 986, __FILE__, __LINE__, true);
12486 1 : return _r;
12487 : }
12488 : next_after_fail1895:;
12489 : }
12490 : else
12491 : {
12492 1 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1896;
12493 1 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1896;
12494 1 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1896;
12495 1 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1896;
12496 1 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1896;
12497 1 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1896;
12498 1 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1896;
12499 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1896;
12500 1 : {
12501 1 : tree res_op0;
12502 1 : {
12503 1 : tree _o1[1], _r1;
12504 1 : {
12505 1 : tree _o2[2], _r2;
12506 1 : {
12507 1 : tree _o3[2], _r3;
12508 1 : _o3[0] = swap_p ? captures[4] : captures[2];
12509 1 : _o3[1] = wide_int_to_tree (sizetype, off);
12510 1 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
12511 1 : _o2[0] = _r3;
12512 : }
12513 1 : _o2[1] = swap_p ? captures[2] : captures[4];
12514 1 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12515 1 : _o1[0] = _r2;
12516 : }
12517 1 : if (TREE_TYPE (_o1[0]) != sizetype)
12518 : {
12519 1 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12520 : }
12521 : else
12522 : _r1 = _o1[0];
12523 1 : res_op0 = _r1;
12524 : }
12525 1 : tree res_op1;
12526 1 : res_op1 = rhs_tree;
12527 1 : tree _r;
12528 1 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12529 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 987, __FILE__, __LINE__, true);
12530 1 : return _r;
12531 : }
12532 0 : next_after_fail1896:;
12533 : }
12534 : }
12535 : }
12536 : }
12537 : }
12538 : }
12539 : }
12540 : }
12541 : }
12542 : break;
12543 : }
12544 : default:;
12545 : }
12546 : break;
12547 : }
12548 0 : case GE_EXPR:
12549 0 : {
12550 0 : tree _q70 = TREE_OPERAND (_p1, 0);
12551 0 : tree _q71 = TREE_OPERAND (_p1, 1);
12552 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
12553 : {
12554 0 : switch (TREE_CODE (_q71))
12555 : {
12556 0 : case POINTER_PLUS_EXPR:
12557 0 : {
12558 0 : tree _q90 = TREE_OPERAND (_q71, 0);
12559 0 : tree _q91 = TREE_OPERAND (_q71, 1);
12560 0 : if ((_q90 == _q21 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q21, 0) && types_match (_q90, _q21)))
12561 : {
12562 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
12563 : {
12564 0 : {
12565 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q71 };
12566 0 : const enum tree_code cmp = LE_EXPR;
12567 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
12568 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
12569 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
12570 : )
12571 : {
12572 0 : {
12573 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
12574 0 : offset_int rhs = off * 2;
12575 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
12576 : )
12577 : {
12578 0 : {
12579 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
12580 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
12581 0 : if (cmp == LT_EXPR
12582 : )
12583 : {
12584 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1897;
12585 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1897;
12586 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1897;
12587 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1897;
12588 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1897;
12589 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1897;
12590 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1897;
12591 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1897;
12592 : {
12593 : tree res_op0;
12594 : {
12595 : tree _o1[1], _r1;
12596 : {
12597 : tree _o2[2], _r2;
12598 : _o2[0] = swap_p ? captures[6] : captures[1];
12599 : _o2[1] = swap_p ? captures[2] : captures[4];
12600 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12601 : _o1[0] = _r2;
12602 : }
12603 : if (TREE_TYPE (_o1[0]) != sizetype)
12604 : {
12605 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12606 : }
12607 : else
12608 : _r1 = _o1[0];
12609 : res_op0 = _r1;
12610 : }
12611 : tree res_op1;
12612 : res_op1 = rhs_tree;
12613 : tree _r;
12614 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12615 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 986, __FILE__, __LINE__, true);
12616 0 : return _r;
12617 : }
12618 : next_after_fail1897:;
12619 : }
12620 : else
12621 : {
12622 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1898;
12623 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1898;
12624 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1898;
12625 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1898;
12626 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1898;
12627 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1898;
12628 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1898;
12629 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1898;
12630 0 : {
12631 0 : tree res_op0;
12632 0 : {
12633 0 : tree _o1[1], _r1;
12634 0 : {
12635 0 : tree _o2[2], _r2;
12636 0 : {
12637 0 : tree _o3[2], _r3;
12638 0 : _o3[0] = swap_p ? captures[4] : captures[2];
12639 0 : _o3[1] = wide_int_to_tree (sizetype, off);
12640 0 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
12641 0 : _o2[0] = _r3;
12642 : }
12643 0 : _o2[1] = swap_p ? captures[2] : captures[4];
12644 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12645 0 : _o1[0] = _r2;
12646 : }
12647 0 : if (TREE_TYPE (_o1[0]) != sizetype)
12648 : {
12649 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12650 : }
12651 : else
12652 : _r1 = _o1[0];
12653 0 : res_op0 = _r1;
12654 : }
12655 0 : tree res_op1;
12656 0 : res_op1 = rhs_tree;
12657 0 : tree _r;
12658 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12659 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 987, __FILE__, __LINE__, true);
12660 0 : return _r;
12661 : }
12662 0 : next_after_fail1898:;
12663 : }
12664 : }
12665 : }
12666 : }
12667 : }
12668 : }
12669 : }
12670 : }
12671 : break;
12672 : }
12673 : default:;
12674 : }
12675 : }
12676 : break;
12677 : }
12678 : default:;
12679 : }
12680 : break;
12681 : }
12682 : default:;
12683 : }
12684 : break;
12685 : }
12686 : default:;
12687 : }
12688 : break;
12689 : }
12690 794256 : case LT_EXPR:
12691 794256 : {
12692 794256 : tree _q20 = TREE_OPERAND (_p0, 0);
12693 794256 : tree _q21 = TREE_OPERAND (_p0, 1);
12694 794256 : switch (TREE_CODE (_q20))
12695 : {
12696 13 : case POINTER_PLUS_EXPR:
12697 13 : {
12698 13 : tree _q30 = TREE_OPERAND (_q20, 0);
12699 13 : tree _q31 = TREE_OPERAND (_q20, 1);
12700 13 : switch (TREE_CODE (_q31))
12701 : {
12702 7 : case INTEGER_CST:
12703 7 : {
12704 7 : switch (TREE_CODE (_p1))
12705 : {
12706 2 : case LT_EXPR:
12707 2 : {
12708 2 : tree _q70 = TREE_OPERAND (_p1, 0);
12709 2 : tree _q71 = TREE_OPERAND (_p1, 1);
12710 2 : switch (TREE_CODE (_q70))
12711 : {
12712 2 : case POINTER_PLUS_EXPR:
12713 2 : {
12714 2 : tree _q80 = TREE_OPERAND (_q70, 0);
12715 2 : tree _q81 = TREE_OPERAND (_q70, 1);
12716 2 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
12717 : {
12718 2 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
12719 : {
12720 2 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
12721 : {
12722 2 : {
12723 2 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70 };
12724 2 : const enum tree_code cmp = LT_EXPR;
12725 2 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
12726 1 : && TYPE_OVERFLOW_WRAPS (sizetype)
12727 3 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
12728 : )
12729 : {
12730 1 : {
12731 1 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
12732 1 : offset_int rhs = off * 2;
12733 1 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
12734 : )
12735 : {
12736 1 : {
12737 1 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
12738 1 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
12739 1 : if (cmp == LT_EXPR
12740 : )
12741 : {
12742 1 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1899;
12743 1 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1899;
12744 1 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1899;
12745 1 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1899;
12746 1 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1899;
12747 1 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1899;
12748 1 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1899;
12749 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1899;
12750 1 : {
12751 1 : tree res_op0;
12752 1 : {
12753 1 : tree _o1[1], _r1;
12754 1 : {
12755 1 : tree _o2[2], _r2;
12756 1 : _o2[0] = swap_p ? captures[6] : captures[1];
12757 1 : _o2[1] = swap_p ? captures[2] : captures[4];
12758 1 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12759 1 : _o1[0] = _r2;
12760 : }
12761 1 : if (TREE_TYPE (_o1[0]) != sizetype)
12762 : {
12763 1 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12764 : }
12765 : else
12766 : _r1 = _o1[0];
12767 1 : res_op0 = _r1;
12768 : }
12769 1 : tree res_op1;
12770 1 : res_op1 = rhs_tree;
12771 1 : tree _r;
12772 1 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12773 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 986, __FILE__, __LINE__, true);
12774 1 : return _r;
12775 : }
12776 0 : next_after_fail1899:;
12777 : }
12778 : else
12779 : {
12780 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1900;
12781 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1900;
12782 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1900;
12783 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1900;
12784 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1900;
12785 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1900;
12786 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1900;
12787 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1900;
12788 : {
12789 : tree res_op0;
12790 : {
12791 : tree _o1[1], _r1;
12792 : {
12793 : tree _o2[2], _r2;
12794 : {
12795 : tree _o3[2], _r3;
12796 : _o3[0] = swap_p ? captures[4] : captures[2];
12797 : _o3[1] = wide_int_to_tree (sizetype, off);
12798 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
12799 : _o2[0] = _r3;
12800 : }
12801 : _o2[1] = swap_p ? captures[2] : captures[4];
12802 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12803 : _o1[0] = _r2;
12804 : }
12805 : if (TREE_TYPE (_o1[0]) != sizetype)
12806 : {
12807 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12808 : }
12809 : else
12810 : _r1 = _o1[0];
12811 : res_op0 = _r1;
12812 : }
12813 : tree res_op1;
12814 : res_op1 = rhs_tree;
12815 : tree _r;
12816 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12817 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 987, __FILE__, __LINE__, true);
12818 : return _r;
12819 : }
12820 : next_after_fail1900:;
12821 : }
12822 : }
12823 : }
12824 : }
12825 : }
12826 : }
12827 : }
12828 : }
12829 : }
12830 : break;
12831 : }
12832 : default:;
12833 : }
12834 : break;
12835 : }
12836 0 : case GT_EXPR:
12837 0 : {
12838 0 : tree _q70 = TREE_OPERAND (_p1, 0);
12839 0 : tree _q71 = TREE_OPERAND (_p1, 1);
12840 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
12841 : {
12842 0 : switch (TREE_CODE (_q71))
12843 : {
12844 0 : case POINTER_PLUS_EXPR:
12845 0 : {
12846 0 : tree _q90 = TREE_OPERAND (_q71, 0);
12847 0 : tree _q91 = TREE_OPERAND (_q71, 1);
12848 0 : if ((_q90 == _q21 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q21, 0) && types_match (_q90, _q21)))
12849 : {
12850 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
12851 : {
12852 0 : {
12853 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q71 };
12854 0 : const enum tree_code cmp = LT_EXPR;
12855 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
12856 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
12857 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
12858 : )
12859 : {
12860 0 : {
12861 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
12862 0 : offset_int rhs = off * 2;
12863 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
12864 : )
12865 : {
12866 0 : {
12867 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
12868 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
12869 0 : if (cmp == LT_EXPR
12870 : )
12871 : {
12872 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1901;
12873 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1901;
12874 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1901;
12875 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1901;
12876 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1901;
12877 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1901;
12878 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1901;
12879 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1901;
12880 0 : {
12881 0 : tree res_op0;
12882 0 : {
12883 0 : tree _o1[1], _r1;
12884 0 : {
12885 0 : tree _o2[2], _r2;
12886 0 : _o2[0] = swap_p ? captures[6] : captures[1];
12887 0 : _o2[1] = swap_p ? captures[2] : captures[4];
12888 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12889 0 : _o1[0] = _r2;
12890 : }
12891 0 : if (TREE_TYPE (_o1[0]) != sizetype)
12892 : {
12893 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12894 : }
12895 : else
12896 : _r1 = _o1[0];
12897 0 : res_op0 = _r1;
12898 : }
12899 0 : tree res_op1;
12900 0 : res_op1 = rhs_tree;
12901 0 : tree _r;
12902 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12903 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 986, __FILE__, __LINE__, true);
12904 0 : return _r;
12905 : }
12906 0 : next_after_fail1901:;
12907 : }
12908 : else
12909 : {
12910 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1902;
12911 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1902;
12912 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1902;
12913 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1902;
12914 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1902;
12915 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1902;
12916 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1902;
12917 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1902;
12918 : {
12919 : tree res_op0;
12920 : {
12921 : tree _o1[1], _r1;
12922 : {
12923 : tree _o2[2], _r2;
12924 : {
12925 : tree _o3[2], _r3;
12926 : _o3[0] = swap_p ? captures[4] : captures[2];
12927 : _o3[1] = wide_int_to_tree (sizetype, off);
12928 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
12929 : _o2[0] = _r3;
12930 : }
12931 : _o2[1] = swap_p ? captures[2] : captures[4];
12932 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12933 : _o1[0] = _r2;
12934 : }
12935 : if (TREE_TYPE (_o1[0]) != sizetype)
12936 : {
12937 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12938 : }
12939 : else
12940 : _r1 = _o1[0];
12941 : res_op0 = _r1;
12942 : }
12943 : tree res_op1;
12944 : res_op1 = rhs_tree;
12945 : tree _r;
12946 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12947 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 987, __FILE__, __LINE__, true);
12948 : return _r;
12949 : }
12950 : next_after_fail1902:;
12951 : }
12952 : }
12953 : }
12954 : }
12955 : }
12956 : }
12957 : }
12958 : }
12959 : break;
12960 : }
12961 : default:;
12962 : }
12963 : }
12964 : break;
12965 : }
12966 : default:;
12967 : }
12968 : break;
12969 : }
12970 : default:;
12971 : }
12972 : break;
12973 : }
12974 : default:;
12975 : }
12976 : break;
12977 : }
12978 21015 : case GE_EXPR:
12979 21015 : {
12980 21015 : tree _q20 = TREE_OPERAND (_p0, 0);
12981 21015 : tree _q21 = TREE_OPERAND (_p0, 1);
12982 21015 : switch (TREE_CODE (_q21))
12983 : {
12984 0 : case POINTER_PLUS_EXPR:
12985 0 : {
12986 0 : tree _q40 = TREE_OPERAND (_q21, 0);
12987 0 : tree _q41 = TREE_OPERAND (_q21, 1);
12988 0 : switch (TREE_CODE (_q41))
12989 : {
12990 0 : case INTEGER_CST:
12991 0 : {
12992 0 : switch (TREE_CODE (_p1))
12993 : {
12994 0 : case LE_EXPR:
12995 0 : {
12996 0 : tree _q70 = TREE_OPERAND (_p1, 0);
12997 0 : tree _q71 = TREE_OPERAND (_p1, 1);
12998 0 : switch (TREE_CODE (_q70))
12999 : {
13000 0 : case POINTER_PLUS_EXPR:
13001 0 : {
13002 0 : tree _q80 = TREE_OPERAND (_q70, 0);
13003 0 : tree _q81 = TREE_OPERAND (_q70, 1);
13004 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
13005 : {
13006 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
13007 : {
13008 0 : if ((_q71 == _q40 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q40, 0) && types_match (_q71, _q40)))
13009 : {
13010 0 : {
13011 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q70 };
13012 0 : const enum tree_code cmp = LE_EXPR;
13013 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
13014 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
13015 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
13016 : )
13017 : {
13018 0 : {
13019 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
13020 0 : offset_int rhs = off * 2;
13021 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
13022 : )
13023 : {
13024 0 : {
13025 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
13026 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
13027 0 : if (cmp == LT_EXPR
13028 : )
13029 : {
13030 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1903;
13031 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1903;
13032 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1903;
13033 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1903;
13034 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1903;
13035 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1903;
13036 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1903;
13037 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1903;
13038 : {
13039 : tree res_op0;
13040 : {
13041 : tree _o1[1], _r1;
13042 : {
13043 : tree _o2[2], _r2;
13044 : _o2[0] = swap_p ? captures[6] : captures[1];
13045 : _o2[1] = swap_p ? captures[2] : captures[4];
13046 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
13047 : _o1[0] = _r2;
13048 : }
13049 : if (TREE_TYPE (_o1[0]) != sizetype)
13050 : {
13051 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
13052 : }
13053 : else
13054 : _r1 = _o1[0];
13055 : res_op0 = _r1;
13056 : }
13057 : tree res_op1;
13058 : res_op1 = rhs_tree;
13059 : tree _r;
13060 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
13061 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 986, __FILE__, __LINE__, true);
13062 0 : return _r;
13063 : }
13064 : next_after_fail1903:;
13065 : }
13066 : else
13067 : {
13068 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1904;
13069 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1904;
13070 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1904;
13071 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1904;
13072 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1904;
13073 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1904;
13074 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1904;
13075 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1904;
13076 0 : {
13077 0 : tree res_op0;
13078 0 : {
13079 0 : tree _o1[1], _r1;
13080 0 : {
13081 0 : tree _o2[2], _r2;
13082 0 : {
13083 0 : tree _o3[2], _r3;
13084 0 : _o3[0] = swap_p ? captures[4] : captures[2];
13085 0 : _o3[1] = wide_int_to_tree (sizetype, off);
13086 0 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
13087 0 : _o2[0] = _r3;
13088 : }
13089 0 : _o2[1] = swap_p ? captures[2] : captures[4];
13090 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
13091 0 : _o1[0] = _r2;
13092 : }
13093 0 : if (TREE_TYPE (_o1[0]) != sizetype)
13094 : {
13095 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
13096 : }
13097 : else
13098 : _r1 = _o1[0];
13099 0 : res_op0 = _r1;
13100 : }
13101 0 : tree res_op1;
13102 0 : res_op1 = rhs_tree;
13103 0 : tree _r;
13104 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
13105 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 987, __FILE__, __LINE__, true);
13106 0 : return _r;
13107 : }
13108 0 : next_after_fail1904:;
13109 : }
13110 : }
13111 : }
13112 : }
13113 : }
13114 : }
13115 : }
13116 : }
13117 : }
13118 : break;
13119 : }
13120 : default:;
13121 : }
13122 : break;
13123 : }
13124 0 : case GE_EXPR:
13125 0 : {
13126 0 : tree _q70 = TREE_OPERAND (_p1, 0);
13127 0 : tree _q71 = TREE_OPERAND (_p1, 1);
13128 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
13129 : {
13130 0 : switch (TREE_CODE (_q71))
13131 : {
13132 0 : case POINTER_PLUS_EXPR:
13133 0 : {
13134 0 : tree _q90 = TREE_OPERAND (_q71, 0);
13135 0 : tree _q91 = TREE_OPERAND (_q71, 1);
13136 0 : if ((_q90 == _q20 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q20, 0) && types_match (_q90, _q20)))
13137 : {
13138 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
13139 : {
13140 0 : {
13141 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q71 };
13142 0 : const enum tree_code cmp = LE_EXPR;
13143 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
13144 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
13145 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
13146 : )
13147 : {
13148 0 : {
13149 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
13150 0 : offset_int rhs = off * 2;
13151 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
13152 : )
13153 : {
13154 0 : {
13155 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
13156 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
13157 0 : if (cmp == LT_EXPR
13158 : )
13159 : {
13160 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1905;
13161 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1905;
13162 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1905;
13163 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1905;
13164 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1905;
13165 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1905;
13166 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1905;
13167 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1905;
13168 : {
13169 : tree res_op0;
13170 : {
13171 : tree _o1[1], _r1;
13172 : {
13173 : tree _o2[2], _r2;
13174 : _o2[0] = swap_p ? captures[6] : captures[1];
13175 : _o2[1] = swap_p ? captures[2] : captures[4];
13176 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
13177 : _o1[0] = _r2;
13178 : }
13179 : if (TREE_TYPE (_o1[0]) != sizetype)
13180 : {
13181 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
13182 : }
13183 : else
13184 : _r1 = _o1[0];
13185 : res_op0 = _r1;
13186 : }
13187 : tree res_op1;
13188 : res_op1 = rhs_tree;
13189 : tree _r;
13190 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
13191 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 986, __FILE__, __LINE__, true);
13192 0 : return _r;
13193 : }
13194 : next_after_fail1905:;
13195 : }
13196 : else
13197 : {
13198 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1906;
13199 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1906;
13200 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1906;
13201 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1906;
13202 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1906;
13203 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1906;
13204 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1906;
13205 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1906;
13206 0 : {
13207 0 : tree res_op0;
13208 0 : {
13209 0 : tree _o1[1], _r1;
13210 0 : {
13211 0 : tree _o2[2], _r2;
13212 0 : {
13213 0 : tree _o3[2], _r3;
13214 0 : _o3[0] = swap_p ? captures[4] : captures[2];
13215 0 : _o3[1] = wide_int_to_tree (sizetype, off);
13216 0 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
13217 0 : _o2[0] = _r3;
13218 : }
13219 0 : _o2[1] = swap_p ? captures[2] : captures[4];
13220 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
13221 0 : _o1[0] = _r2;
13222 : }
13223 0 : if (TREE_TYPE (_o1[0]) != sizetype)
13224 : {
13225 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
13226 : }
13227 : else
13228 : _r1 = _o1[0];
13229 0 : res_op0 = _r1;
13230 : }
13231 0 : tree res_op1;
13232 0 : res_op1 = rhs_tree;
13233 0 : tree _r;
13234 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
13235 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 987, __FILE__, __LINE__, true);
13236 0 : return _r;
13237 : }
13238 0 : next_after_fail1906:;
13239 : }
13240 : }
13241 : }
13242 : }
13243 : }
13244 : }
13245 : }
13246 : }
13247 : break;
13248 : }
13249 : default:;
13250 : }
13251 : }
13252 : break;
13253 : }
13254 : default:;
13255 : }
13256 : break;
13257 : }
13258 : default:;
13259 : }
13260 : break;
13261 : }
13262 : default:;
13263 : }
13264 : break;
13265 : }
13266 125058 : case GT_EXPR:
13267 125058 : {
13268 125058 : tree _q20 = TREE_OPERAND (_p0, 0);
13269 125058 : tree _q21 = TREE_OPERAND (_p0, 1);
13270 125058 : switch (TREE_CODE (_q21))
13271 : {
13272 0 : case POINTER_PLUS_EXPR:
13273 0 : {
13274 0 : tree _q40 = TREE_OPERAND (_q21, 0);
13275 0 : tree _q41 = TREE_OPERAND (_q21, 1);
13276 0 : switch (TREE_CODE (_q41))
13277 : {
13278 0 : case INTEGER_CST:
13279 0 : {
13280 0 : switch (TREE_CODE (_p1))
13281 : {
13282 0 : case LT_EXPR:
13283 0 : {
13284 0 : tree _q70 = TREE_OPERAND (_p1, 0);
13285 0 : tree _q71 = TREE_OPERAND (_p1, 1);
13286 0 : switch (TREE_CODE (_q70))
13287 : {
13288 0 : case POINTER_PLUS_EXPR:
13289 0 : {
13290 0 : tree _q80 = TREE_OPERAND (_q70, 0);
13291 0 : tree _q81 = TREE_OPERAND (_q70, 1);
13292 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
13293 : {
13294 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
13295 : {
13296 0 : if ((_q71 == _q40 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q40, 0) && types_match (_q71, _q40)))
13297 : {
13298 0 : {
13299 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q70 };
13300 0 : const enum tree_code cmp = LT_EXPR;
13301 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
13302 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
13303 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
13304 : )
13305 : {
13306 0 : {
13307 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
13308 0 : offset_int rhs = off * 2;
13309 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
13310 : )
13311 : {
13312 0 : {
13313 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
13314 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
13315 0 : if (cmp == LT_EXPR
13316 : )
13317 : {
13318 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1907;
13319 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1907;
13320 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1907;
13321 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1907;
13322 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1907;
13323 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1907;
13324 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1907;
13325 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1907;
13326 0 : {
13327 0 : tree res_op0;
13328 0 : {
13329 0 : tree _o1[1], _r1;
13330 0 : {
13331 0 : tree _o2[2], _r2;
13332 0 : _o2[0] = swap_p ? captures[6] : captures[1];
13333 0 : _o2[1] = swap_p ? captures[2] : captures[4];
13334 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
13335 0 : _o1[0] = _r2;
13336 : }
13337 0 : if (TREE_TYPE (_o1[0]) != sizetype)
13338 : {
13339 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
13340 : }
13341 : else
13342 : _r1 = _o1[0];
13343 0 : res_op0 = _r1;
13344 : }
13345 0 : tree res_op1;
13346 0 : res_op1 = rhs_tree;
13347 0 : tree _r;
13348 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
13349 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 986, __FILE__, __LINE__, true);
13350 0 : return _r;
13351 : }
13352 0 : next_after_fail1907:;
13353 : }
13354 : else
13355 : {
13356 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1908;
13357 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1908;
13358 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1908;
13359 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1908;
13360 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1908;
13361 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1908;
13362 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1908;
13363 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1908;
13364 : {
13365 : tree res_op0;
13366 : {
13367 : tree _o1[1], _r1;
13368 : {
13369 : tree _o2[2], _r2;
13370 : {
13371 : tree _o3[2], _r3;
13372 : _o3[0] = swap_p ? captures[4] : captures[2];
13373 : _o3[1] = wide_int_to_tree (sizetype, off);
13374 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
13375 : _o2[0] = _r3;
13376 : }
13377 : _o2[1] = swap_p ? captures[2] : captures[4];
13378 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
13379 : _o1[0] = _r2;
13380 : }
13381 : if (TREE_TYPE (_o1[0]) != sizetype)
13382 : {
13383 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
13384 : }
13385 : else
13386 : _r1 = _o1[0];
13387 : res_op0 = _r1;
13388 : }
13389 : tree res_op1;
13390 : res_op1 = rhs_tree;
13391 : tree _r;
13392 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
13393 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 987, __FILE__, __LINE__, true);
13394 : return _r;
13395 : }
13396 : next_after_fail1908:;
13397 : }
13398 : }
13399 : }
13400 : }
13401 : }
13402 : }
13403 : }
13404 : }
13405 : }
13406 : break;
13407 : }
13408 : default:;
13409 : }
13410 : break;
13411 : }
13412 0 : case GT_EXPR:
13413 0 : {
13414 0 : tree _q70 = TREE_OPERAND (_p1, 0);
13415 0 : tree _q71 = TREE_OPERAND (_p1, 1);
13416 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
13417 : {
13418 0 : switch (TREE_CODE (_q71))
13419 : {
13420 0 : case POINTER_PLUS_EXPR:
13421 0 : {
13422 0 : tree _q90 = TREE_OPERAND (_q71, 0);
13423 0 : tree _q91 = TREE_OPERAND (_q71, 1);
13424 0 : if ((_q90 == _q20 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q20, 0) && types_match (_q90, _q20)))
13425 : {
13426 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
13427 : {
13428 0 : {
13429 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q71 };
13430 0 : const enum tree_code cmp = LT_EXPR;
13431 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
13432 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
13433 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
13434 : )
13435 : {
13436 0 : {
13437 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
13438 0 : offset_int rhs = off * 2;
13439 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
13440 : )
13441 : {
13442 0 : {
13443 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
13444 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
13445 0 : if (cmp == LT_EXPR
13446 : )
13447 : {
13448 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1909;
13449 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1909;
13450 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1909;
13451 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1909;
13452 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1909;
13453 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1909;
13454 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1909;
13455 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1909;
13456 0 : {
13457 0 : tree res_op0;
13458 0 : {
13459 0 : tree _o1[1], _r1;
13460 0 : {
13461 0 : tree _o2[2], _r2;
13462 0 : _o2[0] = swap_p ? captures[6] : captures[1];
13463 0 : _o2[1] = swap_p ? captures[2] : captures[4];
13464 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
13465 0 : _o1[0] = _r2;
13466 : }
13467 0 : if (TREE_TYPE (_o1[0]) != sizetype)
13468 : {
13469 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
13470 : }
13471 : else
13472 : _r1 = _o1[0];
13473 0 : res_op0 = _r1;
13474 : }
13475 0 : tree res_op1;
13476 0 : res_op1 = rhs_tree;
13477 0 : tree _r;
13478 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
13479 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 986, __FILE__, __LINE__, true);
13480 0 : return _r;
13481 : }
13482 0 : next_after_fail1909:;
13483 : }
13484 : else
13485 : {
13486 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1910;
13487 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1910;
13488 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1910;
13489 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1910;
13490 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1910;
13491 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1910;
13492 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1910;
13493 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1910;
13494 : {
13495 : tree res_op0;
13496 : {
13497 : tree _o1[1], _r1;
13498 : {
13499 : tree _o2[2], _r2;
13500 : {
13501 : tree _o3[2], _r3;
13502 : _o3[0] = swap_p ? captures[4] : captures[2];
13503 : _o3[1] = wide_int_to_tree (sizetype, off);
13504 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
13505 : _o2[0] = _r3;
13506 : }
13507 : _o2[1] = swap_p ? captures[2] : captures[4];
13508 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
13509 : _o1[0] = _r2;
13510 : }
13511 : if (TREE_TYPE (_o1[0]) != sizetype)
13512 : {
13513 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
13514 : }
13515 : else
13516 : _r1 = _o1[0];
13517 : res_op0 = _r1;
13518 : }
13519 : tree res_op1;
13520 : res_op1 = rhs_tree;
13521 : tree _r;
13522 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
13523 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 987, __FILE__, __LINE__, true);
13524 : return _r;
13525 : }
13526 : next_after_fail1910:;
13527 : }
13528 : }
13529 : }
13530 : }
13531 : }
13532 : }
13533 : }
13534 : }
13535 : break;
13536 : }
13537 : default:;
13538 : }
13539 : }
13540 : break;
13541 : }
13542 : default:;
13543 : }
13544 : break;
13545 : }
13546 : default:;
13547 : }
13548 : break;
13549 : }
13550 : default:;
13551 : }
13552 : break;
13553 : }
13554 : default:;
13555 : }
13556 : return NULL_TREE;
13557 : }
13558 : #pragma GCC diagnostic pop
|
