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 1222233440 : tree_nop_convert (tree t, tree *res_ops)
11 : {
12 1222233440 : const tree type = TREE_TYPE (t);
13 1222233440 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 1222233440 : if (TREE_SIDE_EFFECTS (t)) return false;
15 1170643311 : switch (TREE_CODE (t))
16 : {
17 231883832 : CASE_CONVERT:
18 231883832 : {
19 231883832 : tree _p0 = TREE_OPERAND (t, 0);
20 231883832 : {
21 231883832 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
22 231883832 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
23 : )
24 : {
25 179768870 : {
26 179768870 : res_ops[0] = captures[0];
27 179768870 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 0, __FILE__, __LINE__, false);
28 179768870 : return true;
29 : }
30 : }
31 : }
32 : break;
33 : }
34 4687387 : case VIEW_CONVERT_EXPR:
35 4687387 : {
36 4687387 : tree _p0 = TREE_OPERAND (t, 0);
37 4687387 : {
38 4687387 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
39 3199921 : if (VECTOR_TYPE_P (type) && VECTOR_TYPE_P (TREE_TYPE (captures[0]))
40 3199903 : && known_eq (TYPE_VECTOR_SUBPARTS (type),
41 : TYPE_VECTOR_SUBPARTS (TREE_TYPE (captures[0])))
42 6898018 : && tree_nop_conversion_p (TREE_TYPE (type), TREE_TYPE (TREE_TYPE (captures[0])))
43 : )
44 : {
45 2210625 : {
46 2210625 : res_ops[0] = captures[0];
47 2210625 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1, __FILE__, __LINE__, false);
48 2210625 : return true;
49 : }
50 : }
51 : }
52 2476762 : break;
53 : }
54 : default:;
55 : }
56 : return false;
57 : }
58 :
59 : bool
60 99615331 : tree_with_known_nonzero_bits (tree t)
61 : {
62 99615331 : const tree type = TREE_TYPE (t);
63 99615331 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
64 99615331 : if (TREE_SIDE_EFFECTS (t)) return false;
65 93406609 : switch (TREE_CODE (t))
66 : {
67 271684 : case BIT_IOR_EXPR:
68 271684 : {
69 271684 : tree _p0 = TREE_OPERAND (t, 0);
70 271684 : tree _p1 = TREE_OPERAND (t, 1);
71 271684 : if (tree_with_known_nonzero_bits_1 (_p0))
72 : {
73 264201 : {
74 264201 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
75 264201 : {
76 264201 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 39, __FILE__, __LINE__, false);
77 264201 : return true;
78 : }
79 : }
80 : }
81 7483 : if (tree_with_known_nonzero_bits_1 (_p1))
82 : {
83 186 : {
84 186 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _p0 };
85 186 : {
86 186 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 39, __FILE__, __LINE__, false);
87 186 : return true;
88 : }
89 : }
90 : }
91 : break;
92 : }
93 93142222 : default:;
94 : }
95 93142222 : if (tree_with_known_nonzero_bits_1 (t))
96 : {
97 40066103 : {
98 40066103 : tree captures[1] ATTRIBUTE_UNUSED = { t };
99 40066103 : {
100 40066103 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 40, __FILE__, __LINE__, false);
101 40066103 : return true;
102 : }
103 : }
104 : }
105 : return false;
106 : }
107 :
108 : tree
109 316 : generic_simplify_4 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
110 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
111 : const enum tree_code ARG_UNUSED (outer_op),
112 : const enum tree_code ARG_UNUSED (inner_op))
113 : {
114 316 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
115 316 : if (real_zerop (captures[2])
116 34 : && real_zerop (captures[3])
117 350 : && !HONOR_SIGN_DEPENDENT_ROUNDING (type)
118 : )
119 : {
120 10 : {
121 10 : bool inner_plus = ((inner_op == PLUS_EXPR)
122 10 : ^ REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (captures[2])));
123 10 : bool outer_plus
124 10 : = ((outer_op == PLUS_EXPR)
125 10 : ^ REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (captures[3])));
126 10 : if (outer_plus && !inner_plus
127 : )
128 : {
129 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail75;
130 2 : {
131 2 : tree res_op0;
132 2 : res_op0 = captures[1];
133 2 : tree res_op1;
134 2 : res_op1 = captures[3];
135 2 : tree _r;
136 2 : _r = fold_build2_loc (loc, outer_op, type, res_op0, res_op1);
137 2 : if (TREE_SIDE_EFFECTS (captures[2]))
138 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
139 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 52, __FILE__, __LINE__, true);
140 2 : return _r;
141 : }
142 0 : next_after_fail75:;
143 : }
144 : else
145 : {
146 8 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail76;
147 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail76;
148 8 : {
149 8 : tree _r;
150 8 : _r = captures[0];
151 8 : if (TREE_SIDE_EFFECTS (captures[3]))
152 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
153 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 53, __FILE__, __LINE__, true);
154 8 : return _r;
155 : }
156 : next_after_fail76:;
157 : }
158 : }
159 : }
160 : return NULL_TREE;
161 : }
162 :
163 : tree
164 833 : generic_simplify_19 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
165 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
166 : {
167 833 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
168 833 : if (!TYPE_SATURATING (type)
169 : )
170 : {
171 833 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
172 1666 : && !FIXED_POINT_TYPE_P (type)
173 : )
174 : {
175 833 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail99;
176 833 : {
177 833 : tree res_op0;
178 833 : res_op0 = captures[2];
179 833 : tree res_op1;
180 833 : res_op1 = captures[1];
181 833 : tree _r;
182 833 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
183 833 : if (TREE_SIDE_EFFECTS (captures[0]))
184 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
185 833 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 76, __FILE__, __LINE__, true);
186 833 : return _r;
187 : }
188 0 : next_after_fail99:;
189 : }
190 : }
191 : return NULL_TREE;
192 : }
193 :
194 : tree
195 2315431 : generic_simplify_25 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
196 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
197 : const enum tree_code ARG_UNUSED (plusminus))
198 : {
199 2315431 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
200 2315431 : if (!TYPE_SATURATING (type)
201 2315431 : && (!FLOAT_TYPE_P (type) || flag_associative_math)
202 : )
203 : {
204 110 : if (!ANY_INTEGRAL_TYPE_P (type)
205 2315208 : || TYPE_OVERFLOW_WRAPS (type)
206 4032953 : || (INTEGRAL_TYPE_P (type)
207 1717635 : && tree_expr_nonzero_p (captures[1])
208 3237480 : && expr_not_equal_to (captures[1], wi::minus_one (TYPE_PRECISION (type)),
209 : gimple_match_ctx (captures[0])))
210 : )
211 : {
212 1519541 : if (single_use (captures[0]) || single_use (captures[3])
213 : )
214 : {
215 1519541 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail105;
216 1519541 : {
217 1519541 : tree res_op0;
218 1519541 : {
219 1519541 : tree _o1[2], _r1;
220 1519541 : _o1[0] = captures[2];
221 1519541 : _o1[1] = captures[4];
222 1519541 : _r1 = fold_build2_loc (loc, plusminus, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
223 1519541 : res_op0 = _r1;
224 : }
225 1519541 : tree res_op1;
226 1519541 : res_op1 = captures[1];
227 1519541 : tree _r;
228 1519541 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
229 1519541 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 82, __FILE__, __LINE__, true);
230 1519541 : return _r;
231 : }
232 0 : next_after_fail105:;
233 : }
234 : else
235 : {
236 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail106;
237 : {
238 : tree res_op0;
239 : {
240 : tree _o1[2], _r1;
241 : _o1[0] = captures[2];
242 : _o1[1] = captures[4];
243 : _r1 = fold_build2_loc (loc, plusminus, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
244 : res_op0 = _r1;
245 : }
246 : tree res_op1;
247 : res_op1 = captures[1];
248 : tree _r;
249 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
250 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 83, __FILE__, __LINE__, true);
251 : return _r;
252 : }
253 : next_after_fail106:;
254 : }
255 : }
256 : }
257 : return NULL_TREE;
258 : }
259 :
260 : tree
261 4 : generic_simplify_37 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
262 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
263 : const enum tree_code ARG_UNUSED (log1),
264 : const enum tree_code ARG_UNUSED (log2),
265 : const combined_fn ARG_UNUSED (popcount))
266 : {
267 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
268 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail119;
269 4 : {
270 4 : tree res_op0;
271 4 : {
272 4 : tree _o1[2], _r1;
273 4 : _o1[0] = captures[2];
274 4 : _o1[1] = captures[5];
275 4 : _r1 = fold_build2_loc (loc, log2, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
276 4 : res_op0 = _r1;
277 : }
278 4 : tree _r;
279 4 : _r = maybe_build_call_expr_loc (loc, popcount, type, 1, res_op0);
280 4 : if (!_r)
281 0 : goto next_after_fail119;
282 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 96, __FILE__, __LINE__, true);
283 : return _r;
284 : }
285 : next_after_fail119:;
286 : return NULL_TREE;
287 : }
288 :
289 : tree
290 0 : generic_simplify_43 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
291 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
292 : {
293 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
294 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail125;
295 0 : {
296 0 : tree res_op0;
297 0 : res_op0 = unshare_expr (captures[2]);
298 0 : tree res_op1;
299 0 : {
300 0 : tree _o1[2], _r1;
301 0 : _o1[0] = captures[1];
302 0 : _o1[1] = captures[2];
303 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
304 0 : res_op1 = _r1;
305 : }
306 0 : tree _r;
307 0 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
308 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 102, __FILE__, __LINE__, true);
309 : return _r;
310 : }
311 0 : next_after_fail125:;
312 0 : return NULL_TREE;
313 : }
314 :
315 : tree
316 56442 : generic_simplify_50 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
317 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
318 : {
319 56442 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
320 56442 : if (!TYPE_SATURATING (type)
321 : )
322 : {
323 56442 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
324 112873 : && !FIXED_POINT_TYPE_P (type)
325 : )
326 : {
327 56431 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail132;
328 56431 : {
329 56431 : tree res_op0;
330 56431 : res_op0 = captures[1];
331 56431 : tree _r;
332 56431 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
333 56431 : if (TREE_SIDE_EFFECTS (captures[0]))
334 15 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
335 56431 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 108, __FILE__, __LINE__, true);
336 56431 : return _r;
337 : }
338 0 : next_after_fail132:;
339 : }
340 : }
341 : return NULL_TREE;
342 : }
343 :
344 : tree
345 11113 : generic_simplify_57 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
346 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
347 : {
348 11113 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
349 11113 : if (!TYPE_SATURATING (type)
350 : )
351 : {
352 11113 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
353 22226 : && !FIXED_POINT_TYPE_P (type)
354 : )
355 : {
356 11113 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
357 11113 : || (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
358 2982 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1])))
359 : )
360 : {
361 10999 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail143;
362 10999 : {
363 10999 : tree res_op0;
364 10999 : res_op0 = captures[1];
365 10999 : tree _r;
366 10999 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
367 10999 : if (TREE_SIDE_EFFECTS (captures[2]))
368 15 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
369 10999 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 119, __FILE__, __LINE__, true);
370 10999 : return _r;
371 : }
372 0 : next_after_fail143:;
373 : }
374 : }
375 : }
376 : return NULL_TREE;
377 : }
378 :
379 : tree
380 4 : generic_simplify_63 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
381 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
382 : const enum tree_code ARG_UNUSED (log1),
383 : const enum tree_code ARG_UNUSED (log2),
384 : const combined_fn ARG_UNUSED (popcount))
385 : {
386 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
387 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail151;
388 4 : {
389 4 : tree res_op0;
390 4 : {
391 4 : tree _o1[2], _r1;
392 4 : _o1[0] = captures[2];
393 4 : _o1[1] = captures[4];
394 4 : _r1 = fold_build2_loc (loc, log2, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
395 4 : res_op0 = _r1;
396 : }
397 4 : tree _r;
398 4 : _r = maybe_build_call_expr_loc (loc, popcount, type, 1, res_op0);
399 4 : if (!_r)
400 0 : goto next_after_fail151;
401 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 127, __FILE__, __LINE__, true);
402 : return _r;
403 : }
404 : next_after_fail151:;
405 : return NULL_TREE;
406 : }
407 :
408 : tree
409 36 : generic_simplify_67 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
410 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
411 : const enum tree_code ARG_UNUSED (bitop),
412 : const enum tree_code ARG_UNUSED (cmp))
413 : {
414 36 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
415 72 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
416 36 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
417 72 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == TYPE_PRECISION (TREE_TYPE (captures[2]))
418 : )
419 : {
420 36 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail155;
421 36 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail155;
422 36 : {
423 36 : tree res_op0;
424 36 : {
425 36 : tree _o1[2], _r1;
426 36 : _o1[0] = captures[0];
427 36 : {
428 36 : tree _o2[1], _r2;
429 36 : _o2[0] = captures[2];
430 36 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
431 : {
432 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
433 : }
434 : else
435 : _r2 = _o2[0];
436 36 : _o1[1] = _r2;
437 : }
438 36 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
439 36 : res_op0 = _r1;
440 : }
441 36 : tree res_op1;
442 36 : res_op1 = captures[1];
443 36 : tree _r;
444 36 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
445 36 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 131, __FILE__, __LINE__, true);
446 36 : return _r;
447 : }
448 : next_after_fail155:;
449 : }
450 : return NULL_TREE;
451 : }
452 :
453 : tree
454 0 : generic_simplify_79 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
455 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
456 : const enum tree_code ARG_UNUSED (op))
457 : {
458 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
459 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail171;
460 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail171;
461 0 : {
462 0 : tree _r;
463 0 : _r = captures[0];
464 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 142, __FILE__, __LINE__, true);
465 : return _r;
466 : }
467 : next_after_fail171:;
468 : return NULL_TREE;
469 : }
470 :
471 : tree
472 516785 : generic_simplify_88 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
473 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
474 : const enum tree_code ARG_UNUSED (op))
475 : {
476 516785 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
477 516785 : {
478 516785 : bool wascmp;
479 516785 : if (types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
480 516785 : && bitwise_inverted_equal_p (captures[0], captures[1], wascmp)
481 : )
482 : {
483 47 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail180;
484 47 : {
485 47 : tree res_op0;
486 47 : res_op0 = wascmp
487 47 : ? constant_boolean_node (true, type)
488 40 : : build_all_ones_cst (TREE_TYPE (captures[0]));
489 47 : tree _r;
490 47 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
491 47 : if (TREE_SIDE_EFFECTS (captures[0]))
492 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
493 47 : if (TREE_SIDE_EFFECTS (captures[1]))
494 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
495 47 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 147, __FILE__, __LINE__, true);
496 47 : return _r;
497 : }
498 0 : next_after_fail180:;
499 : }
500 : }
501 516738 : return NULL_TREE;
502 : }
503 :
504 : tree
505 3815137 : generic_simplify_104 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
506 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
507 : const enum tree_code ARG_UNUSED (bitop))
508 : {
509 3815137 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
510 3815137 : if (((TREE_CODE (captures[3]) == INTEGER_CST
511 1673519 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
512 1493574 : && (int_fits_type_p (captures[3], TREE_TYPE (captures[1]))
513 10880 : || tree_nop_conversion_p (TREE_TYPE (captures[1]), type)))
514 2330155 : || types_match (captures[1], captures[3]))
515 1892090 : && !POINTER_TYPE_P (TREE_TYPE (captures[1]))
516 1892090 : && !VECTOR_TYPE_P (TREE_TYPE (captures[1]))
517 1892087 : && TREE_CODE (TREE_TYPE (captures[1])) != OFFSET_TYPE
518 1892087 : && (bitop != BIT_AND_EXPR ||
519 :
520 : )
521 3815137 : && (
522 91282 : TYPE_PRECISION (TREE_TYPE (captures[1])) < TYPE_PRECISION (type)
523 : || (
524 :
525 : && TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (type))
526 90228 : || GET_MODE_CLASS (TYPE_MODE (type)) != MODE_INT
527 90228 : || !type_has_mode_precision_p (type)
528 90228 : || (
529 :
530 : && TREE_CODE (captures[3]) != INTEGER_CST
531 : && tree_nop_conversion_p (type, TREE_TYPE (captures[1]))
532 : && single_use (captures[0])
533 : && single_use (captures[2])))
534 : )
535 : {
536 1057 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail200;
537 1057 : {
538 1057 : tree res_op0;
539 1057 : {
540 1057 : tree _o1[2], _r1;
541 1057 : _o1[0] = captures[1];
542 1057 : {
543 1057 : tree _o2[1], _r2;
544 1057 : _o2[0] = captures[3];
545 1057 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
546 : {
547 1057 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
548 : }
549 : else
550 : _r2 = _o2[0];
551 1057 : _o1[1] = _r2;
552 : }
553 1057 : _r1 = fold_build2_loc (loc, bitop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
554 1057 : res_op0 = _r1;
555 : }
556 1057 : tree _r;
557 1057 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
558 1057 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 158, __FILE__, __LINE__, true);
559 1057 : return _r;
560 : }
561 0 : next_after_fail200:;
562 : }
563 : return NULL_TREE;
564 : }
565 :
566 : tree
567 0 : generic_simplify_118 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
568 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
569 : const enum tree_code ARG_UNUSED (op))
570 : {
571 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
572 0 : if (INTEGRAL_TYPE_P (type)
573 0 : && (tree_nonzero_bits (captures[0]) & tree_nonzero_bits (captures[2])) == 0
574 : )
575 : {
576 0 : {
577 0 : tree t = type;
578 0 : if (!TYPE_OVERFLOW_WRAPS (t))
579 0 : t = unsigned_type_for (t);
580 0 : wide_int c = wi::add (wi::to_wide (captures[3]), 1);
581 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail215;
582 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail215;
583 0 : {
584 0 : tree res_op0;
585 0 : {
586 0 : tree _o1[2], _r1;
587 0 : {
588 0 : tree _o2[1], _r2;
589 0 : _o2[0] = captures[2];
590 0 : if (TREE_TYPE (_o2[0]) != t)
591 : {
592 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, t, _o2[0]);
593 : }
594 : else
595 : _r2 = _o2[0];
596 0 : _o1[0] = _r2;
597 : }
598 0 : _o1[1] = wide_int_to_tree (t, c);
599 0 : _r1 = fold_build2_loc (loc, MULT_EXPR, t, _o1[0], _o1[1]);
600 0 : res_op0 = _r1;
601 : }
602 0 : tree _r;
603 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
604 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 168, __FILE__, __LINE__, true);
605 0 : return _r;
606 : }
607 0 : next_after_fail215:;
608 0 : }
609 : }
610 : return NULL_TREE;
611 : }
612 :
613 : tree
614 4 : generic_simplify_126 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
615 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
616 : {
617 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
618 4 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail229;
619 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail229;
620 4 : {
621 4 : tree _r;
622 4 : _r = captures[2];
623 4 : if (TREE_SIDE_EFFECTS (captures[1]))
624 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
625 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 182, __FILE__, __LINE__, true);
626 : return _r;
627 : }
628 : next_after_fail229:;
629 : return NULL_TREE;
630 : }
631 :
632 : tree
633 0 : generic_simplify_132 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
634 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
635 : const enum tree_code ARG_UNUSED (cmp))
636 : {
637 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
638 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail253;
639 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail253;
640 0 : {
641 0 : tree res_op0;
642 0 : {
643 0 : tree _o1[2], _r1;
644 0 : _o1[0] = build_zero_cst (TREE_TYPE (captures[0]));
645 0 : _o1[1] = captures[2];
646 0 : _r1 = fold_build2_loc (loc, cmp, type, _o1[0], _o1[1]);
647 0 : res_op0 = _r1;
648 : }
649 0 : tree res_op1;
650 0 : res_op1 = captures[3];
651 0 : tree _r;
652 0 : _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
653 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 199, __FILE__, __LINE__, true);
654 : return _r;
655 : }
656 : next_after_fail253:;
657 : return NULL_TREE;
658 : }
659 :
660 : tree
661 0 : generic_simplify_137 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
662 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
663 : const enum tree_code ARG_UNUSED (code2),
664 : const enum tree_code ARG_UNUSED (code1))
665 : {
666 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
667 0 : if ((TREE_CODE (captures[2]) == INTEGER_CST
668 0 : && TREE_CODE (captures[5]) == INTEGER_CST)
669 0 : || ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
670 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[2])))
671 0 : || POINTER_TYPE_P (TREE_TYPE (captures[2])))
672 0 : && bitwise_equal_p (captures[2], captures[5]))
673 : )
674 : {
675 0 : {
676 0 : bool one_before = false;
677 0 : bool one_after = false;
678 0 : int cmp = 0;
679 0 : bool allbits = true;
680 0 : if (TREE_CODE (captures[2]) == INTEGER_CST
681 0 : && TREE_CODE (captures[5]) == INTEGER_CST)
682 : {
683 0 : allbits = TYPE_PRECISION (TREE_TYPE (captures[2])) <= TYPE_PRECISION (TREE_TYPE (captures[5]));
684 0 : auto t1 = wi::to_wide (fold_convert (TREE_TYPE (captures[5]), captures[2]));
685 0 : auto t2 = wi::to_wide (captures[5]);
686 0 : cmp = wi::cmp (t1, t2, TYPE_SIGN (TREE_TYPE (captures[5])));
687 0 : if (cmp < 0
688 0 : && t1 == t2 - 1)
689 : one_before = true;
690 0 : if (cmp > 0
691 0 : && t1 == t2 + 1)
692 : one_after = true;
693 : }
694 0 : bool val;
695 0 : switch (code2)
696 : {
697 0 : case EQ_EXPR: val = (cmp == 0); break;
698 0 : case NE_EXPR: val = (cmp != 0); break;
699 0 : case LT_EXPR: val = (cmp < 0); break;
700 0 : case GT_EXPR: val = (cmp > 0); break;
701 0 : case LE_EXPR: val = (cmp <= 0); break;
702 0 : case GE_EXPR: val = (cmp >= 0); break;
703 0 : default: gcc_unreachable ();
704 : }
705 0 : if (code1 == EQ_EXPR && val
706 : )
707 : {
708 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail259;
709 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail259;
710 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail259;
711 0 : {
712 0 : tree _r;
713 0 : _r = captures[3];
714 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 184, __FILE__, __LINE__, true);
715 0 : return _r;
716 : }
717 : next_after_fail259:;
718 : }
719 : else
720 : {
721 0 : if (code1 == NE_EXPR && val && allbits
722 : )
723 : {
724 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail260;
725 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail260;
726 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail260;
727 0 : {
728 0 : tree _r;
729 0 : _r = constant_boolean_node (true, type);
730 0 : if (TREE_SIDE_EFFECTS (captures[1]))
731 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
732 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 185, __FILE__, __LINE__, true);
733 0 : return _r;
734 : }
735 : next_after_fail260:;
736 : }
737 : else
738 : {
739 0 : if (code1 == NE_EXPR && !val && allbits
740 : )
741 : {
742 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail261;
743 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail261;
744 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail261;
745 0 : {
746 0 : tree _r;
747 0 : _r = captures[0];
748 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 186, __FILE__, __LINE__, true);
749 0 : return _r;
750 : }
751 : next_after_fail261:;
752 : }
753 : else
754 : {
755 0 : if (code1 == EQ_EXPR
756 0 : && code2 == GT_EXPR
757 0 : && cmp == 0
758 0 : && allbits
759 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
760 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GE_EXPR))
761 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
762 : )
763 : {
764 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail262;
765 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail262;
766 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail262;
767 0 : {
768 0 : tree res_op0;
769 0 : res_op0 = captures[4];
770 0 : tree res_op1;
771 0 : res_op1 = captures[5];
772 0 : tree _r;
773 0 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
774 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 187, __FILE__, __LINE__, true);
775 0 : return _r;
776 : }
777 : next_after_fail262:;
778 : }
779 : else
780 : {
781 0 : if (code1 == EQ_EXPR
782 0 : && code2 == LT_EXPR
783 0 : && cmp == 0
784 0 : && allbits
785 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
786 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LE_EXPR))
787 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
788 : )
789 : {
790 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail263;
791 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail263;
792 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail263;
793 0 : {
794 0 : tree res_op0;
795 0 : res_op0 = captures[4];
796 0 : tree res_op1;
797 0 : res_op1 = captures[5];
798 0 : tree _r;
799 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
800 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 188, __FILE__, __LINE__, true);
801 0 : return _r;
802 : }
803 : next_after_fail263:;
804 : }
805 : else
806 : {
807 0 : if (code1 == EQ_EXPR
808 0 : && code2 == GE_EXPR
809 : && one_before
810 0 : && allbits
811 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
812 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GE_EXPR))
813 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
814 : )
815 : {
816 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail264;
817 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail264;
818 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail264;
819 0 : {
820 0 : tree res_op0;
821 0 : res_op0 = captures[4];
822 0 : tree res_op1;
823 0 : {
824 0 : tree _o1[1], _r1;
825 0 : _o1[0] = captures[2];
826 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
827 : {
828 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
829 : }
830 : else
831 : _r1 = _o1[0];
832 0 : res_op1 = _r1;
833 : }
834 0 : tree _r;
835 0 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
836 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 189, __FILE__, __LINE__, true);
837 0 : return _r;
838 : }
839 : next_after_fail264:;
840 : }
841 : else
842 : {
843 0 : if (code1 == EQ_EXPR
844 0 : && code2 == LE_EXPR
845 : && one_after
846 0 : && allbits
847 0 : && ((VECTOR_BOOLEAN_TYPE_P (type)
848 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LE_EXPR))
849 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
850 : )
851 : {
852 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail265;
853 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail265;
854 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail265;
855 0 : {
856 0 : tree res_op0;
857 0 : res_op0 = captures[4];
858 0 : tree res_op1;
859 0 : {
860 0 : tree _o1[1], _r1;
861 0 : _o1[0] = captures[2];
862 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
863 : {
864 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
865 : }
866 : else
867 : _r1 = _o1[0];
868 0 : res_op1 = _r1;
869 : }
870 0 : tree _r;
871 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
872 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 190, __FILE__, __LINE__, true);
873 0 : return _r;
874 : }
875 : next_after_fail265:;
876 : }
877 : }
878 : }
879 : }
880 : }
881 : }
882 : }
883 : }
884 : }
885 : return NULL_TREE;
886 : }
887 :
888 : tree
889 8395623 : generic_simplify_180 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
890 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
891 : const enum tree_code ARG_UNUSED (op))
892 : {
893 8395623 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
894 8395623 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail317;
895 8395623 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail317;
896 8395623 : {
897 8395623 : tree res_op0;
898 8395623 : res_op0 = captures[0];
899 8395623 : tree _r;
900 8395623 : _r = non_lvalue_loc (loc, res_op0);
901 8395623 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 236, __FILE__, __LINE__, true);
902 : return _r;
903 : }
904 : next_after_fail317:;
905 : return NULL_TREE;
906 : }
907 :
908 : tree
909 101907 : generic_simplify_187 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
910 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
911 : {
912 101907 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
913 101907 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
914 101907 : && tree_nop_conversion_p (type, TREE_TYPE (captures[1]))
915 : )
916 : {
917 33306 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail326;
918 33306 : {
919 33306 : tree res_op0;
920 33306 : {
921 33306 : tree _o1[1], _r1;
922 33306 : _o1[0] = captures[0];
923 33306 : if (TREE_TYPE (_o1[0]) != type)
924 : {
925 9485 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
926 : }
927 : else
928 : _r1 = _o1[0];
929 33306 : res_op0 = _r1;
930 : }
931 33306 : tree res_op1;
932 33306 : {
933 33306 : tree _o1[1], _r1;
934 33306 : {
935 33306 : tree _o2[1], _r2;
936 33306 : _o2[0] = captures[1];
937 33306 : _r2 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
938 33306 : _o1[0] = _r2;
939 : }
940 33306 : if (TREE_TYPE (_o1[0]) != type)
941 : {
942 7 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
943 : }
944 : else
945 : _r1 = _o1[0];
946 33306 : res_op1 = _r1;
947 : }
948 33306 : tree _r;
949 33306 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
950 33306 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 242, __FILE__, __LINE__, true);
951 33306 : return _r;
952 : }
953 0 : next_after_fail326:;
954 : }
955 : return NULL_TREE;
956 : }
957 :
958 : tree
959 38 : generic_simplify_200 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
960 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
961 : const combined_fn ARG_UNUSED (POW))
962 : {
963 38 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
964 38 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
965 : )
966 : {
967 38 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail340;
968 38 : {
969 38 : tree res_op0;
970 38 : res_op0 = captures[1];
971 38 : tree res_op1;
972 38 : {
973 38 : tree _o1[2], _r1;
974 38 : _o1[0] = captures[2];
975 38 : _o1[1] = captures[4];
976 38 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
977 38 : res_op1 = _r1;
978 : }
979 38 : tree _r;
980 38 : _r = maybe_build_call_expr_loc (loc, POW, type, 2, res_op0, res_op1);
981 38 : if (!_r)
982 0 : goto next_after_fail340;
983 38 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 255, __FILE__, __LINE__, true);
984 38 : return _r;
985 : }
986 : next_after_fail340:;
987 : }
988 : return NULL_TREE;
989 : }
990 :
991 : tree
992 0 : generic_simplify_208 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
993 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
994 : const enum tree_code ARG_UNUSED (op))
995 : {
996 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
997 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail351;
998 0 : {
999 0 : tree _r;
1000 0 : _r = constant_boolean_node (op == NE_EXPR ? true : false, type);
1001 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1002 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1003 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 265, __FILE__, __LINE__, true);
1004 : return _r;
1005 : }
1006 0 : next_after_fail351:;
1007 0 : return NULL_TREE;
1008 : }
1009 :
1010 : tree
1011 1748795 : generic_simplify_213 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1012 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1013 : const enum tree_code ARG_UNUSED (cmp))
1014 : {
1015 1748795 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1016 3497590 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1017 1748795 : && integer_nonzerop (captures[2])
1018 1747005 : && !TREE_OVERFLOW (captures[2])
1019 3495800 : && !TREE_OVERFLOW (captures[3])
1020 : )
1021 : {
1022 1747005 : {
1023 1747005 : tree lo, hi; bool neg_overflow;
1024 1747005 : enum tree_code code = fold_div_compare (cmp, captures[2], captures[3], &lo, &hi,
1025 : &neg_overflow);
1026 1747005 : if (code == LT_EXPR || code == GE_EXPR
1027 : )
1028 : {
1029 41174 : if (TREE_OVERFLOW (lo)
1030 : )
1031 : {
1032 8664 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail356;
1033 8664 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail356;
1034 8664 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail356;
1035 8664 : {
1036 8664 : tree _r;
1037 8664 : _r = build_int_cst (type, (code == LT_EXPR) ^ neg_overflow);
1038 8664 : if (TREE_SIDE_EFFECTS (captures[1]))
1039 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1040 8664 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 270, __FILE__, __LINE__, true);
1041 1747002 : return _r;
1042 : }
1043 3 : next_after_fail356:;
1044 : }
1045 : else
1046 : {
1047 32510 : if (code == LT_EXPR
1048 : )
1049 : {
1050 729 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail357;
1051 729 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail357;
1052 729 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail357;
1053 729 : {
1054 729 : tree res_op0;
1055 729 : res_op0 = captures[1];
1056 729 : tree res_op1;
1057 729 : res_op1 = lo;
1058 729 : tree _r;
1059 729 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
1060 729 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 271, __FILE__, __LINE__, true);
1061 729 : return _r;
1062 : }
1063 3 : next_after_fail357:;
1064 : }
1065 : else
1066 : {
1067 31781 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail358;
1068 31781 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail358;
1069 31781 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail358;
1070 31781 : {
1071 31781 : tree res_op0;
1072 31781 : res_op0 = captures[1];
1073 31781 : tree res_op1;
1074 31781 : res_op1 = lo;
1075 31781 : tree _r;
1076 31781 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
1077 31781 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 272, __FILE__, __LINE__, true);
1078 31781 : return _r;
1079 : }
1080 3 : next_after_fail358:;
1081 : }
1082 : }
1083 : }
1084 : else
1085 : {
1086 1705831 : if (code == LE_EXPR || code == GT_EXPR
1087 : )
1088 : {
1089 1702778 : if (TREE_OVERFLOW (hi)
1090 : )
1091 : {
1092 536332 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail359;
1093 536332 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail359;
1094 536332 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail359;
1095 536332 : {
1096 536332 : tree _r;
1097 536332 : _r = build_int_cst (type, (code == LE_EXPR) ^ neg_overflow);
1098 536332 : if (TREE_SIDE_EFFECTS (captures[1]))
1099 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1100 536332 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 273, __FILE__, __LINE__, true);
1101 536332 : return _r;
1102 : }
1103 3 : next_after_fail359:;
1104 : }
1105 : else
1106 : {
1107 1166446 : if (code == LE_EXPR
1108 : )
1109 : {
1110 684 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail360;
1111 684 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail360;
1112 684 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail360;
1113 684 : {
1114 684 : tree res_op0;
1115 684 : res_op0 = captures[1];
1116 684 : tree res_op1;
1117 684 : res_op1 = hi;
1118 684 : tree _r;
1119 684 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1120 684 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 274, __FILE__, __LINE__, true);
1121 684 : return _r;
1122 : }
1123 3 : next_after_fail360:;
1124 : }
1125 : else
1126 : {
1127 1165762 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail361;
1128 1165762 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail361;
1129 1165762 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail361;
1130 1165762 : {
1131 1165762 : tree res_op0;
1132 1165762 : res_op0 = captures[1];
1133 1165762 : tree res_op1;
1134 1165762 : res_op1 = hi;
1135 1165762 : tree _r;
1136 1165762 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
1137 1165762 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 275, __FILE__, __LINE__, true);
1138 1165762 : return _r;
1139 : }
1140 3 : next_after_fail361:;
1141 : }
1142 : }
1143 : }
1144 : else
1145 : {
1146 3053 : if (!lo && !hi
1147 : )
1148 : {
1149 40 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail362;
1150 40 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail362;
1151 40 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail362;
1152 40 : {
1153 40 : tree _r;
1154 40 : _r = build_int_cst (type, code == NE_EXPR);
1155 40 : if (TREE_SIDE_EFFECTS (captures[1]))
1156 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1157 40 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 276, __FILE__, __LINE__, true);
1158 40 : return _r;
1159 : }
1160 3 : next_after_fail362:;
1161 : }
1162 : else
1163 : {
1164 3013 : if (code == EQ_EXPR && !hi
1165 : )
1166 : {
1167 15 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail363;
1168 15 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail363;
1169 15 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail363;
1170 15 : {
1171 15 : tree res_op0;
1172 15 : res_op0 = captures[1];
1173 15 : tree res_op1;
1174 15 : res_op1 = lo;
1175 15 : tree _r;
1176 15 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
1177 15 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 277, __FILE__, __LINE__, true);
1178 15 : return _r;
1179 : }
1180 3 : next_after_fail363:;
1181 : }
1182 : else
1183 : {
1184 910 : if (code == EQ_EXPR && !lo
1185 : )
1186 : {
1187 11 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail364;
1188 11 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail364;
1189 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail364;
1190 11 : {
1191 11 : tree res_op0;
1192 11 : res_op0 = captures[1];
1193 11 : tree res_op1;
1194 11 : res_op1 = hi;
1195 11 : tree _r;
1196 11 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1197 11 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 278, __FILE__, __LINE__, true);
1198 11 : return _r;
1199 : }
1200 3 : next_after_fail364:;
1201 : }
1202 : else
1203 : {
1204 2987 : if (code == NE_EXPR && !hi
1205 : )
1206 : {
1207 4 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail365;
1208 4 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail365;
1209 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail365;
1210 4 : {
1211 4 : tree res_op0;
1212 4 : res_op0 = captures[1];
1213 4 : tree res_op1;
1214 4 : res_op1 = lo;
1215 4 : tree _r;
1216 4 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
1217 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 279, __FILE__, __LINE__, true);
1218 4 : return _r;
1219 : }
1220 3 : next_after_fail365:;
1221 : }
1222 : else
1223 : {
1224 2084 : if (code == NE_EXPR && !lo
1225 : )
1226 : {
1227 18 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail366;
1228 18 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail366;
1229 18 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail366;
1230 18 : {
1231 18 : tree res_op0;
1232 18 : res_op0 = captures[1];
1233 18 : tree res_op1;
1234 18 : res_op1 = hi;
1235 18 : tree _r;
1236 18 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
1237 18 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 280, __FILE__, __LINE__, true);
1238 18 : return _r;
1239 : }
1240 3 : next_after_fail366:;
1241 : }
1242 : else
1243 : {
1244 2965 : if (1
1245 : )
1246 : {
1247 2965 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail367;
1248 2962 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail367;
1249 2962 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail367;
1250 2962 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail367;
1251 2962 : {
1252 2962 : tree _r;
1253 2962 : _r = build_range_check (UNKNOWN_LOCATION, type, captures[1], code == EQ_EXPR,
1254 : lo, hi);
1255 2962 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 281, __FILE__, __LINE__, true);
1256 2962 : return _r;
1257 : }
1258 3 : next_after_fail367:;
1259 : }
1260 : else
1261 : {
1262 : {
1263 : tree etype = range_check_type (TREE_TYPE (captures[1]));
1264 : if (etype)
1265 : {
1266 : hi = fold_convert (etype, hi);
1267 : lo = fold_convert (etype, lo);
1268 : hi = const_binop (MINUS_EXPR, etype, hi, lo);
1269 : }
1270 : if (etype && hi && !TREE_OVERFLOW (hi)
1271 : )
1272 : {
1273 : if (code == EQ_EXPR
1274 : )
1275 : {
1276 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail368;
1277 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail368;
1278 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail368;
1279 : {
1280 : tree res_op0;
1281 : {
1282 : tree _o1[2], _r1;
1283 : {
1284 : tree _o2[1], _r2;
1285 : _o2[0] = captures[1];
1286 : if (TREE_TYPE (_o2[0]) != etype)
1287 : {
1288 : _r2 = fold_build1_loc (loc, NOP_EXPR, etype, _o2[0]);
1289 : }
1290 : else
1291 : _r2 = _o2[0];
1292 : _o1[0] = _r2;
1293 : }
1294 : _o1[1] = lo;
1295 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1296 : res_op0 = _r1;
1297 : }
1298 : tree res_op1;
1299 : res_op1 = hi;
1300 : tree _r;
1301 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1302 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 282, __FILE__, __LINE__, true);
1303 : return _r;
1304 : }
1305 : next_after_fail368:;
1306 : }
1307 : else
1308 : {
1309 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail369;
1310 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail369;
1311 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail369;
1312 : {
1313 : tree res_op0;
1314 : {
1315 : tree _o1[2], _r1;
1316 : {
1317 : tree _o2[1], _r2;
1318 : _o2[0] = captures[1];
1319 : if (TREE_TYPE (_o2[0]) != etype)
1320 : {
1321 : _r2 = fold_build1_loc (loc, NOP_EXPR, etype, _o2[0]);
1322 : }
1323 : else
1324 : _r2 = _o2[0];
1325 : _o1[0] = _r2;
1326 : }
1327 : _o1[1] = lo;
1328 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1329 : res_op0 = _r1;
1330 : }
1331 : tree res_op1;
1332 : res_op1 = hi;
1333 : tree _r;
1334 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
1335 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 283, __FILE__, __LINE__, true);
1336 : return _r;
1337 : }
1338 : next_after_fail369:;
1339 : }
1340 : }
1341 : }
1342 : }
1343 : }
1344 : }
1345 : }
1346 : }
1347 : }
1348 : }
1349 : }
1350 : }
1351 : }
1352 : return NULL_TREE;
1353 : }
1354 :
1355 : tree
1356 145162 : generic_simplify_270 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1357 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1358 : const enum tree_code ARG_UNUSED (cmp))
1359 : {
1360 145162 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1361 145162 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail500;
1362 145162 : {
1363 145162 : tree res_op0;
1364 145162 : {
1365 145162 : tree _o1[2], _r1;
1366 145162 : _o1[0] = captures[0];
1367 145162 : {
1368 145162 : tree _o2[1], _r2;
1369 145162 : _o2[0] = captures[1];
1370 145162 : _r2 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
1371 145162 : if (EXPR_P (_r2))
1372 145133 : goto next_after_fail500;
1373 29 : _o1[1] = _r2;
1374 : }
1375 29 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1376 29 : res_op0 = _r1;
1377 : }
1378 29 : tree res_op1;
1379 29 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
1380 29 : tree _r;
1381 29 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1382 29 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 404, __FILE__, __LINE__, true);
1383 : return _r;
1384 : }
1385 : next_after_fail500:;
1386 : return NULL_TREE;
1387 : }
1388 :
1389 : tree
1390 32532539 : generic_simplify_274 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1391 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1392 : const enum tree_code ARG_UNUSED (cmp))
1393 : {
1394 32532539 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1395 32532539 : if (tree_expr_nonzero_p (captures[0])
1396 : )
1397 : {
1398 1312914 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail504;
1399 1312914 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail504;
1400 1312914 : {
1401 1312914 : tree _r;
1402 1312914 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1403 1312914 : if (TREE_SIDE_EFFECTS (captures[0]))
1404 7785 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1405 1312914 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 408, __FILE__, __LINE__, true);
1406 1312914 : return _r;
1407 : }
1408 : next_after_fail504:;
1409 : }
1410 : return NULL_TREE;
1411 : }
1412 :
1413 : tree
1414 81 : generic_simplify_279 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1415 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1416 : const enum tree_code ARG_UNUSED (sgncmp),
1417 : const enum tree_code ARG_UNUSED (cmp),
1418 : const enum tree_code ARG_UNUSED (ncmp))
1419 : {
1420 81 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1421 162 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1422 81 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1423 162 : && types_match (captures[0], captures[2])
1424 : )
1425 : {
1426 81 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail509;
1427 81 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail509;
1428 81 : {
1429 81 : tree res_op0;
1430 81 : {
1431 81 : tree _o1[2], _r1;
1432 81 : _o1[0] = captures[0];
1433 81 : _o1[1] = captures[2];
1434 81 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1435 81 : res_op0 = _r1;
1436 : }
1437 81 : tree res_op1;
1438 81 : res_op1 = captures[1];
1439 81 : tree _r;
1440 81 : _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
1441 81 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 412, __FILE__, __LINE__, true);
1442 81 : return _r;
1443 : }
1444 : next_after_fail509:;
1445 : }
1446 : return NULL_TREE;
1447 : }
1448 :
1449 : tree
1450 3049957 : generic_simplify_283 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1451 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1452 : const enum tree_code ARG_UNUSED (cmp))
1453 : {
1454 3049957 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1455 3049957 : {
1456 3049957 : poly_int64 off0, off1;
1457 3049957 : tree base0, base1;
1458 3049957 : int equal = address_compare (cmp, TREE_TYPE (captures[0]), captures[1], captures[2], base0, base1,
1459 : off0, off1,
1460 : 1
1461 : );
1462 3049957 : if (equal == 1
1463 : )
1464 : {
1465 3015385 : if (cmp == EQ_EXPR && (known_eq (off0, off1) || known_ne (off0, off1))
1466 : )
1467 : {
1468 217981 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail513;
1469 217981 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail513;
1470 217981 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail513;
1471 217981 : {
1472 217981 : tree _r;
1473 217981 : _r = constant_boolean_node (known_eq (off0, off1), type);
1474 217981 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 415, __FILE__, __LINE__, true);
1475 3033190 : return _r;
1476 : }
1477 16767 : next_after_fail513:;
1478 : }
1479 : else
1480 : {
1481 2739495 : if (cmp == NE_EXPR && (known_eq (off0, off1) || known_ne (off0, off1))
1482 : )
1483 : {
1484 2739495 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail514;
1485 2739495 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail514;
1486 2739495 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail514;
1487 2739495 : {
1488 2739495 : tree _r;
1489 2739495 : _r = constant_boolean_node (known_ne (off0, off1), type);
1490 2739495 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 416, __FILE__, __LINE__, true);
1491 2739495 : return _r;
1492 : }
1493 16767 : next_after_fail514:;
1494 : }
1495 : else
1496 : {
1497 50826 : if (cmp == LT_EXPR && (known_lt (off0, off1) || known_ge (off0, off1))
1498 : )
1499 : {
1500 50826 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail515;
1501 50826 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail515;
1502 50826 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail515;
1503 50826 : {
1504 50826 : tree _r;
1505 50826 : _r = constant_boolean_node (known_lt (off0, off1), type);
1506 50826 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 417, __FILE__, __LINE__, true);
1507 50826 : return _r;
1508 : }
1509 16767 : next_after_fail515:;
1510 : }
1511 : else
1512 : {
1513 5390 : if (cmp == LE_EXPR && (known_le (off0, off1) || known_gt (off0, off1))
1514 : )
1515 : {
1516 5390 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail516;
1517 5390 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail516;
1518 5390 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail516;
1519 5390 : {
1520 5390 : tree _r;
1521 5390 : _r = constant_boolean_node (known_le (off0, off1), type);
1522 5390 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 418, __FILE__, __LINE__, true);
1523 5390 : return _r;
1524 : }
1525 16767 : next_after_fail516:;
1526 : }
1527 : else
1528 : {
1529 1200 : if (cmp == GE_EXPR && (known_ge (off0, off1) || known_lt (off0, off1))
1530 : )
1531 : {
1532 1200 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail517;
1533 1200 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail517;
1534 1200 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail517;
1535 1200 : {
1536 1200 : tree _r;
1537 1200 : _r = constant_boolean_node (known_ge (off0, off1), type);
1538 1200 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 419, __FILE__, __LINE__, true);
1539 1200 : return _r;
1540 : }
1541 16767 : next_after_fail517:;
1542 : }
1543 : else
1544 : {
1545 493 : if (cmp == GT_EXPR && (known_gt (off0, off1) || known_le (off0, off1))
1546 : )
1547 : {
1548 493 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail518;
1549 493 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail518;
1550 493 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail518;
1551 493 : {
1552 493 : tree _r;
1553 493 : _r = constant_boolean_node (known_gt (off0, off1), type);
1554 493 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 420, __FILE__, __LINE__, true);
1555 493 : return _r;
1556 : }
1557 16767 : next_after_fail518:;
1558 : }
1559 : }
1560 : }
1561 : }
1562 : }
1563 : }
1564 : }
1565 : else
1566 : {
1567 34572 : if (equal == 0
1568 : )
1569 : {
1570 17805 : if (cmp == EQ_EXPR
1571 : )
1572 : {
1573 11772 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail519;
1574 11772 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail519;
1575 11772 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail519;
1576 11772 : {
1577 11772 : tree _r;
1578 11772 : _r = constant_boolean_node (false, type);
1579 11772 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 421, __FILE__, __LINE__, true);
1580 11772 : return _r;
1581 : }
1582 16767 : next_after_fail519:;
1583 : }
1584 : else
1585 : {
1586 6033 : if (cmp == NE_EXPR
1587 : )
1588 : {
1589 6033 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail520;
1590 6033 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail520;
1591 6033 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail520;
1592 6033 : {
1593 6033 : tree _r;
1594 6033 : _r = constant_boolean_node (true, type);
1595 6033 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 422, __FILE__, __LINE__, true);
1596 6033 : return _r;
1597 : }
1598 16767 : next_after_fail520:;
1599 : }
1600 : }
1601 : }
1602 : }
1603 : }
1604 16767 : return NULL_TREE;
1605 : }
1606 :
1607 : tree
1608 282544 : generic_simplify_298 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1609 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1610 : const enum tree_code ARG_UNUSED (cmp),
1611 : const enum tree_code ARG_UNUSED (icmp),
1612 : const enum tree_code ARG_UNUSED (ncmp))
1613 : {
1614 282544 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1615 282544 : if (types_match (type, TREE_TYPE (captures[0]))
1616 : )
1617 : {
1618 46025 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail561;
1619 46025 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail561;
1620 46025 : {
1621 46025 : tree res_op0;
1622 46025 : res_op0 = captures[1];
1623 46025 : tree res_op1;
1624 46025 : res_op1 = captures[2];
1625 46025 : tree _r;
1626 46025 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1627 46025 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 455, __FILE__, __LINE__, true);
1628 46025 : return _r;
1629 : }
1630 : next_after_fail561:;
1631 : }
1632 : return NULL_TREE;
1633 : }
1634 :
1635 : tree
1636 0 : generic_simplify_304 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1637 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1638 : const combined_fn ARG_UNUSED (COPYSIGN_ALL))
1639 : {
1640 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1641 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail568;
1642 0 : {
1643 0 : tree _r;
1644 0 : _r = captures[0];
1645 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 462, __FILE__, __LINE__, true);
1646 : return _r;
1647 : }
1648 0 : next_after_fail568:;
1649 0 : return NULL_TREE;
1650 : }
1651 :
1652 : tree
1653 2366 : generic_simplify_309 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1654 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1655 : const enum tree_code ARG_UNUSED (div))
1656 : {
1657 2366 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1658 2366 : if (!integer_zerop (captures[1])
1659 : )
1660 : {
1661 1737 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail575;
1662 1737 : {
1663 1737 : tree _r;
1664 1737 : _r = captures[0];
1665 1737 : if (TREE_SIDE_EFFECTS (captures[1]))
1666 59 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1667 1737 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 467, __FILE__, __LINE__, true);
1668 1737 : return _r;
1669 : }
1670 0 : next_after_fail575:;
1671 : }
1672 : return NULL_TREE;
1673 : }
1674 :
1675 : tree
1676 9021 : generic_simplify_315 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1677 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1678 : const enum tree_code ARG_UNUSED (div))
1679 : {
1680 9021 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1681 9021 : {
1682 9021 : wi::overflow_type overflow;
1683 9021 : wide_int mul = wi::mul (wi::to_wide (captures[2]), wi::to_wide (captures[3]),
1684 18042 : TYPE_SIGN (type), &overflow);
1685 9021 : if (div == EXACT_DIV_EXPR
1686 9021 : || optimize_successive_divisions_p (captures[3], captures[0])
1687 : )
1688 : {
1689 0 : if (!overflow
1690 : )
1691 : {
1692 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail581;
1693 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail581;
1694 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail581;
1695 0 : {
1696 0 : tree res_op0;
1697 0 : res_op0 = captures[1];
1698 0 : tree res_op1;
1699 0 : res_op1 = wide_int_to_tree (type, mul);
1700 0 : tree _r;
1701 0 : _r = fold_build2_loc (loc, div, type, res_op0, res_op1);
1702 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 473, __FILE__, __LINE__, true);
1703 0 : return _r;
1704 : }
1705 9021 : next_after_fail581:;
1706 : }
1707 : else
1708 : {
1709 0 : if (TYPE_UNSIGNED (type)
1710 0 : || mul != wi::min_value (TYPE_PRECISION (type), SIGNED)
1711 : )
1712 : {
1713 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail582;
1714 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail582;
1715 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail582;
1716 0 : {
1717 0 : tree _r;
1718 0 : _r = build_zero_cst (type);
1719 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1720 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1721 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 474, __FILE__, __LINE__, true);
1722 0 : return _r;
1723 : }
1724 9021 : next_after_fail582:;
1725 : }
1726 : }
1727 : }
1728 0 : }
1729 9021 : return NULL_TREE;
1730 : }
1731 :
1732 : tree
1733 2 : generic_simplify_328 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1734 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
1735 : {
1736 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1737 0 : if (FLOAT_TYPE_P (type)
1738 2 : && ! HONOR_NANS (type)
1739 2 : && ! HONOR_INFINITIES (type)
1740 : )
1741 : {
1742 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail595;
1743 0 : {
1744 0 : tree _r;
1745 0 : _r = build_minus_one_cst (type);
1746 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1747 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1748 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 487, __FILE__, __LINE__, true);
1749 0 : return _r;
1750 : }
1751 0 : next_after_fail595:;
1752 : }
1753 : return NULL_TREE;
1754 : }
1755 :
1756 : tree
1757 6 : generic_simplify_336 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1758 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1759 : const combined_fn ARG_UNUSED (TAN),
1760 : const combined_fn ARG_UNUSED (SIN),
1761 : const combined_fn ARG_UNUSED (COS))
1762 : {
1763 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1764 6 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1765 : )
1766 : {
1767 6 : if (! HONOR_NANS (captures[1])
1768 6 : && ! HONOR_INFINITIES (captures[1])
1769 : )
1770 : {
1771 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail605;
1772 6 : {
1773 6 : tree res_op0;
1774 6 : res_op0 = build_one_cst (type);
1775 6 : tree res_op1;
1776 6 : {
1777 6 : tree _o1[1], _r1;
1778 6 : _o1[0] = captures[1];
1779 6 : _r1 = maybe_build_call_expr_loc (loc, COS, TREE_TYPE (_o1[0]), 1, _o1[0]);
1780 6 : if (!_r1)
1781 0 : goto next_after_fail605;
1782 6 : res_op1 = _r1;
1783 : }
1784 6 : tree _r;
1785 6 : _r = fold_build2_loc (loc, RDIV_EXPR, type, res_op0, res_op1);
1786 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 497, __FILE__, __LINE__, true);
1787 6 : return _r;
1788 : }
1789 : next_after_fail605:;
1790 : }
1791 : }
1792 : return NULL_TREE;
1793 : }
1794 :
1795 : tree
1796 0 : generic_simplify_345 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1797 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1798 : const enum tree_code ARG_UNUSED (cmp))
1799 : {
1800 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1801 0 : if (INTEGRAL_TYPE_P (type)
1802 : )
1803 : {
1804 0 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail620;
1805 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail620;
1806 0 : {
1807 0 : tree _r;
1808 0 : _r = captures[2];
1809 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1810 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1811 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 512, __FILE__, __LINE__, true);
1812 0 : return _r;
1813 : }
1814 : next_after_fail620:;
1815 : }
1816 : return NULL_TREE;
1817 : }
1818 :
1819 : tree
1820 51 : generic_simplify_349 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1821 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1822 : const enum tree_code ARG_UNUSED (op))
1823 : {
1824 51 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1825 51 : if (bitwise_equal_p (captures[0], captures[2])
1826 1 : && tree_expr_nonzero_p (captures[3])
1827 52 : && expr_no_side_effects_p (captures[2])
1828 : )
1829 : {
1830 1 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail624;
1831 1 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail624;
1832 1 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail624;
1833 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail624;
1834 1 : {
1835 1 : tree _r;
1836 1 : _r = captures[1];
1837 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 515, __FILE__, __LINE__, true);
1838 1 : return _r;
1839 : }
1840 : next_after_fail624:;
1841 : }
1842 : return NULL_TREE;
1843 : }
1844 :
1845 : tree
1846 0 : generic_simplify_354 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1847 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1848 : const enum tree_code ARG_UNUSED (op))
1849 : {
1850 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1851 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail629;
1852 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail629;
1853 0 : {
1854 0 : tree _r;
1855 0 : _r = captures[2];
1856 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 520, __FILE__, __LINE__, true);
1857 : return _r;
1858 : }
1859 : next_after_fail629:;
1860 : return NULL_TREE;
1861 : }
1862 :
1863 : tree
1864 0 : generic_simplify_360 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1865 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1866 : const enum tree_code ARG_UNUSED (op))
1867 : {
1868 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1869 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail635;
1870 0 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail635;
1871 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail635;
1872 0 : {
1873 0 : tree _r;
1874 0 : _r = captures[2];
1875 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 526, __FILE__, __LINE__, true);
1876 : return _r;
1877 : }
1878 : next_after_fail635:;
1879 : return NULL_TREE;
1880 : }
1881 :
1882 : tree
1883 3 : generic_simplify_367 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1884 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1885 : const combined_fn ARG_UNUSED (func))
1886 : {
1887 3 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1888 3 : if (wi::to_widest (captures[4]) == TYPE_PRECISION (TREE_TYPE (captures[3])) - 1
1889 : )
1890 : {
1891 3 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail643;
1892 3 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail643;
1893 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail643;
1894 3 : {
1895 3 : tree _r;
1896 3 : _r = captures[2];
1897 3 : if (TREE_SIDE_EFFECTS (captures[1]))
1898 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1899 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 533, __FILE__, __LINE__, true);
1900 3 : return _r;
1901 : }
1902 : next_after_fail643:;
1903 : }
1904 : return NULL_TREE;
1905 : }
1906 :
1907 : tree
1908 1018 : generic_simplify_376 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1909 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1910 : const enum tree_code ARG_UNUSED (op))
1911 : {
1912 1018 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1913 2036 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1914 2036 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
1915 : )
1916 : {
1917 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail656;
1918 0 : {
1919 0 : tree res_op0;
1920 0 : res_op0 = captures[0];
1921 0 : tree res_op1;
1922 0 : res_op1 = captures[2];
1923 0 : tree _r;
1924 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1925 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1926 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1927 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 546, __FILE__, __LINE__, true);
1928 0 : return _r;
1929 : }
1930 0 : next_after_fail656:;
1931 : }
1932 : return NULL_TREE;
1933 : }
1934 :
1935 : tree
1936 64 : generic_simplify_379 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1937 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1938 : const enum tree_code ARG_UNUSED (minmax),
1939 : const enum tree_code ARG_UNUSED (cmp),
1940 : const enum tree_code ARG_UNUSED (comb))
1941 : {
1942 64 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1943 64 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail660;
1944 64 : {
1945 64 : if (! tree_invariant_p (captures[2])) goto next_after_fail660;
1946 64 : tree res_op0;
1947 64 : {
1948 64 : tree _o1[2], _r1;
1949 64 : _o1[0] = captures[0];
1950 64 : _o1[1] = unshare_expr (captures[2]);
1951 64 : _r1 = fold_build2_loc (loc, cmp, type, _o1[0], _o1[1]);
1952 64 : res_op0 = _r1;
1953 : }
1954 64 : tree res_op1;
1955 64 : {
1956 64 : tree _o1[2], _r1;
1957 64 : _o1[0] = captures[1];
1958 64 : _o1[1] = captures[2];
1959 64 : _r1 = fold_build2_loc (loc, cmp, type, _o1[0], _o1[1]);
1960 64 : res_op1 = _r1;
1961 : }
1962 64 : tree _r;
1963 64 : _r = fold_build2_loc (loc, comb, type, res_op0, res_op1);
1964 64 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 550, __FILE__, __LINE__, true);
1965 : return _r;
1966 : }
1967 : next_after_fail660:;
1968 : return NULL_TREE;
1969 : }
1970 :
1971 : tree
1972 0 : generic_simplify_390 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1973 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1974 : const enum tree_code ARG_UNUSED (cmp),
1975 : const enum tree_code ARG_UNUSED (out))
1976 : {
1977 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1978 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1979 0 : && types_match (TREE_TYPE (captures[1]), TREE_TYPE (captures[2]))
1980 : )
1981 : {
1982 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail703;
1983 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail703;
1984 0 : {
1985 0 : tree res_op0;
1986 0 : {
1987 0 : tree _o1[1], _r1;
1988 0 : _o1[0] = captures[0];
1989 0 : _r1 = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
1990 0 : res_op0 = _r1;
1991 : }
1992 0 : tree res_op1;
1993 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[1]));
1994 0 : tree _r;
1995 0 : _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
1996 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 576, __FILE__, __LINE__, true);
1997 0 : return _r;
1998 : }
1999 : next_after_fail703:;
2000 : }
2001 : return NULL_TREE;
2002 : }
2003 :
2004 : tree
2005 771753 : generic_simplify_397 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2006 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2007 : const enum tree_code ARG_UNUSED (cmp),
2008 : const enum tree_code ARG_UNUSED (icmp))
2009 : {
2010 771753 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2011 1540688 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2012 771753 : && TYPE_UNSIGNED (TREE_TYPE (captures[0]))
2013 358159 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > 1
2014 1901665 : && (wi::to_wide (captures[2])
2015 1846230 : == wi::max_value (TYPE_PRECISION (TREE_TYPE (captures[0])), SIGNED) - 1)
2016 : )
2017 : {
2018 5081 : {
2019 5081 : tree stype = signed_type_for (TREE_TYPE (captures[0]));
2020 5081 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail717;
2021 5081 : {
2022 5081 : tree res_op0;
2023 5081 : {
2024 5081 : tree _o1[1], _r1;
2025 5081 : _o1[0] = captures[0];
2026 5081 : if (TREE_TYPE (_o1[0]) != stype)
2027 : {
2028 5081 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
2029 : }
2030 : else
2031 : _r1 = _o1[0];
2032 5081 : res_op0 = _r1;
2033 : }
2034 5081 : tree res_op1;
2035 5081 : res_op1 = build_int_cst (stype, 0);
2036 5081 : tree _r;
2037 5081 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
2038 5081 : if (TREE_SIDE_EFFECTS (captures[1]))
2039 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2040 5081 : if (TREE_SIDE_EFFECTS (captures[2]))
2041 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2042 5081 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 590, __FILE__, __LINE__, true);
2043 5081 : return _r;
2044 : }
2045 0 : next_after_fail717:;
2046 : }
2047 : }
2048 : return NULL_TREE;
2049 : }
2050 :
2051 : tree
2052 0 : generic_simplify_403 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2053 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2054 : const enum tree_code ARG_UNUSED (cmp),
2055 : const enum tree_code ARG_UNUSED (out))
2056 : {
2057 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2058 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2])) && !VECTOR_TYPE_P (TREE_TYPE (captures[2]))
2059 : )
2060 : {
2061 0 : {
2062 0 : tree t = TREE_TYPE (captures[2]), cpx = build_complex_type (t);
2063 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail723;
2064 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail723;
2065 0 : {
2066 0 : tree res_op0;
2067 0 : {
2068 0 : tree _o1[1], _r1;
2069 0 : {
2070 0 : tree _o2[2], _r2;
2071 0 : _o2[0] = captures[2];
2072 0 : _o2[1] = captures[1];
2073 0 : _r2 = maybe_build_call_expr_loc (loc, CFN_MUL_OVERFLOW, cpx, 2, _o2[0], _o2[1]);
2074 0 : if (!_r2)
2075 0 : goto next_after_fail723;
2076 0 : _o1[0] = _r2;
2077 : }
2078 0 : _r1 = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
2079 0 : res_op0 = _r1;
2080 : }
2081 0 : tree res_op1;
2082 0 : res_op1 = build_zero_cst (t);
2083 0 : tree _r;
2084 0 : _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
2085 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 578, __FILE__, __LINE__, true);
2086 0 : return _r;
2087 : }
2088 : next_after_fail723:;
2089 : }
2090 : }
2091 : return NULL_TREE;
2092 : }
2093 :
2094 : tree
2095 11 : generic_simplify_410 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2096 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2097 : {
2098 11 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2099 11 : if (wi::ltu_p (wi::to_wide (captures[1]), element_precision (type))
2100 : )
2101 : {
2102 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail734;
2103 11 : {
2104 11 : tree res_op0;
2105 11 : {
2106 11 : tree _o1[1], _r1;
2107 11 : _o1[0] = captures[0];
2108 11 : if (TREE_TYPE (_o1[0]) != type)
2109 : {
2110 8 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
2111 : }
2112 : else
2113 : _r1 = _o1[0];
2114 11 : res_op0 = _r1;
2115 : }
2116 11 : tree res_op1;
2117 11 : {
2118 11 : tree _o1[2], _r1;
2119 11 : _o1[0] = build_minus_one_cst (type);
2120 11 : _o1[1] = captures[1];
2121 11 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2122 11 : res_op1 = _r1;
2123 : }
2124 11 : tree _r;
2125 11 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2126 11 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 603, __FILE__, __LINE__, true);
2127 11 : return _r;
2128 : }
2129 0 : next_after_fail734:;
2130 : }
2131 : return NULL_TREE;
2132 : }
2133 :
2134 : tree
2135 267 : generic_simplify_419 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2136 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2137 : const combined_fn ARG_UNUSED (bswap))
2138 : {
2139 267 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2140 267 : if (BITS_PER_UNIT == 8
2141 : && CHAR_TYPE_SIZE == 8
2142 267 : && tree_fits_uhwi_p (captures[2])
2143 : )
2144 : {
2145 267 : {
2146 267 : unsigned HOST_WIDE_INT prec = TYPE_PRECISION (TREE_TYPE (captures[0]));
2147 267 : unsigned HOST_WIDE_INT bits = tree_to_uhwi (captures[2]);
2148 267 : tree st = TYPE_PRECISION (type) > prec ? TREE_TYPE (captures[0]) : type;
2149 267 : if (TYPE_PRECISION (type) > prec
2150 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
2151 0 : && TYPE_UNSIGNED (type)
2152 267 : && bits < prec && bits + 8 >= prec
2153 : )
2154 : {
2155 0 : {
2156 0 : tree nst = build_int_cst (integer_type_node, prec - 8);
2157 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail747;
2158 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail747;
2159 0 : {
2160 0 : tree res_op0;
2161 0 : {
2162 0 : tree _o1[1], _r1;
2163 0 : {
2164 0 : tree _o2[2], _r2;
2165 0 : {
2166 0 : tree _o3[1], _r3;
2167 0 : _o3[0] = captures[1];
2168 0 : if (TREE_TYPE (_o3[0]) != st)
2169 : {
2170 0 : _r3 = fold_build1_loc (loc, NOP_EXPR, st, _o3[0]);
2171 : }
2172 : else
2173 : _r3 = _o3[0];
2174 0 : _o2[0] = _r3;
2175 : }
2176 0 : _o2[1] = nst;
2177 0 : _r2 = fold_build2_loc (loc, LSHIFT_EXPR, st, _o2[0], _o2[1]);
2178 0 : _o1[0] = _r2;
2179 : }
2180 0 : if (TREE_TYPE (_o1[0]) != type)
2181 : {
2182 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2183 : }
2184 : else
2185 : _r1 = _o1[0];
2186 0 : res_op0 = _r1;
2187 : }
2188 0 : tree res_op1;
2189 0 : res_op1 = captures[2];
2190 0 : tree _r;
2191 0 : _r = fold_build2_loc (loc, RSHIFT_EXPR, type, res_op0, res_op1);
2192 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 614, __FILE__, __LINE__, true);
2193 0 : return _r;
2194 : }
2195 : next_after_fail747:;
2196 : }
2197 : }
2198 : else
2199 : {
2200 267 : if (bits + 8 == prec
2201 : )
2202 : {
2203 46 : if (TYPE_UNSIGNED (st)
2204 : )
2205 : {
2206 36 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail748;
2207 36 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail748;
2208 36 : {
2209 36 : tree res_op0;
2210 36 : {
2211 36 : tree _o1[1], _r1;
2212 36 : _o1[0] = captures[1];
2213 36 : if (TREE_TYPE (_o1[0]) != unsigned_char_type_node)
2214 : {
2215 36 : _r1 = fold_build1_loc (loc, NOP_EXPR, unsigned_char_type_node, _o1[0]);
2216 : }
2217 : else
2218 : _r1 = _o1[0];
2219 36 : res_op0 = _r1;
2220 : }
2221 36 : tree _r;
2222 36 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2223 36 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 615, __FILE__, __LINE__, true);
2224 36 : return _r;
2225 : }
2226 : next_after_fail748:;
2227 : }
2228 : else
2229 : {
2230 10 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail749;
2231 10 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail749;
2232 10 : {
2233 10 : tree res_op0;
2234 10 : {
2235 10 : tree _o1[1], _r1;
2236 10 : _o1[0] = captures[1];
2237 10 : if (TREE_TYPE (_o1[0]) != signed_char_type_node)
2238 : {
2239 10 : _r1 = fold_build1_loc (loc, NOP_EXPR, signed_char_type_node, _o1[0]);
2240 : }
2241 : else
2242 : _r1 = _o1[0];
2243 10 : res_op0 = _r1;
2244 : }
2245 10 : tree _r;
2246 10 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2247 10 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 616, __FILE__, __LINE__, true);
2248 10 : return _r;
2249 : }
2250 : next_after_fail749:;
2251 : }
2252 : }
2253 : else
2254 : {
2255 221 : if (bits < prec && bits + 8 > prec
2256 : )
2257 : {
2258 57 : {
2259 57 : tree nst = build_int_cst (integer_type_node, bits & 7);
2260 57 : tree bt = TYPE_UNSIGNED (st) ? unsigned_char_type_node
2261 57 : : signed_char_type_node;
2262 57 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail750;
2263 57 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail750;
2264 57 : {
2265 57 : tree res_op0;
2266 57 : {
2267 57 : tree _o1[2], _r1;
2268 57 : {
2269 57 : tree _o2[1], _r2;
2270 57 : _o2[0] = captures[1];
2271 57 : if (TREE_TYPE (_o2[0]) != bt)
2272 : {
2273 57 : _r2 = fold_build1_loc (loc, NOP_EXPR, bt, _o2[0]);
2274 : }
2275 : else
2276 : _r2 = _o2[0];
2277 57 : _o1[0] = _r2;
2278 : }
2279 57 : _o1[1] = nst;
2280 57 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, bt, _o1[0], _o1[1]);
2281 57 : res_op0 = _r1;
2282 : }
2283 57 : tree _r;
2284 57 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2285 57 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 617, __FILE__, __LINE__, true);
2286 57 : return _r;
2287 : }
2288 : next_after_fail750:;
2289 : }
2290 : }
2291 : }
2292 : }
2293 : }
2294 : }
2295 : return NULL_TREE;
2296 : }
2297 :
2298 : tree
2299 0 : generic_simplify_433 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2300 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2301 : const combined_fn ARG_UNUSED (pow))
2302 : {
2303 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2304 0 : if (flag_unsafe_math_optimizations
2305 : )
2306 : {
2307 0 : if (! HONOR_INFINITIES (type)
2308 0 : && ! flag_trapping_math
2309 0 : && ! flag_errno_math
2310 : )
2311 : {
2312 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail778;
2313 0 : {
2314 0 : tree res_op0;
2315 0 : res_op0 = captures[2];
2316 0 : tree res_op1;
2317 0 : {
2318 0 : tree _o1[1], _r1;
2319 0 : _o1[0] = captures[3];
2320 0 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2321 0 : res_op1 = _r1;
2322 : }
2323 0 : tree _r;
2324 0 : _r = maybe_build_call_expr_loc (loc, pow, type, 2, res_op0, res_op1);
2325 0 : if (!_r)
2326 0 : goto next_after_fail778;
2327 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2328 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2329 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 633, __FILE__, __LINE__, true);
2330 0 : return _r;
2331 : }
2332 : next_after_fail778:;
2333 : }
2334 : }
2335 : return NULL_TREE;
2336 : }
2337 :
2338 : tree
2339 0 : generic_simplify_437 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2340 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2341 : const combined_fn ARG_UNUSED (copysigns),
2342 : const combined_fn ARG_UNUSED (hypots))
2343 : {
2344 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2345 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail782;
2346 0 : {
2347 0 : tree res_op0;
2348 0 : res_op0 = captures[0];
2349 0 : tree res_op1;
2350 0 : res_op1 = captures[2];
2351 0 : tree _r;
2352 0 : _r = maybe_build_call_expr_loc (loc, hypots, type, 2, res_op0, res_op1);
2353 0 : if (!_r)
2354 0 : goto next_after_fail782;
2355 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2356 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2357 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 637, __FILE__, __LINE__, true);
2358 : return _r;
2359 : }
2360 : next_after_fail782:;
2361 : return NULL_TREE;
2362 : }
2363 :
2364 : tree
2365 8 : generic_simplify_442 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2366 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2367 : {
2368 8 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2369 16 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2370 16 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
2371 : )
2372 : {
2373 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail787;
2374 0 : {
2375 0 : tree res_op0;
2376 0 : res_op0 = captures[0];
2377 0 : tree res_op1;
2378 0 : res_op1 = captures[1];
2379 0 : tree _r;
2380 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2381 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 642, __FILE__, __LINE__, true);
2382 0 : return _r;
2383 : }
2384 0 : next_after_fail787:;
2385 : }
2386 : return NULL_TREE;
2387 : }
2388 :
2389 : tree
2390 2 : generic_simplify_447 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2391 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2392 : {
2393 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2394 2 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail792;
2395 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail792;
2396 2 : {
2397 2 : tree res_op0;
2398 2 : res_op0 = captures[0];
2399 2 : tree res_op1;
2400 2 : {
2401 2 : tree _o1[1], _r1;
2402 2 : _o1[0] = captures[5];
2403 2 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2404 2 : res_op1 = _r1;
2405 : }
2406 2 : tree _r;
2407 2 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2408 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 647, __FILE__, __LINE__, true);
2409 : return _r;
2410 : }
2411 : next_after_fail792:;
2412 : return NULL_TREE;
2413 : }
2414 :
2415 : tree
2416 0 : generic_simplify_454 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2417 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2418 : {
2419 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2420 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail799;
2421 0 : {
2422 0 : tree res_op0;
2423 0 : res_op0 = captures[0];
2424 0 : tree res_op1;
2425 0 : res_op1 = captures[1];
2426 0 : tree _r;
2427 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
2428 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 653, __FILE__, __LINE__, true);
2429 : return _r;
2430 : }
2431 0 : next_after_fail799:;
2432 0 : return NULL_TREE;
2433 : }
2434 :
2435 : tree
2436 13 : generic_simplify_458 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2437 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2438 : {
2439 13 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2440 13 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail803;
2441 13 : {
2442 13 : tree _r;
2443 13 : _r = build_zero_cst (type);
2444 13 : if (TREE_SIDE_EFFECTS (captures[0]))
2445 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2446 13 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 657, __FILE__, __LINE__, true);
2447 : return _r;
2448 : }
2449 0 : next_after_fail803:;
2450 0 : return NULL_TREE;
2451 : }
2452 :
2453 : tree
2454 8 : generic_simplify_463 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2455 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2456 : const enum tree_code ARG_UNUSED (eqne))
2457 : {
2458 8 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2459 8 : if (eqne == EQ_EXPR
2460 : )
2461 : {
2462 4 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail809;
2463 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail809;
2464 4 : {
2465 4 : tree _r;
2466 4 : _r = constant_boolean_node (false, type);
2467 4 : if (TREE_SIDE_EFFECTS (captures[2]))
2468 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2469 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 662, __FILE__, __LINE__, true);
2470 4 : return _r;
2471 : }
2472 : next_after_fail809:;
2473 : }
2474 : else
2475 : {
2476 4 : if (eqne == NE_EXPR
2477 : )
2478 : {
2479 4 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail810;
2480 4 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail810;
2481 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail810;
2482 4 : {
2483 4 : tree _r;
2484 4 : _r = captures[0];
2485 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 663, __FILE__, __LINE__, true);
2486 4 : return _r;
2487 : }
2488 : next_after_fail810:;
2489 : }
2490 : }
2491 : return NULL_TREE;
2492 : }
2493 :
2494 : tree
2495 4 : generic_simplify_474 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2496 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2497 : {
2498 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2499 4 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail853;
2500 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail853;
2501 4 : {
2502 4 : tree _r;
2503 4 : _r = captures[2];
2504 4 : if (TREE_SIDE_EFFECTS (captures[1]))
2505 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2506 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 678, __FILE__, __LINE__, true);
2507 : return _r;
2508 : }
2509 : next_after_fail853:;
2510 : return NULL_TREE;
2511 : }
2512 :
2513 : tree
2514 129295 : generic_simplify_478 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2515 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2516 : const enum tree_code ARG_UNUSED (shift))
2517 : {
2518 129295 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2519 129295 : if (tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
2520 129295 : && TYPE_PRECISION (type) <= HOST_BITS_PER_WIDE_INT
2521 129295 : && tree_fits_uhwi_p (captures[4])
2522 129295 : && tree_to_uhwi (captures[4]) > 0
2523 258589 : && tree_to_uhwi (captures[4]) < TYPE_PRECISION (type)
2524 : )
2525 : {
2526 129294 : {
2527 129294 : unsigned int shiftc = tree_to_uhwi (captures[4]);
2528 129294 : unsigned HOST_WIDE_INT mask = TREE_INT_CST_LOW (captures[5]);
2529 129294 : unsigned HOST_WIDE_INT newmask, zerobits = 0;
2530 129294 : tree shift_type = TREE_TYPE (captures[2]);
2531 129294 : unsigned int prec;
2532 129294 : if (shift == LSHIFT_EXPR)
2533 5222 : zerobits = ((HOST_WIDE_INT_1U << shiftc) - 1);
2534 124072 : else if (shift == RSHIFT_EXPR
2535 124072 : && type_has_mode_precision_p (shift_type))
2536 : {
2537 124072 : prec = TYPE_PRECISION (TREE_TYPE (captures[2]));
2538 124072 : tree arg00 = captures[3];
2539 124072 : if (captures[2] != captures[3]
2540 124072 : && TYPE_UNSIGNED (TREE_TYPE (captures[3])))
2541 : {
2542 123814 : tree inner_type = TREE_TYPE (captures[3]);
2543 123814 : if (type_has_mode_precision_p (inner_type)
2544 123814 : && TYPE_PRECISION (inner_type) < prec)
2545 : {
2546 270 : prec = TYPE_PRECISION (inner_type);
2547 270 : if (shiftc < prec)
2548 269 : shift_type = inner_type;
2549 : }
2550 : }
2551 124072 : zerobits = HOST_WIDE_INT_M1U;
2552 124072 : if (shiftc < prec)
2553 : {
2554 124071 : zerobits >>= HOST_BITS_PER_WIDE_INT - shiftc;
2555 124071 : zerobits <<= prec - shiftc;
2556 : }
2557 124072 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[2]))
2558 124072 : && prec == TYPE_PRECISION (TREE_TYPE (captures[2])))
2559 : {
2560 822 : if ((mask & zerobits) == 0)
2561 815 : shift_type = unsigned_type_for (TREE_TYPE (captures[2]));
2562 : else
2563 : zerobits = 0;
2564 : }
2565 : }
2566 129287 : if ((mask & zerobits) == mask
2567 : )
2568 : {
2569 1 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail857;
2570 1 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail857;
2571 1 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail857;
2572 1 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail857;
2573 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail857;
2574 1 : {
2575 1 : tree _r;
2576 1 : _r = build_int_cst (type, 0);
2577 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 682, __FILE__, __LINE__, true);
2578 1 : return _r;
2579 : }
2580 : next_after_fail857:;
2581 : }
2582 : else
2583 : {
2584 129293 : {
2585 129293 : newmask = mask | zerobits;
2586 129293 : if (newmask != mask && (newmask & (newmask + 1)) == 0
2587 : )
2588 : {
2589 : {
2590 7054 : for (prec = BITS_PER_UNIT;
2591 10764 : prec < HOST_BITS_PER_WIDE_INT; prec <<= 1)
2592 8674 : if (newmask == (HOST_WIDE_INT_1U << prec) - 1)
2593 : break;
2594 3710 : if (prec < HOST_BITS_PER_WIDE_INT
2595 2090 : || newmask == HOST_WIDE_INT_M1U
2596 : )
2597 : {
2598 2022 : {
2599 2022 : tree newmaskt = build_int_cst_type (TREE_TYPE (captures[5]), newmask);
2600 2022 : if (!tree_int_cst_equal (newmaskt, captures[5])
2601 : )
2602 : {
2603 2022 : if (shift_type != TREE_TYPE (captures[2])
2604 : )
2605 : {
2606 96 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail858;
2607 96 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail858;
2608 96 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail858;
2609 96 : {
2610 96 : tree res_op0;
2611 96 : {
2612 96 : tree _o1[1], _r1;
2613 96 : {
2614 96 : tree _o2[2], _r2;
2615 96 : {
2616 96 : tree _o3[1], _r3;
2617 96 : _o3[0] = captures[2];
2618 96 : if (TREE_TYPE (_o3[0]) != shift_type)
2619 : {
2620 96 : _r3 = fold_build1_loc (loc, NOP_EXPR, shift_type, _o3[0]);
2621 : }
2622 : else
2623 : _r3 = _o3[0];
2624 96 : _o2[0] = _r3;
2625 : }
2626 96 : _o2[1] = captures[4];
2627 96 : _r2 = fold_build2_loc (loc, shift, shift_type, _o2[0], _o2[1]);
2628 96 : _o1[0] = _r2;
2629 : }
2630 96 : if (TREE_TYPE (_o1[0]) != type)
2631 : {
2632 96 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2633 : }
2634 : else
2635 : _r1 = _o1[0];
2636 96 : res_op0 = _r1;
2637 : }
2638 96 : tree res_op1;
2639 96 : res_op1 = newmaskt;
2640 96 : tree _r;
2641 96 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2642 96 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 683, __FILE__, __LINE__, true);
2643 96 : return _r;
2644 : }
2645 : next_after_fail858:;
2646 : }
2647 : else
2648 : {
2649 1926 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail859;
2650 879 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail859;
2651 879 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail859;
2652 879 : {
2653 879 : tree res_op0;
2654 879 : res_op0 = captures[0];
2655 879 : tree res_op1;
2656 879 : res_op1 = newmaskt;
2657 879 : tree _r;
2658 879 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2659 879 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 684, __FILE__, __LINE__, true);
2660 879 : return _r;
2661 : }
2662 : next_after_fail859:;
2663 : }
2664 : }
2665 : }
2666 : }
2667 : }
2668 : }
2669 : }
2670 : }
2671 : }
2672 : }
2673 : return NULL_TREE;
2674 : }
2675 :
2676 : tree
2677 429896 : generic_simplify_487 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2678 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2679 : const enum tree_code ARG_UNUSED (op))
2680 : {
2681 429896 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2682 859792 : if (INTEGRAL_TYPE_P (type)
2683 429896 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2684 67575 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2685 67575 : && type_has_mode_precision_p (TREE_TYPE (captures[2]))
2686 67575 : && type_has_mode_precision_p (TREE_TYPE (captures[4]))
2687 67575 : && type_has_mode_precision_p (type)
2688 67575 : && TYPE_PRECISION (TREE_TYPE (captures[1])) > TYPE_PRECISION (TREE_TYPE (captures[2]))
2689 52 : && types_match (captures[2], captures[4])
2690 33 : && (tree_int_cst_min_precision (captures[5], TYPE_SIGN (TREE_TYPE (captures[2])))
2691 33 : <= TYPE_PRECISION (TREE_TYPE (captures[2])))
2692 429923 : && (wi::to_wide (captures[5])
2693 429950 : & wi::mask (TYPE_PRECISION (TREE_TYPE (captures[2])),
2694 429950 : true, TYPE_PRECISION (type))) == 0
2695 : )
2696 : {
2697 25 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))
2698 : )
2699 : {
2700 12 : {
2701 12 : tree ntype = TREE_TYPE (captures[2]);
2702 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail875;
2703 12 : {
2704 12 : tree res_op0;
2705 12 : {
2706 12 : tree _o1[2], _r1;
2707 12 : {
2708 12 : tree _o2[2], _r2;
2709 12 : _o2[0] = captures[2];
2710 12 : _o2[1] = captures[4];
2711 12 : _r2 = fold_build2_loc (loc, op, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
2712 12 : _o1[0] = _r2;
2713 : }
2714 12 : {
2715 12 : tree _o2[1], _r2;
2716 12 : _o2[0] = captures[5];
2717 12 : if (TREE_TYPE (_o2[0]) != ntype)
2718 : {
2719 12 : _r2 = fold_build1_loc (loc, NOP_EXPR, ntype, _o2[0]);
2720 : }
2721 : else
2722 : _r2 = _o2[0];
2723 12 : _o1[1] = _r2;
2724 : }
2725 12 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2726 12 : res_op0 = _r1;
2727 : }
2728 12 : tree _r;
2729 12 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2730 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 690, __FILE__, __LINE__, true);
2731 12 : return _r;
2732 : }
2733 0 : next_after_fail875:;
2734 : }
2735 : }
2736 : else
2737 : {
2738 13 : {
2739 13 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
2740 13 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail876;
2741 13 : {
2742 13 : tree res_op0;
2743 13 : {
2744 13 : tree _o1[2], _r1;
2745 13 : {
2746 13 : tree _o2[2], _r2;
2747 13 : {
2748 13 : tree _o3[1], _r3;
2749 13 : _o3[0] = captures[2];
2750 13 : if (TREE_TYPE (_o3[0]) != utype)
2751 : {
2752 13 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
2753 : }
2754 : else
2755 : _r3 = _o3[0];
2756 13 : _o2[0] = _r3;
2757 : }
2758 13 : {
2759 13 : tree _o3[1], _r3;
2760 13 : _o3[0] = captures[4];
2761 13 : if (TREE_TYPE (_o3[0]) != utype)
2762 : {
2763 13 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
2764 : }
2765 : else
2766 : _r3 = _o3[0];
2767 13 : _o2[1] = _r3;
2768 : }
2769 13 : _r2 = fold_build2_loc (loc, op, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
2770 13 : _o1[0] = _r2;
2771 : }
2772 13 : {
2773 13 : tree _o2[1], _r2;
2774 13 : _o2[0] = captures[5];
2775 13 : if (TREE_TYPE (_o2[0]) != utype)
2776 : {
2777 13 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2778 : }
2779 : else
2780 : _r2 = _o2[0];
2781 13 : _o1[1] = _r2;
2782 : }
2783 13 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2784 13 : res_op0 = _r1;
2785 : }
2786 13 : tree _r;
2787 13 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2788 13 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 691, __FILE__, __LINE__, true);
2789 13 : return _r;
2790 : }
2791 0 : next_after_fail876:;
2792 : }
2793 : }
2794 : }
2795 : return NULL_TREE;
2796 : }
2797 :
2798 : tree
2799 20 : generic_simplify_518 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2800 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2801 : const enum tree_code ARG_UNUSED (minmax),
2802 : const enum tree_code ARG_UNUSED (cmp))
2803 : {
2804 20 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2805 20 : {
2806 20 : poly_int64 off0, off1;
2807 20 : tree base0, base1;
2808 20 : int equal = address_compare (cmp, TREE_TYPE (captures[0]), captures[1], captures[3], base0, base1,
2809 : off0, off1,
2810 : 1
2811 : );
2812 20 : if (equal == 1
2813 : )
2814 : {
2815 0 : if (minmax == MIN_EXPR
2816 : )
2817 : {
2818 0 : if (known_le (off0, off1)
2819 : )
2820 : {
2821 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail918;
2822 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail918;
2823 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail918;
2824 0 : {
2825 0 : tree _r;
2826 0 : _r = captures[0];
2827 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 718, __FILE__, __LINE__, true);
2828 0 : return _r;
2829 : }
2830 20 : next_after_fail918:;
2831 : }
2832 : else
2833 : {
2834 0 : if (known_gt (off0, off1)
2835 : )
2836 : {
2837 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail919;
2838 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail919;
2839 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail919;
2840 0 : {
2841 0 : tree _r;
2842 0 : _r = captures[2];
2843 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 719, __FILE__, __LINE__, true);
2844 0 : return _r;
2845 : }
2846 20 : next_after_fail919:;
2847 : }
2848 : }
2849 : }
2850 : else
2851 : {
2852 0 : if (known_ge (off0, off1)
2853 : )
2854 : {
2855 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail920;
2856 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail920;
2857 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail920;
2858 0 : {
2859 0 : tree _r;
2860 0 : _r = captures[0];
2861 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 720, __FILE__, __LINE__, true);
2862 0 : return _r;
2863 : }
2864 20 : next_after_fail920:;
2865 : }
2866 : else
2867 : {
2868 0 : if (known_lt (off0, off1)
2869 : )
2870 : {
2871 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail921;
2872 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail921;
2873 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail921;
2874 0 : {
2875 0 : tree _r;
2876 0 : _r = captures[2];
2877 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 721, __FILE__, __LINE__, true);
2878 0 : return _r;
2879 : }
2880 20 : next_after_fail921:;
2881 : }
2882 : }
2883 : }
2884 : }
2885 : }
2886 20 : return NULL_TREE;
2887 : }
2888 :
2889 : tree
2890 0 : generic_simplify_540 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2891 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
2892 : const combined_fn ARG_UNUSED (cond_op))
2893 : {
2894 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2895 0 : {
2896 0 : tree op_type = TREE_TYPE (captures[5]);
2897 0 : if (inverse_conditions_p (captures[0], captures[2])
2898 0 : && element_precision (type) == element_precision (op_type)
2899 : )
2900 : {
2901 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail946;
2902 0 : {
2903 0 : tree res_op0;
2904 0 : {
2905 0 : tree _o1[4], _r1;
2906 0 : _o1[0] = captures[2];
2907 0 : _o1[1] = captures[3];
2908 0 : _o1[2] = captures[4];
2909 0 : {
2910 0 : tree _o2[1], _r2;
2911 0 : _o2[0] = captures[1];
2912 0 : if (TREE_TYPE (_o2[0]) != op_type)
2913 : {
2914 0 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
2915 : }
2916 : else
2917 : _r2 = _o2[0];
2918 0 : _o1[3] = _r2;
2919 : }
2920 0 : _r1 = maybe_build_call_expr_loc (loc, cond_op, TREE_TYPE (_o1[1]), 4, _o1[0], _o1[1], _o1[2], _o1[3]);
2921 0 : if (!_r1)
2922 0 : goto next_after_fail946;
2923 0 : res_op0 = _r1;
2924 : }
2925 0 : tree _r;
2926 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
2927 0 : if (TREE_SIDE_EFFECTS (captures[0]))
2928 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2929 0 : if (TREE_SIDE_EFFECTS (captures[5]))
2930 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
2931 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 741, __FILE__, __LINE__, true);
2932 0 : return _r;
2933 : }
2934 : next_after_fail946:;
2935 : }
2936 : }
2937 : return NULL_TREE;
2938 : }
2939 :
2940 : tree
2941 0 : generic_simplify_550 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2942 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2943 : const enum tree_code ARG_UNUSED (cmp))
2944 : {
2945 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2946 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail956;
2947 0 : {
2948 0 : tree res_op0;
2949 0 : res_op0 = unshare_expr (captures[0]);
2950 0 : tree res_op1;
2951 0 : res_op1 = captures[0];
2952 0 : tree _r;
2953 0 : _r = fold_build2_loc (loc, UNORDERED_EXPR, type, res_op0, res_op1);
2954 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 751, __FILE__, __LINE__, true);
2955 : return _r;
2956 : }
2957 0 : next_after_fail956:;
2958 0 : return NULL_TREE;
2959 : }
2960 :
2961 : tree
2962 0 : generic_simplify_556 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2963 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2964 : const combined_fn ARG_UNUSED (logs),
2965 : const combined_fn ARG_UNUSED (pows))
2966 : {
2967 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2968 0 : if (flag_unsafe_math_optimizations
2969 : )
2970 : {
2971 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail962;
2972 0 : {
2973 0 : tree res_op0;
2974 0 : res_op0 = captures[1];
2975 0 : tree res_op1;
2976 0 : {
2977 0 : tree _o1[1], _r1;
2978 0 : _o1[0] = captures[0];
2979 0 : _r1 = maybe_build_call_expr_loc (loc, logs, TREE_TYPE (_o1[0]), 1, _o1[0]);
2980 0 : if (!_r1)
2981 0 : goto next_after_fail962;
2982 0 : res_op1 = _r1;
2983 : }
2984 0 : tree _r;
2985 0 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
2986 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 757, __FILE__, __LINE__, true);
2987 0 : return _r;
2988 : }
2989 : next_after_fail962:;
2990 : }
2991 : return NULL_TREE;
2992 : }
2993 :
2994 : tree
2995 0 : generic_simplify_567 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2996 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2997 : const combined_fn ARG_UNUSED (froms),
2998 : const combined_fn ARG_UNUSED (tos))
2999 : {
3000 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3001 0 : if (optimize && canonicalize_math_p ()
3002 : )
3003 : {
3004 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail973;
3005 0 : {
3006 0 : tree res_op0;
3007 0 : res_op0 = captures[0];
3008 0 : tree _r;
3009 0 : _r = maybe_build_call_expr_loc (loc, tos, type, 1, res_op0);
3010 0 : if (!_r)
3011 0 : goto next_after_fail973;
3012 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 768, __FILE__, __LINE__, true);
3013 0 : return _r;
3014 : }
3015 : next_after_fail973:;
3016 : }
3017 : return NULL_TREE;
3018 : }
3019 :
3020 : tree
3021 0 : generic_simplify_575 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3022 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3023 : const combined_fn ARG_UNUSED (SIGNBIT))
3024 : {
3025 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3026 0 : if (!HONOR_SIGNED_ZEROS (captures[0])
3027 : )
3028 : {
3029 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail981;
3030 0 : {
3031 0 : tree res_op0;
3032 0 : {
3033 0 : tree _o1[2], _r1;
3034 0 : _o1[0] = captures[0];
3035 0 : _o1[1] = build_real (TREE_TYPE (captures[0]), dconst0);
3036 0 : _r1 = fold_build2_loc (loc, LT_EXPR, boolean_type_node, _o1[0], _o1[1]);
3037 0 : res_op0 = _r1;
3038 : }
3039 0 : tree _r;
3040 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3041 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 776, __FILE__, __LINE__, true);
3042 0 : return _r;
3043 : }
3044 0 : next_after_fail981:;
3045 : }
3046 : return NULL_TREE;
3047 : }
3048 :
3049 : tree
3050 0 : generic_simplify_584 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3051 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures))
3052 : {
3053 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3054 0 : if (canonicalize_math_after_vectorization_p ()
3055 : )
3056 : {
3057 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail990;
3058 : {
3059 : tree res_op0;
3060 : res_op0 = captures[0];
3061 : tree res_op1;
3062 : res_op1 = captures[1];
3063 : tree res_op2;
3064 : res_op2 = captures[2];
3065 : tree _r;
3066 : _r = maybe_build_call_expr_loc (loc, CFN_FMA, type, 3, res_op0, res_op1, res_op2);
3067 : if (!_r)
3068 : goto next_after_fail990;
3069 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 785, __FILE__, __LINE__, true);
3070 : return _r;
3071 : }
3072 0 : next_after_fail990:;
3073 : }
3074 0 : return NULL_TREE;
3075 : }
3076 :
3077 : tree
3078 0 : generic_simplify_594 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3079 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3080 : const combined_fn ARG_UNUSED (ctz))
3081 : {
3082 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3083 0 : {
3084 0 : tree t = TREE_TYPE (captures[0]);
3085 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1000;
3086 0 : {
3087 0 : tree res_op0;
3088 0 : {
3089 0 : tree _o1[1], _r1;
3090 0 : _o1[0] = captures[1];
3091 0 : if (TREE_TYPE (_o1[0]) != t)
3092 : {
3093 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, t, _o1[0]);
3094 : }
3095 : else
3096 : _r1 = _o1[0];
3097 0 : res_op0 = _r1;
3098 : }
3099 0 : tree _r;
3100 0 : _r = maybe_build_call_expr_loc (loc, ctz, type, 1, res_op0);
3101 0 : if (!_r)
3102 0 : goto next_after_fail1000;
3103 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 794, __FILE__, __LINE__, true);
3104 : return _r;
3105 : }
3106 : next_after_fail1000:;
3107 : }
3108 : return NULL_TREE;
3109 : }
3110 :
3111 : tree
3112 0 : generic_simplify_604 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3113 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3114 : const combined_fn ARG_UNUSED (bswap),
3115 : const combined_fn ARG_UNUSED (parity))
3116 : {
3117 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3118 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3119 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
3120 0 : && TYPE_PRECISION (TREE_TYPE (captures[0]))
3121 0 : >= TYPE_PRECISION (TREE_TYPE (captures[1]))
3122 : )
3123 : {
3124 0 : {
3125 0 : tree type0 = TREE_TYPE (captures[0]);
3126 0 : tree type1 = TREE_TYPE (captures[1]);
3127 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1011;
3128 0 : {
3129 0 : tree res_op0;
3130 0 : {
3131 0 : tree _o1[1], _r1;
3132 0 : {
3133 0 : tree _o2[1], _r2;
3134 0 : _o2[0] = captures[2];
3135 0 : if (TREE_TYPE (_o2[0]) != type1)
3136 : {
3137 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, type1, _o2[0]);
3138 : }
3139 : else
3140 : _r2 = _o2[0];
3141 0 : _o1[0] = _r2;
3142 : }
3143 0 : if (TREE_TYPE (_o1[0]) != type0)
3144 : {
3145 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type0, _o1[0]);
3146 : }
3147 : else
3148 : _r1 = _o1[0];
3149 0 : res_op0 = _r1;
3150 : }
3151 0 : tree _r;
3152 0 : _r = maybe_build_call_expr_loc (loc, parity, type, 1, res_op0);
3153 0 : if (!_r)
3154 0 : goto next_after_fail1011;
3155 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 801, __FILE__, __LINE__, true);
3156 0 : return _r;
3157 : }
3158 : next_after_fail1011:;
3159 : }
3160 : }
3161 : return NULL_TREE;
3162 : }
3163 :
3164 : tree
3165 878961035 : generic_simplify_CONVERT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0)
3166 : {
3167 878961035 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3168 878961035 : switch (TREE_CODE (_p0))
3169 : {
3170 610574 : case NEGATE_EXPR:
3171 610574 : {
3172 610574 : tree _q20 = TREE_OPERAND (_p0, 0);
3173 610574 : switch (TREE_CODE (_q20))
3174 : {
3175 158170 : CASE_CONVERT:
3176 158170 : {
3177 158170 : tree _q30 = TREE_OPERAND (_q20, 0);
3178 158170 : {
3179 158170 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q30 };
3180 158170 : if (INTEGRAL_TYPE_P (type)
3181 157869 : && tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
3182 154363 : && (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (captures[2]))
3183 153585 : || TYPE_UNSIGNED (type))
3184 164640 : && TREE_CODE (type) != BOOLEAN_TYPE
3185 : )
3186 : {
3187 6470 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1025;
3188 6470 : {
3189 6470 : tree res_op0;
3190 6470 : {
3191 6470 : tree _o1[1], _r1;
3192 6470 : _o1[0] = captures[2];
3193 6470 : if (TREE_TYPE (_o1[0]) != type)
3194 : {
3195 6428 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3196 : }
3197 : else
3198 : _r1 = _o1[0];
3199 6470 : res_op0 = _r1;
3200 : }
3201 6470 : tree _r;
3202 6470 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
3203 6470 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 813, __FILE__, __LINE__, true);
3204 6470 : return _r;
3205 : }
3206 0 : next_after_fail1025:;
3207 : }
3208 : }
3209 151700 : break;
3210 : }
3211 : default:;
3212 : }
3213 : break;
3214 : }
3215 1642710 : case BIT_AND_EXPR:
3216 1642710 : {
3217 1642710 : tree _q20 = TREE_OPERAND (_p0, 0);
3218 1642710 : tree _q21 = TREE_OPERAND (_p0, 1);
3219 1642710 : {
3220 1642710 : tree _q20_pops[1];
3221 1642710 : if (tree_nop_convert (_q20, _q20_pops))
3222 : {
3223 647946 : tree _q30 = _q20_pops[0];
3224 647946 : {
3225 647946 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3226 647946 : tree res = generic_simplify_420 (loc, type, _p0, captures, BIT_AND_EXPR);
3227 647946 : if (res) return res;
3228 : }
3229 : }
3230 : }
3231 1642710 : {
3232 1642710 : tree _q21_pops[1];
3233 1642710 : if (tree_nop_convert (_q21, _q21_pops))
3234 : {
3235 506338 : tree _q40 = _q21_pops[0];
3236 506338 : {
3237 506338 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3238 506338 : tree res = generic_simplify_420 (loc, type, _p0, captures, BIT_AND_EXPR);
3239 506338 : if (res) return res;
3240 : }
3241 : }
3242 : }
3243 1642710 : switch (TREE_CODE (_q20))
3244 : {
3245 924826 : CASE_CONVERT:
3246 924826 : {
3247 924826 : tree _q30 = TREE_OPERAND (_q20, 0);
3248 924826 : {
3249 924826 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3250 924826 : tree res = generic_simplify_421 (loc, type, _p0, captures, BIT_AND_EXPR);
3251 924826 : if (res) return res;
3252 : }
3253 924826 : break;
3254 : }
3255 1642710 : default:;
3256 : }
3257 1642710 : switch (TREE_CODE (_q21))
3258 : {
3259 507117 : CASE_CONVERT:
3260 507117 : {
3261 507117 : tree _q40 = TREE_OPERAND (_q21, 0);
3262 507117 : {
3263 507117 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3264 507117 : tree res = generic_simplify_421 (loc, type, _p0, captures, BIT_AND_EXPR);
3265 507117 : if (res) return res;
3266 : }
3267 507117 : break;
3268 : }
3269 : default:;
3270 : }
3271 : break;
3272 : }
3273 1326663 : case BIT_IOR_EXPR:
3274 1326663 : {
3275 1326663 : tree _q20 = TREE_OPERAND (_p0, 0);
3276 1326663 : tree _q21 = TREE_OPERAND (_p0, 1);
3277 1326663 : {
3278 1326663 : tree _q20_pops[1];
3279 1326663 : if (tree_nop_convert (_q20, _q20_pops))
3280 : {
3281 413554 : tree _q30 = _q20_pops[0];
3282 413554 : {
3283 413554 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3284 413554 : tree res = generic_simplify_420 (loc, type, _p0, captures, BIT_IOR_EXPR);
3285 413554 : if (res) return res;
3286 : }
3287 : }
3288 : }
3289 1326663 : {
3290 1326663 : tree _q21_pops[1];
3291 1326663 : if (tree_nop_convert (_q21, _q21_pops))
3292 : {
3293 1059042 : tree _q40 = _q21_pops[0];
3294 1059042 : {
3295 1059042 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3296 1059042 : tree res = generic_simplify_420 (loc, type, _p0, captures, BIT_IOR_EXPR);
3297 1059042 : if (res) return res;
3298 : }
3299 : }
3300 : }
3301 1326663 : switch (TREE_CODE (_q20))
3302 : {
3303 463107 : CASE_CONVERT:
3304 463107 : {
3305 463107 : tree _q30 = TREE_OPERAND (_q20, 0);
3306 463107 : {
3307 463107 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3308 463107 : tree res = generic_simplify_421 (loc, type, _p0, captures, BIT_IOR_EXPR);
3309 463107 : if (res) return res;
3310 : }
3311 463107 : break;
3312 : }
3313 1326663 : default:;
3314 : }
3315 1326663 : switch (TREE_CODE (_q21))
3316 : {
3317 1066800 : CASE_CONVERT:
3318 1066800 : {
3319 1066800 : tree _q40 = TREE_OPERAND (_q21, 0);
3320 1066800 : {
3321 1066800 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3322 1066800 : tree res = generic_simplify_421 (loc, type, _p0, captures, BIT_IOR_EXPR);
3323 1066800 : if (res) return res;
3324 : }
3325 1066800 : break;
3326 : }
3327 : default:;
3328 : }
3329 : break;
3330 : }
3331 572465 : case BIT_XOR_EXPR:
3332 572465 : {
3333 572465 : tree _q20 = TREE_OPERAND (_p0, 0);
3334 572465 : tree _q21 = TREE_OPERAND (_p0, 1);
3335 572465 : {
3336 572465 : tree _q20_pops[1];
3337 572465 : if (tree_nop_convert (_q20, _q20_pops))
3338 : {
3339 328071 : tree _q30 = _q20_pops[0];
3340 328071 : {
3341 328071 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3342 328071 : tree res = generic_simplify_420 (loc, type, _p0, captures, BIT_XOR_EXPR);
3343 328071 : if (res) return res;
3344 : }
3345 : }
3346 : }
3347 572465 : {
3348 572465 : tree _q21_pops[1];
3349 572465 : if (tree_nop_convert (_q21, _q21_pops))
3350 : {
3351 461111 : tree _q40 = _q21_pops[0];
3352 461111 : {
3353 461111 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3354 461111 : tree res = generic_simplify_420 (loc, type, _p0, captures, BIT_XOR_EXPR);
3355 461111 : if (res) return res;
3356 : }
3357 : }
3358 : }
3359 572465 : switch (TREE_CODE (_q20))
3360 : {
3361 368153 : CASE_CONVERT:
3362 368153 : {
3363 368153 : tree _q30 = TREE_OPERAND (_q20, 0);
3364 368153 : {
3365 368153 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
3366 368153 : tree res = generic_simplify_421 (loc, type, _p0, captures, BIT_XOR_EXPR);
3367 368153 : if (res) return res;
3368 : }
3369 368153 : break;
3370 : }
3371 572465 : default:;
3372 : }
3373 572465 : switch (TREE_CODE (_q21))
3374 : {
3375 500179 : CASE_CONVERT:
3376 500179 : {
3377 500179 : tree _q40 = TREE_OPERAND (_q21, 0);
3378 500179 : {
3379 500179 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
3380 500179 : tree res = generic_simplify_421 (loc, type, _p0, captures, BIT_XOR_EXPR);
3381 500179 : if (res) return res;
3382 : }
3383 500179 : break;
3384 : }
3385 : default:;
3386 : }
3387 : break;
3388 : }
3389 9889782 : case MULT_EXPR:
3390 9889782 : {
3391 9889782 : tree _q20 = TREE_OPERAND (_p0, 0);
3392 9889782 : tree _q21 = TREE_OPERAND (_p0, 1);
3393 9889782 : if (tree_zero_one_valued_p (_q20))
3394 : {
3395 66291 : switch (TREE_CODE (_q21))
3396 : {
3397 60814 : case INTEGER_CST:
3398 60814 : {
3399 60814 : {
3400 60814 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
3401 60814 : if (INTEGRAL_TYPE_P (type)
3402 60814 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3403 60814 : && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (captures[0]))
3404 60820 : && (TYPE_UNSIGNED (type) || TYPE_PRECISION (type) > 1)
3405 : )
3406 : {
3407 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1026;
3408 6 : {
3409 6 : tree res_op0;
3410 6 : {
3411 6 : tree _o1[1], _r1;
3412 6 : _o1[0] = captures[1];
3413 6 : if (TREE_TYPE (_o1[0]) != type)
3414 : {
3415 6 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3416 : }
3417 : else
3418 : _r1 = _o1[0];
3419 6 : res_op0 = _r1;
3420 : }
3421 6 : tree res_op1;
3422 6 : {
3423 6 : tree _o1[1], _r1;
3424 6 : _o1[0] = captures[2];
3425 6 : if (TREE_TYPE (_o1[0]) != type)
3426 : {
3427 6 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3428 : }
3429 : else
3430 : _r1 = _o1[0];
3431 6 : res_op1 = _r1;
3432 : }
3433 6 : tree _r;
3434 6 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
3435 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 814, __FILE__, __LINE__, true);
3436 6 : return _r;
3437 : }
3438 0 : next_after_fail1026:;
3439 : }
3440 : }
3441 60808 : break;
3442 : }
3443 : default:;
3444 : }
3445 : }
3446 : break;
3447 : }
3448 1544096 : case POINTER_DIFF_EXPR:
3449 1544096 : {
3450 1544096 : tree _q20 = TREE_OPERAND (_p0, 0);
3451 1544096 : tree _q21 = TREE_OPERAND (_p0, 1);
3452 1544096 : switch (TREE_CODE (_q21))
3453 : {
3454 200 : case INTEGER_CST:
3455 200 : {
3456 200 : {
3457 200 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3458 200 : if (POINTER_TYPE_P (type)
3459 : )
3460 : {
3461 18 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1027;
3462 18 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1027;
3463 18 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1027;
3464 18 : {
3465 18 : tree _r;
3466 18 : _r = build_fold_addr_expr_with_type
3467 : (build2 (MEM_REF, char_type_node, captures[0],
3468 : wide_int_to_tree (ptr_type_node, wi::neg (wi::to_wide (captures[1])))),
3469 : type);
3470 18 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 815, __FILE__, __LINE__, true);
3471 18 : return _r;
3472 : }
3473 182 : next_after_fail1027:;
3474 : }
3475 : }
3476 182 : break;
3477 : }
3478 : default:;
3479 : }
3480 : break;
3481 : }
3482 203638 : case EQ_EXPR:
3483 203638 : {
3484 203638 : tree _q20 = TREE_OPERAND (_p0, 0);
3485 203638 : tree _q21 = TREE_OPERAND (_p0, 1);
3486 203638 : if (tree_zero_one_valued_p (_q20))
3487 : {
3488 1598 : switch (TREE_CODE (_q21))
3489 : {
3490 726 : case INTEGER_CST:
3491 726 : {
3492 726 : {
3493 726 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3494 726 : tree res = generic_simplify_422 (loc, type, _p0, captures, EQ_EXPR);
3495 726 : if (res) return res;
3496 : }
3497 679 : break;
3498 : }
3499 : default:;
3500 : }
3501 : }
3502 : break;
3503 : }
3504 253546 : case NE_EXPR:
3505 253546 : {
3506 253546 : tree _q20 = TREE_OPERAND (_p0, 0);
3507 253546 : tree _q21 = TREE_OPERAND (_p0, 1);
3508 253546 : if (tree_zero_one_valued_p (_q20))
3509 : {
3510 1845 : switch (TREE_CODE (_q21))
3511 : {
3512 1519 : case INTEGER_CST:
3513 1519 : {
3514 1519 : {
3515 1519 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3516 1519 : tree res = generic_simplify_422 (loc, type, _p0, captures, NE_EXPR);
3517 1519 : if (res) return res;
3518 : }
3519 1 : break;
3520 : }
3521 : default:;
3522 : }
3523 : }
3524 : break;
3525 : }
3526 1985 : case MIN_EXPR:
3527 1985 : {
3528 1985 : tree _q20 = TREE_OPERAND (_p0, 0);
3529 1985 : tree _q21 = TREE_OPERAND (_p0, 1);
3530 1985 : switch (TREE_CODE (_q20))
3531 : {
3532 722 : CASE_CONVERT:
3533 722 : {
3534 722 : tree _q30 = TREE_OPERAND (_q20, 0);
3535 722 : switch (TREE_CODE (_q21))
3536 : {
3537 650 : case INTEGER_CST:
3538 650 : {
3539 650 : {
3540 650 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q21 };
3541 650 : tree res = generic_simplify_423 (loc, type, _p0, captures, MIN_EXPR);
3542 650 : if (res) return res;
3543 : }
3544 650 : break;
3545 : }
3546 : default:;
3547 : }
3548 : break;
3549 : }
3550 : default:;
3551 : }
3552 : break;
3553 : }
3554 298385 : case MAX_EXPR:
3555 298385 : {
3556 298385 : tree _q20 = TREE_OPERAND (_p0, 0);
3557 298385 : tree _q21 = TREE_OPERAND (_p0, 1);
3558 298385 : switch (TREE_CODE (_q20))
3559 : {
3560 6469 : CASE_CONVERT:
3561 6469 : {
3562 6469 : tree _q30 = TREE_OPERAND (_q20, 0);
3563 6469 : switch (TREE_CODE (_q21))
3564 : {
3565 6433 : case INTEGER_CST:
3566 6433 : {
3567 6433 : {
3568 6433 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q21 };
3569 6433 : tree res = generic_simplify_423 (loc, type, _p0, captures, MAX_EXPR);
3570 6433 : if (res) return res;
3571 : }
3572 6433 : break;
3573 : }
3574 : default:;
3575 : }
3576 : break;
3577 : }
3578 : default:;
3579 : }
3580 : break;
3581 : }
3582 462492 : case LSHIFT_EXPR:
3583 462492 : {
3584 462492 : tree _q20 = TREE_OPERAND (_p0, 0);
3585 462492 : tree _q21 = TREE_OPERAND (_p0, 1);
3586 462492 : switch (TREE_CODE (_q21))
3587 : {
3588 140730 : case INTEGER_CST:
3589 140730 : {
3590 140730 : {
3591 140730 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
3592 140730 : if (INTEGRAL_TYPE_P (type)
3593 140703 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3594 140703 : && !integer_zerop (captures[2])
3595 280660 : && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (captures[0]))
3596 : )
3597 : {
3598 138647 : if (TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (captures[0]))
3599 138647 : || wi::ltu_p (wi::to_wide (captures[2]), TYPE_PRECISION (type))
3600 : )
3601 : {
3602 138359 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1028;
3603 138359 : {
3604 138359 : tree res_op0;
3605 138359 : {
3606 138359 : tree _o1[1], _r1;
3607 138359 : _o1[0] = captures[1];
3608 138359 : if (TREE_TYPE (_o1[0]) != type)
3609 : {
3610 129285 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3611 : }
3612 : else
3613 : _r1 = _o1[0];
3614 138359 : res_op0 = _r1;
3615 : }
3616 138359 : tree res_op1;
3617 138359 : res_op1 = captures[2];
3618 138359 : tree _r;
3619 138359 : _r = fold_build2_loc (loc, LSHIFT_EXPR, type, res_op0, res_op1);
3620 138359 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 816, __FILE__, __LINE__, true);
3621 138359 : return _r;
3622 : }
3623 0 : next_after_fail1028:;
3624 : }
3625 : else
3626 : {
3627 288 : if (wi::ltu_p (wi::to_wide (captures[2]), TYPE_PRECISION (TREE_TYPE (captures[0])))
3628 : )
3629 : {
3630 239 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1029;
3631 239 : {
3632 239 : tree _r;
3633 239 : _r = build_zero_cst (type);
3634 239 : if (TREE_SIDE_EFFECTS (captures[1]))
3635 14 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3636 239 : if (TREE_SIDE_EFFECTS (captures[2]))
3637 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
3638 239 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 817, __FILE__, __LINE__, true);
3639 239 : return _r;
3640 : }
3641 0 : next_after_fail1029:;
3642 : }
3643 : }
3644 : }
3645 : }
3646 2132 : break;
3647 : }
3648 : default:;
3649 : }
3650 : break;
3651 : }
3652 878814378 : default:;
3653 : }
3654 878814378 : {
3655 878814378 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3656 1757628756 : if ((
3657 :
3658 : && useless_type_conversion_p (type, TREE_TYPE (captures[0])))
3659 : || (
3660 : 1
3661 878814378 : && type == TREE_TYPE (captures[0]))
3662 : )
3663 : {
3664 59325909 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1030;
3665 59325909 : {
3666 59325909 : tree _r;
3667 59325909 : _r = captures[0];
3668 59325909 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 818, __FILE__, __LINE__, true);
3669 59325909 : return _r;
3670 : }
3671 0 : next_after_fail1030:;
3672 : }
3673 : }
3674 819488469 : switch (TREE_CODE (_p0))
3675 : {
3676 126897598 : CASE_CONVERT:
3677 126897598 : {
3678 126897598 : tree _q20 = TREE_OPERAND (_p0, 0);
3679 126897598 : {
3680 126897598 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3681 126897598 : {
3682 126897598 : tree inside_type = TREE_TYPE (captures[1]);
3683 126897598 : tree inter_type = TREE_TYPE (captures[0]);
3684 126897598 : int inside_int = INTEGRAL_TYPE_P (inside_type);
3685 126897598 : int inside_ptr = POINTER_TYPE_P (inside_type);
3686 126897598 : int inside_float = FLOAT_TYPE_P (inside_type);
3687 126897598 : int inside_vec = VECTOR_TYPE_P (inside_type);
3688 126897598 : unsigned int inside_prec = element_precision (inside_type);
3689 126897598 : int inside_unsignedp = TYPE_UNSIGNED (inside_type);
3690 126897598 : int inter_int = INTEGRAL_TYPE_P (inter_type);
3691 126897598 : int inter_ptr = POINTER_TYPE_P (inter_type);
3692 126897598 : int inter_float = FLOAT_TYPE_P (inter_type);
3693 126897598 : int inter_vec = VECTOR_TYPE_P (inter_type);
3694 126897598 : unsigned int inter_prec = element_precision (inter_type);
3695 126897598 : int inter_unsignedp = TYPE_UNSIGNED (inter_type);
3696 126897598 : int final_int = INTEGRAL_TYPE_P (type);
3697 126897598 : int final_ptr = POINTER_TYPE_P (type);
3698 126897598 : int final_float = FLOAT_TYPE_P (type);
3699 126897598 : int final_vec = VECTOR_TYPE_P (type);
3700 126897598 : unsigned int final_prec = element_precision (type);
3701 126897598 : int final_unsignedp = TYPE_UNSIGNED (type);
3702 126897598 : if (((
3703 :
3704 : && useless_type_conversion_p (type, inside_type))
3705 : || (
3706 : 1
3707 126897598 : && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
3708 28000794 : && (((inter_int || inter_ptr) && final_int)
3709 21880802 : || (inter_float && final_float))
3710 133095718 : && inter_prec >= final_prec
3711 : )
3712 : {
3713 5665265 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1031;
3714 5665265 : {
3715 5665265 : tree res_op0;
3716 5665265 : res_op0 = captures[1];
3717 5665265 : tree _r;
3718 5665265 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3719 5665265 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 819, __FILE__, __LINE__, true);
3720 5665265 : return _r;
3721 : }
3722 0 : next_after_fail1031:;
3723 : }
3724 : else
3725 : {
3726 121232333 : if (((inter_int && inside_int) || (inter_float && inside_float))
3727 14069829 : && (final_int || final_float)
3728 13939905 : && inter_prec >= inside_prec
3729 12627941 : && (inter_float || inter_unsignedp == inside_unsignedp)
3730 : )
3731 : {
3732 8515675 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1032;
3733 8515675 : {
3734 8515675 : tree res_op0;
3735 8515675 : res_op0 = captures[1];
3736 8515675 : tree _r;
3737 8515675 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3738 8515675 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 820, __FILE__, __LINE__, true);
3739 8515675 : return _r;
3740 : }
3741 0 : next_after_fail1032:;
3742 0 : }
3743 : else
3744 : {
3745 112716658 : if (inside_int && inter_int && final_int
3746 5417930 : && ((inside_prec < inter_prec && inter_prec < final_prec
3747 503813 : && inside_unsignedp && !inter_unsignedp)
3748 4940897 : || final_prec == inter_prec
3749 2352370 : || (inside_prec < inter_prec && inter_prec > final_prec
3750 152660 : && !inside_unsignedp && inter_unsignedp))
3751 : )
3752 : {
3753 3131106 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1033;
3754 3131106 : {
3755 3131106 : tree res_op0;
3756 3131106 : res_op0 = captures[1];
3757 3131106 : tree _r;
3758 3131106 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3759 3131106 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 821, __FILE__, __LINE__, true);
3760 3131106 : return _r;
3761 : }
3762 0 : next_after_fail1033:;
3763 0 : }
3764 : else
3765 : {
3766 109585552 : if (! inside_float && ! inter_float && ! final_float
3767 : && ! inside_vec && ! inter_vec && ! final_vec
3768 109579248 : && (inter_prec >= inside_prec || inter_prec >= final_prec)
3769 108780408 : && ! (inside_int && inter_int
3770 1617904 : && inter_unsignedp != inside_unsignedp
3771 1617904 : && inter_prec < final_prec)
3772 107462316 : && ((inter_unsignedp && inter_prec > inside_prec)
3773 107462316 : == (final_unsignedp && final_prec > inter_prec))
3774 107439958 : && ! (inside_ptr && inter_prec != final_prec)
3775 106965906 : && ! (final_ptr && inside_prec != inter_prec)
3776 : )
3777 : {
3778 106945160 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1034;
3779 106945160 : {
3780 106945160 : tree res_op0;
3781 106945160 : res_op0 = captures[1];
3782 106945160 : tree _r;
3783 106945160 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3784 106945160 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 822, __FILE__, __LINE__, true);
3785 106945160 : return _r;
3786 : }
3787 0 : next_after_fail1034:;
3788 0 : }
3789 : else
3790 : {
3791 2640392 : if (inside_int && inter_int && final_int
3792 2146369 : && final_prec <= inside_prec
3793 738871 : && inter_prec >= inside_prec
3794 : )
3795 : {
3796 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1035;
3797 0 : {
3798 0 : tree res_op0;
3799 0 : res_op0 = captures[1];
3800 0 : tree _r;
3801 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3802 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 823, __FILE__, __LINE__, true);
3803 0 : return _r;
3804 : }
3805 0 : next_after_fail1035:;
3806 0 : }
3807 : else
3808 : {
3809 : if (0
3810 : && final_int && inter_int && inside_int
3811 : && final_prec >= inside_prec
3812 : && inside_prec > inter_prec
3813 : && inter_unsignedp
3814 : )
3815 : {
3816 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1036;
3817 : {
3818 : tree res_op0;
3819 : {
3820 : tree _o1[2], _r1;
3821 : _o1[0] = captures[1];
3822 : _o1[1] = wide_int_to_tree
3823 : (inside_type,
3824 : wi::mask (inter_prec, false,
3825 : TYPE_PRECISION (inside_type)));
3826 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3827 : res_op0 = _r1;
3828 : }
3829 : tree _r;
3830 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3831 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 824, __FILE__, __LINE__, true);
3832 : return _r;
3833 : }
3834 : next_after_fail1036:;
3835 : }
3836 : else
3837 : {
3838 : if (0
3839 : && inside_int && inter_float && final_int &&
3840 : (unsigned) significand_size (TYPE_MODE (inter_type))
3841 : >= inside_prec - !inside_unsignedp
3842 : )
3843 : {
3844 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1037;
3845 : {
3846 : tree res_op0;
3847 : res_op0 = captures[1];
3848 : tree _r;
3849 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3850 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 825, __FILE__, __LINE__, true);
3851 : return _r;
3852 : }
3853 : next_after_fail1037:;
3854 : }
3855 : }
3856 : }
3857 : }
3858 : }
3859 : }
3860 : }
3861 : }
3862 : }
3863 2640392 : break;
3864 : }
3865 3066 : case FLOAT_EXPR:
3866 3066 : {
3867 3066 : tree _q20 = TREE_OPERAND (_p0, 0);
3868 3066 : {
3869 3066 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3870 3066 : {
3871 3066 : tree inside_type = TREE_TYPE (captures[1]);
3872 3066 : tree inter_type = TREE_TYPE (captures[0]);
3873 3066 : int inside_int = INTEGRAL_TYPE_P (inside_type);
3874 3066 : int inside_ptr = POINTER_TYPE_P (inside_type);
3875 3066 : int inside_float = FLOAT_TYPE_P (inside_type);
3876 3066 : int inside_vec = VECTOR_TYPE_P (inside_type);
3877 3066 : unsigned int inside_prec = element_precision (inside_type);
3878 3066 : int inside_unsignedp = TYPE_UNSIGNED (inside_type);
3879 3066 : int inter_int = INTEGRAL_TYPE_P (inter_type);
3880 3066 : int inter_ptr = POINTER_TYPE_P (inter_type);
3881 3066 : int inter_float = FLOAT_TYPE_P (inter_type);
3882 3066 : int inter_vec = VECTOR_TYPE_P (inter_type);
3883 3066 : unsigned int inter_prec = element_precision (inter_type);
3884 3066 : int inter_unsignedp = TYPE_UNSIGNED (inter_type);
3885 3066 : int final_int = INTEGRAL_TYPE_P (type);
3886 3066 : int final_ptr = POINTER_TYPE_P (type);
3887 3066 : int final_float = FLOAT_TYPE_P (type);
3888 3066 : int final_vec = VECTOR_TYPE_P (type);
3889 3066 : unsigned int final_prec = element_precision (type);
3890 3066 : int final_unsignedp = TYPE_UNSIGNED (type);
3891 3066 : if (((
3892 :
3893 : && useless_type_conversion_p (type, inside_type))
3894 : || (
3895 : 1
3896 3066 : && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
3897 0 : && (((inter_int || inter_ptr) && final_int)
3898 0 : || (inter_float && final_float))
3899 3066 : && inter_prec >= final_prec
3900 : )
3901 : {
3902 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1038;
3903 0 : {
3904 0 : tree res_op0;
3905 0 : res_op0 = captures[1];
3906 0 : tree _r;
3907 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3908 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 819, __FILE__, __LINE__, true);
3909 0 : return _r;
3910 : }
3911 0 : next_after_fail1038:;
3912 : }
3913 : else
3914 : {
3915 3066 : if (((inter_int && inside_int) || (inter_float && inside_float))
3916 0 : && (final_int || final_float)
3917 0 : && inter_prec >= inside_prec
3918 0 : && (inter_float || inter_unsignedp == inside_unsignedp)
3919 : )
3920 : {
3921 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1039;
3922 0 : {
3923 0 : tree res_op0;
3924 0 : res_op0 = captures[1];
3925 0 : tree _r;
3926 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3927 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 820, __FILE__, __LINE__, true);
3928 0 : return _r;
3929 : }
3930 0 : next_after_fail1039:;
3931 0 : }
3932 : else
3933 : {
3934 3066 : if (inside_int && inter_int && final_int
3935 0 : && ((inside_prec < inter_prec && inter_prec < final_prec
3936 0 : && inside_unsignedp && !inter_unsignedp)
3937 0 : || final_prec == inter_prec
3938 0 : || (inside_prec < inter_prec && inter_prec > final_prec
3939 0 : && !inside_unsignedp && inter_unsignedp))
3940 : )
3941 : {
3942 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1040;
3943 0 : {
3944 0 : tree res_op0;
3945 0 : res_op0 = captures[1];
3946 0 : tree _r;
3947 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3948 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 821, __FILE__, __LINE__, true);
3949 0 : return _r;
3950 : }
3951 0 : next_after_fail1040:;
3952 0 : }
3953 : else
3954 : {
3955 3066 : if (! inside_float && ! inter_float && ! final_float
3956 : && ! inside_vec && ! inter_vec && ! final_vec
3957 0 : && (inter_prec >= inside_prec || inter_prec >= final_prec)
3958 0 : && ! (inside_int && inter_int
3959 0 : && inter_unsignedp != inside_unsignedp
3960 0 : && inter_prec < final_prec)
3961 0 : && ((inter_unsignedp && inter_prec > inside_prec)
3962 0 : == (final_unsignedp && final_prec > inter_prec))
3963 0 : && ! (inside_ptr && inter_prec != final_prec)
3964 0 : && ! (final_ptr && inside_prec != inter_prec)
3965 : )
3966 : {
3967 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1041;
3968 0 : {
3969 0 : tree res_op0;
3970 0 : res_op0 = captures[1];
3971 0 : tree _r;
3972 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3973 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 822, __FILE__, __LINE__, true);
3974 0 : return _r;
3975 : }
3976 0 : next_after_fail1041:;
3977 0 : }
3978 : else
3979 : {
3980 3066 : if (inside_int && inter_int && final_int
3981 0 : && final_prec <= inside_prec
3982 0 : && inter_prec >= inside_prec
3983 : )
3984 : {
3985 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1042;
3986 0 : {
3987 0 : tree res_op0;
3988 0 : res_op0 = captures[1];
3989 0 : tree _r;
3990 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3991 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 823, __FILE__, __LINE__, true);
3992 0 : return _r;
3993 : }
3994 0 : next_after_fail1042:;
3995 0 : }
3996 : else
3997 : {
3998 : if (0
3999 : && final_int && inter_int && inside_int
4000 : && final_prec >= inside_prec
4001 : && inside_prec > inter_prec
4002 : && inter_unsignedp
4003 : )
4004 : {
4005 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1043;
4006 : {
4007 : tree res_op0;
4008 : {
4009 : tree _o1[2], _r1;
4010 : _o1[0] = captures[1];
4011 : _o1[1] = wide_int_to_tree
4012 : (inside_type,
4013 : wi::mask (inter_prec, false,
4014 : TYPE_PRECISION (inside_type)));
4015 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4016 : res_op0 = _r1;
4017 : }
4018 : tree _r;
4019 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4020 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 824, __FILE__, __LINE__, true);
4021 : return _r;
4022 : }
4023 : next_after_fail1043:;
4024 : }
4025 : else
4026 : {
4027 : if (0
4028 : && inside_int && inter_float && final_int &&
4029 : (unsigned) significand_size (TYPE_MODE (inter_type))
4030 : >= inside_prec - !inside_unsignedp
4031 : )
4032 : {
4033 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1044;
4034 : {
4035 : tree res_op0;
4036 : res_op0 = captures[1];
4037 : tree _r;
4038 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4039 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 825, __FILE__, __LINE__, true);
4040 : return _r;
4041 : }
4042 : next_after_fail1044:;
4043 : }
4044 : }
4045 : }
4046 : }
4047 : }
4048 : }
4049 : }
4050 : }
4051 : }
4052 3066 : break;
4053 : }
4054 1278894 : case BIT_AND_EXPR:
4055 1278894 : {
4056 1278894 : tree _q20 = TREE_OPERAND (_p0, 0);
4057 1278894 : tree _q21 = TREE_OPERAND (_p0, 1);
4058 1278894 : switch (TREE_CODE (_q21))
4059 : {
4060 661424 : case INTEGER_CST:
4061 661424 : {
4062 661424 : {
4063 661424 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4064 661424 : if (INTEGRAL_TYPE_P (type)
4065 660916 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4066 660916 : && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (captures[0]))
4067 961720 : && operand_equal_p (captures[1], build_low_bits_mask (TREE_TYPE (captures[1]),
4068 300296 : TYPE_PRECISION (type)), 0)
4069 : )
4070 : {
4071 12202 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1045;
4072 12202 : {
4073 12202 : tree res_op0;
4074 12202 : res_op0 = captures[0];
4075 12202 : tree _r;
4076 12202 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4077 12202 : if (TREE_SIDE_EFFECTS (captures[1]))
4078 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4079 12202 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 826, __FILE__, __LINE__, true);
4080 12202 : return _r;
4081 : }
4082 0 : next_after_fail1045:;
4083 : }
4084 : }
4085 649222 : break;
4086 : }
4087 : default:;
4088 : }
4089 : break;
4090 : }
4091 5 : case VEC_COND_EXPR:
4092 5 : {
4093 5 : tree _q20 = TREE_OPERAND (_p0, 0);
4094 5 : tree _q21 = TREE_OPERAND (_p0, 1);
4095 5 : tree _q22 = TREE_OPERAND (_p0, 2);
4096 5 : {
4097 5 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
4098 5 : if (VECTOR_TYPE_P (type)
4099 0 : && types_match (TREE_TYPE (captures[1]), truth_type_for (type))
4100 5 : && (expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
4101 0 : || !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1])))
4102 : )
4103 : {
4104 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1046;
4105 0 : {
4106 0 : tree res_op0;
4107 0 : res_op0 = captures[1];
4108 0 : tree res_op1;
4109 0 : {
4110 0 : tree _o1[1], _r1;
4111 0 : _o1[0] = captures[2];
4112 0 : if (TREE_TYPE (_o1[0]) != type)
4113 : {
4114 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4115 0 : if (EXPR_P (_r1))
4116 0 : goto next_after_fail1046;
4117 : }
4118 : else
4119 : _r1 = _o1[0];
4120 0 : res_op1 = _r1;
4121 : }
4122 0 : tree res_op2;
4123 0 : {
4124 0 : tree _o1[1], _r1;
4125 0 : _o1[0] = captures[3];
4126 0 : if (TREE_TYPE (_o1[0]) != type)
4127 : {
4128 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4129 0 : if (EXPR_P (_r1))
4130 0 : goto next_after_fail1046;
4131 : }
4132 : else
4133 : _r1 = _o1[0];
4134 0 : res_op2 = _r1;
4135 : }
4136 0 : tree _r;
4137 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4138 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 827, __FILE__, __LINE__, true);
4139 0 : return _r;
4140 : }
4141 5 : next_after_fail1046:;
4142 : }
4143 : }
4144 5 : break;
4145 : }
4146 883485 : case COND_EXPR:
4147 883485 : {
4148 883485 : tree _q20 = TREE_OPERAND (_p0, 0);
4149 883485 : tree _q21 = TREE_OPERAND (_p0, 1);
4150 883485 : tree _q22 = TREE_OPERAND (_p0, 2);
4151 883485 : switch (TREE_CODE (_q21))
4152 : {
4153 222962 : case INTEGER_CST:
4154 222962 : {
4155 222962 : switch (TREE_CODE (_q22))
4156 : {
4157 158348 : case INTEGER_CST:
4158 158348 : {
4159 158348 : {
4160 158348 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
4161 158348 : if (INTEGRAL_TYPE_P (type)
4162 158348 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4163 : )
4164 : {
4165 158348 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1047;
4166 158348 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1047;
4167 158348 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1047;
4168 158348 : {
4169 158348 : tree res_op0;
4170 158348 : res_op0 = captures[1];
4171 158348 : tree res_op1;
4172 158348 : {
4173 158348 : tree _o1[1], _r1;
4174 158348 : _o1[0] = captures[2];
4175 158348 : if (TREE_TYPE (_o1[0]) != type)
4176 : {
4177 158348 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4178 : }
4179 : else
4180 : _r1 = _o1[0];
4181 158348 : res_op1 = _r1;
4182 : }
4183 158348 : tree res_op2;
4184 158348 : {
4185 158348 : tree _o1[1], _r1;
4186 158348 : _o1[0] = captures[3];
4187 158348 : if (TREE_TYPE (_o1[0]) != type)
4188 : {
4189 158348 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4190 : }
4191 : else
4192 : _r1 = _o1[0];
4193 158348 : res_op2 = _r1;
4194 : }
4195 158348 : tree _r;
4196 158348 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
4197 158348 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 828, __FILE__, __LINE__, true);
4198 158348 : return _r;
4199 : }
4200 0 : next_after_fail1047:;
4201 : }
4202 : }
4203 0 : break;
4204 : }
4205 : default:;
4206 : }
4207 : break;
4208 : }
4209 : default:;
4210 : }
4211 : break;
4212 : }
4213 11678510 : case PLUS_EXPR:
4214 11678510 : {
4215 11678510 : tree _q20 = TREE_OPERAND (_p0, 0);
4216 11678510 : tree _q21 = TREE_OPERAND (_p0, 1);
4217 11678510 : switch (TREE_CODE (_q20))
4218 : {
4219 4560165 : CASE_CONVERT:
4220 4560165 : {
4221 4560165 : tree _q30 = TREE_OPERAND (_q20, 0);
4222 4560165 : switch (TREE_CODE (_q21))
4223 : {
4224 395072 : CASE_CONVERT:
4225 395072 : {
4226 395072 : tree _q50 = TREE_OPERAND (_q21, 0);
4227 395072 : {
4228 395072 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4229 395072 : tree res = generic_simplify_424 (loc, type, _p0, captures, PLUS_EXPR);
4230 395072 : if (res) return res;
4231 : }
4232 395023 : break;
4233 : }
4234 4560116 : default:;
4235 : }
4236 4560116 : {
4237 4560116 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4238 4560116 : tree res = generic_simplify_425 (loc, type, _p0, captures, PLUS_EXPR);
4239 4560116 : if (res) return res;
4240 : }
4241 4547106 : break;
4242 : }
4243 11665451 : default:;
4244 : }
4245 11665451 : switch (TREE_CODE (_q21))
4246 : {
4247 1549243 : CASE_CONVERT:
4248 1549243 : {
4249 1549243 : tree _q40 = TREE_OPERAND (_q21, 0);
4250 1549243 : {
4251 1549243 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4252 1549243 : tree res = generic_simplify_426 (loc, type, _p0, captures, PLUS_EXPR);
4253 1549243 : if (res) return res;
4254 : }
4255 1549243 : break;
4256 : }
4257 11665451 : default:;
4258 : }
4259 11665451 : {
4260 11665451 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4261 11665451 : tree res = generic_simplify_427 (loc, type, _p0, captures, PLUS_EXPR);
4262 11665451 : if (res) return res;
4263 : }
4264 11665417 : break;
4265 : }
4266 921792 : case MINUS_EXPR:
4267 921792 : {
4268 921792 : tree _q20 = TREE_OPERAND (_p0, 0);
4269 921792 : tree _q21 = TREE_OPERAND (_p0, 1);
4270 921792 : switch (TREE_CODE (_q20))
4271 : {
4272 350342 : CASE_CONVERT:
4273 350342 : {
4274 350342 : tree _q30 = TREE_OPERAND (_q20, 0);
4275 350342 : switch (TREE_CODE (_q21))
4276 : {
4277 200191 : CASE_CONVERT:
4278 200191 : {
4279 200191 : tree _q50 = TREE_OPERAND (_q21, 0);
4280 200191 : {
4281 200191 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4282 200191 : tree res = generic_simplify_424 (loc, type, _p0, captures, MINUS_EXPR);
4283 200191 : if (res) return res;
4284 : }
4285 200169 : break;
4286 : }
4287 350320 : default:;
4288 : }
4289 350320 : {
4290 350320 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4291 350320 : tree res = generic_simplify_425 (loc, type, _p0, captures, MINUS_EXPR);
4292 350320 : if (res) return res;
4293 : }
4294 349207 : break;
4295 : }
4296 920657 : default:;
4297 : }
4298 920657 : switch (TREE_CODE (_q21))
4299 : {
4300 259708 : CASE_CONVERT:
4301 259708 : {
4302 259708 : tree _q40 = TREE_OPERAND (_q21, 0);
4303 259708 : {
4304 259708 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4305 259708 : tree res = generic_simplify_426 (loc, type, _p0, captures, MINUS_EXPR);
4306 259708 : if (res) return res;
4307 : }
4308 259698 : break;
4309 : }
4310 920647 : default:;
4311 : }
4312 920647 : {
4313 920647 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4314 920647 : tree res = generic_simplify_427 (loc, type, _p0, captures, MINUS_EXPR);
4315 920647 : if (res) return res;
4316 : }
4317 920615 : break;
4318 : }
4319 9671998 : case MULT_EXPR:
4320 9671998 : {
4321 9671998 : tree _q20 = TREE_OPERAND (_p0, 0);
4322 9671998 : tree _q21 = TREE_OPERAND (_p0, 1);
4323 9671998 : switch (TREE_CODE (_q20))
4324 : {
4325 4432278 : CASE_CONVERT:
4326 4432278 : {
4327 4432278 : tree _q30 = TREE_OPERAND (_q20, 0);
4328 4432278 : switch (TREE_CODE (_q21))
4329 : {
4330 321650 : CASE_CONVERT:
4331 321650 : {
4332 321650 : tree _q50 = TREE_OPERAND (_q21, 0);
4333 321650 : {
4334 321650 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4335 321650 : tree res = generic_simplify_424 (loc, type, _p0, captures, MULT_EXPR);
4336 321650 : if (res) return res;
4337 : }
4338 321650 : break;
4339 : }
4340 4432278 : default:;
4341 : }
4342 4432278 : {
4343 4432278 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4344 4432278 : tree res = generic_simplify_425 (loc, type, _p0, captures, MULT_EXPR);
4345 4432278 : if (res) return res;
4346 : }
4347 4432159 : break;
4348 : }
4349 9671879 : default:;
4350 : }
4351 9671879 : switch (TREE_CODE (_q21))
4352 : {
4353 694899 : CASE_CONVERT:
4354 694899 : {
4355 694899 : tree _q40 = TREE_OPERAND (_q21, 0);
4356 694899 : {
4357 694899 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4358 694899 : tree res = generic_simplify_426 (loc, type, _p0, captures, MULT_EXPR);
4359 694899 : if (res) return res;
4360 : }
4361 694899 : break;
4362 : }
4363 9671879 : default:;
4364 : }
4365 9671879 : {
4366 9671879 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4367 9671879 : tree res = generic_simplify_427 (loc, type, _p0, captures, MULT_EXPR);
4368 9671879 : if (res) return res;
4369 : }
4370 9671846 : break;
4371 : }
4372 3074 : case RDIV_EXPR:
4373 3074 : {
4374 3074 : tree _q20 = TREE_OPERAND (_p0, 0);
4375 3074 : tree _q21 = TREE_OPERAND (_p0, 1);
4376 3074 : switch (TREE_CODE (_q20))
4377 : {
4378 971 : CASE_CONVERT:
4379 971 : {
4380 971 : tree _q30 = TREE_OPERAND (_q20, 0);
4381 971 : switch (TREE_CODE (_q21))
4382 : {
4383 669 : CASE_CONVERT:
4384 669 : {
4385 669 : tree _q50 = TREE_OPERAND (_q21, 0);
4386 669 : {
4387 669 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
4388 669 : tree res = generic_simplify_424 (loc, type, _p0, captures, RDIV_EXPR);
4389 669 : if (res) return res;
4390 : }
4391 668 : break;
4392 : }
4393 970 : default:;
4394 : }
4395 970 : {
4396 970 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
4397 970 : tree res = generic_simplify_425 (loc, type, _p0, captures, RDIV_EXPR);
4398 970 : if (res) return res;
4399 : }
4400 968 : break;
4401 : }
4402 3071 : default:;
4403 : }
4404 3071 : switch (TREE_CODE (_q21))
4405 : {
4406 1658 : CASE_CONVERT:
4407 1658 : {
4408 1658 : tree _q40 = TREE_OPERAND (_q21, 0);
4409 1658 : {
4410 1658 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
4411 1658 : tree res = generic_simplify_426 (loc, type, _p0, captures, RDIV_EXPR);
4412 1658 : if (res) return res;
4413 : }
4414 1013 : break;
4415 : }
4416 2426 : default:;
4417 : }
4418 2426 : {
4419 2426 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
4420 2426 : tree res = generic_simplify_427 (loc, type, _p0, captures, RDIV_EXPR);
4421 2426 : if (res) return res;
4422 : }
4423 2384 : break;
4424 : }
4425 588399 : case NEGATE_EXPR:
4426 588399 : {
4427 588399 : tree _q20 = TREE_OPERAND (_p0, 0);
4428 588399 : {
4429 588399 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4430 588399 : tree res = generic_simplify_428 (loc, type, _p0, captures);
4431 588399 : if (res) return res;
4432 : }
4433 588377 : break;
4434 : }
4435 : default:;
4436 : }
4437 : return NULL_TREE;
4438 : }
4439 :
4440 : tree
4441 6916 : generic_simplify_CEIL_DIV_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
4442 : {
4443 6916 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4444 6916 : if (integer_onep (_p1))
4445 : {
4446 1755 : {
4447 1755 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4448 1755 : tree res = generic_simplify_180 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4449 1755 : if (res) return res;
4450 : }
4451 : }
4452 5161 : if (integer_zerop (_p0))
4453 : {
4454 0 : {
4455 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4456 0 : tree res = generic_simplify_309 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4457 0 : if (res) return res;
4458 : }
4459 : }
4460 5161 : switch (TREE_CODE (_p1))
4461 : {
4462 34 : case SSA_NAME:
4463 34 : {
4464 34 : {
4465 34 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4466 34 : tree res = generic_simplify_311 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4467 34 : if (res) return res;
4468 : }
4469 34 : break;
4470 : }
4471 5161 : default:;
4472 : }
4473 5161 : if (integer_minus_onep (_p1))
4474 : {
4475 0 : {
4476 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4477 0 : tree res = generic_simplify_310 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4478 0 : if (res) return res;
4479 : }
4480 : }
4481 5161 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
4482 : {
4483 0 : {
4484 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4485 0 : tree res = generic_simplify_312 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4486 0 : if (res) return res;
4487 : }
4488 : }
4489 5161 : switch (TREE_CODE (_p1))
4490 : {
4491 0 : case ABS_EXPR:
4492 0 : {
4493 0 : tree _q30 = TREE_OPERAND (_p1, 0);
4494 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
4495 : {
4496 0 : {
4497 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4498 0 : tree res = generic_simplify_313 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4499 0 : if (res) return res;
4500 : }
4501 : }
4502 : break;
4503 : }
4504 5161 : default:;
4505 : }
4506 5161 : switch (TREE_CODE (_p0))
4507 : {
4508 0 : case ABS_EXPR:
4509 0 : {
4510 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4511 0 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4512 : {
4513 0 : {
4514 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4515 0 : tree res = generic_simplify_313 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4516 0 : if (res) return res;
4517 : }
4518 : }
4519 : break;
4520 : }
4521 5161 : default:;
4522 : }
4523 5161 : switch (TREE_CODE (_p1))
4524 : {
4525 0 : case NEGATE_EXPR:
4526 0 : {
4527 0 : tree _q30 = TREE_OPERAND (_p1, 0);
4528 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
4529 : {
4530 0 : {
4531 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4532 0 : tree res = generic_simplify_314 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4533 0 : if (res) return res;
4534 : }
4535 : }
4536 : break;
4537 : }
4538 5161 : default:;
4539 : }
4540 5161 : switch (TREE_CODE (_p0))
4541 : {
4542 0 : case NEGATE_EXPR:
4543 0 : {
4544 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4545 0 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4546 : {
4547 0 : {
4548 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4549 0 : tree res = generic_simplify_314 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4550 0 : if (res) return res;
4551 : }
4552 : }
4553 : break;
4554 : }
4555 536 : CASE_CONVERT:
4556 536 : {
4557 536 : tree _q20 = TREE_OPERAND (_p0, 0);
4558 536 : switch (TREE_CODE (_q20))
4559 : {
4560 0 : case BIT_AND_EXPR:
4561 0 : {
4562 0 : tree _q30 = TREE_OPERAND (_q20, 0);
4563 0 : tree _q31 = TREE_OPERAND (_q20, 1);
4564 0 : switch (TREE_CODE (_q31))
4565 : {
4566 0 : case INTEGER_CST:
4567 0 : {
4568 0 : switch (TREE_CODE (_p1))
4569 : {
4570 0 : case INTEGER_CST:
4571 0 : {
4572 0 : {
4573 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
4574 0 : tree res = generic_simplify_316 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4575 0 : if (res) return res;
4576 : }
4577 0 : break;
4578 : }
4579 : default:;
4580 : }
4581 : break;
4582 : }
4583 : default:;
4584 : }
4585 : break;
4586 : }
4587 : default:;
4588 : }
4589 : break;
4590 : }
4591 0 : case BIT_AND_EXPR:
4592 0 : {
4593 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4594 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4595 0 : switch (TREE_CODE (_q21))
4596 : {
4597 0 : case INTEGER_CST:
4598 0 : {
4599 0 : switch (TREE_CODE (_p1))
4600 : {
4601 0 : case INTEGER_CST:
4602 0 : {
4603 0 : {
4604 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4605 0 : tree res = generic_simplify_316 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4606 0 : if (res) return res;
4607 : }
4608 0 : break;
4609 : }
4610 : default:;
4611 : }
4612 : break;
4613 : }
4614 : default:;
4615 : }
4616 : break;
4617 : }
4618 0 : case MULT_EXPR:
4619 0 : {
4620 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4621 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4622 0 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
4623 : {
4624 0 : {
4625 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
4626 0 : tree res = generic_simplify_318 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4627 0 : if (res) return res;
4628 : }
4629 : }
4630 0 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4631 : {
4632 0 : {
4633 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
4634 0 : tree res = generic_simplify_318 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4635 0 : if (res) return res;
4636 : }
4637 : }
4638 0 : switch (TREE_CODE (_q21))
4639 : {
4640 0 : case INTEGER_CST:
4641 0 : {
4642 0 : switch (TREE_CODE (_p1))
4643 : {
4644 0 : case MULT_EXPR:
4645 0 : {
4646 0 : tree _q50 = TREE_OPERAND (_p1, 0);
4647 0 : tree _q51 = TREE_OPERAND (_p1, 1);
4648 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4649 : {
4650 0 : switch (TREE_CODE (_q51))
4651 : {
4652 0 : case INTEGER_CST:
4653 0 : {
4654 0 : {
4655 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
4656 0 : tree res = generic_simplify_319 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR);
4657 0 : if (res) return res;
4658 : }
4659 0 : break;
4660 : }
4661 : default:;
4662 : }
4663 : }
4664 : break;
4665 : }
4666 : default:;
4667 : }
4668 : break;
4669 : }
4670 : default:;
4671 : }
4672 : break;
4673 : }
4674 0 : case VEC_COND_EXPR:
4675 0 : {
4676 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4677 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4678 0 : tree _q22 = TREE_OPERAND (_p0, 2);
4679 0 : switch (TREE_CODE (_p1))
4680 : {
4681 0 : case VEC_COND_EXPR:
4682 0 : {
4683 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4684 0 : tree _q61 = TREE_OPERAND (_p1, 1);
4685 0 : tree _q62 = TREE_OPERAND (_p1, 2);
4686 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4687 : {
4688 0 : {
4689 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
4690 0 : if (VECTOR_TYPE_P (type)
4691 0 : && (TREE_CODE_CLASS (CEIL_DIV_EXPR) != tcc_comparison
4692 : || types_match (type, TREE_TYPE (captures[2]))
4693 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
4694 : || (optimize_vectors_before_lowering_p ()
4695 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
4696 : )
4697 : {
4698 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1559;
4699 0 : {
4700 0 : tree res_op0;
4701 0 : res_op0 = captures[1];
4702 0 : tree res_op1;
4703 0 : {
4704 0 : tree _o1[2], _r1;
4705 0 : _o1[0] = captures[2];
4706 0 : _o1[1] = captures[5];
4707 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4708 0 : if (EXPR_P (_r1))
4709 0 : goto next_after_fail1559;
4710 0 : res_op1 = _r1;
4711 : }
4712 0 : tree res_op2;
4713 0 : {
4714 0 : tree _o1[2], _r1;
4715 0 : _o1[0] = captures[3];
4716 0 : _o1[1] = captures[6];
4717 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4718 0 : if (EXPR_P (_r1))
4719 0 : goto next_after_fail1559;
4720 0 : res_op2 = _r1;
4721 : }
4722 0 : tree _r;
4723 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4724 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
4725 0 : return _r;
4726 : }
4727 0 : next_after_fail1559:;
4728 : }
4729 : }
4730 : }
4731 : break;
4732 : }
4733 0 : default:;
4734 : }
4735 0 : {
4736 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
4737 0 : if (VECTOR_TYPE_P (type)
4738 0 : && (TREE_CODE_CLASS (CEIL_DIV_EXPR) != tcc_comparison
4739 : || types_match (type, TREE_TYPE (captures[2]))
4740 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
4741 : || (optimize_vectors_before_lowering_p ()
4742 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
4743 : )
4744 : {
4745 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1560;
4746 0 : {
4747 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1560;
4748 0 : tree res_op0;
4749 0 : res_op0 = captures[1];
4750 0 : tree res_op1;
4751 0 : {
4752 0 : tree _o1[2], _r1;
4753 0 : _o1[0] = captures[2];
4754 0 : _o1[1] = unshare_expr (captures[4]);
4755 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4756 0 : if (EXPR_P (_r1))
4757 0 : goto next_after_fail1560;
4758 0 : res_op1 = _r1;
4759 : }
4760 0 : tree res_op2;
4761 0 : {
4762 0 : tree _o1[2], _r1;
4763 0 : _o1[0] = captures[3];
4764 0 : _o1[1] = captures[4];
4765 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4766 0 : if (EXPR_P (_r1))
4767 0 : goto next_after_fail1560;
4768 0 : res_op2 = _r1;
4769 : }
4770 0 : tree _r;
4771 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4772 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
4773 0 : return _r;
4774 : }
4775 0 : next_after_fail1560:;
4776 : }
4777 : }
4778 0 : break;
4779 : }
4780 5161 : default:;
4781 : }
4782 5161 : switch (TREE_CODE (_p1))
4783 : {
4784 0 : case VEC_COND_EXPR:
4785 0 : {
4786 0 : tree _q30 = TREE_OPERAND (_p1, 0);
4787 0 : tree _q31 = TREE_OPERAND (_p1, 1);
4788 0 : tree _q32 = TREE_OPERAND (_p1, 2);
4789 0 : {
4790 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
4791 0 : if (VECTOR_TYPE_P (type)
4792 0 : && (TREE_CODE_CLASS (CEIL_DIV_EXPR) != tcc_comparison
4793 : || types_match (type, TREE_TYPE (captures[3]))
4794 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
4795 : || (optimize_vectors_before_lowering_p ()
4796 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
4797 : )
4798 : {
4799 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1561;
4800 0 : {
4801 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1561;
4802 0 : tree res_op0;
4803 0 : res_op0 = captures[2];
4804 0 : tree res_op1;
4805 0 : {
4806 0 : tree _o1[2], _r1;
4807 0 : _o1[0] = unshare_expr (captures[0]);
4808 0 : _o1[1] = captures[3];
4809 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4810 0 : if (EXPR_P (_r1))
4811 0 : goto next_after_fail1561;
4812 0 : res_op1 = _r1;
4813 : }
4814 0 : tree res_op2;
4815 0 : {
4816 0 : tree _o1[2], _r1;
4817 0 : _o1[0] = captures[0];
4818 0 : _o1[1] = captures[4];
4819 0 : _r1 = fold_build2_loc (loc, CEIL_DIV_EXPR, type, _o1[0], _o1[1]);
4820 0 : if (EXPR_P (_r1))
4821 0 : goto next_after_fail1561;
4822 0 : res_op2 = _r1;
4823 : }
4824 0 : tree _r;
4825 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4826 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
4827 0 : return _r;
4828 : }
4829 0 : next_after_fail1561:;
4830 : }
4831 : }
4832 0 : break;
4833 : }
4834 : default:;
4835 : }
4836 : return NULL_TREE;
4837 : }
4838 :
4839 : tree
4840 4435268 : generic_simplify_EXACT_DIV_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
4841 : {
4842 4435268 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4843 4435268 : if (integer_onep (_p1))
4844 : {
4845 2946924 : {
4846 2946924 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4847 2946924 : tree res = generic_simplify_180 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
4848 2946924 : if (res) return res;
4849 : }
4850 : }
4851 1488344 : switch (TREE_CODE (_p0))
4852 : {
4853 9465 : CASE_CONVERT:
4854 9465 : {
4855 9465 : tree _q20 = TREE_OPERAND (_p0, 0);
4856 9465 : switch (TREE_CODE (_p1))
4857 : {
4858 0 : CASE_CONVERT:
4859 0 : {
4860 0 : tree _q40 = TREE_OPERAND (_p1, 0);
4861 0 : switch (TREE_CODE (_q40))
4862 : {
4863 0 : case LSHIFT_EXPR:
4864 0 : {
4865 0 : tree _q50 = TREE_OPERAND (_q40, 0);
4866 0 : tree _q51 = TREE_OPERAND (_q40, 1);
4867 0 : if (integer_onep (_q50))
4868 : {
4869 0 : {
4870 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q50, _q51 };
4871 0 : tree res = generic_simplify_307 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
4872 0 : if (res) return res;
4873 : }
4874 : }
4875 : break;
4876 : }
4877 : default:;
4878 : }
4879 : break;
4880 : }
4881 0 : case LSHIFT_EXPR:
4882 0 : {
4883 0 : tree _q40 = TREE_OPERAND (_p1, 0);
4884 0 : tree _q41 = TREE_OPERAND (_p1, 1);
4885 0 : if (integer_onep (_q40))
4886 : {
4887 0 : {
4888 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q41 };
4889 0 : tree res = generic_simplify_307 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
4890 0 : if (res) return res;
4891 : }
4892 : }
4893 : break;
4894 : }
4895 : default:;
4896 : }
4897 : break;
4898 : }
4899 1488344 : default:;
4900 : }
4901 1488344 : switch (TREE_CODE (_p1))
4902 : {
4903 2 : CASE_CONVERT:
4904 2 : {
4905 2 : tree _q30 = TREE_OPERAND (_p1, 0);
4906 2 : switch (TREE_CODE (_q30))
4907 : {
4908 0 : case LSHIFT_EXPR:
4909 0 : {
4910 0 : tree _q40 = TREE_OPERAND (_q30, 0);
4911 0 : tree _q41 = TREE_OPERAND (_q30, 1);
4912 0 : if (integer_onep (_q40))
4913 : {
4914 0 : {
4915 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q40, _q41 };
4916 0 : tree res = generic_simplify_308 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
4917 0 : if (res) return res;
4918 : }
4919 : }
4920 : break;
4921 : }
4922 : default:;
4923 : }
4924 : break;
4925 : }
4926 0 : case LSHIFT_EXPR:
4927 0 : {
4928 0 : tree _q30 = TREE_OPERAND (_p1, 0);
4929 0 : tree _q31 = TREE_OPERAND (_p1, 1);
4930 0 : if (integer_onep (_q30))
4931 : {
4932 0 : {
4933 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q30, _q31 };
4934 0 : tree res = generic_simplify_308 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
4935 0 : if (res) return res;
4936 : }
4937 : }
4938 : break;
4939 : }
4940 1488344 : default:;
4941 : }
4942 1488344 : if (integer_zerop (_p0))
4943 : {
4944 0 : {
4945 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4946 0 : tree res = generic_simplify_309 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
4947 0 : if (res) return res;
4948 : }
4949 : }
4950 1488344 : switch (TREE_CODE (_p1))
4951 : {
4952 0 : case SSA_NAME:
4953 0 : {
4954 0 : {
4955 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4956 0 : tree res = generic_simplify_311 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
4957 0 : if (res) return res;
4958 : }
4959 0 : break;
4960 : }
4961 1488344 : default:;
4962 : }
4963 1488344 : if (integer_minus_onep (_p1))
4964 : {
4965 0 : {
4966 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4967 0 : tree res = generic_simplify_310 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
4968 0 : if (res) return res;
4969 : }
4970 : }
4971 1488344 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
4972 : {
4973 0 : {
4974 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4975 0 : tree res = generic_simplify_312 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
4976 0 : if (res) return res;
4977 : }
4978 : }
4979 1488344 : switch (TREE_CODE (_p1))
4980 : {
4981 0 : case ABS_EXPR:
4982 0 : {
4983 0 : tree _q30 = TREE_OPERAND (_p1, 0);
4984 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
4985 : {
4986 0 : {
4987 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4988 0 : tree res = generic_simplify_313 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
4989 0 : if (res) return res;
4990 : }
4991 : }
4992 : break;
4993 : }
4994 1488344 : default:;
4995 : }
4996 1488344 : switch (TREE_CODE (_p0))
4997 : {
4998 0 : case ABS_EXPR:
4999 0 : {
5000 0 : tree _q20 = TREE_OPERAND (_p0, 0);
5001 0 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5002 : {
5003 0 : {
5004 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
5005 0 : tree res = generic_simplify_313 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5006 0 : if (res) return res;
5007 : }
5008 : }
5009 : break;
5010 : }
5011 1488344 : default:;
5012 : }
5013 1488344 : switch (TREE_CODE (_p1))
5014 : {
5015 0 : case NEGATE_EXPR:
5016 0 : {
5017 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5018 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5019 : {
5020 0 : {
5021 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
5022 0 : tree res = generic_simplify_314 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5023 0 : if (res) return res;
5024 : }
5025 : }
5026 : break;
5027 : }
5028 1488344 : default:;
5029 : }
5030 1488344 : switch (TREE_CODE (_p0))
5031 : {
5032 1466 : case NEGATE_EXPR:
5033 1466 : {
5034 1466 : tree _q20 = TREE_OPERAND (_p0, 0);
5035 1466 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5036 : {
5037 0 : {
5038 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
5039 0 : tree res = generic_simplify_314 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5040 0 : if (res) return res;
5041 : }
5042 : }
5043 : break;
5044 : }
5045 0 : case EXACT_DIV_EXPR:
5046 0 : {
5047 0 : tree _q20 = TREE_OPERAND (_p0, 0);
5048 0 : tree _q21 = TREE_OPERAND (_p0, 1);
5049 0 : switch (TREE_CODE (_q21))
5050 : {
5051 0 : case INTEGER_CST:
5052 0 : {
5053 0 : switch (TREE_CODE (_p1))
5054 : {
5055 0 : case INTEGER_CST:
5056 0 : {
5057 0 : {
5058 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
5059 0 : tree res = generic_simplify_315 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5060 0 : if (res) return res;
5061 : }
5062 0 : break;
5063 : }
5064 : default:;
5065 : }
5066 : break;
5067 : }
5068 : default:;
5069 : }
5070 : break;
5071 : }
5072 9465 : CASE_CONVERT:
5073 9465 : {
5074 9465 : tree _q20 = TREE_OPERAND (_p0, 0);
5075 9465 : switch (TREE_CODE (_q20))
5076 : {
5077 0 : case BIT_AND_EXPR:
5078 0 : {
5079 0 : tree _q30 = TREE_OPERAND (_q20, 0);
5080 0 : tree _q31 = TREE_OPERAND (_q20, 1);
5081 0 : switch (TREE_CODE (_q31))
5082 : {
5083 0 : case INTEGER_CST:
5084 0 : {
5085 0 : switch (TREE_CODE (_p1))
5086 : {
5087 0 : case INTEGER_CST:
5088 0 : {
5089 0 : {
5090 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
5091 0 : tree res = generic_simplify_316 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5092 0 : if (res) return res;
5093 : }
5094 0 : break;
5095 : }
5096 : default:;
5097 : }
5098 : break;
5099 : }
5100 : default:;
5101 : }
5102 : break;
5103 : }
5104 : default:;
5105 : }
5106 : break;
5107 : }
5108 0 : case BIT_AND_EXPR:
5109 0 : {
5110 0 : tree _q20 = TREE_OPERAND (_p0, 0);
5111 0 : tree _q21 = TREE_OPERAND (_p0, 1);
5112 0 : switch (TREE_CODE (_q21))
5113 : {
5114 0 : case INTEGER_CST:
5115 0 : {
5116 0 : switch (TREE_CODE (_p1))
5117 : {
5118 0 : case INTEGER_CST:
5119 0 : {
5120 0 : {
5121 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5122 0 : tree res = generic_simplify_316 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5123 0 : if (res) return res;
5124 : }
5125 0 : break;
5126 : }
5127 : default:;
5128 : }
5129 : break;
5130 : }
5131 : default:;
5132 : }
5133 : break;
5134 : }
5135 18648 : case MULT_EXPR:
5136 18648 : {
5137 18648 : tree _q20 = TREE_OPERAND (_p0, 0);
5138 18648 : tree _q21 = TREE_OPERAND (_p0, 1);
5139 18648 : if (integer_pow2p (_q21))
5140 : {
5141 17516 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5142 : {
5143 17436 : {
5144 17436 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5145 17436 : tree res = generic_simplify_317 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5146 17436 : if (res) return res;
5147 : }
5148 : }
5149 : }
5150 1219 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5151 : {
5152 7 : {
5153 7 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
5154 7 : tree res = generic_simplify_318 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5155 7 : if (res) return res;
5156 : }
5157 : }
5158 1212 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5159 : {
5160 0 : {
5161 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
5162 0 : tree res = generic_simplify_318 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5163 0 : if (res) return res;
5164 : }
5165 : }
5166 1212 : switch (TREE_CODE (_q21))
5167 : {
5168 1212 : case INTEGER_CST:
5169 1212 : {
5170 1212 : switch (TREE_CODE (_p1))
5171 : {
5172 0 : case MULT_EXPR:
5173 0 : {
5174 0 : tree _q50 = TREE_OPERAND (_p1, 0);
5175 0 : tree _q51 = TREE_OPERAND (_p1, 1);
5176 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5177 : {
5178 0 : switch (TREE_CODE (_q51))
5179 : {
5180 0 : case INTEGER_CST:
5181 0 : {
5182 0 : {
5183 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
5184 0 : tree res = generic_simplify_319 (loc, type, _p0, _p1, captures, EXACT_DIV_EXPR);
5185 0 : if (res) return res;
5186 : }
5187 0 : break;
5188 : }
5189 : default:;
5190 : }
5191 : }
5192 : break;
5193 : }
5194 : default:;
5195 : }
5196 : break;
5197 : }
5198 : default:;
5199 : }
5200 : break;
5201 : }
5202 0 : case VEC_COND_EXPR:
5203 0 : {
5204 0 : tree _q20 = TREE_OPERAND (_p0, 0);
5205 0 : tree _q21 = TREE_OPERAND (_p0, 1);
5206 0 : tree _q22 = TREE_OPERAND (_p0, 2);
5207 0 : switch (TREE_CODE (_p1))
5208 : {
5209 0 : case VEC_COND_EXPR:
5210 0 : {
5211 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5212 0 : tree _q61 = TREE_OPERAND (_p1, 1);
5213 0 : tree _q62 = TREE_OPERAND (_p1, 2);
5214 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
5215 : {
5216 0 : {
5217 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
5218 0 : if (VECTOR_TYPE_P (type)
5219 0 : && (TREE_CODE_CLASS (EXACT_DIV_EXPR) != tcc_comparison
5220 : || types_match (type, TREE_TYPE (captures[2]))
5221 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
5222 : || (optimize_vectors_before_lowering_p ()
5223 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
5224 : )
5225 : {
5226 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1568;
5227 0 : {
5228 0 : tree res_op0;
5229 0 : res_op0 = captures[1];
5230 0 : tree res_op1;
5231 0 : {
5232 0 : tree _o1[2], _r1;
5233 0 : _o1[0] = captures[2];
5234 0 : _o1[1] = captures[5];
5235 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5236 0 : if (EXPR_P (_r1))
5237 0 : goto next_after_fail1568;
5238 0 : res_op1 = _r1;
5239 : }
5240 0 : tree res_op2;
5241 0 : {
5242 0 : tree _o1[2], _r1;
5243 0 : _o1[0] = captures[3];
5244 0 : _o1[1] = captures[6];
5245 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5246 0 : if (EXPR_P (_r1))
5247 0 : goto next_after_fail1568;
5248 0 : res_op2 = _r1;
5249 : }
5250 0 : tree _r;
5251 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
5252 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
5253 0 : return _r;
5254 : }
5255 0 : next_after_fail1568:;
5256 : }
5257 : }
5258 : }
5259 : break;
5260 : }
5261 0 : default:;
5262 : }
5263 0 : {
5264 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
5265 0 : if (VECTOR_TYPE_P (type)
5266 0 : && (TREE_CODE_CLASS (EXACT_DIV_EXPR) != tcc_comparison
5267 : || types_match (type, TREE_TYPE (captures[2]))
5268 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
5269 : || (optimize_vectors_before_lowering_p ()
5270 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
5271 : )
5272 : {
5273 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1569;
5274 0 : {
5275 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1569;
5276 0 : tree res_op0;
5277 0 : res_op0 = captures[1];
5278 0 : tree res_op1;
5279 0 : {
5280 0 : tree _o1[2], _r1;
5281 0 : _o1[0] = captures[2];
5282 0 : _o1[1] = unshare_expr (captures[4]);
5283 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5284 0 : if (EXPR_P (_r1))
5285 0 : goto next_after_fail1569;
5286 0 : res_op1 = _r1;
5287 : }
5288 0 : tree res_op2;
5289 0 : {
5290 0 : tree _o1[2], _r1;
5291 0 : _o1[0] = captures[3];
5292 0 : _o1[1] = captures[4];
5293 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5294 0 : if (EXPR_P (_r1))
5295 0 : goto next_after_fail1569;
5296 0 : res_op2 = _r1;
5297 : }
5298 0 : tree _r;
5299 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
5300 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
5301 0 : return _r;
5302 : }
5303 0 : next_after_fail1569:;
5304 : }
5305 : }
5306 0 : break;
5307 : }
5308 1470908 : default:;
5309 : }
5310 1470908 : switch (TREE_CODE (_p1))
5311 : {
5312 0 : case VEC_COND_EXPR:
5313 0 : {
5314 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5315 0 : tree _q31 = TREE_OPERAND (_p1, 1);
5316 0 : tree _q32 = TREE_OPERAND (_p1, 2);
5317 0 : {
5318 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
5319 0 : if (VECTOR_TYPE_P (type)
5320 0 : && (TREE_CODE_CLASS (EXACT_DIV_EXPR) != tcc_comparison
5321 : || types_match (type, TREE_TYPE (captures[3]))
5322 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
5323 : || (optimize_vectors_before_lowering_p ()
5324 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
5325 : )
5326 : {
5327 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1570;
5328 0 : {
5329 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1570;
5330 0 : tree res_op0;
5331 0 : res_op0 = captures[2];
5332 0 : tree res_op1;
5333 0 : {
5334 0 : tree _o1[2], _r1;
5335 0 : _o1[0] = unshare_expr (captures[0]);
5336 0 : _o1[1] = captures[3];
5337 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5338 0 : if (EXPR_P (_r1))
5339 0 : goto next_after_fail1570;
5340 0 : res_op1 = _r1;
5341 : }
5342 0 : tree res_op2;
5343 0 : {
5344 0 : tree _o1[2], _r1;
5345 0 : _o1[0] = captures[0];
5346 0 : _o1[1] = captures[4];
5347 0 : _r1 = fold_build2_loc (loc, EXACT_DIV_EXPR, type, _o1[0], _o1[1]);
5348 0 : if (EXPR_P (_r1))
5349 0 : goto next_after_fail1570;
5350 0 : res_op2 = _r1;
5351 : }
5352 0 : tree _r;
5353 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
5354 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
5355 0 : return _r;
5356 : }
5357 0 : next_after_fail1570:;
5358 : }
5359 : }
5360 0 : break;
5361 : }
5362 : default:;
5363 : }
5364 : return NULL_TREE;
5365 : }
5366 :
5367 : tree
5368 10375479 : generic_simplify_LE_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
5369 : {
5370 10375479 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
5371 10375479 : switch (TREE_CODE (_p0))
5372 : {
5373 2318 : case RDIV_EXPR:
5374 2318 : {
5375 2318 : tree _q20 = TREE_OPERAND (_p0, 0);
5376 2318 : tree _q21 = TREE_OPERAND (_p0, 1);
5377 2318 : switch (TREE_CODE (_q20))
5378 : {
5379 548 : case REAL_CST:
5380 548 : {
5381 548 : if (real_zerop (_p1))
5382 : {
5383 2 : {
5384 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5385 2 : tree res = generic_simplify_370 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
5386 2 : if (res) return res;
5387 : }
5388 : }
5389 : break;
5390 : }
5391 : default:;
5392 : }
5393 : break;
5394 : }
5395 10375477 : default:;
5396 : }
5397 10375477 : switch (TREE_CODE (_p1))
5398 : {
5399 7 : case TRUNC_MOD_EXPR:
5400 7 : {
5401 7 : tree _q30 = TREE_OPERAND (_p1, 0);
5402 7 : tree _q31 = TREE_OPERAND (_p1, 1);
5403 7 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5404 : {
5405 0 : {
5406 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
5407 0 : tree res = generic_simplify_371 (loc, type, _p0, _p1, captures, GE_EXPR);
5408 0 : if (res) return res;
5409 : }
5410 : }
5411 : break;
5412 : }
5413 10375477 : default:;
5414 : }
5415 10375477 : switch (TREE_CODE (_p0))
5416 : {
5417 61881 : case MULT_EXPR:
5418 61881 : {
5419 61881 : tree _q20 = TREE_OPERAND (_p0, 0);
5420 61881 : tree _q21 = TREE_OPERAND (_p0, 1);
5421 61881 : switch (TREE_CODE (_p1))
5422 : {
5423 2720 : case MULT_EXPR:
5424 2720 : {
5425 2720 : tree _q50 = TREE_OPERAND (_p1, 0);
5426 2720 : tree _q51 = TREE_OPERAND (_p1, 1);
5427 2720 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5428 : {
5429 1869 : {
5430 1869 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5431 1869 : tree res = generic_simplify_372 (loc, type, _p0, _p1, captures, LE_EXPR);
5432 1869 : if (res) return res;
5433 : }
5434 : }
5435 1739 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5436 : {
5437 1 : {
5438 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5439 1 : tree res = generic_simplify_372 (loc, type, _p0, _p1, captures, LE_EXPR);
5440 1 : if (res) return res;
5441 : }
5442 : }
5443 1739 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5444 : {
5445 4 : {
5446 4 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
5447 4 : tree res = generic_simplify_372 (loc, type, _p0, _p1, captures, LE_EXPR);
5448 4 : if (res) return res;
5449 : }
5450 : }
5451 1739 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5452 : {
5453 315 : {
5454 315 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
5455 315 : tree res = generic_simplify_372 (loc, type, _p0, _p1, captures, LE_EXPR);
5456 315 : if (res) return res;
5457 : }
5458 : }
5459 : break;
5460 : }
5461 : default:;
5462 : }
5463 : break;
5464 : }
5465 1726644 : case PLUS_EXPR:
5466 1726644 : {
5467 1726644 : tree _q20 = TREE_OPERAND (_p0, 0);
5468 1726644 : tree _q21 = TREE_OPERAND (_p0, 1);
5469 1726644 : if (integer_minus_onep (_q21))
5470 : {
5471 559903 : switch (TREE_CODE (_p1))
5472 : {
5473 356610 : case INTEGER_CST:
5474 356610 : {
5475 356610 : {
5476 356610 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5477 356610 : tree res = generic_simplify_397 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR);
5478 356610 : if (res) return res;
5479 : }
5480 356608 : break;
5481 : }
5482 : default:;
5483 : }
5484 : }
5485 1726642 : switch (TREE_CODE (_p1))
5486 : {
5487 87345 : case PLUS_EXPR:
5488 87345 : {
5489 87345 : tree _q50 = TREE_OPERAND (_p1, 0);
5490 87345 : tree _q51 = TREE_OPERAND (_p1, 1);
5491 87345 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5492 : {
5493 7070 : {
5494 7070 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5495 7070 : tree res = generic_simplify_373 (loc, type, _p0, _p1, captures, LE_EXPR);
5496 7070 : if (res) return res;
5497 : }
5498 : }
5499 83214 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5500 : {
5501 13 : {
5502 13 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5503 13 : tree res = generic_simplify_373 (loc, type, _p0, _p1, captures, LE_EXPR);
5504 13 : if (res) return res;
5505 : }
5506 : }
5507 83214 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5508 : {
5509 191 : {
5510 191 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
5511 191 : tree res = generic_simplify_373 (loc, type, _p0, _p1, captures, LE_EXPR);
5512 191 : if (res) return res;
5513 : }
5514 : }
5515 83206 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5516 : {
5517 6986 : {
5518 6986 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
5519 6986 : tree res = generic_simplify_373 (loc, type, _p0, _p1, captures, LE_EXPR);
5520 6986 : if (res) return res;
5521 : }
5522 : }
5523 : break;
5524 : }
5525 1721977 : default:;
5526 : }
5527 1721977 : switch (TREE_CODE (_q21))
5528 : {
5529 1599895 : case INTEGER_CST:
5530 1599895 : {
5531 1599895 : switch (TREE_CODE (_p1))
5532 : {
5533 80629 : case PLUS_EXPR:
5534 80629 : {
5535 80629 : tree _q50 = TREE_OPERAND (_p1, 0);
5536 80629 : tree _q51 = TREE_OPERAND (_p1, 1);
5537 80629 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5538 : {
5539 2881 : {
5540 2881 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5541 2881 : tree res = generic_simplify_374 (loc, type, _p0, _p1, captures, LE_EXPR);
5542 2881 : if (res) return res;
5543 : }
5544 : }
5545 : break;
5546 : }
5547 : default:;
5548 : }
5549 : break;
5550 : }
5551 1721977 : default:;
5552 : }
5553 1721977 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5554 : {
5555 74047 : {
5556 74047 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
5557 74047 : tree res = generic_simplify_375 (loc, type, _p0, _p1, captures, LE_EXPR);
5558 74047 : if (res) return res;
5559 : }
5560 : }
5561 1680264 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5562 : {
5563 3116 : {
5564 3116 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
5565 3116 : tree res = generic_simplify_375 (loc, type, _p0, _p1, captures, LE_EXPR);
5566 3116 : if (res) return res;
5567 : }
5568 : }
5569 : break;
5570 : }
5571 2031245 : CASE_CONVERT:
5572 2031245 : {
5573 2031245 : tree _q20 = TREE_OPERAND (_p0, 0);
5574 2031245 : switch (TREE_CODE (_q20))
5575 : {
5576 0 : case EXACT_DIV_EXPR:
5577 0 : {
5578 0 : tree _q30 = TREE_OPERAND (_q20, 0);
5579 0 : tree _q31 = TREE_OPERAND (_q20, 1);
5580 0 : switch (TREE_CODE (_q31))
5581 : {
5582 0 : case INTEGER_CST:
5583 0 : {
5584 0 : switch (TREE_CODE (_p1))
5585 : {
5586 0 : CASE_CONVERT:
5587 0 : {
5588 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5589 0 : switch (TREE_CODE (_q60))
5590 : {
5591 0 : case EXACT_DIV_EXPR:
5592 0 : {
5593 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5594 0 : tree _q71 = TREE_OPERAND (_q60, 1);
5595 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
5596 : {
5597 0 : {
5598 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q70 };
5599 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, LE_EXPR);
5600 0 : if (res) return res;
5601 : }
5602 : }
5603 : break;
5604 : }
5605 : default:;
5606 : }
5607 : break;
5608 : }
5609 : default:;
5610 : }
5611 : break;
5612 : }
5613 : default:;
5614 : }
5615 : break;
5616 : }
5617 : default:;
5618 : }
5619 : break;
5620 : }
5621 417 : case EXACT_DIV_EXPR:
5622 417 : {
5623 417 : tree _q20 = TREE_OPERAND (_p0, 0);
5624 417 : tree _q21 = TREE_OPERAND (_p0, 1);
5625 417 : switch (TREE_CODE (_q21))
5626 : {
5627 417 : case INTEGER_CST:
5628 417 : {
5629 417 : switch (TREE_CODE (_p1))
5630 : {
5631 0 : case EXACT_DIV_EXPR:
5632 0 : {
5633 0 : tree _q50 = TREE_OPERAND (_p1, 0);
5634 0 : tree _q51 = TREE_OPERAND (_p1, 1);
5635 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5636 : {
5637 0 : {
5638 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
5639 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, LE_EXPR);
5640 0 : if (res) return res;
5641 : }
5642 : }
5643 : break;
5644 : }
5645 : default:;
5646 : }
5647 : break;
5648 : }
5649 : default:;
5650 : }
5651 : break;
5652 : }
5653 10811 : case TRUNC_DIV_EXPR:
5654 10811 : {
5655 10811 : tree _q20 = TREE_OPERAND (_p0, 0);
5656 10811 : tree _q21 = TREE_OPERAND (_p0, 1);
5657 10811 : switch (TREE_CODE (_q21))
5658 : {
5659 2814 : case INTEGER_CST:
5660 2814 : {
5661 2814 : switch (TREE_CODE (_p1))
5662 : {
5663 1389 : case INTEGER_CST:
5664 1389 : {
5665 1389 : {
5666 1389 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
5667 1389 : tree res = generic_simplify_213 (loc, type, _p0, _p1, captures, LE_EXPR);
5668 1389 : if (res) return res;
5669 : }
5670 679 : break;
5671 : }
5672 : default:;
5673 : }
5674 : break;
5675 : }
5676 : default:;
5677 : }
5678 : break;
5679 : }
5680 70144 : case MINUS_EXPR:
5681 70144 : {
5682 70144 : tree _q20 = TREE_OPERAND (_p0, 0);
5683 70144 : tree _q21 = TREE_OPERAND (_p0, 1);
5684 70144 : switch (TREE_CODE (_p1))
5685 : {
5686 500 : case MINUS_EXPR:
5687 500 : {
5688 500 : tree _q50 = TREE_OPERAND (_p1, 0);
5689 500 : tree _q51 = TREE_OPERAND (_p1, 1);
5690 500 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5691 : {
5692 54 : {
5693 54 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5694 54 : tree res = generic_simplify_376 (loc, type, _p0, _p1, captures, LE_EXPR);
5695 54 : if (res) return res;
5696 : }
5697 : }
5698 500 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5699 : {
5700 26 : {
5701 26 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5702 26 : tree res = generic_simplify_377 (loc, type, _p0, _p1, captures, LE_EXPR);
5703 26 : if (res) return res;
5704 : }
5705 : }
5706 : break;
5707 : }
5708 : default:;
5709 : }
5710 : break;
5711 : }
5712 5315 : case POINTER_DIFF_EXPR:
5713 5315 : {
5714 5315 : tree _q20 = TREE_OPERAND (_p0, 0);
5715 5315 : tree _q21 = TREE_OPERAND (_p0, 1);
5716 5315 : switch (TREE_CODE (_p1))
5717 : {
5718 251 : case POINTER_DIFF_EXPR:
5719 251 : {
5720 251 : tree _q50 = TREE_OPERAND (_p1, 0);
5721 251 : tree _q51 = TREE_OPERAND (_p1, 1);
5722 251 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5723 : {
5724 0 : {
5725 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
5726 0 : tree res = generic_simplify_218 (loc, type, _p0, _p1, captures, LE_EXPR);
5727 0 : if (res) return res;
5728 : }
5729 : }
5730 251 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5731 : {
5732 0 : {
5733 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
5734 0 : tree res = generic_simplify_219 (loc, type, _p0, _p1, captures, LE_EXPR);
5735 0 : if (res) return res;
5736 : }
5737 : }
5738 : break;
5739 : }
5740 : default:;
5741 : }
5742 : break;
5743 : }
5744 10327097 : default:;
5745 : }
5746 10327097 : switch (TREE_CODE (_p1))
5747 : {
5748 118489 : case PLUS_EXPR:
5749 118489 : {
5750 118489 : tree _q30 = TREE_OPERAND (_p1, 0);
5751 118489 : tree _q31 = TREE_OPERAND (_p1, 1);
5752 118489 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5753 : {
5754 0 : {
5755 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
5756 0 : tree res = generic_simplify_375 (loc, type, _p0, _p1, captures, GE_EXPR);
5757 0 : if (res) return res;
5758 : }
5759 : }
5760 118489 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5761 : {
5762 57 : {
5763 57 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q31, _p0 };
5764 57 : tree res = generic_simplify_375 (loc, type, _p0, _p1, captures, GE_EXPR);
5765 57 : if (res) return res;
5766 : }
5767 : }
5768 : break;
5769 : }
5770 1215 : case MINUS_EXPR:
5771 1215 : {
5772 1215 : tree _q30 = TREE_OPERAND (_p1, 0);
5773 1215 : tree _q31 = TREE_OPERAND (_p1, 1);
5774 1215 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5775 : {
5776 0 : {
5777 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
5778 0 : tree res = generic_simplify_217 (loc, type, _p0, _p1, captures, LE_EXPR);
5779 0 : if (res) return res;
5780 : }
5781 : }
5782 : break;
5783 : }
5784 10327070 : default:;
5785 : }
5786 10327070 : switch (TREE_CODE (_p0))
5787 : {
5788 70144 : case MINUS_EXPR:
5789 70144 : {
5790 70144 : tree _q20 = TREE_OPERAND (_p0, 0);
5791 70144 : tree _q21 = TREE_OPERAND (_p0, 1);
5792 70144 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5793 : {
5794 2510 : {
5795 2510 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
5796 2510 : tree res = generic_simplify_217 (loc, type, _p0, _p1, captures, GE_EXPR);
5797 2510 : if (res) return res;
5798 : }
5799 : }
5800 : break;
5801 : }
5802 5260 : case BIT_AND_EXPR:
5803 5260 : {
5804 5260 : tree _q20 = TREE_OPERAND (_p0, 0);
5805 5260 : tree _q21 = TREE_OPERAND (_p0, 1);
5806 5260 : if (tree_expr_nonnegative_p (_q20))
5807 : {
5808 4456 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5809 : {
5810 0 : {
5811 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5812 0 : tree res = generic_simplify_378 (loc, type, _p0, _p1, captures, LE_EXPR, BIT_AND_EXPR);
5813 0 : if (res) return res;
5814 : }
5815 : }
5816 : }
5817 5260 : if (tree_expr_nonnegative_p (_q21))
5818 : {
5819 4866 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5820 : {
5821 0 : {
5822 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
5823 0 : tree res = generic_simplify_378 (loc, type, _p0, _p1, captures, LE_EXPR, BIT_AND_EXPR);
5824 0 : if (res) return res;
5825 : }
5826 : }
5827 : }
5828 : break;
5829 : }
5830 10327070 : default:;
5831 : }
5832 10327070 : switch (TREE_CODE (_p1))
5833 : {
5834 46 : case BIT_IOR_EXPR:
5835 46 : {
5836 46 : tree _q30 = TREE_OPERAND (_p1, 0);
5837 46 : tree _q31 = TREE_OPERAND (_p1, 1);
5838 46 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5839 : {
5840 0 : if (tree_expr_nonnegative_p (_q30))
5841 : {
5842 0 : {
5843 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
5844 0 : tree res = generic_simplify_378 (loc, type, _p0, _p1, captures, GE_EXPR, BIT_IOR_EXPR);
5845 0 : if (res) return res;
5846 : }
5847 : }
5848 : }
5849 46 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5850 : {
5851 0 : if (tree_expr_nonnegative_p (_q31))
5852 : {
5853 0 : {
5854 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
5855 0 : tree res = generic_simplify_378 (loc, type, _p0, _p1, captures, GE_EXPR, BIT_IOR_EXPR);
5856 0 : if (res) return res;
5857 : }
5858 : }
5859 : }
5860 : break;
5861 : }
5862 10327070 : default:;
5863 : }
5864 10327070 : switch (TREE_CODE (_p0))
5865 : {
5866 4378 : case MAX_EXPR:
5867 4378 : {
5868 4378 : tree _q20 = TREE_OPERAND (_p0, 0);
5869 4378 : tree _q21 = TREE_OPERAND (_p0, 1);
5870 4378 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5871 : {
5872 0 : {
5873 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5874 0 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR, GE_EXPR);
5875 0 : if (res) return res;
5876 : }
5877 : }
5878 4378 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5879 : {
5880 1 : {
5881 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
5882 1 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR, GE_EXPR);
5883 1 : if (res) return res;
5884 : }
5885 : }
5886 4377 : switch (TREE_CODE (_q21))
5887 : {
5888 4136 : case INTEGER_CST:
5889 4136 : {
5890 4136 : switch (TREE_CODE (_p1))
5891 : {
5892 0 : case INTEGER_CST:
5893 0 : {
5894 0 : {
5895 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5896 0 : tree res = generic_simplify_379 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR, BIT_AND_EXPR);
5897 0 : if (res) return res;
5898 : }
5899 0 : break;
5900 : }
5901 : default:;
5902 : }
5903 : break;
5904 : }
5905 : default:;
5906 : }
5907 : break;
5908 : }
5909 10327069 : default:;
5910 : }
5911 10327069 : switch (TREE_CODE (_p1))
5912 : {
5913 306 : case MIN_EXPR:
5914 306 : {
5915 306 : tree _q30 = TREE_OPERAND (_p1, 0);
5916 306 : tree _q31 = TREE_OPERAND (_p1, 1);
5917 306 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5918 : {
5919 0 : {
5920 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
5921 0 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR, LE_EXPR);
5922 0 : if (res) return res;
5923 : }
5924 : }
5925 306 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5926 : {
5927 0 : {
5928 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
5929 0 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR, LE_EXPR);
5930 0 : if (res) return res;
5931 : }
5932 : }
5933 : break;
5934 : }
5935 13 : case MAX_EXPR:
5936 13 : {
5937 13 : tree _q30 = TREE_OPERAND (_p1, 0);
5938 13 : tree _q31 = TREE_OPERAND (_p1, 1);
5939 13 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5940 : {
5941 0 : {
5942 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
5943 0 : tree res = generic_simplify_380 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR);
5944 0 : if (res) return res;
5945 : }
5946 : }
5947 13 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5948 : {
5949 0 : {
5950 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
5951 0 : tree res = generic_simplify_380 (loc, type, _p0, _p1, captures, MAX_EXPR, LE_EXPR);
5952 0 : if (res) return res;
5953 : }
5954 : }
5955 : break;
5956 : }
5957 10327069 : default:;
5958 : }
5959 10327069 : switch (TREE_CODE (_p0))
5960 : {
5961 9656 : case MIN_EXPR:
5962 9656 : {
5963 9656 : tree _q20 = TREE_OPERAND (_p0, 0);
5964 9656 : tree _q21 = TREE_OPERAND (_p0, 1);
5965 9656 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5966 : {
5967 0 : {
5968 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5969 0 : tree res = generic_simplify_380 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR);
5970 0 : if (res) return res;
5971 : }
5972 : }
5973 9656 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5974 : {
5975 0 : {
5976 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
5977 0 : tree res = generic_simplify_380 (loc, type, _p0, _p1, captures, MIN_EXPR, GE_EXPR);
5978 0 : if (res) return res;
5979 : }
5980 : }
5981 9656 : switch (TREE_CODE (_q21))
5982 : {
5983 919 : case INTEGER_CST:
5984 919 : {
5985 919 : switch (TREE_CODE (_p1))
5986 : {
5987 0 : case INTEGER_CST:
5988 0 : {
5989 0 : {
5990 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5991 0 : tree res = generic_simplify_379 (loc, type, _p0, _p1, captures, MIN_EXPR, LE_EXPR, BIT_IOR_EXPR);
5992 0 : if (res) return res;
5993 : }
5994 0 : break;
5995 : }
5996 : default:;
5997 : }
5998 : break;
5999 : }
6000 : default:;
6001 : }
6002 : break;
6003 : }
6004 9 : case VEC_COND_EXPR:
6005 9 : {
6006 9 : tree _q20 = TREE_OPERAND (_p0, 0);
6007 9 : tree _q21 = TREE_OPERAND (_p0, 1);
6008 9 : tree _q22 = TREE_OPERAND (_p0, 2);
6009 9 : switch (TREE_CODE (_p1))
6010 : {
6011 2 : case VEC_COND_EXPR:
6012 2 : {
6013 2 : tree _q60 = TREE_OPERAND (_p1, 0);
6014 2 : tree _q61 = TREE_OPERAND (_p1, 1);
6015 2 : tree _q62 = TREE_OPERAND (_p1, 2);
6016 2 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6017 : {
6018 0 : {
6019 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
6020 0 : if (VECTOR_TYPE_P (type)
6021 0 : && (TREE_CODE_CLASS (LE_EXPR) != tcc_comparison
6022 0 : || types_match (type, TREE_TYPE (captures[2]))
6023 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
6024 : || (optimize_vectors_before_lowering_p ()
6025 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
6026 : )
6027 : {
6028 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1616;
6029 0 : {
6030 0 : tree res_op0;
6031 0 : res_op0 = captures[1];
6032 0 : tree res_op1;
6033 0 : {
6034 0 : tree _o1[2], _r1;
6035 0 : _o1[0] = captures[2];
6036 0 : _o1[1] = captures[5];
6037 0 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6038 0 : if (EXPR_P (_r1))
6039 0 : goto next_after_fail1616;
6040 0 : res_op1 = _r1;
6041 : }
6042 0 : tree res_op2;
6043 0 : {
6044 0 : tree _o1[2], _r1;
6045 0 : _o1[0] = captures[3];
6046 0 : _o1[1] = captures[6];
6047 0 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6048 0 : if (EXPR_P (_r1))
6049 0 : goto next_after_fail1616;
6050 0 : res_op2 = _r1;
6051 : }
6052 0 : tree _r;
6053 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
6054 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
6055 0 : return _r;
6056 : }
6057 0 : next_after_fail1616:;
6058 : }
6059 : }
6060 : }
6061 : break;
6062 : }
6063 9 : default:;
6064 : }
6065 9 : {
6066 9 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
6067 9 : if (VECTOR_TYPE_P (type)
6068 9 : && (TREE_CODE_CLASS (LE_EXPR) != tcc_comparison
6069 9 : || types_match (type, TREE_TYPE (captures[2]))
6070 9 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
6071 : || (optimize_vectors_before_lowering_p ()
6072 1 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
6073 : )
6074 : {
6075 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1617;
6076 9 : {
6077 9 : if (! tree_invariant_p (captures[4])) goto next_after_fail1617;
6078 7 : tree res_op0;
6079 7 : res_op0 = captures[1];
6080 7 : tree res_op1;
6081 7 : {
6082 7 : tree _o1[2], _r1;
6083 7 : _o1[0] = captures[2];
6084 7 : _o1[1] = unshare_expr (captures[4]);
6085 7 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6086 7 : if (EXPR_P (_r1))
6087 0 : goto next_after_fail1617;
6088 7 : res_op1 = _r1;
6089 : }
6090 7 : tree res_op2;
6091 7 : {
6092 7 : tree _o1[2], _r1;
6093 7 : _o1[0] = captures[3];
6094 7 : _o1[1] = captures[4];
6095 7 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6096 7 : if (EXPR_P (_r1))
6097 0 : goto next_after_fail1617;
6098 7 : res_op2 = _r1;
6099 : }
6100 7 : tree _r;
6101 7 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
6102 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
6103 7 : return _r;
6104 : }
6105 2 : next_after_fail1617:;
6106 : }
6107 : }
6108 2 : break;
6109 : }
6110 10327062 : default:;
6111 : }
6112 10327062 : switch (TREE_CODE (_p1))
6113 : {
6114 2 : case VEC_COND_EXPR:
6115 2 : {
6116 2 : tree _q30 = TREE_OPERAND (_p1, 0);
6117 2 : tree _q31 = TREE_OPERAND (_p1, 1);
6118 2 : tree _q32 = TREE_OPERAND (_p1, 2);
6119 2 : {
6120 2 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
6121 2 : if (VECTOR_TYPE_P (type)
6122 2 : && (TREE_CODE_CLASS (LE_EXPR) != tcc_comparison
6123 2 : || types_match (type, TREE_TYPE (captures[3]))
6124 2 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
6125 : || (optimize_vectors_before_lowering_p ()
6126 1 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
6127 : )
6128 : {
6129 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1618;
6130 2 : {
6131 2 : if (! tree_invariant_p (captures[0])) goto next_after_fail1618;
6132 0 : tree res_op0;
6133 0 : res_op0 = captures[2];
6134 0 : tree res_op1;
6135 0 : {
6136 0 : tree _o1[2], _r1;
6137 0 : _o1[0] = unshare_expr (captures[0]);
6138 0 : _o1[1] = captures[3];
6139 0 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6140 0 : if (EXPR_P (_r1))
6141 0 : goto next_after_fail1618;
6142 0 : res_op1 = _r1;
6143 : }
6144 0 : tree res_op2;
6145 0 : {
6146 0 : tree _o1[2], _r1;
6147 0 : _o1[0] = captures[0];
6148 0 : _o1[1] = captures[4];
6149 0 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
6150 0 : if (EXPR_P (_r1))
6151 0 : goto next_after_fail1618;
6152 0 : res_op2 = _r1;
6153 : }
6154 0 : tree _r;
6155 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
6156 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
6157 0 : return _r;
6158 : }
6159 2 : next_after_fail1618:;
6160 : }
6161 : }
6162 2 : break;
6163 : }
6164 10327062 : default:;
6165 : }
6166 10327062 : if (uniform_integer_cst_p (_p1))
6167 : {
6168 7653775 : {
6169 7653775 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
6170 7653775 : tree res = generic_simplify_398 (loc, type, _p0, _p1, captures, LE_EXPR, LT_EXPR);
6171 7653775 : if (res) return res;
6172 : }
6173 : }
6174 10230991 : switch (TREE_CODE (_p0))
6175 : {
6176 60479 : case MULT_EXPR:
6177 60479 : {
6178 60479 : tree _q20 = TREE_OPERAND (_p0, 0);
6179 60479 : tree _q21 = TREE_OPERAND (_p0, 1);
6180 60479 : switch (TREE_CODE (_q21))
6181 : {
6182 53144 : case INTEGER_CST:
6183 53144 : {
6184 53144 : if (integer_zerop (_p1))
6185 : {
6186 948 : {
6187 948 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
6188 948 : tree res = generic_simplify_247 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6189 948 : if (res) return res;
6190 : }
6191 : }
6192 : break;
6193 : }
6194 : default:;
6195 : }
6196 : break;
6197 : }
6198 10230246 : default:;
6199 : }
6200 10230246 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
6201 : {
6202 4946 : {
6203 4946 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
6204 4946 : tree res = generic_simplify_249 (loc, type, _p0, _p1, captures, LE_EXPR);
6205 4946 : if (res) return res;
6206 : }
6207 : }
6208 10225342 : switch (TREE_CODE (_p0))
6209 : {
6210 2516 : case BIT_NOT_EXPR:
6211 2516 : {
6212 2516 : tree _q20 = TREE_OPERAND (_p0, 0);
6213 2516 : switch (TREE_CODE (_p1))
6214 : {
6215 0 : case BIT_NOT_EXPR:
6216 0 : {
6217 0 : tree _q40 = TREE_OPERAND (_p1, 0);
6218 0 : {
6219 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _p1, _q40 };
6220 0 : tree res = generic_simplify_253 (loc, type, _p0, _p1, captures, LE_EXPR);
6221 0 : if (res) return res;
6222 : }
6223 0 : break;
6224 : }
6225 2516 : default:;
6226 : }
6227 2516 : {
6228 2516 : tree _p1_pops[1];
6229 2516 : if (tree_nop_convert (_p1, _p1_pops))
6230 : {
6231 1 : tree _q40 = _p1_pops[0];
6232 1 : switch (TREE_CODE (_q40))
6233 : {
6234 0 : case BIT_NOT_EXPR:
6235 0 : {
6236 0 : tree _q50 = TREE_OPERAND (_q40, 0);
6237 0 : {
6238 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40, _q50 };
6239 0 : tree res = generic_simplify_253 (loc, type, _p0, _p1, captures, LE_EXPR);
6240 0 : if (res) return res;
6241 : }
6242 0 : break;
6243 : }
6244 : default:;
6245 : }
6246 : }
6247 : }
6248 2516 : if (CONSTANT_CLASS_P (_p1))
6249 : {
6250 2222 : {
6251 2222 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
6252 2222 : tree res = generic_simplify_252 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6253 2222 : if (res) return res;
6254 : }
6255 : }
6256 : break;
6257 : }
6258 10223120 : default:;
6259 : }
6260 10223120 : {
6261 10223120 : tree _p0_pops[1];
6262 10223120 : if (tree_nop_convert (_p0, _p0_pops))
6263 : {
6264 1019026 : tree _q20 = _p0_pops[0];
6265 1019026 : switch (TREE_CODE (_q20))
6266 : {
6267 0 : case BIT_NOT_EXPR:
6268 0 : {
6269 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6270 0 : switch (TREE_CODE (_p1))
6271 : {
6272 0 : case BIT_NOT_EXPR:
6273 0 : {
6274 0 : tree _q50 = TREE_OPERAND (_p1, 0);
6275 0 : {
6276 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _p1, _q50 };
6277 0 : tree res = generic_simplify_251 (loc, type, _p0, _p1, captures, LE_EXPR);
6278 0 : if (res) return res;
6279 : }
6280 0 : break;
6281 : }
6282 0 : default:;
6283 : }
6284 0 : {
6285 0 : tree _p1_pops[1];
6286 0 : if (tree_nop_convert (_p1, _p1_pops))
6287 : {
6288 0 : tree _q50 = _p1_pops[0];
6289 0 : switch (TREE_CODE (_q50))
6290 : {
6291 0 : case BIT_NOT_EXPR:
6292 0 : {
6293 0 : tree _q60 = TREE_OPERAND (_q50, 0);
6294 0 : {
6295 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50, _q60 };
6296 0 : tree res = generic_simplify_251 (loc, type, _p0, _p1, captures, LE_EXPR);
6297 0 : if (res) return res;
6298 : }
6299 0 : break;
6300 : }
6301 : default:;
6302 : }
6303 : }
6304 : }
6305 0 : if (CONSTANT_CLASS_P (_p1))
6306 : {
6307 0 : {
6308 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
6309 0 : tree res = generic_simplify_252 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6310 0 : if (res) return res;
6311 : }
6312 : }
6313 : break;
6314 : }
6315 : default:;
6316 : }
6317 : }
6318 : }
6319 10223120 : switch (TREE_CODE (_p1))
6320 : {
6321 186323 : case REAL_CST:
6322 186323 : {
6323 186323 : {
6324 186323 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
6325 186323 : tree res = generic_simplify_254 (loc, type, _p0, _p1, captures, LE_EXPR);
6326 186323 : if (res) return res;
6327 : }
6328 186247 : break;
6329 : }
6330 10223044 : default:;
6331 : }
6332 10223044 : switch (TREE_CODE (_p0))
6333 : {
6334 1678638 : case PLUS_EXPR:
6335 1678638 : {
6336 1678638 : tree _q20 = TREE_OPERAND (_p0, 0);
6337 1678638 : tree _q21 = TREE_OPERAND (_p0, 1);
6338 1678638 : switch (TREE_CODE (_q21))
6339 : {
6340 86 : case REAL_CST:
6341 86 : {
6342 86 : switch (TREE_CODE (_p1))
6343 : {
6344 81 : case REAL_CST:
6345 81 : {
6346 81 : {
6347 81 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6348 81 : tree res = generic_simplify_255 (loc, type, _p0, _p1, captures, PLUS_EXPR, LE_EXPR);
6349 81 : if (res) return res;
6350 : }
6351 81 : break;
6352 : }
6353 : default:;
6354 : }
6355 : break;
6356 : }
6357 1577308 : case INTEGER_CST:
6358 1577308 : {
6359 1577308 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
6360 : {
6361 1968 : {
6362 1968 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q20, _q21 };
6363 1968 : tree res = generic_simplify_382 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR);
6364 1968 : if (res) return res;
6365 : }
6366 : }
6367 : break;
6368 : }
6369 : default:;
6370 : }
6371 : break;
6372 : }
6373 64529 : case MINUS_EXPR:
6374 64529 : {
6375 64529 : tree _q20 = TREE_OPERAND (_p0, 0);
6376 64529 : tree _q21 = TREE_OPERAND (_p0, 1);
6377 64529 : switch (TREE_CODE (_q21))
6378 : {
6379 1225 : case REAL_CST:
6380 1225 : {
6381 1225 : switch (TREE_CODE (_p1))
6382 : {
6383 1202 : case REAL_CST:
6384 1202 : {
6385 1202 : {
6386 1202 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6387 1202 : tree res = generic_simplify_255 (loc, type, _p0, _p1, captures, MINUS_EXPR, LE_EXPR);
6388 1202 : if (res) return res;
6389 : }
6390 1202 : break;
6391 : }
6392 : default:;
6393 : }
6394 : break;
6395 : }
6396 64529 : default:;
6397 : }
6398 64529 : switch (TREE_CODE (_q20))
6399 : {
6400 2 : case REAL_CST:
6401 2 : {
6402 2 : switch (TREE_CODE (_p1))
6403 : {
6404 0 : case REAL_CST:
6405 0 : {
6406 0 : {
6407 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6408 0 : tree res = generic_simplify_256 (loc, type, _p0, _p1, captures, LE_EXPR);
6409 0 : if (res) return res;
6410 : }
6411 0 : break;
6412 : }
6413 : default:;
6414 : }
6415 : break;
6416 : }
6417 : default:;
6418 : }
6419 : break;
6420 : }
6421 11745 : case FLOAT_EXPR:
6422 11745 : {
6423 11745 : tree _q20 = TREE_OPERAND (_p0, 0);
6424 11745 : switch (TREE_CODE (_p1))
6425 : {
6426 0 : case FLOAT_EXPR:
6427 0 : {
6428 0 : tree _q40 = TREE_OPERAND (_p1, 0);
6429 0 : {
6430 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
6431 0 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, LE_EXPR, LE_EXPR);
6432 0 : if (res) return res;
6433 : }
6434 0 : break;
6435 : }
6436 235 : case REAL_CST:
6437 235 : {
6438 235 : {
6439 235 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6440 235 : tree res = generic_simplify_260 (loc, type, _p0, _p1, captures, LE_EXPR, LE_EXPR);
6441 235 : if (res) return res;
6442 : }
6443 156 : break;
6444 : }
6445 : default:;
6446 : }
6447 : break;
6448 : }
6449 417 : case EXACT_DIV_EXPR:
6450 417 : {
6451 417 : tree _q20 = TREE_OPERAND (_p0, 0);
6452 417 : tree _q21 = TREE_OPERAND (_p0, 1);
6453 417 : switch (TREE_CODE (_q21))
6454 : {
6455 417 : case INTEGER_CST:
6456 417 : {
6457 417 : switch (TREE_CODE (_p1))
6458 : {
6459 340 : case INTEGER_CST:
6460 340 : {
6461 340 : {
6462 340 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6463 340 : tree res = generic_simplify_383 (loc, type, _p0, _p1, captures, LE_EXPR);
6464 340 : if (res) return res;
6465 : }
6466 0 : break;
6467 : }
6468 : default:;
6469 : }
6470 : break;
6471 : }
6472 : default:;
6473 : }
6474 : break;
6475 : }
6476 2028012 : CASE_CONVERT:
6477 2028012 : {
6478 2028012 : tree _q20 = TREE_OPERAND (_p0, 0);
6479 2028012 : switch (TREE_CODE (_q20))
6480 : {
6481 0 : case EXACT_DIV_EXPR:
6482 0 : {
6483 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6484 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6485 0 : switch (TREE_CODE (_q31))
6486 : {
6487 0 : case INTEGER_CST:
6488 0 : {
6489 0 : switch (TREE_CODE (_p1))
6490 : {
6491 0 : case INTEGER_CST:
6492 0 : {
6493 0 : {
6494 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
6495 0 : tree res = generic_simplify_384 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6496 0 : if (res) return res;
6497 : }
6498 0 : break;
6499 : }
6500 : default:;
6501 : }
6502 : break;
6503 : }
6504 : default:;
6505 : }
6506 : break;
6507 : }
6508 2028012 : default:;
6509 : }
6510 2028012 : switch (TREE_CODE (_p1))
6511 : {
6512 110172 : CASE_CONVERT:
6513 110172 : {
6514 110172 : tree _q40 = TREE_OPERAND (_p1, 0);
6515 110172 : {
6516 110172 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
6517 110172 : tree res = generic_simplify_264 (loc, type, _p0, _p1, captures, LE_EXPR);
6518 110172 : if (res) return res;
6519 : }
6520 28832 : break;
6521 : }
6522 1946672 : default:;
6523 : }
6524 1946672 : {
6525 1946672 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
6526 1946672 : tree res = generic_simplify_265 (loc, type, _p0, _p1, captures, LE_EXPR);
6527 1946672 : if (res) return res;
6528 : }
6529 1003914 : switch (TREE_CODE (_q20))
6530 : {
6531 5861 : case ADDR_EXPR:
6532 5861 : {
6533 5861 : switch (TREE_CODE (_p1))
6534 : {
6535 5550 : CASE_CONVERT:
6536 5550 : {
6537 5550 : tree _q40 = TREE_OPERAND (_p1, 0);
6538 5550 : switch (TREE_CODE (_q40))
6539 : {
6540 5550 : case ADDR_EXPR:
6541 5550 : {
6542 5550 : {
6543 5550 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
6544 5550 : tree res = generic_simplify_283 (loc, type, _p0, _p1, captures, LE_EXPR);
6545 5550 : if (res) return res;
6546 : }
6547 160 : break;
6548 : }
6549 : default:;
6550 : }
6551 : break;
6552 : }
6553 0 : case ADDR_EXPR:
6554 0 : {
6555 0 : {
6556 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
6557 0 : tree res = generic_simplify_283 (loc, type, _p0, _p1, captures, LE_EXPR);
6558 0 : if (res) return res;
6559 : }
6560 0 : break;
6561 : }
6562 : default:;
6563 : }
6564 : break;
6565 : }
6566 998524 : default:;
6567 : }
6568 998524 : if (uniform_integer_cst_p (_p1))
6569 : {
6570 536180 : {
6571 536180 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
6572 536180 : tree res = generic_simplify_385 (loc, type, _p0, _p1, captures, LE_EXPR);
6573 536180 : if (res) return res;
6574 : }
6575 : }
6576 : break;
6577 : }
6578 5260 : case BIT_AND_EXPR:
6579 5260 : {
6580 5260 : tree _q20 = TREE_OPERAND (_p0, 0);
6581 5260 : tree _q21 = TREE_OPERAND (_p0, 1);
6582 5260 : switch (TREE_CODE (_q21))
6583 : {
6584 4779 : case INTEGER_CST:
6585 4779 : {
6586 4779 : switch (TREE_CODE (_p1))
6587 : {
6588 2712 : case INTEGER_CST:
6589 2712 : {
6590 2712 : {
6591 2712 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
6592 2712 : tree res = generic_simplify_399 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR);
6593 2712 : if (res) return res;
6594 : }
6595 2665 : break;
6596 : }
6597 : default:;
6598 : }
6599 : break;
6600 : }
6601 : default:;
6602 : }
6603 : break;
6604 : }
6605 5462 : case NEGATE_EXPR:
6606 5462 : {
6607 5462 : tree _q20 = TREE_OPERAND (_p0, 0);
6608 5462 : switch (TREE_CODE (_p1))
6609 : {
6610 32 : case NEGATE_EXPR:
6611 32 : {
6612 32 : tree _q40 = TREE_OPERAND (_p1, 0);
6613 32 : {
6614 32 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6615 32 : tree res = generic_simplify_262 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6616 32 : if (res) return res;
6617 : }
6618 32 : break;
6619 : }
6620 5462 : default:;
6621 : }
6622 5462 : if (CONSTANT_CLASS_P (_p1))
6623 : {
6624 452 : {
6625 452 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6626 452 : tree res = generic_simplify_263 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
6627 452 : if (res) return res;
6628 : }
6629 : }
6630 : break;
6631 : }
6632 1483 : case ADDR_EXPR:
6633 1483 : {
6634 1483 : switch (TREE_CODE (_p1))
6635 : {
6636 18 : CASE_CONVERT:
6637 18 : {
6638 18 : tree _q30 = TREE_OPERAND (_p1, 0);
6639 18 : switch (TREE_CODE (_q30))
6640 : {
6641 18 : case ADDR_EXPR:
6642 18 : {
6643 18 : {
6644 18 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q30 };
6645 18 : tree res = generic_simplify_284 (loc, type, _p0, _p1, captures, LE_EXPR);
6646 18 : if (res) return res;
6647 : }
6648 0 : break;
6649 : }
6650 : default:;
6651 : }
6652 : break;
6653 : }
6654 645 : case ADDR_EXPR:
6655 645 : {
6656 645 : {
6657 645 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
6658 645 : tree res = generic_simplify_284 (loc, type, _p0, _p1, captures, LE_EXPR);
6659 645 : if (res) return res;
6660 : }
6661 300 : break;
6662 : }
6663 : default:;
6664 : }
6665 : break;
6666 : }
6667 205589 : case CALL_EXPR:
6668 205589 : switch (get_call_combined_fn (_p0))
6669 : {
6670 2 : case CFN_BUILT_IN_SQRTF:
6671 2 : if (call_expr_nargs (_p0) == 1)
6672 : {
6673 2 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
6674 2 : switch (TREE_CODE (_p1))
6675 : {
6676 2 : case REAL_CST:
6677 2 : {
6678 2 : {
6679 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6680 2 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, LE_EXPR);
6681 2 : if (res) return res;
6682 : }
6683 0 : break;
6684 : }
6685 0 : case CALL_EXPR:
6686 0 : switch (get_call_combined_fn (_p1))
6687 : {
6688 0 : case CFN_BUILT_IN_SQRTF:
6689 0 : if (call_expr_nargs (_p1) == 1)
6690 : {
6691 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
6692 0 : {
6693 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6694 0 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, LE_EXPR);
6695 0 : if (res) return res;
6696 : }
6697 : }
6698 : break;
6699 : default:;
6700 : }
6701 : break;
6702 : default:;
6703 : }
6704 : }
6705 : break;
6706 0 : case CFN_BUILT_IN_SQRTL:
6707 0 : if (call_expr_nargs (_p0) == 1)
6708 : {
6709 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
6710 0 : switch (TREE_CODE (_p1))
6711 : {
6712 0 : case REAL_CST:
6713 0 : {
6714 0 : {
6715 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6716 0 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, LE_EXPR);
6717 0 : if (res) return res;
6718 : }
6719 0 : break;
6720 : }
6721 0 : case CALL_EXPR:
6722 0 : switch (get_call_combined_fn (_p1))
6723 : {
6724 0 : case CFN_BUILT_IN_SQRTL:
6725 0 : if (call_expr_nargs (_p1) == 1)
6726 : {
6727 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
6728 0 : {
6729 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6730 0 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, LE_EXPR);
6731 0 : if (res) return res;
6732 : }
6733 : }
6734 : break;
6735 : default:;
6736 : }
6737 : break;
6738 : default:;
6739 : }
6740 : }
6741 : break;
6742 2 : case CFN_BUILT_IN_SQRT:
6743 2 : if (call_expr_nargs (_p0) == 1)
6744 : {
6745 2 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
6746 2 : switch (TREE_CODE (_p1))
6747 : {
6748 2 : case REAL_CST:
6749 2 : {
6750 2 : {
6751 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6752 2 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, LE_EXPR);
6753 2 : if (res) return res;
6754 : }
6755 2 : break;
6756 : }
6757 0 : case CALL_EXPR:
6758 0 : switch (get_call_combined_fn (_p1))
6759 : {
6760 0 : case CFN_BUILT_IN_SQRT:
6761 0 : if (call_expr_nargs (_p1) == 1)
6762 : {
6763 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
6764 0 : {
6765 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6766 0 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, LE_EXPR);
6767 0 : if (res) return res;
6768 : }
6769 : }
6770 : break;
6771 : default:;
6772 : }
6773 : break;
6774 : default:;
6775 : }
6776 : }
6777 : break;
6778 0 : case CFN_SQRT:
6779 0 : if (call_expr_nargs (_p0) == 1)
6780 : {
6781 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
6782 0 : switch (TREE_CODE (_p1))
6783 : {
6784 0 : case REAL_CST:
6785 0 : {
6786 0 : {
6787 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6788 0 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, CFN_SQRT, LE_EXPR);
6789 0 : if (res) return res;
6790 : }
6791 0 : break;
6792 : }
6793 0 : case CALL_EXPR:
6794 0 : switch (get_call_combined_fn (_p1))
6795 : {
6796 0 : case CFN_SQRT:
6797 0 : if (call_expr_nargs (_p1) == 1)
6798 : {
6799 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
6800 0 : {
6801 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6802 0 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, CFN_SQRT, LE_EXPR);
6803 0 : if (res) return res;
6804 : }
6805 : }
6806 : break;
6807 : default:;
6808 : }
6809 : break;
6810 : default:;
6811 : }
6812 : }
6813 : break;
6814 : default:;
6815 : }
6816 : break;
6817 9168967 : default:;
6818 : }
6819 9168967 : if (uniform_integer_cst_p (_p1))
6820 : {
6821 6589908 : {
6822 6589908 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
6823 6589908 : tree res = generic_simplify_386 (loc, type, _p0, _p1, captures, LE_EXPR);
6824 6589908 : if (res) return res;
6825 : }
6826 : }
6827 8616389 : switch (TREE_CODE (_p0))
6828 : {
6829 961266 : CASE_CONVERT:
6830 961266 : {
6831 961266 : tree _q20 = TREE_OPERAND (_p0, 0);
6832 961266 : switch (TREE_CODE (_q20))
6833 : {
6834 96078 : case PLUS_EXPR:
6835 96078 : {
6836 96078 : tree _q30 = TREE_OPERAND (_q20, 0);
6837 96078 : tree _q31 = TREE_OPERAND (_q20, 1);
6838 96078 : switch (TREE_CODE (_q30))
6839 : {
6840 81896 : CASE_CONVERT:
6841 81896 : {
6842 81896 : tree _q40 = TREE_OPERAND (_q30, 0);
6843 81896 : switch (TREE_CODE (_q31))
6844 : {
6845 81313 : case INTEGER_CST:
6846 81313 : {
6847 81313 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
6848 : {
6849 4 : {
6850 4 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q40, _q31 };
6851 4 : tree res = generic_simplify_387 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR);
6852 4 : if (res) return res;
6853 : }
6854 : }
6855 : break;
6856 : }
6857 : default:;
6858 : }
6859 : break;
6860 : }
6861 : default:;
6862 : }
6863 : break;
6864 : }
6865 : default:;
6866 : }
6867 : break;
6868 : }
6869 8616385 : default:;
6870 : }
6871 8616385 : switch (TREE_CODE (_p1))
6872 : {
6873 223791 : CASE_CONVERT:
6874 223791 : {
6875 223791 : tree _q30 = TREE_OPERAND (_p1, 0);
6876 223791 : switch (TREE_CODE (_q30))
6877 : {
6878 1939 : case PLUS_EXPR:
6879 1939 : {
6880 1939 : tree _q40 = TREE_OPERAND (_q30, 0);
6881 1939 : tree _q41 = TREE_OPERAND (_q30, 1);
6882 1939 : switch (TREE_CODE (_q40))
6883 : {
6884 426 : CASE_CONVERT:
6885 426 : {
6886 426 : tree _q50 = TREE_OPERAND (_q40, 0);
6887 426 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
6888 : {
6889 0 : switch (TREE_CODE (_q41))
6890 : {
6891 0 : case INTEGER_CST:
6892 0 : {
6893 0 : {
6894 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0, _q41 };
6895 0 : tree res = generic_simplify_387 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR);
6896 0 : if (res) return res;
6897 : }
6898 0 : break;
6899 : }
6900 : default:;
6901 : }
6902 : }
6903 : break;
6904 : }
6905 : default:;
6906 : }
6907 : break;
6908 : }
6909 : default:;
6910 : }
6911 : break;
6912 : }
6913 118146 : case PLUS_EXPR:
6914 118146 : {
6915 118146 : tree _q30 = TREE_OPERAND (_p1, 0);
6916 118146 : tree _q31 = TREE_OPERAND (_p1, 1);
6917 118146 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
6918 : {
6919 30 : switch (TREE_CODE (_q31))
6920 : {
6921 30 : case INTEGER_CST:
6922 30 : {
6923 30 : {
6924 30 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0, _q31 };
6925 30 : tree res = generic_simplify_382 (loc, type, _p0, _p1, captures, GE_EXPR, LE_EXPR);
6926 30 : if (res) return res;
6927 : }
6928 0 : break;
6929 : }
6930 : default:;
6931 : }
6932 : }
6933 : break;
6934 : }
6935 8616355 : default:;
6936 : }
6937 8616355 : switch (TREE_CODE (_p0))
6938 : {
6939 62421 : case MINUS_EXPR:
6940 62421 : {
6941 62421 : tree _q20 = TREE_OPERAND (_p0, 0);
6942 62421 : tree _q21 = TREE_OPERAND (_p0, 1);
6943 62421 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
6944 : {
6945 2510 : {
6946 2510 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
6947 2510 : tree res = generic_simplify_388 (loc, type, _p0, _p1, captures, LE_EXPR);
6948 2510 : if (res) return res;
6949 : }
6950 : }
6951 : break;
6952 : }
6953 8616228 : default:;
6954 : }
6955 8616228 : switch (TREE_CODE (_p1))
6956 : {
6957 118116 : case PLUS_EXPR:
6958 118116 : {
6959 118116 : tree _q30 = TREE_OPERAND (_p1, 0);
6960 118116 : tree _q31 = TREE_OPERAND (_p1, 1);
6961 118116 : switch (TREE_CODE (_q30))
6962 : {
6963 4 : case MINUS_EXPR:
6964 4 : {
6965 4 : tree _q40 = TREE_OPERAND (_q30, 0);
6966 4 : tree _q41 = TREE_OPERAND (_q30, 1);
6967 4 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
6968 : {
6969 0 : if (integer_minus_onep (_q31))
6970 : {
6971 0 : {
6972 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
6973 0 : tree res = generic_simplify_400 (loc, type, _p0, _p1, captures, GE_EXPR);
6974 0 : if (res) return res;
6975 : }
6976 : }
6977 : }
6978 : break;
6979 : }
6980 : default:;
6981 : }
6982 : break;
6983 : }
6984 8616228 : default:;
6985 : }
6986 8616228 : switch (TREE_CODE (_p0))
6987 : {
6988 12 : case REALPART_EXPR:
6989 12 : {
6990 12 : tree _q20 = TREE_OPERAND (_p0, 0);
6991 12 : switch (TREE_CODE (_q20))
6992 : {
6993 0 : case CALL_EXPR:
6994 0 : switch (get_call_combined_fn (_q20))
6995 : {
6996 0 : case CFN_SUB_OVERFLOW:
6997 0 : if (call_expr_nargs (_q20) == 2)
6998 : {
6999 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
7000 0 : tree _q31 = CALL_EXPR_ARG (_q20, 1);
7001 0 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
7002 : {
7003 0 : {
7004 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7005 0 : tree res = generic_simplify_401 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR);
7006 0 : if (res) return res;
7007 : }
7008 : }
7009 : }
7010 : break;
7011 : default:;
7012 : }
7013 : break;
7014 : default:;
7015 : }
7016 : break;
7017 : }
7018 8616228 : default:;
7019 : }
7020 8616228 : switch (TREE_CODE (_p1))
7021 : {
7022 0 : case REALPART_EXPR:
7023 0 : {
7024 0 : tree _q30 = TREE_OPERAND (_p1, 0);
7025 0 : switch (TREE_CODE (_q30))
7026 : {
7027 0 : case CALL_EXPR:
7028 0 : switch (get_call_combined_fn (_q30))
7029 : {
7030 0 : case CFN_ADD_OVERFLOW:
7031 0 : if (call_expr_nargs (_q30) == 2)
7032 : {
7033 0 : tree _q40 = CALL_EXPR_ARG (_q30, 0);
7034 0 : tree _q41 = CALL_EXPR_ARG (_q30, 1);
7035 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
7036 : {
7037 0 : {
7038 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p0, _q41 };
7039 0 : tree res = generic_simplify_402 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
7040 0 : if (res) return res;
7041 : }
7042 : }
7043 0 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
7044 : {
7045 0 : {
7046 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p0, _q40 };
7047 0 : tree res = generic_simplify_402 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
7048 0 : if (res) return res;
7049 : }
7050 : }
7051 : }
7052 : break;
7053 : default:;
7054 : }
7055 : break;
7056 : default:;
7057 : }
7058 : break;
7059 : }
7060 340 : case TRUNC_DIV_EXPR:
7061 340 : {
7062 340 : tree _q30 = TREE_OPERAND (_p1, 0);
7063 340 : tree _q31 = TREE_OPERAND (_p1, 1);
7064 340 : if (integer_all_onesp (_q30))
7065 : {
7066 0 : {
7067 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q31, _p0 };
7068 0 : tree res = generic_simplify_403 (loc, type, _p0, _p1, captures, GE_EXPR, EQ_EXPR);
7069 0 : if (res) return res;
7070 : }
7071 : }
7072 : break;
7073 : }
7074 8616228 : default:;
7075 : }
7076 8616228 : switch (TREE_CODE (_p0))
7077 : {
7078 57433 : case MULT_EXPR:
7079 57433 : {
7080 57433 : tree _q20 = TREE_OPERAND (_p0, 0);
7081 57433 : tree _q21 = TREE_OPERAND (_p0, 1);
7082 57433 : switch (TREE_CODE (_q21))
7083 : {
7084 810 : case REAL_CST:
7085 810 : {
7086 810 : switch (TREE_CODE (_p1))
7087 : {
7088 542 : case REAL_CST:
7089 542 : {
7090 542 : {
7091 542 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7092 542 : tree res = generic_simplify_393 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
7093 542 : if (res) return res;
7094 : }
7095 540 : break;
7096 : }
7097 : default:;
7098 : }
7099 : break;
7100 : }
7101 : default:;
7102 : }
7103 : break;
7104 : }
7105 26 : case REAL_CST:
7106 26 : {
7107 26 : switch (TREE_CODE (_p1))
7108 : {
7109 0 : case CALL_EXPR:
7110 0 : switch (get_call_combined_fn (_p1))
7111 : {
7112 0 : case CFN_BUILT_IN_EXP:
7113 0 : if (call_expr_nargs (_p1) == 1)
7114 : {
7115 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7116 0 : {
7117 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7118 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, GE_EXPR);
7119 0 : if (res) return res;
7120 : }
7121 : }
7122 : break;
7123 0 : case CFN_BUILT_IN_LOG:
7124 0 : if (call_expr_nargs (_p1) == 1)
7125 : {
7126 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7127 0 : {
7128 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7129 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, GE_EXPR);
7130 0 : if (res) return res;
7131 : }
7132 : }
7133 : break;
7134 0 : case CFN_BUILT_IN_EXP10F:
7135 0 : if (call_expr_nargs (_p1) == 1)
7136 : {
7137 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7138 0 : {
7139 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7140 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, GE_EXPR);
7141 0 : if (res) return res;
7142 : }
7143 : }
7144 : break;
7145 0 : case CFN_BUILT_IN_EXP10L:
7146 0 : if (call_expr_nargs (_p1) == 1)
7147 : {
7148 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7149 0 : {
7150 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7151 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, GE_EXPR);
7152 0 : if (res) return res;
7153 : }
7154 : }
7155 : break;
7156 0 : case CFN_BUILT_IN_EXP2:
7157 0 : if (call_expr_nargs (_p1) == 1)
7158 : {
7159 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7160 0 : {
7161 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7162 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, GE_EXPR);
7163 0 : if (res) return res;
7164 : }
7165 : }
7166 : break;
7167 0 : case CFN_BUILT_IN_EXPF:
7168 0 : if (call_expr_nargs (_p1) == 1)
7169 : {
7170 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7171 0 : {
7172 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7173 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, GE_EXPR);
7174 0 : if (res) return res;
7175 : }
7176 : }
7177 : break;
7178 0 : case CFN_BUILT_IN_EXPL:
7179 0 : if (call_expr_nargs (_p1) == 1)
7180 : {
7181 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7182 0 : {
7183 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7184 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, GE_EXPR);
7185 0 : if (res) return res;
7186 : }
7187 : }
7188 : break;
7189 0 : case CFN_BUILT_IN_LOG2:
7190 0 : if (call_expr_nargs (_p1) == 1)
7191 : {
7192 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7193 0 : {
7194 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7195 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, GE_EXPR);
7196 0 : if (res) return res;
7197 : }
7198 : }
7199 : break;
7200 0 : case CFN_BUILT_IN_LOGF:
7201 0 : if (call_expr_nargs (_p1) == 1)
7202 : {
7203 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7204 0 : {
7205 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7206 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, GE_EXPR);
7207 0 : if (res) return res;
7208 : }
7209 : }
7210 : break;
7211 0 : case CFN_BUILT_IN_LOGL:
7212 0 : if (call_expr_nargs (_p1) == 1)
7213 : {
7214 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7215 0 : {
7216 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7217 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, GE_EXPR);
7218 0 : if (res) return res;
7219 : }
7220 : }
7221 : break;
7222 0 : case CFN_BUILT_IN_LOG10F:
7223 0 : if (call_expr_nargs (_p1) == 1)
7224 : {
7225 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7226 0 : {
7227 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7228 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, GE_EXPR);
7229 0 : if (res) return res;
7230 : }
7231 : }
7232 : break;
7233 0 : case CFN_BUILT_IN_LOG10L:
7234 0 : if (call_expr_nargs (_p1) == 1)
7235 : {
7236 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7237 0 : {
7238 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7239 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, GE_EXPR);
7240 0 : if (res) return res;
7241 : }
7242 : }
7243 : break;
7244 0 : case CFN_EXP:
7245 0 : if (call_expr_nargs (_p1) == 1)
7246 : {
7247 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7248 0 : {
7249 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7250 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, GE_EXPR);
7251 0 : if (res) return res;
7252 : }
7253 : }
7254 : break;
7255 0 : case CFN_LOG:
7256 0 : if (call_expr_nargs (_p1) == 1)
7257 : {
7258 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7259 0 : {
7260 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7261 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, GE_EXPR);
7262 0 : if (res) return res;
7263 : }
7264 : }
7265 : break;
7266 0 : case CFN_EXP2:
7267 0 : if (call_expr_nargs (_p1) == 1)
7268 : {
7269 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7270 0 : {
7271 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7272 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, GE_EXPR);
7273 0 : if (res) return res;
7274 : }
7275 : }
7276 : break;
7277 0 : case CFN_LOG2:
7278 0 : if (call_expr_nargs (_p1) == 1)
7279 : {
7280 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7281 0 : {
7282 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7283 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, GE_EXPR);
7284 0 : if (res) return res;
7285 : }
7286 : }
7287 : break;
7288 0 : case CFN_EXP10:
7289 0 : if (call_expr_nargs (_p1) == 1)
7290 : {
7291 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7292 0 : {
7293 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7294 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, GE_EXPR);
7295 0 : if (res) return res;
7296 : }
7297 : }
7298 : break;
7299 0 : case CFN_LOG10:
7300 0 : if (call_expr_nargs (_p1) == 1)
7301 : {
7302 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7303 0 : {
7304 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7305 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, GE_EXPR);
7306 0 : if (res) return res;
7307 : }
7308 : }
7309 : break;
7310 0 : case CFN_BUILT_IN_EXP10:
7311 0 : if (call_expr_nargs (_p1) == 1)
7312 : {
7313 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7314 0 : {
7315 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7316 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, GE_EXPR);
7317 0 : if (res) return res;
7318 : }
7319 : }
7320 : break;
7321 0 : case CFN_BUILT_IN_EXP2F:
7322 0 : if (call_expr_nargs (_p1) == 1)
7323 : {
7324 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7325 0 : {
7326 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7327 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, GE_EXPR);
7328 0 : if (res) return res;
7329 : }
7330 : }
7331 : break;
7332 0 : case CFN_BUILT_IN_EXP2L:
7333 0 : if (call_expr_nargs (_p1) == 1)
7334 : {
7335 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7336 0 : {
7337 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7338 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, GE_EXPR);
7339 0 : if (res) return res;
7340 : }
7341 : }
7342 : break;
7343 0 : case CFN_BUILT_IN_LOG10:
7344 0 : if (call_expr_nargs (_p1) == 1)
7345 : {
7346 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7347 0 : {
7348 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7349 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, GE_EXPR);
7350 0 : if (res) return res;
7351 : }
7352 : }
7353 : break;
7354 0 : case CFN_BUILT_IN_LOG2F:
7355 0 : if (call_expr_nargs (_p1) == 1)
7356 : {
7357 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7358 0 : {
7359 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7360 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, GE_EXPR);
7361 0 : if (res) return res;
7362 : }
7363 : }
7364 : break;
7365 0 : case CFN_BUILT_IN_LOG2L:
7366 0 : if (call_expr_nargs (_p1) == 1)
7367 : {
7368 0 : tree _q30 = CALL_EXPR_ARG (_p1, 0);
7369 0 : {
7370 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
7371 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, GE_EXPR);
7372 0 : if (res) return res;
7373 : }
7374 : }
7375 : break;
7376 : default:;
7377 : }
7378 : break;
7379 : default:;
7380 : }
7381 : break;
7382 : }
7383 1580870 : case PLUS_EXPR:
7384 1580870 : {
7385 1580870 : tree _q20 = TREE_OPERAND (_p0, 0);
7386 1580870 : tree _q21 = TREE_OPERAND (_p0, 1);
7387 1580870 : switch (TREE_CODE (_q21))
7388 : {
7389 1482102 : case INTEGER_CST:
7390 1482102 : {
7391 1482102 : switch (TREE_CODE (_p1))
7392 : {
7393 965963 : case INTEGER_CST:
7394 965963 : {
7395 965963 : {
7396 965963 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
7397 965963 : tree res = generic_simplify_394 (loc, type, _p0, _p1, captures, PLUS_EXPR, MINUS_EXPR, LE_EXPR, GE_EXPR);
7398 965963 : if (res) return res;
7399 : }
7400 784206 : break;
7401 : }
7402 : default:;
7403 : }
7404 : break;
7405 : }
7406 : default:;
7407 : }
7408 : break;
7409 : }
7410 62294 : case MINUS_EXPR:
7411 62294 : {
7412 62294 : tree _q20 = TREE_OPERAND (_p0, 0);
7413 62294 : tree _q21 = TREE_OPERAND (_p0, 1);
7414 62294 : switch (TREE_CODE (_q21))
7415 : {
7416 2223 : case INTEGER_CST:
7417 2223 : {
7418 2223 : switch (TREE_CODE (_p1))
7419 : {
7420 2223 : case INTEGER_CST:
7421 2223 : {
7422 2223 : {
7423 2223 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
7424 2223 : tree res = generic_simplify_394 (loc, type, _p0, _p1, captures, MINUS_EXPR, PLUS_EXPR, LE_EXPR, GE_EXPR);
7425 2223 : if (res) return res;
7426 : }
7427 2222 : break;
7428 : }
7429 : default:;
7430 : }
7431 : break;
7432 : }
7433 62293 : default:;
7434 : }
7435 62293 : switch (TREE_CODE (_q20))
7436 : {
7437 2028 : case INTEGER_CST:
7438 2028 : {
7439 2028 : switch (TREE_CODE (_p1))
7440 : {
7441 1071 : case INTEGER_CST:
7442 1071 : {
7443 1071 : {
7444 1071 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7445 1071 : tree res = generic_simplify_290 (loc, type, _p0, _p1, captures, LE_EXPR, GE_EXPR);
7446 1071 : if (res) return res;
7447 : }
7448 0 : break;
7449 : }
7450 : default:;
7451 : }
7452 : break;
7453 : }
7454 : default:;
7455 : }
7456 : break;
7457 : }
7458 205179 : case CALL_EXPR:
7459 205179 : switch (get_call_combined_fn (_p0))
7460 : {
7461 18 : case CFN_BUILT_IN_CTZ:
7462 18 : if (call_expr_nargs (_p0) == 1)
7463 : {
7464 18 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7465 18 : switch (TREE_CODE (_p1))
7466 : {
7467 18 : case INTEGER_CST:
7468 18 : {
7469 18 : {
7470 18 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7471 18 : tree res = generic_simplify_395 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_BUILT_IN_CTZ);
7472 18 : if (res) return res;
7473 : }
7474 16 : break;
7475 : }
7476 : default:;
7477 : }
7478 : }
7479 : break;
7480 0 : case CFN_BUILT_IN_EXP:
7481 0 : if (call_expr_nargs (_p0) == 1)
7482 : {
7483 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7484 0 : switch (TREE_CODE (_p1))
7485 : {
7486 0 : case REAL_CST:
7487 0 : {
7488 0 : {
7489 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7490 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, LE_EXPR);
7491 0 : if (res) return res;
7492 : }
7493 0 : break;
7494 : }
7495 : default:;
7496 : }
7497 : }
7498 : break;
7499 8 : case CFN_BUILT_IN_FFS:
7500 8 : if (call_expr_nargs (_p0) == 1)
7501 : {
7502 8 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7503 8 : switch (TREE_CODE (_p1))
7504 : {
7505 8 : case INTEGER_CST:
7506 8 : {
7507 8 : {
7508 8 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7509 8 : tree res = generic_simplify_406 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_FFS);
7510 8 : if (res) return res;
7511 : }
7512 2 : break;
7513 : }
7514 : default:;
7515 : }
7516 : }
7517 : break;
7518 0 : case CFN_BUILT_IN_LOG:
7519 0 : if (call_expr_nargs (_p0) == 1)
7520 : {
7521 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7522 0 : switch (TREE_CODE (_p1))
7523 : {
7524 0 : case REAL_CST:
7525 0 : {
7526 0 : {
7527 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7528 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG, CFN_BUILT_IN_EXP, LE_EXPR);
7529 0 : if (res) return res;
7530 : }
7531 0 : break;
7532 : }
7533 : default:;
7534 : }
7535 : }
7536 : break;
7537 0 : case CFN_BUILT_IN_FFSIMAX:
7538 0 : if (call_expr_nargs (_p0) == 1)
7539 : {
7540 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7541 0 : switch (TREE_CODE (_p1))
7542 : {
7543 0 : case INTEGER_CST:
7544 0 : {
7545 0 : {
7546 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7547 0 : tree res = generic_simplify_406 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_FFSIMAX);
7548 0 : if (res) return res;
7549 : }
7550 0 : break;
7551 : }
7552 : default:;
7553 : }
7554 : }
7555 : break;
7556 0 : case CFN_BUILT_IN_EXP10F:
7557 0 : if (call_expr_nargs (_p0) == 1)
7558 : {
7559 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7560 0 : switch (TREE_CODE (_p1))
7561 : {
7562 0 : case REAL_CST:
7563 0 : {
7564 0 : {
7565 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7566 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, LE_EXPR);
7567 0 : if (res) return res;
7568 : }
7569 0 : break;
7570 : }
7571 : default:;
7572 : }
7573 : }
7574 : break;
7575 0 : case CFN_BUILT_IN_EXP10L:
7576 0 : if (call_expr_nargs (_p0) == 1)
7577 : {
7578 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7579 0 : switch (TREE_CODE (_p1))
7580 : {
7581 0 : case REAL_CST:
7582 0 : {
7583 0 : {
7584 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7585 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, LE_EXPR);
7586 0 : if (res) return res;
7587 : }
7588 0 : break;
7589 : }
7590 : default:;
7591 : }
7592 : }
7593 : break;
7594 37 : case CFN_BUILT_IN_POPCOUNT:
7595 37 : if (call_expr_nargs (_p0) == 1)
7596 : {
7597 37 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7598 37 : if (integer_zerop (_p1))
7599 : {
7600 1 : {
7601 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
7602 1 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNT);
7603 1 : if (res) return res;
7604 : }
7605 : }
7606 : }
7607 : break;
7608 0 : case CFN_BUILT_IN_CTZL:
7609 0 : if (call_expr_nargs (_p0) == 1)
7610 : {
7611 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7612 0 : switch (TREE_CODE (_p1))
7613 : {
7614 0 : case INTEGER_CST:
7615 0 : {
7616 0 : {
7617 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7618 0 : tree res = generic_simplify_395 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_BUILT_IN_CTZL);
7619 0 : if (res) return res;
7620 : }
7621 0 : break;
7622 : }
7623 : default:;
7624 : }
7625 : }
7626 : break;
7627 0 : case CFN_BUILT_IN_EXP2:
7628 0 : if (call_expr_nargs (_p0) == 1)
7629 : {
7630 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7631 0 : switch (TREE_CODE (_p1))
7632 : {
7633 0 : case REAL_CST:
7634 0 : {
7635 0 : {
7636 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7637 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, LE_EXPR);
7638 0 : if (res) return res;
7639 : }
7640 0 : break;
7641 : }
7642 : default:;
7643 : }
7644 : }
7645 : break;
7646 0 : case CFN_BUILT_IN_EXPF:
7647 0 : if (call_expr_nargs (_p0) == 1)
7648 : {
7649 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7650 0 : switch (TREE_CODE (_p1))
7651 : {
7652 0 : case REAL_CST:
7653 0 : {
7654 0 : {
7655 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7656 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, LE_EXPR);
7657 0 : if (res) return res;
7658 : }
7659 0 : break;
7660 : }
7661 : default:;
7662 : }
7663 : }
7664 : break;
7665 0 : case CFN_BUILT_IN_EXPL:
7666 0 : if (call_expr_nargs (_p0) == 1)
7667 : {
7668 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7669 0 : switch (TREE_CODE (_p1))
7670 : {
7671 0 : case REAL_CST:
7672 0 : {
7673 0 : {
7674 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7675 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, LE_EXPR);
7676 0 : if (res) return res;
7677 : }
7678 0 : break;
7679 : }
7680 : default:;
7681 : }
7682 : }
7683 : break;
7684 3 : case CFN_BUILT_IN_FFSL:
7685 3 : if (call_expr_nargs (_p0) == 1)
7686 : {
7687 3 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7688 3 : switch (TREE_CODE (_p1))
7689 : {
7690 3 : case INTEGER_CST:
7691 3 : {
7692 3 : {
7693 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7694 3 : tree res = generic_simplify_406 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_FFSL);
7695 3 : if (res) return res;
7696 : }
7697 0 : break;
7698 : }
7699 : default:;
7700 : }
7701 : }
7702 : break;
7703 0 : case CFN_BUILT_IN_LOG2:
7704 0 : if (call_expr_nargs (_p0) == 1)
7705 : {
7706 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7707 0 : switch (TREE_CODE (_p1))
7708 : {
7709 0 : case REAL_CST:
7710 0 : {
7711 0 : {
7712 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7713 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2, CFN_BUILT_IN_EXP2, LE_EXPR);
7714 0 : if (res) return res;
7715 : }
7716 0 : break;
7717 : }
7718 : default:;
7719 : }
7720 : }
7721 : break;
7722 0 : case CFN_BUILT_IN_LOGF:
7723 0 : if (call_expr_nargs (_p0) == 1)
7724 : {
7725 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7726 0 : switch (TREE_CODE (_p1))
7727 : {
7728 0 : case REAL_CST:
7729 0 : {
7730 0 : {
7731 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7732 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_EXPF, LE_EXPR);
7733 0 : if (res) return res;
7734 : }
7735 0 : break;
7736 : }
7737 : default:;
7738 : }
7739 : }
7740 : break;
7741 0 : case CFN_BUILT_IN_LOGL:
7742 0 : if (call_expr_nargs (_p0) == 1)
7743 : {
7744 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7745 0 : switch (TREE_CODE (_p1))
7746 : {
7747 0 : case REAL_CST:
7748 0 : {
7749 0 : {
7750 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7751 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL, CFN_BUILT_IN_EXPL, LE_EXPR);
7752 0 : if (res) return res;
7753 : }
7754 0 : break;
7755 : }
7756 : default:;
7757 : }
7758 : }
7759 : break;
7760 1 : case CFN_BUILT_IN_POPCOUNTLL:
7761 1 : if (call_expr_nargs (_p0) == 1)
7762 : {
7763 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7764 1 : if (integer_zerop (_p1))
7765 : {
7766 1 : {
7767 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
7768 1 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNTLL);
7769 1 : if (res) return res;
7770 : }
7771 : }
7772 : }
7773 : break;
7774 0 : case CFN_BUILT_IN_LOG10F:
7775 0 : if (call_expr_nargs (_p0) == 1)
7776 : {
7777 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7778 0 : switch (TREE_CODE (_p1))
7779 : {
7780 0 : case REAL_CST:
7781 0 : {
7782 0 : {
7783 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7784 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F, CFN_BUILT_IN_EXP10F, LE_EXPR);
7785 0 : if (res) return res;
7786 : }
7787 0 : break;
7788 : }
7789 : default:;
7790 : }
7791 : }
7792 : break;
7793 0 : case CFN_BUILT_IN_LOG10L:
7794 0 : if (call_expr_nargs (_p0) == 1)
7795 : {
7796 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7797 0 : switch (TREE_CODE (_p1))
7798 : {
7799 0 : case REAL_CST:
7800 0 : {
7801 0 : {
7802 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7803 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L, CFN_BUILT_IN_EXP10L, LE_EXPR);
7804 0 : if (res) return res;
7805 : }
7806 0 : break;
7807 : }
7808 : default:;
7809 : }
7810 : }
7811 : break;
7812 0 : case CFN_BUILT_IN_CTZIMAX:
7813 0 : if (call_expr_nargs (_p0) == 1)
7814 : {
7815 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7816 0 : switch (TREE_CODE (_p1))
7817 : {
7818 0 : case INTEGER_CST:
7819 0 : {
7820 0 : {
7821 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7822 0 : tree res = generic_simplify_395 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_BUILT_IN_CTZIMAX);
7823 0 : if (res) return res;
7824 : }
7825 0 : break;
7826 : }
7827 : default:;
7828 : }
7829 : }
7830 : break;
7831 0 : case CFN_POPCOUNT:
7832 0 : if (call_expr_nargs (_p0) == 1)
7833 : {
7834 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7835 0 : if (integer_zerop (_p1))
7836 : {
7837 0 : {
7838 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
7839 0 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_POPCOUNT);
7840 0 : if (res) return res;
7841 : }
7842 : }
7843 : }
7844 : break;
7845 0 : case CFN_CTZ:
7846 0 : if (call_expr_nargs (_p0) == 2)
7847 : {
7848 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7849 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
7850 0 : switch (TREE_CODE (_p1))
7851 : {
7852 0 : case INTEGER_CST:
7853 0 : {
7854 0 : {
7855 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
7856 0 : tree res = generic_simplify_396 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR);
7857 0 : if (res) return res;
7858 : }
7859 0 : break;
7860 : }
7861 : default:;
7862 : }
7863 : }
7864 0 : if (call_expr_nargs (_p0) == 1)
7865 : {
7866 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7867 0 : switch (TREE_CODE (_p1))
7868 : {
7869 0 : case INTEGER_CST:
7870 0 : {
7871 0 : {
7872 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7873 0 : tree res = generic_simplify_395 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_CTZ);
7874 0 : if (res) return res;
7875 : }
7876 0 : break;
7877 : }
7878 : default:;
7879 : }
7880 : }
7881 : break;
7882 0 : case CFN_EXP:
7883 0 : if (call_expr_nargs (_p0) == 1)
7884 : {
7885 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7886 0 : switch (TREE_CODE (_p1))
7887 : {
7888 0 : case REAL_CST:
7889 0 : {
7890 0 : {
7891 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7892 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, LE_EXPR);
7893 0 : if (res) return res;
7894 : }
7895 0 : break;
7896 : }
7897 : default:;
7898 : }
7899 : }
7900 : break;
7901 0 : case CFN_FFS:
7902 0 : if (call_expr_nargs (_p0) == 1)
7903 : {
7904 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7905 0 : switch (TREE_CODE (_p1))
7906 : {
7907 0 : case INTEGER_CST:
7908 0 : {
7909 0 : {
7910 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7911 0 : tree res = generic_simplify_406 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_FFS);
7912 0 : if (res) return res;
7913 : }
7914 0 : break;
7915 : }
7916 : default:;
7917 : }
7918 : }
7919 : break;
7920 0 : case CFN_LOG:
7921 0 : if (call_expr_nargs (_p0) == 1)
7922 : {
7923 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7924 0 : switch (TREE_CODE (_p1))
7925 : {
7926 0 : case REAL_CST:
7927 0 : {
7928 0 : {
7929 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7930 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_LOG, CFN_EXP, LE_EXPR);
7931 0 : if (res) return res;
7932 : }
7933 0 : break;
7934 : }
7935 : default:;
7936 : }
7937 : }
7938 : break;
7939 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
7940 0 : if (call_expr_nargs (_p0) == 1)
7941 : {
7942 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7943 0 : if (integer_zerop (_p1))
7944 : {
7945 0 : {
7946 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
7947 0 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
7948 0 : if (res) return res;
7949 : }
7950 : }
7951 : }
7952 : break;
7953 0 : case CFN_EXP2:
7954 0 : if (call_expr_nargs (_p0) == 1)
7955 : {
7956 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7957 0 : switch (TREE_CODE (_p1))
7958 : {
7959 0 : case REAL_CST:
7960 0 : {
7961 0 : {
7962 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7963 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, LE_EXPR);
7964 0 : if (res) return res;
7965 : }
7966 0 : break;
7967 : }
7968 : default:;
7969 : }
7970 : }
7971 : break;
7972 0 : case CFN_LOG2:
7973 0 : if (call_expr_nargs (_p0) == 1)
7974 : {
7975 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7976 0 : switch (TREE_CODE (_p1))
7977 : {
7978 0 : case REAL_CST:
7979 0 : {
7980 0 : {
7981 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
7982 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_LOG2, CFN_EXP2, LE_EXPR);
7983 0 : if (res) return res;
7984 : }
7985 0 : break;
7986 : }
7987 : default:;
7988 : }
7989 : }
7990 : break;
7991 0 : case CFN_EXP10:
7992 0 : if (call_expr_nargs (_p0) == 1)
7993 : {
7994 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7995 0 : switch (TREE_CODE (_p1))
7996 : {
7997 0 : case REAL_CST:
7998 0 : {
7999 0 : {
8000 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8001 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, LE_EXPR);
8002 0 : if (res) return res;
8003 : }
8004 0 : break;
8005 : }
8006 : default:;
8007 : }
8008 : }
8009 : break;
8010 1 : case CFN_BUILT_IN_POPCOUNTL:
8011 1 : if (call_expr_nargs (_p0) == 1)
8012 : {
8013 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8014 1 : if (integer_zerop (_p1))
8015 : {
8016 1 : {
8017 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8018 1 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNTL);
8019 1 : if (res) return res;
8020 : }
8021 : }
8022 : }
8023 : break;
8024 0 : case CFN_BUILT_IN_CTZLL:
8025 0 : if (call_expr_nargs (_p0) == 1)
8026 : {
8027 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8028 0 : switch (TREE_CODE (_p1))
8029 : {
8030 0 : case INTEGER_CST:
8031 0 : {
8032 0 : {
8033 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8034 0 : tree res = generic_simplify_395 (loc, type, _p0, _p1, captures, LE_EXPR, NE_EXPR, CFN_BUILT_IN_CTZLL);
8035 0 : if (res) return res;
8036 : }
8037 0 : break;
8038 : }
8039 : default:;
8040 : }
8041 : }
8042 : break;
8043 0 : case CFN_LOG10:
8044 0 : if (call_expr_nargs (_p0) == 1)
8045 : {
8046 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8047 0 : switch (TREE_CODE (_p1))
8048 : {
8049 0 : case REAL_CST:
8050 0 : {
8051 0 : {
8052 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8053 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_LOG10, CFN_EXP10, LE_EXPR);
8054 0 : if (res) return res;
8055 : }
8056 0 : break;
8057 : }
8058 : default:;
8059 : }
8060 : }
8061 : break;
8062 0 : case CFN_BUILT_IN_EXP10:
8063 0 : if (call_expr_nargs (_p0) == 1)
8064 : {
8065 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8066 0 : switch (TREE_CODE (_p1))
8067 : {
8068 0 : case REAL_CST:
8069 0 : {
8070 0 : {
8071 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8072 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, LE_EXPR);
8073 0 : if (res) return res;
8074 : }
8075 0 : break;
8076 : }
8077 : default:;
8078 : }
8079 : }
8080 : break;
8081 0 : case CFN_BUILT_IN_EXP2F:
8082 0 : if (call_expr_nargs (_p0) == 1)
8083 : {
8084 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8085 0 : switch (TREE_CODE (_p1))
8086 : {
8087 0 : case REAL_CST:
8088 0 : {
8089 0 : {
8090 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8091 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, LE_EXPR);
8092 0 : if (res) return res;
8093 : }
8094 0 : break;
8095 : }
8096 : default:;
8097 : }
8098 : }
8099 : break;
8100 0 : case CFN_BUILT_IN_EXP2L:
8101 0 : if (call_expr_nargs (_p0) == 1)
8102 : {
8103 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8104 0 : switch (TREE_CODE (_p1))
8105 : {
8106 0 : case REAL_CST:
8107 0 : {
8108 0 : {
8109 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8110 0 : tree res = generic_simplify_405 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, LE_EXPR);
8111 0 : if (res) return res;
8112 : }
8113 0 : break;
8114 : }
8115 : default:;
8116 : }
8117 : }
8118 : break;
8119 3 : case CFN_BUILT_IN_FFSLL:
8120 3 : if (call_expr_nargs (_p0) == 1)
8121 : {
8122 3 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8123 3 : switch (TREE_CODE (_p1))
8124 : {
8125 3 : case INTEGER_CST:
8126 3 : {
8127 3 : {
8128 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8129 3 : tree res = generic_simplify_406 (loc, type, _p0, _p1, captures, LE_EXPR, EQ_EXPR, NE_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_FFSLL);
8130 3 : if (res) return res;
8131 : }
8132 0 : break;
8133 : }
8134 : default:;
8135 : }
8136 : }
8137 : break;
8138 0 : case CFN_BUILT_IN_LOG10:
8139 0 : if (call_expr_nargs (_p0) == 1)
8140 : {
8141 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8142 0 : switch (TREE_CODE (_p1))
8143 : {
8144 0 : case REAL_CST:
8145 0 : {
8146 0 : {
8147 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8148 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10, CFN_BUILT_IN_EXP10, LE_EXPR);
8149 0 : if (res) return res;
8150 : }
8151 0 : break;
8152 : }
8153 : default:;
8154 : }
8155 : }
8156 : break;
8157 0 : case CFN_BUILT_IN_LOG2F:
8158 0 : if (call_expr_nargs (_p0) == 1)
8159 : {
8160 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8161 0 : switch (TREE_CODE (_p1))
8162 : {
8163 0 : case REAL_CST:
8164 0 : {
8165 0 : {
8166 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8167 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F, CFN_BUILT_IN_EXP2F, LE_EXPR);
8168 0 : if (res) return res;
8169 : }
8170 0 : break;
8171 : }
8172 : default:;
8173 : }
8174 : }
8175 : break;
8176 0 : case CFN_BUILT_IN_LOG2L:
8177 0 : if (call_expr_nargs (_p0) == 1)
8178 : {
8179 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8180 0 : switch (TREE_CODE (_p1))
8181 : {
8182 0 : case REAL_CST:
8183 0 : {
8184 0 : {
8185 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8186 0 : tree res = generic_simplify_404 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L, CFN_BUILT_IN_EXP2L, LE_EXPR);
8187 0 : if (res) return res;
8188 : }
8189 0 : break;
8190 : }
8191 : default:;
8192 : }
8193 : }
8194 : break;
8195 : default:;
8196 : }
8197 : break;
8198 : default:;
8199 : }
8200 : return NULL_TREE;
8201 : }
8202 :
8203 : tree
8204 4068 : generic_simplify_CEIL_MOD_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
8205 : {
8206 4068 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8207 4068 : if (integer_zerop (_p0))
8208 : {
8209 0 : {
8210 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8211 0 : tree res = generic_simplify_321 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8212 0 : if (res) return res;
8213 : }
8214 : }
8215 4068 : if (integer_onep (_p1))
8216 : {
8217 0 : {
8218 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8219 0 : tree res = generic_simplify_322 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8220 0 : if (res) return res;
8221 : }
8222 : }
8223 4068 : if (integer_minus_onep (_p1))
8224 : {
8225 0 : {
8226 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8227 0 : tree res = generic_simplify_323 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8228 0 : if (res) return res;
8229 : }
8230 : }
8231 4068 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
8232 : {
8233 0 : {
8234 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8235 0 : tree res = generic_simplify_324 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8236 0 : if (res) return res;
8237 : }
8238 : }
8239 4068 : switch (TREE_CODE (_p0))
8240 : {
8241 0 : case CEIL_MOD_EXPR:
8242 0 : {
8243 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8244 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8245 0 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8246 : {
8247 0 : {
8248 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8249 0 : tree res = generic_simplify_325 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8250 0 : if (res) return res;
8251 : }
8252 : }
8253 : break;
8254 : }
8255 0 : case MULT_EXPR:
8256 0 : {
8257 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8258 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8259 0 : switch (TREE_CODE (_q21))
8260 : {
8261 0 : case INTEGER_CST:
8262 0 : {
8263 0 : switch (TREE_CODE (_p1))
8264 : {
8265 0 : case INTEGER_CST:
8266 0 : {
8267 0 : {
8268 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8269 0 : tree res = generic_simplify_326 (loc, type, _p0, _p1, captures, CEIL_MOD_EXPR);
8270 0 : if (res) return res;
8271 : }
8272 0 : break;
8273 : }
8274 : default:;
8275 : }
8276 : break;
8277 : }
8278 : default:;
8279 : }
8280 : break;
8281 : }
8282 0 : case VEC_COND_EXPR:
8283 0 : {
8284 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8285 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8286 0 : tree _q22 = TREE_OPERAND (_p0, 2);
8287 0 : switch (TREE_CODE (_p1))
8288 : {
8289 0 : case VEC_COND_EXPR:
8290 0 : {
8291 0 : tree _q60 = TREE_OPERAND (_p1, 0);
8292 0 : tree _q61 = TREE_OPERAND (_p1, 1);
8293 0 : tree _q62 = TREE_OPERAND (_p1, 2);
8294 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
8295 : {
8296 0 : {
8297 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
8298 0 : if (VECTOR_TYPE_P (type)
8299 0 : && (TREE_CODE_CLASS (CEIL_MOD_EXPR) != tcc_comparison
8300 : || types_match (type, TREE_TYPE (captures[2]))
8301 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8302 : || (optimize_vectors_before_lowering_p ()
8303 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8304 : )
8305 : {
8306 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1626;
8307 0 : {
8308 0 : tree res_op0;
8309 0 : res_op0 = captures[1];
8310 0 : tree res_op1;
8311 0 : {
8312 0 : tree _o1[2], _r1;
8313 0 : _o1[0] = captures[2];
8314 0 : _o1[1] = captures[5];
8315 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8316 0 : if (EXPR_P (_r1))
8317 0 : goto next_after_fail1626;
8318 0 : res_op1 = _r1;
8319 : }
8320 0 : tree res_op2;
8321 0 : {
8322 0 : tree _o1[2], _r1;
8323 0 : _o1[0] = captures[3];
8324 0 : _o1[1] = captures[6];
8325 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8326 0 : if (EXPR_P (_r1))
8327 0 : goto next_after_fail1626;
8328 0 : res_op2 = _r1;
8329 : }
8330 0 : tree _r;
8331 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8332 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
8333 0 : return _r;
8334 : }
8335 0 : next_after_fail1626:;
8336 : }
8337 : }
8338 : }
8339 : break;
8340 : }
8341 0 : default:;
8342 : }
8343 0 : {
8344 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
8345 0 : if (VECTOR_TYPE_P (type)
8346 0 : && (TREE_CODE_CLASS (CEIL_MOD_EXPR) != tcc_comparison
8347 : || types_match (type, TREE_TYPE (captures[2]))
8348 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8349 : || (optimize_vectors_before_lowering_p ()
8350 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8351 : )
8352 : {
8353 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1627;
8354 0 : {
8355 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1627;
8356 0 : tree res_op0;
8357 0 : res_op0 = captures[1];
8358 0 : tree res_op1;
8359 0 : {
8360 0 : tree _o1[2], _r1;
8361 0 : _o1[0] = captures[2];
8362 0 : _o1[1] = unshare_expr (captures[4]);
8363 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8364 0 : if (EXPR_P (_r1))
8365 0 : goto next_after_fail1627;
8366 0 : res_op1 = _r1;
8367 : }
8368 0 : tree res_op2;
8369 0 : {
8370 0 : tree _o1[2], _r1;
8371 0 : _o1[0] = captures[3];
8372 0 : _o1[1] = captures[4];
8373 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8374 0 : if (EXPR_P (_r1))
8375 0 : goto next_after_fail1627;
8376 0 : res_op2 = _r1;
8377 : }
8378 0 : tree _r;
8379 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8380 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
8381 0 : return _r;
8382 : }
8383 0 : next_after_fail1627:;
8384 : }
8385 : }
8386 0 : break;
8387 : }
8388 4068 : default:;
8389 : }
8390 4068 : switch (TREE_CODE (_p1))
8391 : {
8392 0 : case VEC_COND_EXPR:
8393 0 : {
8394 0 : tree _q30 = TREE_OPERAND (_p1, 0);
8395 0 : tree _q31 = TREE_OPERAND (_p1, 1);
8396 0 : tree _q32 = TREE_OPERAND (_p1, 2);
8397 0 : {
8398 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
8399 0 : if (VECTOR_TYPE_P (type)
8400 0 : && (TREE_CODE_CLASS (CEIL_MOD_EXPR) != tcc_comparison
8401 : || types_match (type, TREE_TYPE (captures[3]))
8402 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
8403 : || (optimize_vectors_before_lowering_p ()
8404 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
8405 : )
8406 : {
8407 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1628;
8408 0 : {
8409 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1628;
8410 0 : tree res_op0;
8411 0 : res_op0 = captures[2];
8412 0 : tree res_op1;
8413 0 : {
8414 0 : tree _o1[2], _r1;
8415 0 : _o1[0] = unshare_expr (captures[0]);
8416 0 : _o1[1] = captures[3];
8417 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8418 0 : if (EXPR_P (_r1))
8419 0 : goto next_after_fail1628;
8420 0 : res_op1 = _r1;
8421 : }
8422 0 : tree res_op2;
8423 0 : {
8424 0 : tree _o1[2], _r1;
8425 0 : _o1[0] = captures[0];
8426 0 : _o1[1] = captures[4];
8427 0 : _r1 = fold_build2_loc (loc, CEIL_MOD_EXPR, type, _o1[0], _o1[1]);
8428 0 : if (EXPR_P (_r1))
8429 0 : goto next_after_fail1628;
8430 0 : res_op2 = _r1;
8431 : }
8432 0 : tree _r;
8433 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8434 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
8435 0 : return _r;
8436 : }
8437 0 : next_after_fail1628:;
8438 : }
8439 : }
8440 0 : break;
8441 : }
8442 : default:;
8443 : }
8444 : return NULL_TREE;
8445 : }
8446 :
8447 : tree
8448 0 : generic_simplify_ROUND_MOD_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
8449 : {
8450 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8451 0 : if (integer_zerop (_p0))
8452 : {
8453 0 : {
8454 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8455 0 : tree res = generic_simplify_321 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8456 0 : if (res) return res;
8457 : }
8458 : }
8459 0 : if (integer_onep (_p1))
8460 : {
8461 0 : {
8462 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8463 0 : tree res = generic_simplify_322 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8464 0 : if (res) return res;
8465 : }
8466 : }
8467 0 : if (integer_minus_onep (_p1))
8468 : {
8469 0 : {
8470 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8471 0 : tree res = generic_simplify_323 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8472 0 : if (res) return res;
8473 : }
8474 : }
8475 0 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
8476 : {
8477 0 : {
8478 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8479 0 : tree res = generic_simplify_324 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8480 0 : if (res) return res;
8481 : }
8482 : }
8483 0 : switch (TREE_CODE (_p0))
8484 : {
8485 0 : case ROUND_MOD_EXPR:
8486 0 : {
8487 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8488 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8489 0 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8490 : {
8491 0 : {
8492 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8493 0 : tree res = generic_simplify_325 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8494 0 : if (res) return res;
8495 : }
8496 : }
8497 : break;
8498 : }
8499 0 : case MULT_EXPR:
8500 0 : {
8501 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8502 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8503 0 : switch (TREE_CODE (_q21))
8504 : {
8505 0 : case INTEGER_CST:
8506 0 : {
8507 0 : switch (TREE_CODE (_p1))
8508 : {
8509 0 : case INTEGER_CST:
8510 0 : {
8511 0 : {
8512 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8513 0 : tree res = generic_simplify_326 (loc, type, _p0, _p1, captures, ROUND_MOD_EXPR);
8514 0 : if (res) return res;
8515 : }
8516 0 : break;
8517 : }
8518 : default:;
8519 : }
8520 : break;
8521 : }
8522 : default:;
8523 : }
8524 : break;
8525 : }
8526 0 : case VEC_COND_EXPR:
8527 0 : {
8528 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8529 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8530 0 : tree _q22 = TREE_OPERAND (_p0, 2);
8531 0 : switch (TREE_CODE (_p1))
8532 : {
8533 0 : case VEC_COND_EXPR:
8534 0 : {
8535 0 : tree _q60 = TREE_OPERAND (_p1, 0);
8536 0 : tree _q61 = TREE_OPERAND (_p1, 1);
8537 0 : tree _q62 = TREE_OPERAND (_p1, 2);
8538 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
8539 : {
8540 0 : {
8541 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
8542 0 : if (VECTOR_TYPE_P (type)
8543 0 : && (TREE_CODE_CLASS (ROUND_MOD_EXPR) != tcc_comparison
8544 : || types_match (type, TREE_TYPE (captures[2]))
8545 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8546 : || (optimize_vectors_before_lowering_p ()
8547 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8548 : )
8549 : {
8550 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1629;
8551 0 : {
8552 0 : tree res_op0;
8553 0 : res_op0 = captures[1];
8554 0 : tree res_op1;
8555 0 : {
8556 0 : tree _o1[2], _r1;
8557 0 : _o1[0] = captures[2];
8558 0 : _o1[1] = captures[5];
8559 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8560 0 : if (EXPR_P (_r1))
8561 0 : goto next_after_fail1629;
8562 0 : res_op1 = _r1;
8563 : }
8564 0 : tree res_op2;
8565 0 : {
8566 0 : tree _o1[2], _r1;
8567 0 : _o1[0] = captures[3];
8568 0 : _o1[1] = captures[6];
8569 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8570 0 : if (EXPR_P (_r1))
8571 0 : goto next_after_fail1629;
8572 0 : res_op2 = _r1;
8573 : }
8574 0 : tree _r;
8575 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8576 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
8577 0 : return _r;
8578 : }
8579 0 : next_after_fail1629:;
8580 : }
8581 : }
8582 : }
8583 : break;
8584 : }
8585 0 : default:;
8586 : }
8587 0 : {
8588 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
8589 0 : if (VECTOR_TYPE_P (type)
8590 0 : && (TREE_CODE_CLASS (ROUND_MOD_EXPR) != tcc_comparison
8591 : || types_match (type, TREE_TYPE (captures[2]))
8592 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8593 : || (optimize_vectors_before_lowering_p ()
8594 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8595 : )
8596 : {
8597 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1630;
8598 0 : {
8599 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1630;
8600 0 : tree res_op0;
8601 0 : res_op0 = captures[1];
8602 0 : tree res_op1;
8603 0 : {
8604 0 : tree _o1[2], _r1;
8605 0 : _o1[0] = captures[2];
8606 0 : _o1[1] = unshare_expr (captures[4]);
8607 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8608 0 : if (EXPR_P (_r1))
8609 0 : goto next_after_fail1630;
8610 0 : res_op1 = _r1;
8611 : }
8612 0 : tree res_op2;
8613 0 : {
8614 0 : tree _o1[2], _r1;
8615 0 : _o1[0] = captures[3];
8616 0 : _o1[1] = captures[4];
8617 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8618 0 : if (EXPR_P (_r1))
8619 0 : goto next_after_fail1630;
8620 0 : res_op2 = _r1;
8621 : }
8622 0 : tree _r;
8623 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8624 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
8625 0 : return _r;
8626 : }
8627 0 : next_after_fail1630:;
8628 : }
8629 : }
8630 0 : break;
8631 : }
8632 0 : default:;
8633 : }
8634 0 : switch (TREE_CODE (_p1))
8635 : {
8636 0 : case VEC_COND_EXPR:
8637 0 : {
8638 0 : tree _q30 = TREE_OPERAND (_p1, 0);
8639 0 : tree _q31 = TREE_OPERAND (_p1, 1);
8640 0 : tree _q32 = TREE_OPERAND (_p1, 2);
8641 0 : {
8642 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
8643 0 : if (VECTOR_TYPE_P (type)
8644 0 : && (TREE_CODE_CLASS (ROUND_MOD_EXPR) != tcc_comparison
8645 : || types_match (type, TREE_TYPE (captures[3]))
8646 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
8647 : || (optimize_vectors_before_lowering_p ()
8648 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
8649 : )
8650 : {
8651 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1631;
8652 0 : {
8653 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1631;
8654 0 : tree res_op0;
8655 0 : res_op0 = captures[2];
8656 0 : tree res_op1;
8657 0 : {
8658 0 : tree _o1[2], _r1;
8659 0 : _o1[0] = unshare_expr (captures[0]);
8660 0 : _o1[1] = captures[3];
8661 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8662 0 : if (EXPR_P (_r1))
8663 0 : goto next_after_fail1631;
8664 0 : res_op1 = _r1;
8665 : }
8666 0 : tree res_op2;
8667 0 : {
8668 0 : tree _o1[2], _r1;
8669 0 : _o1[0] = captures[0];
8670 0 : _o1[1] = captures[4];
8671 0 : _r1 = fold_build2_loc (loc, ROUND_MOD_EXPR, type, _o1[0], _o1[1]);
8672 0 : if (EXPR_P (_r1))
8673 0 : goto next_after_fail1631;
8674 0 : res_op2 = _r1;
8675 : }
8676 0 : tree _r;
8677 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8678 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
8679 0 : return _r;
8680 : }
8681 0 : next_after_fail1631:;
8682 : }
8683 : }
8684 0 : break;
8685 : }
8686 : default:;
8687 : }
8688 : return NULL_TREE;
8689 : }
8690 :
8691 : tree
8692 2072741 : generic_simplify_TRUNC_MOD_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
8693 : {
8694 2072741 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8695 2072741 : if (integer_zerop (_p0))
8696 : {
8697 919 : {
8698 919 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8699 919 : tree res = generic_simplify_321 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8700 919 : if (res) return res;
8701 : }
8702 : }
8703 2071956 : if (integer_onep (_p1))
8704 : {
8705 216139 : {
8706 216139 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8707 216139 : tree res = generic_simplify_322 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8708 216139 : if (res) return res;
8709 : }
8710 : }
8711 1855817 : if (integer_minus_onep (_p1))
8712 : {
8713 529 : {
8714 529 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8715 529 : tree res = generic_simplify_323 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8716 529 : if (res) return res;
8717 : }
8718 : }
8719 1855797 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
8720 : {
8721 227 : {
8722 227 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8723 227 : tree res = generic_simplify_324 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8724 227 : if (res) return res;
8725 : }
8726 : }
8727 1855704 : switch (TREE_CODE (_p0))
8728 : {
8729 107 : case TRUNC_MOD_EXPR:
8730 107 : {
8731 107 : tree _q20 = TREE_OPERAND (_p0, 0);
8732 107 : tree _q21 = TREE_OPERAND (_p0, 1);
8733 107 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8734 : {
8735 52 : {
8736 52 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8737 52 : tree res = generic_simplify_325 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8738 52 : if (res) return res;
8739 : }
8740 : }
8741 : break;
8742 : }
8743 7409 : case MULT_EXPR:
8744 7409 : {
8745 7409 : tree _q20 = TREE_OPERAND (_p0, 0);
8746 7409 : tree _q21 = TREE_OPERAND (_p0, 1);
8747 7409 : switch (TREE_CODE (_q21))
8748 : {
8749 7316 : case INTEGER_CST:
8750 7316 : {
8751 7316 : switch (TREE_CODE (_p1))
8752 : {
8753 7294 : case INTEGER_CST:
8754 7294 : {
8755 7294 : {
8756 7294 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8757 7294 : tree res = generic_simplify_326 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8758 7294 : if (res) return res;
8759 : }
8760 7294 : break;
8761 : }
8762 : default:;
8763 : }
8764 : break;
8765 : }
8766 : default:;
8767 : }
8768 : break;
8769 : }
8770 1855652 : default:;
8771 : }
8772 1855652 : switch (TREE_CODE (_p1))
8773 : {
8774 1587793 : case INTEGER_CST:
8775 1587793 : {
8776 1587793 : {
8777 1587793 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8778 1587793 : if (TYPE_SIGN (type) == SIGNED
8779 276818 : && !TREE_OVERFLOW (captures[1])
8780 1587797 : && wi::neg_p (wi::to_wide (captures[1]))
8781 313 : && !TYPE_OVERFLOW_TRAPS (type)
8782 1588106 : && !sign_bit_p (captures[1], captures[1])
8783 : )
8784 : {
8785 309 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1632;
8786 309 : {
8787 309 : tree res_op0;
8788 309 : res_op0 = captures[0];
8789 309 : tree res_op1;
8790 309 : {
8791 309 : tree _o1[1], _r1;
8792 309 : _o1[0] = captures[1];
8793 309 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
8794 309 : res_op1 = _r1;
8795 : }
8796 309 : tree _r;
8797 309 : _r = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, res_op0, res_op1);
8798 309 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 986, __FILE__, __LINE__, true);
8799 309 : return _r;
8800 : }
8801 0 : next_after_fail1632:;
8802 : }
8803 : }
8804 1587484 : break;
8805 : }
8806 54378 : CASE_CONVERT:
8807 54378 : {
8808 54378 : tree _q30 = TREE_OPERAND (_p1, 0);
8809 54378 : switch (TREE_CODE (_q30))
8810 : {
8811 0 : case NEGATE_EXPR:
8812 0 : {
8813 0 : tree _q40 = TREE_OPERAND (_q30, 0);
8814 0 : {
8815 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q40 };
8816 0 : tree res = generic_simplify_407 (loc, type, _p0, _p1, captures);
8817 0 : if (res) return res;
8818 : }
8819 0 : break;
8820 : }
8821 54378 : default:;
8822 : }
8823 54378 : {
8824 54378 : tree _q30_pops[1];
8825 54378 : if (tree_power_of_two_cand (_q30, _q30_pops))
8826 : {
8827 7 : tree _q40 = _q30_pops[0];
8828 7 : {
8829 7 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q40 };
8830 7 : tree res = generic_simplify_327 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8831 7 : if (res) return res;
8832 : }
8833 : }
8834 : }
8835 54371 : break;
8836 : }
8837 94 : case NEGATE_EXPR:
8838 94 : {
8839 94 : tree _q30 = TREE_OPERAND (_p1, 0);
8840 94 : {
8841 94 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q30 };
8842 94 : tree res = generic_simplify_407 (loc, type, _p0, _p1, captures);
8843 94 : if (res) return res;
8844 : }
8845 94 : break;
8846 : }
8847 1855336 : default:;
8848 : }
8849 1855336 : {
8850 1855336 : tree _p1_pops[1];
8851 1855336 : if (tree_power_of_two_cand (_p1, _p1_pops))
8852 : {
8853 1587493 : tree _q30 = _p1_pops[0];
8854 1587493 : {
8855 1587493 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q30 };
8856 1587493 : tree res = generic_simplify_327 (loc, type, _p0, _p1, captures, TRUNC_MOD_EXPR);
8857 1587493 : if (res) return res;
8858 : }
8859 : }
8860 : }
8861 882214 : switch (TREE_CODE (_p0))
8862 : {
8863 0 : case VEC_COND_EXPR:
8864 0 : {
8865 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8866 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8867 0 : tree _q22 = TREE_OPERAND (_p0, 2);
8868 0 : switch (TREE_CODE (_p1))
8869 : {
8870 0 : case VEC_COND_EXPR:
8871 0 : {
8872 0 : tree _q60 = TREE_OPERAND (_p1, 0);
8873 0 : tree _q61 = TREE_OPERAND (_p1, 1);
8874 0 : tree _q62 = TREE_OPERAND (_p1, 2);
8875 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
8876 : {
8877 0 : {
8878 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
8879 0 : if (VECTOR_TYPE_P (type)
8880 0 : && (TREE_CODE_CLASS (TRUNC_MOD_EXPR) != tcc_comparison
8881 : || types_match (type, TREE_TYPE (captures[2]))
8882 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8883 : || (optimize_vectors_before_lowering_p ()
8884 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8885 : )
8886 : {
8887 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1633;
8888 0 : {
8889 0 : tree res_op0;
8890 0 : res_op0 = captures[1];
8891 0 : tree res_op1;
8892 0 : {
8893 0 : tree _o1[2], _r1;
8894 0 : _o1[0] = captures[2];
8895 0 : _o1[1] = captures[5];
8896 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
8897 0 : if (EXPR_P (_r1))
8898 0 : goto next_after_fail1633;
8899 0 : res_op1 = _r1;
8900 : }
8901 0 : tree res_op2;
8902 0 : {
8903 0 : tree _o1[2], _r1;
8904 0 : _o1[0] = captures[3];
8905 0 : _o1[1] = captures[6];
8906 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
8907 0 : if (EXPR_P (_r1))
8908 0 : goto next_after_fail1633;
8909 0 : res_op2 = _r1;
8910 : }
8911 0 : tree _r;
8912 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8913 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
8914 0 : return _r;
8915 : }
8916 0 : next_after_fail1633:;
8917 : }
8918 : }
8919 : }
8920 : break;
8921 : }
8922 0 : default:;
8923 : }
8924 0 : {
8925 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
8926 0 : if (VECTOR_TYPE_P (type)
8927 0 : && (TREE_CODE_CLASS (TRUNC_MOD_EXPR) != tcc_comparison
8928 : || types_match (type, TREE_TYPE (captures[2]))
8929 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
8930 : || (optimize_vectors_before_lowering_p ()
8931 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
8932 : )
8933 : {
8934 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1634;
8935 0 : {
8936 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1634;
8937 0 : tree res_op0;
8938 0 : res_op0 = captures[1];
8939 0 : tree res_op1;
8940 0 : {
8941 0 : tree _o1[2], _r1;
8942 0 : _o1[0] = captures[2];
8943 0 : _o1[1] = unshare_expr (captures[4]);
8944 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
8945 0 : if (EXPR_P (_r1))
8946 0 : goto next_after_fail1634;
8947 0 : res_op1 = _r1;
8948 : }
8949 0 : tree res_op2;
8950 0 : {
8951 0 : tree _o1[2], _r1;
8952 0 : _o1[0] = captures[3];
8953 0 : _o1[1] = captures[4];
8954 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
8955 0 : if (EXPR_P (_r1))
8956 0 : goto next_after_fail1634;
8957 0 : res_op2 = _r1;
8958 : }
8959 0 : tree _r;
8960 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8961 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
8962 0 : return _r;
8963 : }
8964 0 : next_after_fail1634:;
8965 : }
8966 : }
8967 0 : break;
8968 : }
8969 882214 : default:;
8970 : }
8971 882214 : switch (TREE_CODE (_p1))
8972 : {
8973 7 : case VEC_COND_EXPR:
8974 7 : {
8975 7 : tree _q30 = TREE_OPERAND (_p1, 0);
8976 7 : tree _q31 = TREE_OPERAND (_p1, 1);
8977 7 : tree _q32 = TREE_OPERAND (_p1, 2);
8978 7 : {
8979 7 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
8980 7 : if (VECTOR_TYPE_P (type)
8981 7 : && (TREE_CODE_CLASS (TRUNC_MOD_EXPR) != tcc_comparison
8982 : || types_match (type, TREE_TYPE (captures[3]))
8983 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
8984 : || (optimize_vectors_before_lowering_p ()
8985 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
8986 : )
8987 : {
8988 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1635;
8989 7 : {
8990 7 : if (! tree_invariant_p (captures[0])) goto next_after_fail1635;
8991 0 : tree res_op0;
8992 0 : res_op0 = captures[2];
8993 0 : tree res_op1;
8994 0 : {
8995 0 : tree _o1[2], _r1;
8996 0 : _o1[0] = unshare_expr (captures[0]);
8997 0 : _o1[1] = captures[3];
8998 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
8999 0 : if (EXPR_P (_r1))
9000 0 : goto next_after_fail1635;
9001 0 : res_op1 = _r1;
9002 : }
9003 0 : tree res_op2;
9004 0 : {
9005 0 : tree _o1[2], _r1;
9006 0 : _o1[0] = captures[0];
9007 0 : _o1[1] = captures[4];
9008 0 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, _o1[0], _o1[1]);
9009 0 : if (EXPR_P (_r1))
9010 0 : goto next_after_fail1635;
9011 0 : res_op2 = _r1;
9012 : }
9013 0 : tree _r;
9014 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9015 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
9016 0 : return _r;
9017 : }
9018 7 : next_after_fail1635:;
9019 : }
9020 : }
9021 7 : break;
9022 : }
9023 : default:;
9024 : }
9025 : return NULL_TREE;
9026 : }
9027 :
9028 : tree
9029 1259629 : generic_simplify_RSHIFT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
9030 : {
9031 1259629 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
9032 1259629 : switch (TREE_CODE (_p1))
9033 : {
9034 119 : case TRUNC_MOD_EXPR:
9035 119 : {
9036 119 : tree _q30 = TREE_OPERAND (_p1, 0);
9037 119 : tree _q31 = TREE_OPERAND (_p1, 1);
9038 119 : {
9039 119 : tree _q31_pops[1];
9040 119 : if (tree_power_of_two_cand (_q31, _q31_pops))
9041 : {
9042 111 : tree _q50 = _q31_pops[0];
9043 111 : {
9044 111 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q50 };
9045 111 : tree res = generic_simplify_408 (loc, type, _p0, _p1, captures, RSHIFT_EXPR, TRUNC_MOD_EXPR);
9046 111 : if (res) return res;
9047 : }
9048 : }
9049 : }
9050 14 : break;
9051 : }
9052 0 : case FLOOR_MOD_EXPR:
9053 0 : {
9054 0 : tree _q30 = TREE_OPERAND (_p1, 0);
9055 0 : tree _q31 = TREE_OPERAND (_p1, 1);
9056 0 : {
9057 0 : tree _q31_pops[1];
9058 0 : if (tree_power_of_two_cand (_q31, _q31_pops))
9059 : {
9060 0 : tree _q50 = _q31_pops[0];
9061 0 : {
9062 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q50 };
9063 0 : tree res = generic_simplify_408 (loc, type, _p0, _p1, captures, RSHIFT_EXPR, FLOOR_MOD_EXPR);
9064 0 : if (res) return res;
9065 : }
9066 : }
9067 : }
9068 0 : break;
9069 : }
9070 1259524 : default:;
9071 : }
9072 1259524 : if (uniform_integer_cst_p (_p1))
9073 : {
9074 1032591 : {
9075 1032591 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9076 1032591 : tree res = generic_simplify_409 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9077 1032591 : if (res) return res;
9078 : }
9079 : }
9080 1258767 : switch (TREE_CODE (_p0))
9081 : {
9082 58 : case NEGATE_EXPR:
9083 58 : {
9084 58 : tree _q20 = TREE_OPERAND (_p0, 0);
9085 58 : switch (TREE_CODE (_p1))
9086 : {
9087 57 : case INTEGER_CST:
9088 57 : {
9089 57 : {
9090 57 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9091 57 : if (!TYPE_UNSIGNED (type)
9092 57 : && TYPE_OVERFLOW_UNDEFINED (type)
9093 : )
9094 : {
9095 32 : {
9096 32 : tree stype = TREE_TYPE (captures[2]);
9097 32 : tree bt = truth_type_for (type);
9098 32 : tree zeros = build_zero_cst (type);
9099 32 : tree INTEGER_CST = NULL_TREE;
9100 32 : if (INTEGRAL_TYPE_P (type)
9101 : && canonicalize_math_after_vectorization_p ()
9102 : && wi::eq_p (wi::to_wide (captures[2]), TYPE_PRECISION (type) - 1)
9103 : )
9104 : {
9105 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1644;
9106 : {
9107 : tree res_op0;
9108 : {
9109 : tree _o1[1], _r1;
9110 : {
9111 : tree _o2[2], _r2;
9112 : _o2[0] = captures[1];
9113 : _o2[1] = zeros;
9114 : _r2 = fold_build2_loc (loc, GT_EXPR, boolean_type_node, _o2[0], _o2[1]);
9115 : _o1[0] = _r2;
9116 : }
9117 : if (TREE_TYPE (_o1[0]) != type)
9118 : {
9119 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
9120 : }
9121 : else
9122 : _r1 = _o1[0];
9123 : res_op0 = _r1;
9124 : }
9125 : tree _r;
9126 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
9127 : if (TREE_SIDE_EFFECTS (captures[2]))
9128 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
9129 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 991, __FILE__, __LINE__, true);
9130 : return _r;
9131 : }
9132 : next_after_fail1644:;
9133 : }
9134 : else
9135 : {
9136 0 : if (VECTOR_INTEGER_TYPE_P (type)
9137 0 : && TYPE_MODE (bt) == TYPE_MODE (type)
9138 0 : && expand_vec_cmp_expr_p (type, bt, GT_EXPR)
9139 0 : && (INTEGER_CST = uniform_integer_cst_p (captures[2])) != NULL
9140 32 : && wi::eq_p (wi::to_wide (INTEGER_CST), element_precision (type) - 1)
9141 : )
9142 : {
9143 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1645;
9144 0 : {
9145 0 : tree res_op0;
9146 0 : {
9147 0 : tree _o1[2], _r1;
9148 0 : _o1[0] = captures[1];
9149 0 : _o1[1] = zeros;
9150 0 : _r1 = fold_build2_loc (loc, GT_EXPR, bt, _o1[0], _o1[1]);
9151 0 : res_op0 = _r1;
9152 : }
9153 0 : tree _r;
9154 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
9155 0 : if (TREE_SIDE_EFFECTS (captures[2]))
9156 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
9157 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 992, __FILE__, __LINE__, true);
9158 0 : return _r;
9159 : }
9160 0 : next_after_fail1645:;
9161 : }
9162 : }
9163 : }
9164 : }
9165 : }
9166 57 : break;
9167 : }
9168 0 : case VECTOR_CST:
9169 0 : {
9170 0 : {
9171 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9172 0 : if (!TYPE_UNSIGNED (type)
9173 0 : && TYPE_OVERFLOW_UNDEFINED (type)
9174 : )
9175 : {
9176 0 : {
9177 0 : tree stype = TREE_TYPE (captures[2]);
9178 0 : tree bt = truth_type_for (type);
9179 0 : tree zeros = build_zero_cst (type);
9180 0 : tree VECTOR_CST = NULL_TREE;
9181 0 : if (INTEGRAL_TYPE_P (type)
9182 : && canonicalize_math_after_vectorization_p ()
9183 : && wi::eq_p (wi::to_wide (captures[2]), TYPE_PRECISION (type) - 1)
9184 : )
9185 : {
9186 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1646;
9187 : {
9188 : tree res_op0;
9189 : {
9190 : tree _o1[1], _r1;
9191 : {
9192 : tree _o2[2], _r2;
9193 : _o2[0] = captures[1];
9194 : _o2[1] = zeros;
9195 : _r2 = fold_build2_loc (loc, GT_EXPR, boolean_type_node, _o2[0], _o2[1]);
9196 : _o1[0] = _r2;
9197 : }
9198 : if (TREE_TYPE (_o1[0]) != type)
9199 : {
9200 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
9201 : }
9202 : else
9203 : _r1 = _o1[0];
9204 : res_op0 = _r1;
9205 : }
9206 : tree _r;
9207 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
9208 : if (TREE_SIDE_EFFECTS (captures[2]))
9209 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
9210 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 991, __FILE__, __LINE__, true);
9211 : return _r;
9212 : }
9213 : next_after_fail1646:;
9214 : }
9215 : else
9216 : {
9217 0 : if (VECTOR_INTEGER_TYPE_P (type)
9218 0 : && TYPE_MODE (bt) == TYPE_MODE (type)
9219 0 : && expand_vec_cmp_expr_p (type, bt, GT_EXPR)
9220 0 : && (VECTOR_CST = uniform_integer_cst_p (captures[2])) != NULL
9221 0 : && wi::eq_p (wi::to_wide (VECTOR_CST), element_precision (type) - 1)
9222 : )
9223 : {
9224 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1647;
9225 0 : {
9226 0 : tree res_op0;
9227 0 : {
9228 0 : tree _o1[2], _r1;
9229 0 : _o1[0] = captures[1];
9230 0 : _o1[1] = zeros;
9231 0 : _r1 = fold_build2_loc (loc, GT_EXPR, bt, _o1[0], _o1[1]);
9232 0 : res_op0 = _r1;
9233 : }
9234 0 : tree _r;
9235 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
9236 0 : if (TREE_SIDE_EFFECTS (captures[2]))
9237 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
9238 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 992, __FILE__, __LINE__, true);
9239 0 : return _r;
9240 : }
9241 0 : next_after_fail1647:;
9242 : }
9243 : }
9244 : }
9245 : }
9246 : }
9247 0 : break;
9248 : }
9249 : default:;
9250 : }
9251 : break;
9252 : }
9253 437 : case LSHIFT_EXPR:
9254 437 : {
9255 437 : tree _q20 = TREE_OPERAND (_p0, 0);
9256 437 : tree _q21 = TREE_OPERAND (_p0, 1);
9257 437 : switch (TREE_CODE (_q21))
9258 : {
9259 358 : case INTEGER_CST:
9260 358 : {
9261 358 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q21, 0))
9262 : {
9263 67 : {
9264 67 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p1, _q21 };
9265 67 : tree res = generic_simplify_418 (loc, type, _p0, _p1, captures);
9266 67 : if (res) return res;
9267 : }
9268 : }
9269 : break;
9270 : }
9271 : default:;
9272 : }
9273 : break;
9274 : }
9275 1258740 : default:;
9276 : }
9277 1258740 : {
9278 1258740 : tree _p0_pops[1];
9279 1258740 : if (tree_nop_convert (_p0, _p0_pops))
9280 : {
9281 418101 : tree _q20 = _p0_pops[0];
9282 418101 : switch (TREE_CODE (_q20))
9283 : {
9284 20 : case LSHIFT_EXPR:
9285 20 : {
9286 20 : tree _q30 = TREE_OPERAND (_q20, 0);
9287 20 : tree _q31 = TREE_OPERAND (_q20, 1);
9288 20 : switch (TREE_CODE (_q31))
9289 : {
9290 0 : case INTEGER_CST:
9291 0 : {
9292 0 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q31, 0))
9293 : {
9294 0 : {
9295 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p1, _q31 };
9296 0 : tree res = generic_simplify_418 (loc, type, _p0, _p1, captures);
9297 0 : if (res) return res;
9298 : }
9299 : }
9300 : break;
9301 : }
9302 : default:;
9303 : }
9304 : break;
9305 : }
9306 : default:;
9307 : }
9308 : }
9309 : }
9310 1258740 : if (integer_all_onesp (_p0))
9311 : {
9312 10820 : {
9313 10820 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9314 10820 : if (!TYPE_UNSIGNED (type)
9315 : )
9316 : {
9317 119 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1648;
9318 119 : {
9319 119 : tree _r;
9320 119 : _r = captures[0];
9321 119 : if (TREE_SIDE_EFFECTS (captures[1]))
9322 1 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
9323 119 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 993, __FILE__, __LINE__, true);
9324 119 : return _r;
9325 : }
9326 0 : next_after_fail1648:;
9327 : }
9328 : }
9329 : }
9330 1258621 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
9331 : {
9332 25 : {
9333 25 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
9334 25 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1649;
9335 25 : {
9336 25 : tree _r;
9337 25 : _r = build_zero_cst (type);
9338 25 : if (TREE_SIDE_EFFECTS (captures[0]))
9339 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
9340 25 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 994, __FILE__, __LINE__, true);
9341 25 : return _r;
9342 : }
9343 0 : next_after_fail1649:;
9344 : }
9345 : }
9346 1258596 : if (integer_zerop (_p1))
9347 : {
9348 1279 : {
9349 1279 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
9350 1279 : tree res = generic_simplify_411 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9351 1279 : if (res) return res;
9352 : }
9353 : }
9354 1257317 : if (integer_zerop (_p0))
9355 : {
9356 152 : {
9357 152 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9358 152 : tree res = generic_simplify_412 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9359 152 : if (res) return res;
9360 : }
9361 : }
9362 1257165 : switch (TREE_CODE (_p1))
9363 : {
9364 0 : case VECTOR_CST:
9365 0 : {
9366 0 : {
9367 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9368 0 : tree res = generic_simplify_413 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9369 0 : if (res) return res;
9370 : }
9371 0 : break;
9372 : }
9373 0 : case CONSTRUCTOR:
9374 0 : {
9375 0 : {
9376 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9377 0 : tree res = generic_simplify_414 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9378 0 : if (res) return res;
9379 : }
9380 0 : break;
9381 : }
9382 1257165 : default:;
9383 : }
9384 1257165 : switch (TREE_CODE (_p0))
9385 : {
9386 118 : case RSHIFT_EXPR:
9387 118 : {
9388 118 : tree _q20 = TREE_OPERAND (_p0, 0);
9389 118 : tree _q21 = TREE_OPERAND (_p0, 1);
9390 118 : switch (TREE_CODE (_q21))
9391 : {
9392 73 : case INTEGER_CST:
9393 73 : {
9394 73 : switch (TREE_CODE (_p1))
9395 : {
9396 47 : case INTEGER_CST:
9397 47 : {
9398 47 : {
9399 47 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
9400 47 : tree res = generic_simplify_415 (loc, type, _p0, _p1, captures, RSHIFT_EXPR);
9401 47 : if (res) return res;
9402 : }
9403 0 : break;
9404 : }
9405 : default:;
9406 : }
9407 : break;
9408 : }
9409 : default:;
9410 : }
9411 : break;
9412 : }
9413 474622 : CASE_CONVERT:
9414 474622 : {
9415 474622 : tree _q20 = TREE_OPERAND (_p0, 0);
9416 474622 : switch (TREE_CODE (_q20))
9417 : {
9418 6 : case BIT_AND_EXPR:
9419 6 : {
9420 6 : tree _q30 = TREE_OPERAND (_q20, 0);
9421 6 : tree _q31 = TREE_OPERAND (_q20, 1);
9422 6 : switch (TREE_CODE (_q31))
9423 : {
9424 0 : case INTEGER_CST:
9425 0 : {
9426 0 : switch (TREE_CODE (_p1))
9427 : {
9428 0 : case INTEGER_CST:
9429 0 : {
9430 0 : {
9431 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
9432 0 : tree res = generic_simplify_416 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, RSHIFT_EXPR);
9433 0 : if (res) return res;
9434 : }
9435 0 : break;
9436 : }
9437 : default:;
9438 : }
9439 : break;
9440 : }
9441 : default:;
9442 : }
9443 : break;
9444 : }
9445 14 : case BIT_XOR_EXPR:
9446 14 : {
9447 14 : tree _q30 = TREE_OPERAND (_q20, 0);
9448 14 : tree _q31 = TREE_OPERAND (_q20, 1);
9449 14 : switch (TREE_CODE (_q31))
9450 : {
9451 0 : case INTEGER_CST:
9452 0 : {
9453 0 : switch (TREE_CODE (_p1))
9454 : {
9455 0 : case INTEGER_CST:
9456 0 : {
9457 0 : {
9458 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
9459 0 : tree res = generic_simplify_416 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, RSHIFT_EXPR);
9460 0 : if (res) return res;
9461 : }
9462 0 : break;
9463 : }
9464 : default:;
9465 : }
9466 : break;
9467 : }
9468 : default:;
9469 : }
9470 : break;
9471 : }
9472 43 : case BIT_IOR_EXPR:
9473 43 : {
9474 43 : tree _q30 = TREE_OPERAND (_q20, 0);
9475 43 : tree _q31 = TREE_OPERAND (_q20, 1);
9476 43 : switch (TREE_CODE (_q31))
9477 : {
9478 24 : case INTEGER_CST:
9479 24 : {
9480 24 : switch (TREE_CODE (_p1))
9481 : {
9482 7 : case INTEGER_CST:
9483 7 : {
9484 7 : {
9485 7 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
9486 7 : tree res = generic_simplify_416 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, RSHIFT_EXPR);
9487 7 : if (res) return res;
9488 : }
9489 0 : break;
9490 : }
9491 : default:;
9492 : }
9493 : break;
9494 : }
9495 : default:;
9496 : }
9497 : break;
9498 : }
9499 59 : case CALL_EXPR:
9500 59 : switch (get_call_combined_fn (_q20))
9501 : {
9502 0 : case CFN_BUILT_IN_BSWAP128:
9503 0 : if (call_expr_nargs (_q20) == 1)
9504 : {
9505 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
9506 0 : switch (TREE_CODE (_p1))
9507 : {
9508 0 : case INTEGER_CST:
9509 0 : {
9510 0 : {
9511 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9512 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP128);
9513 0 : if (res) return res;
9514 : }
9515 0 : break;
9516 : }
9517 : default:;
9518 : }
9519 : }
9520 : break;
9521 8 : case CFN_BUILT_IN_BSWAP16:
9522 8 : if (call_expr_nargs (_q20) == 1)
9523 : {
9524 8 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
9525 8 : switch (TREE_CODE (_p1))
9526 : {
9527 7 : case INTEGER_CST:
9528 7 : {
9529 7 : {
9530 7 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9531 7 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP16);
9532 7 : if (res) return res;
9533 : }
9534 2 : break;
9535 : }
9536 : default:;
9537 : }
9538 : }
9539 : break;
9540 13 : case CFN_BUILT_IN_BSWAP32:
9541 13 : if (call_expr_nargs (_q20) == 1)
9542 : {
9543 13 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
9544 13 : switch (TREE_CODE (_p1))
9545 : {
9546 13 : case INTEGER_CST:
9547 13 : {
9548 13 : {
9549 13 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9550 13 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP32);
9551 13 : if (res) return res;
9552 : }
9553 9 : break;
9554 : }
9555 : default:;
9556 : }
9557 : }
9558 : break;
9559 18 : case CFN_BUILT_IN_BSWAP64:
9560 18 : if (call_expr_nargs (_q20) == 1)
9561 : {
9562 18 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
9563 18 : switch (TREE_CODE (_p1))
9564 : {
9565 18 : case INTEGER_CST:
9566 18 : {
9567 18 : {
9568 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9569 18 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP64);
9570 18 : if (res) return res;
9571 : }
9572 12 : break;
9573 : }
9574 : default:;
9575 : }
9576 : }
9577 : break;
9578 : default:;
9579 : }
9580 : break;
9581 : default:;
9582 : }
9583 : break;
9584 : }
9585 13879 : case BIT_AND_EXPR:
9586 13879 : {
9587 13879 : tree _q20 = TREE_OPERAND (_p0, 0);
9588 13879 : tree _q21 = TREE_OPERAND (_p0, 1);
9589 13879 : switch (TREE_CODE (_q21))
9590 : {
9591 13829 : case INTEGER_CST:
9592 13829 : {
9593 13829 : switch (TREE_CODE (_p1))
9594 : {
9595 13806 : case INTEGER_CST:
9596 13806 : {
9597 13806 : {
9598 13806 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
9599 13806 : tree res = generic_simplify_417 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, RSHIFT_EXPR);
9600 13806 : if (res) return res;
9601 : }
9602 0 : break;
9603 : }
9604 : default:;
9605 : }
9606 : break;
9607 : }
9608 : default:;
9609 : }
9610 : break;
9611 : }
9612 240 : case BIT_XOR_EXPR:
9613 240 : {
9614 240 : tree _q20 = TREE_OPERAND (_p0, 0);
9615 240 : tree _q21 = TREE_OPERAND (_p0, 1);
9616 240 : switch (TREE_CODE (_q21))
9617 : {
9618 97 : case INTEGER_CST:
9619 97 : {
9620 97 : switch (TREE_CODE (_p1))
9621 : {
9622 97 : case INTEGER_CST:
9623 97 : {
9624 97 : {
9625 97 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
9626 97 : tree res = generic_simplify_417 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, RSHIFT_EXPR);
9627 97 : if (res) return res;
9628 : }
9629 0 : break;
9630 : }
9631 : default:;
9632 : }
9633 : break;
9634 : }
9635 : default:;
9636 : }
9637 : break;
9638 : }
9639 55 : case BIT_IOR_EXPR:
9640 55 : {
9641 55 : tree _q20 = TREE_OPERAND (_p0, 0);
9642 55 : tree _q21 = TREE_OPERAND (_p0, 1);
9643 55 : switch (TREE_CODE (_q21))
9644 : {
9645 10 : case INTEGER_CST:
9646 10 : {
9647 10 : switch (TREE_CODE (_p1))
9648 : {
9649 8 : case INTEGER_CST:
9650 8 : {
9651 8 : {
9652 8 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
9653 8 : tree res = generic_simplify_417 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, RSHIFT_EXPR);
9654 8 : if (res) return res;
9655 : }
9656 0 : break;
9657 : }
9658 : default:;
9659 : }
9660 : break;
9661 : }
9662 : default:;
9663 : }
9664 : break;
9665 : }
9666 0 : case VEC_COND_EXPR:
9667 0 : {
9668 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9669 0 : tree _q21 = TREE_OPERAND (_p0, 1);
9670 0 : tree _q22 = TREE_OPERAND (_p0, 2);
9671 0 : switch (TREE_CODE (_p1))
9672 : {
9673 0 : case VEC_COND_EXPR:
9674 0 : {
9675 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9676 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9677 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9678 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9679 : {
9680 0 : {
9681 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
9682 0 : if (VECTOR_TYPE_P (type)
9683 0 : && (TREE_CODE_CLASS (RSHIFT_EXPR) != tcc_comparison
9684 : || types_match (type, TREE_TYPE (captures[2]))
9685 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9686 : || (optimize_vectors_before_lowering_p ()
9687 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9688 : )
9689 : {
9690 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1650;
9691 0 : {
9692 0 : tree res_op0;
9693 0 : res_op0 = captures[1];
9694 0 : tree res_op1;
9695 0 : {
9696 0 : tree _o1[2], _r1;
9697 0 : _o1[0] = captures[2];
9698 0 : _o1[1] = captures[5];
9699 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
9700 0 : if (EXPR_P (_r1))
9701 0 : goto next_after_fail1650;
9702 0 : res_op1 = _r1;
9703 : }
9704 0 : tree res_op2;
9705 0 : {
9706 0 : tree _o1[2], _r1;
9707 0 : _o1[0] = captures[3];
9708 0 : _o1[1] = captures[6];
9709 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
9710 0 : if (EXPR_P (_r1))
9711 0 : goto next_after_fail1650;
9712 0 : res_op2 = _r1;
9713 : }
9714 0 : tree _r;
9715 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9716 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
9717 0 : return _r;
9718 : }
9719 0 : next_after_fail1650:;
9720 : }
9721 : }
9722 : }
9723 : break;
9724 : }
9725 0 : default:;
9726 : }
9727 0 : {
9728 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
9729 0 : if (VECTOR_TYPE_P (type)
9730 0 : && (TREE_CODE_CLASS (RSHIFT_EXPR) != tcc_comparison
9731 : || types_match (type, TREE_TYPE (captures[2]))
9732 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9733 : || (optimize_vectors_before_lowering_p ()
9734 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9735 : )
9736 : {
9737 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1651;
9738 0 : {
9739 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1651;
9740 0 : tree res_op0;
9741 0 : res_op0 = captures[1];
9742 0 : tree res_op1;
9743 0 : {
9744 0 : tree _o1[2], _r1;
9745 0 : _o1[0] = captures[2];
9746 0 : _o1[1] = unshare_expr (captures[4]);
9747 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
9748 0 : if (EXPR_P (_r1))
9749 0 : goto next_after_fail1651;
9750 0 : res_op1 = _r1;
9751 : }
9752 0 : tree res_op2;
9753 0 : {
9754 0 : tree _o1[2], _r1;
9755 0 : _o1[0] = captures[3];
9756 0 : _o1[1] = captures[4];
9757 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
9758 0 : if (EXPR_P (_r1))
9759 0 : goto next_after_fail1651;
9760 0 : res_op2 = _r1;
9761 : }
9762 0 : tree _r;
9763 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9764 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
9765 0 : return _r;
9766 : }
9767 0 : next_after_fail1651:;
9768 : }
9769 : }
9770 0 : break;
9771 : }
9772 436 : case CALL_EXPR:
9773 436 : switch (get_call_combined_fn (_p0))
9774 : {
9775 0 : case CFN_BUILT_IN_BSWAP128:
9776 0 : if (call_expr_nargs (_p0) == 1)
9777 : {
9778 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9779 0 : switch (TREE_CODE (_p1))
9780 : {
9781 0 : case INTEGER_CST:
9782 0 : {
9783 0 : {
9784 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9785 0 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP128);
9786 0 : if (res) return res;
9787 : }
9788 0 : break;
9789 : }
9790 : default:;
9791 : }
9792 : }
9793 : break;
9794 32 : case CFN_BUILT_IN_BSWAP16:
9795 32 : if (call_expr_nargs (_p0) == 1)
9796 : {
9797 32 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9798 32 : switch (TREE_CODE (_p1))
9799 : {
9800 32 : case INTEGER_CST:
9801 32 : {
9802 32 : {
9803 32 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9804 32 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP16);
9805 32 : if (res) return res;
9806 : }
9807 9 : break;
9808 : }
9809 : default:;
9810 : }
9811 : }
9812 : break;
9813 99 : case CFN_BUILT_IN_BSWAP32:
9814 99 : if (call_expr_nargs (_p0) == 1)
9815 : {
9816 99 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9817 99 : switch (TREE_CODE (_p1))
9818 : {
9819 98 : case INTEGER_CST:
9820 98 : {
9821 98 : {
9822 98 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9823 98 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP32);
9824 98 : if (res) return res;
9825 : }
9826 59 : break;
9827 : }
9828 : default:;
9829 : }
9830 : }
9831 : break;
9832 100 : case CFN_BUILT_IN_BSWAP64:
9833 100 : if (call_expr_nargs (_p0) == 1)
9834 : {
9835 100 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9836 100 : switch (TREE_CODE (_p1))
9837 : {
9838 99 : case INTEGER_CST:
9839 99 : {
9840 99 : {
9841 99 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9842 99 : tree res = generic_simplify_419 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_BSWAP64);
9843 99 : if (res) return res;
9844 : }
9845 73 : break;
9846 : }
9847 : default:;
9848 : }
9849 : }
9850 : break;
9851 : default:;
9852 : }
9853 : break;
9854 1243097 : default:;
9855 : }
9856 1243097 : if (integer_onep (_p0))
9857 : {
9858 524 : {
9859 524 : tree captures[1] ATTRIBUTE_UNUSED = { _p1 };
9860 524 : if (INTEGRAL_TYPE_P (type)
9861 : )
9862 : {
9863 524 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1652;
9864 524 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1652;
9865 524 : {
9866 524 : tree res_op0;
9867 524 : {
9868 524 : tree _o1[2], _r1;
9869 524 : _o1[0] = captures[0];
9870 524 : _o1[1] = build_zero_cst (TREE_TYPE (captures[0]));
9871 524 : _r1 = fold_build2_loc (loc, EQ_EXPR, boolean_type_node, _o1[0], _o1[1]);
9872 524 : res_op0 = _r1;
9873 : }
9874 524 : tree _r;
9875 524 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
9876 524 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 995, __FILE__, __LINE__, true);
9877 524 : return _r;
9878 : }
9879 : next_after_fail1652:;
9880 : }
9881 : }
9882 : }
9883 1242573 : switch (TREE_CODE (_p1))
9884 : {
9885 11 : case VEC_COND_EXPR:
9886 11 : {
9887 11 : tree _q30 = TREE_OPERAND (_p1, 0);
9888 11 : tree _q31 = TREE_OPERAND (_p1, 1);
9889 11 : tree _q32 = TREE_OPERAND (_p1, 2);
9890 11 : {
9891 11 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
9892 11 : if (VECTOR_TYPE_P (type)
9893 11 : && (TREE_CODE_CLASS (RSHIFT_EXPR) != tcc_comparison
9894 : || types_match (type, TREE_TYPE (captures[3]))
9895 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
9896 : || (optimize_vectors_before_lowering_p ()
9897 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
9898 : )
9899 : {
9900 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1653;
9901 11 : {
9902 11 : if (! tree_invariant_p (captures[0])) goto next_after_fail1653;
9903 0 : tree res_op0;
9904 0 : res_op0 = captures[2];
9905 0 : tree res_op1;
9906 0 : {
9907 0 : tree _o1[2], _r1;
9908 0 : _o1[0] = unshare_expr (captures[0]);
9909 0 : _o1[1] = captures[3];
9910 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
9911 0 : if (EXPR_P (_r1))
9912 0 : goto next_after_fail1653;
9913 0 : res_op1 = _r1;
9914 : }
9915 0 : tree res_op2;
9916 0 : {
9917 0 : tree _o1[2], _r1;
9918 0 : _o1[0] = captures[0];
9919 0 : _o1[1] = captures[4];
9920 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, type, _o1[0], _o1[1]);
9921 0 : if (EXPR_P (_r1))
9922 0 : goto next_after_fail1653;
9923 0 : res_op2 = _r1;
9924 : }
9925 0 : tree _r;
9926 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9927 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
9928 0 : return _r;
9929 : }
9930 11 : next_after_fail1653:;
9931 : }
9932 : }
9933 11 : break;
9934 : }
9935 1242573 : default:;
9936 : }
9937 1242573 : switch (TREE_CODE (_p0))
9938 : {
9939 0 : case VEC_PERM_EXPR:
9940 0 : {
9941 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9942 0 : tree _q21 = TREE_OPERAND (_p0, 1);
9943 0 : tree _q22 = TREE_OPERAND (_p0, 2);
9944 0 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
9945 : {
9946 0 : switch (TREE_CODE (_p1))
9947 : {
9948 0 : case VEC_PERM_EXPR:
9949 0 : {
9950 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9951 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9952 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9953 0 : if ((_q61 == _q60 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q60, 0) && types_match (_q61, _q60)))
9954 : {
9955 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
9956 : {
9957 0 : {
9958 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q22, _q60 };
9959 0 : if (VECTOR_INTEGER_TYPE_P (type)
9960 : )
9961 : {
9962 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1654;
9963 0 : {
9964 0 : tree res_op0;
9965 0 : {
9966 0 : tree _o1[2], _r1;
9967 0 : _o1[0] = captures[0];
9968 0 : _o1[1] = captures[2];
9969 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9970 0 : captures[3] = _r1;
9971 : }
9972 0 : res_op0 = unshare_expr (captures[3]);
9973 0 : tree res_op1;
9974 0 : res_op1 = captures[3];
9975 0 : tree res_op2;
9976 0 : res_op2 = captures[1];
9977 0 : tree _r;
9978 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
9979 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 879, __FILE__, __LINE__, true);
9980 0 : return _r;
9981 : }
9982 0 : next_after_fail1654:;
9983 : }
9984 : }
9985 : }
9986 : }
9987 : break;
9988 : }
9989 : default:;
9990 : }
9991 : }
9992 : break;
9993 : }
9994 : default:;
9995 : }
9996 : return NULL_TREE;
9997 : }
9998 :
9999 : tree
10000 378820 : generic_simplify_MAX_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
10001 : {
10002 378820 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10003 378820 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
10004 : {
10005 0 : {
10006 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10007 0 : tree res = generic_simplify_510 (loc, type, _p0, _p1, captures, MAX_EXPR);
10008 0 : if (res) return res;
10009 : }
10010 : }
10011 378820 : switch (TREE_CODE (_p0))
10012 : {
10013 111 : case MAX_EXPR:
10014 111 : {
10015 111 : tree _q20 = TREE_OPERAND (_p0, 0);
10016 111 : tree _q21 = TREE_OPERAND (_p0, 1);
10017 111 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
10018 : {
10019 0 : {
10020 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
10021 0 : tree res = generic_simplify_511 (loc, type, _p0, _p1, captures, MAX_EXPR);
10022 0 : if (res) return res;
10023 : }
10024 : }
10025 111 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
10026 : {
10027 0 : {
10028 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
10029 0 : tree res = generic_simplify_511 (loc, type, _p0, _p1, captures, MAX_EXPR);
10030 0 : if (res) return res;
10031 : }
10032 : }
10033 : break;
10034 : }
10035 378820 : default:;
10036 : }
10037 378820 : switch (TREE_CODE (_p1))
10038 : {
10039 0 : case MAX_EXPR:
10040 0 : {
10041 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10042 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10043 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10044 : {
10045 0 : {
10046 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q31 };
10047 0 : tree res = generic_simplify_512 (loc, type, _p0, _p1, captures, MAX_EXPR);
10048 0 : if (res) return res;
10049 : }
10050 : }
10051 0 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
10052 : {
10053 0 : {
10054 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q30 };
10055 0 : tree res = generic_simplify_512 (loc, type, _p0, _p1, captures, MAX_EXPR);
10056 0 : if (res) return res;
10057 : }
10058 : }
10059 : break;
10060 : }
10061 378820 : default:;
10062 : }
10063 378820 : switch (TREE_CODE (_p0))
10064 : {
10065 3235 : case MIN_EXPR:
10066 3235 : {
10067 3235 : tree _q20 = TREE_OPERAND (_p0, 0);
10068 3235 : tree _q21 = TREE_OPERAND (_p0, 1);
10069 3235 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
10070 : {
10071 1 : {
10072 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10073 1 : tree res = generic_simplify_521 (loc, type, _p0, _p1, captures);
10074 1 : if (res) return res;
10075 : }
10076 : }
10077 3234 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
10078 : {
10079 1 : {
10080 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10081 1 : tree res = generic_simplify_521 (loc, type, _p0, _p1, captures);
10082 1 : if (res) return res;
10083 : }
10084 : }
10085 : break;
10086 : }
10087 378818 : default:;
10088 : }
10089 378818 : switch (TREE_CODE (_p1))
10090 : {
10091 0 : case MIN_EXPR:
10092 0 : {
10093 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10094 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10095 0 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
10096 : {
10097 0 : {
10098 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
10099 0 : tree res = generic_simplify_521 (loc, type, _p0, _p1, captures);
10100 0 : if (res) return res;
10101 : }
10102 : }
10103 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10104 : {
10105 0 : {
10106 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _p0 };
10107 0 : tree res = generic_simplify_521 (loc, type, _p0, _p1, captures);
10108 0 : if (res) return res;
10109 : }
10110 : }
10111 : break;
10112 : }
10113 0 : case NEGATE_EXPR:
10114 0 : {
10115 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10116 0 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10117 : {
10118 0 : {
10119 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10120 0 : tree res = generic_simplify_522 (loc, type, _p0, _p1, captures);
10121 0 : if (res) return res;
10122 : }
10123 : }
10124 : break;
10125 : }
10126 378818 : default:;
10127 : }
10128 378818 : switch (TREE_CODE (_p0))
10129 : {
10130 76 : case NEGATE_EXPR:
10131 76 : {
10132 76 : tree _q20 = TREE_OPERAND (_p0, 0);
10133 76 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
10134 : {
10135 2 : {
10136 2 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10137 2 : tree res = generic_simplify_522 (loc, type, _p0, _p1, captures);
10138 2 : if (res) return res;
10139 : }
10140 : }
10141 : break;
10142 : }
10143 378816 : default:;
10144 : }
10145 378816 : {
10146 378816 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
10147 378816 : if (INTEGRAL_TYPE_P (type)
10148 376896 : && TYPE_MAX_VALUE (type)
10149 755712 : && operand_equal_p (captures[1], TYPE_MAX_VALUE (type), OEP_ONLY_CONST)
10150 : )
10151 : {
10152 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1721;
10153 0 : {
10154 0 : tree _r;
10155 0 : _r = captures[1];
10156 0 : if (TREE_SIDE_EFFECTS (captures[0]))
10157 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
10158 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1010, __FILE__, __LINE__, true);
10159 0 : return _r;
10160 : }
10161 0 : next_after_fail1721:;
10162 : }
10163 : else
10164 : {
10165 378816 : if (INTEGRAL_TYPE_P (type)
10166 376896 : && TYPE_MIN_VALUE (type)
10167 755712 : && operand_equal_p (captures[1], TYPE_MIN_VALUE (type), OEP_ONLY_CONST)
10168 : )
10169 : {
10170 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1722;
10171 11 : {
10172 11 : tree _r;
10173 11 : _r = captures[0];
10174 11 : if (TREE_SIDE_EFFECTS (captures[1]))
10175 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
10176 11 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1011, __FILE__, __LINE__, true);
10177 11 : return _r;
10178 : }
10179 0 : next_after_fail1722:;
10180 : }
10181 : }
10182 : }
10183 378805 : switch (TREE_CODE (_p1))
10184 : {
10185 110 : case PLUS_EXPR:
10186 110 : {
10187 110 : tree _q30 = TREE_OPERAND (_p1, 0);
10188 110 : tree _q31 = TREE_OPERAND (_p1, 1);
10189 110 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10190 : {
10191 0 : switch (TREE_CODE (_q31))
10192 : {
10193 0 : case INTEGER_CST:
10194 0 : {
10195 0 : {
10196 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
10197 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
10198 : )
10199 : {
10200 0 : if (tree_int_cst_sgn (captures[2]) > 0
10201 : )
10202 : {
10203 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1723;
10204 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1723;
10205 0 : {
10206 0 : tree _r;
10207 0 : _r = captures[1];
10208 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1012, __FILE__, __LINE__, true);
10209 0 : return _r;
10210 : }
10211 0 : next_after_fail1723:;
10212 : }
10213 : else
10214 : {
10215 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1724;
10216 0 : {
10217 0 : tree _r;
10218 0 : _r = captures[0];
10219 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10220 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10221 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1013, __FILE__, __LINE__, true);
10222 0 : return _r;
10223 : }
10224 0 : next_after_fail1724:;
10225 : }
10226 : }
10227 : }
10228 0 : break;
10229 : }
10230 : default:;
10231 : }
10232 : }
10233 : break;
10234 : }
10235 378805 : default:;
10236 : }
10237 378805 : switch (TREE_CODE (_p0))
10238 : {
10239 22836 : case PLUS_EXPR:
10240 22836 : {
10241 22836 : tree _q20 = TREE_OPERAND (_p0, 0);
10242 22836 : tree _q21 = TREE_OPERAND (_p0, 1);
10243 22836 : switch (TREE_CODE (_q21))
10244 : {
10245 22798 : case INTEGER_CST:
10246 22798 : {
10247 22798 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
10248 : {
10249 11 : {
10250 11 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
10251 11 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
10252 : )
10253 : {
10254 0 : if (tree_int_cst_sgn (captures[2]) > 0
10255 : )
10256 : {
10257 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1725;
10258 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1725;
10259 0 : {
10260 0 : tree _r;
10261 0 : _r = captures[1];
10262 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1012, __FILE__, __LINE__, true);
10263 0 : return _r;
10264 : }
10265 11 : next_after_fail1725:;
10266 : }
10267 : else
10268 : {
10269 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1726;
10270 0 : {
10271 0 : tree _r;
10272 0 : _r = captures[0];
10273 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10274 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10275 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1013, __FILE__, __LINE__, true);
10276 0 : return _r;
10277 : }
10278 0 : next_after_fail1726:;
10279 : }
10280 : }
10281 : }
10282 : }
10283 : break;
10284 : }
10285 : default:;
10286 : }
10287 : break;
10288 : }
10289 3233 : case MIN_EXPR:
10290 3233 : {
10291 3233 : tree _q20 = TREE_OPERAND (_p0, 0);
10292 3233 : tree _q21 = TREE_OPERAND (_p0, 1);
10293 3233 : switch (TREE_CODE (_p1))
10294 : {
10295 0 : case MAX_EXPR:
10296 0 : {
10297 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10298 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10299 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10300 : {
10301 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10302 : {
10303 0 : {
10304 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10305 0 : if (!HONOR_NANS (captures[0])
10306 : )
10307 : {
10308 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1727;
10309 0 : {
10310 0 : tree res_op0;
10311 0 : res_op0 = captures[0];
10312 0 : tree res_op1;
10313 0 : res_op1 = captures[1];
10314 0 : tree _r;
10315 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
10316 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
10317 0 : return _r;
10318 : }
10319 0 : next_after_fail1727:;
10320 : }
10321 : }
10322 : }
10323 : }
10324 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10325 : {
10326 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10327 : {
10328 0 : {
10329 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10330 0 : if (!HONOR_NANS (captures[0])
10331 : )
10332 : {
10333 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1728;
10334 0 : {
10335 0 : tree res_op0;
10336 0 : res_op0 = captures[0];
10337 0 : tree res_op1;
10338 0 : res_op1 = captures[1];
10339 0 : tree _r;
10340 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
10341 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
10342 0 : return _r;
10343 : }
10344 0 : next_after_fail1728:;
10345 : }
10346 : }
10347 : }
10348 : }
10349 : break;
10350 : }
10351 : default:;
10352 : }
10353 : break;
10354 : }
10355 111 : case MAX_EXPR:
10356 111 : {
10357 111 : tree _q20 = TREE_OPERAND (_p0, 0);
10358 111 : tree _q21 = TREE_OPERAND (_p0, 1);
10359 111 : switch (TREE_CODE (_p1))
10360 : {
10361 0 : case MIN_EXPR:
10362 0 : {
10363 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10364 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10365 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10366 : {
10367 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10368 : {
10369 0 : {
10370 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10371 0 : if (!HONOR_NANS (captures[0])
10372 : )
10373 : {
10374 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1729;
10375 0 : {
10376 0 : tree res_op0;
10377 0 : res_op0 = captures[0];
10378 0 : tree res_op1;
10379 0 : res_op1 = captures[1];
10380 0 : tree _r;
10381 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
10382 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
10383 0 : return _r;
10384 : }
10385 0 : next_after_fail1729:;
10386 : }
10387 : }
10388 : }
10389 : }
10390 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10391 : {
10392 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10393 : {
10394 0 : {
10395 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10396 0 : if (!HONOR_NANS (captures[0])
10397 : )
10398 : {
10399 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1730;
10400 0 : {
10401 0 : tree res_op0;
10402 0 : res_op0 = captures[0];
10403 0 : tree res_op1;
10404 0 : res_op1 = captures[1];
10405 0 : tree _r;
10406 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
10407 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
10408 0 : return _r;
10409 : }
10410 0 : next_after_fail1730:;
10411 : }
10412 : }
10413 : }
10414 : }
10415 : break;
10416 : }
10417 : default:;
10418 : }
10419 : break;
10420 : }
10421 32199 : CASE_CONVERT:
10422 32199 : {
10423 32199 : tree _q20 = TREE_OPERAND (_p0, 0);
10424 32199 : switch (TREE_CODE (_q20))
10425 : {
10426 0 : case ADDR_EXPR:
10427 0 : {
10428 0 : switch (TREE_CODE (_p1))
10429 : {
10430 0 : CASE_CONVERT:
10431 0 : {
10432 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10433 0 : switch (TREE_CODE (_q40))
10434 : {
10435 0 : case ADDR_EXPR:
10436 0 : {
10437 0 : {
10438 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10439 0 : tree res = generic_simplify_515 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR);
10440 0 : if (res) return res;
10441 : }
10442 0 : break;
10443 : }
10444 : default:;
10445 : }
10446 : break;
10447 : }
10448 0 : case ADDR_EXPR:
10449 0 : {
10450 0 : {
10451 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
10452 0 : tree res = generic_simplify_516 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR);
10453 0 : if (res) return res;
10454 : }
10455 0 : break;
10456 : }
10457 : default:;
10458 : }
10459 : break;
10460 : }
10461 : default:;
10462 : }
10463 : break;
10464 : }
10465 10 : case ADDR_EXPR:
10466 10 : {
10467 10 : switch (TREE_CODE (_p1))
10468 : {
10469 0 : CASE_CONVERT:
10470 0 : {
10471 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10472 0 : switch (TREE_CODE (_q30))
10473 : {
10474 0 : case ADDR_EXPR:
10475 0 : {
10476 0 : {
10477 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _p1, _q30 };
10478 0 : tree res = generic_simplify_517 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR);
10479 0 : if (res) return res;
10480 : }
10481 0 : break;
10482 : }
10483 : default:;
10484 : }
10485 : break;
10486 : }
10487 10 : case ADDR_EXPR:
10488 10 : {
10489 10 : {
10490 10 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _p1, _p1 };
10491 10 : tree res = generic_simplify_518 (loc, type, _p0, _p1, captures, MAX_EXPR, GT_EXPR);
10492 10 : if (res) return res;
10493 : }
10494 10 : break;
10495 : }
10496 : default:;
10497 : }
10498 : break;
10499 : }
10500 74 : case NEGATE_EXPR:
10501 74 : {
10502 74 : tree _q20 = TREE_OPERAND (_p0, 0);
10503 74 : switch (TREE_CODE (_p1))
10504 : {
10505 0 : case NEGATE_EXPR:
10506 0 : {
10507 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10508 0 : {
10509 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10510 0 : if (FLOAT_TYPE_P (TREE_TYPE (captures[1]))
10511 0 : || (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
10512 0 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1])))
10513 : )
10514 : {
10515 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1731;
10516 0 : {
10517 0 : tree res_op0;
10518 0 : {
10519 0 : tree _o1[2], _r1;
10520 0 : _o1[0] = captures[1];
10521 0 : _o1[1] = captures[3];
10522 0 : _r1 = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10523 0 : res_op0 = _r1;
10524 : }
10525 0 : tree _r;
10526 0 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
10527 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1009, __FILE__, __LINE__, true);
10528 0 : return _r;
10529 : }
10530 0 : next_after_fail1731:;
10531 : }
10532 : }
10533 0 : break;
10534 : }
10535 : default:;
10536 : }
10537 : break;
10538 : }
10539 0 : case BIT_NOT_EXPR:
10540 0 : {
10541 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10542 0 : switch (TREE_CODE (_p1))
10543 : {
10544 0 : case BIT_NOT_EXPR:
10545 0 : {
10546 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10547 0 : {
10548 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10549 0 : tree res = generic_simplify_519 (loc, type, _p0, _p1, captures, MAX_EXPR, MIN_EXPR);
10550 0 : if (res) return res;
10551 : }
10552 0 : break;
10553 : }
10554 : default:;
10555 : }
10556 : break;
10557 : }
10558 0 : case VEC_COND_EXPR:
10559 0 : {
10560 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10561 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10562 0 : tree _q22 = TREE_OPERAND (_p0, 2);
10563 0 : switch (TREE_CODE (_p1))
10564 : {
10565 0 : case VEC_COND_EXPR:
10566 0 : {
10567 0 : tree _q60 = TREE_OPERAND (_p1, 0);
10568 0 : tree _q61 = TREE_OPERAND (_p1, 1);
10569 0 : tree _q62 = TREE_OPERAND (_p1, 2);
10570 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
10571 : {
10572 0 : {
10573 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
10574 0 : if (VECTOR_TYPE_P (type)
10575 0 : && (TREE_CODE_CLASS (MAX_EXPR) != tcc_comparison
10576 : || types_match (type, TREE_TYPE (captures[2]))
10577 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10578 : || (optimize_vectors_before_lowering_p ()
10579 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10580 : )
10581 : {
10582 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1732;
10583 0 : {
10584 0 : tree res_op0;
10585 0 : res_op0 = captures[1];
10586 0 : tree res_op1;
10587 0 : {
10588 0 : tree _o1[2], _r1;
10589 0 : _o1[0] = captures[2];
10590 0 : _o1[1] = captures[5];
10591 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
10592 0 : if (EXPR_P (_r1))
10593 0 : goto next_after_fail1732;
10594 0 : res_op1 = _r1;
10595 : }
10596 0 : tree res_op2;
10597 0 : {
10598 0 : tree _o1[2], _r1;
10599 0 : _o1[0] = captures[3];
10600 0 : _o1[1] = captures[6];
10601 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
10602 0 : if (EXPR_P (_r1))
10603 0 : goto next_after_fail1732;
10604 0 : res_op2 = _r1;
10605 : }
10606 0 : tree _r;
10607 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10608 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
10609 0 : return _r;
10610 : }
10611 0 : next_after_fail1732:;
10612 : }
10613 : }
10614 : }
10615 : break;
10616 : }
10617 0 : default:;
10618 : }
10619 0 : {
10620 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
10621 0 : if (VECTOR_TYPE_P (type)
10622 0 : && (TREE_CODE_CLASS (MAX_EXPR) != tcc_comparison
10623 : || types_match (type, TREE_TYPE (captures[2]))
10624 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10625 : || (optimize_vectors_before_lowering_p ()
10626 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10627 : )
10628 : {
10629 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1733;
10630 0 : {
10631 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1733;
10632 0 : tree res_op0;
10633 0 : res_op0 = captures[1];
10634 0 : tree res_op1;
10635 0 : {
10636 0 : tree _o1[2], _r1;
10637 0 : _o1[0] = captures[2];
10638 0 : _o1[1] = unshare_expr (captures[4]);
10639 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
10640 0 : if (EXPR_P (_r1))
10641 0 : goto next_after_fail1733;
10642 0 : res_op1 = _r1;
10643 : }
10644 0 : tree res_op2;
10645 0 : {
10646 0 : tree _o1[2], _r1;
10647 0 : _o1[0] = captures[3];
10648 0 : _o1[1] = captures[4];
10649 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
10650 0 : if (EXPR_P (_r1))
10651 0 : goto next_after_fail1733;
10652 0 : res_op2 = _r1;
10653 : }
10654 0 : tree _r;
10655 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10656 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
10657 0 : return _r;
10658 : }
10659 0 : next_after_fail1733:;
10660 : }
10661 : }
10662 0 : break;
10663 : }
10664 378805 : default:;
10665 : }
10666 378805 : switch (TREE_CODE (_p1))
10667 : {
10668 0 : case VEC_COND_EXPR:
10669 0 : {
10670 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10671 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10672 0 : tree _q32 = TREE_OPERAND (_p1, 2);
10673 0 : {
10674 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
10675 0 : if (VECTOR_TYPE_P (type)
10676 0 : && (TREE_CODE_CLASS (MAX_EXPR) != tcc_comparison
10677 : || types_match (type, TREE_TYPE (captures[3]))
10678 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
10679 : || (optimize_vectors_before_lowering_p ()
10680 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
10681 : )
10682 : {
10683 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1734;
10684 0 : {
10685 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1734;
10686 0 : tree res_op0;
10687 0 : res_op0 = captures[2];
10688 0 : tree res_op1;
10689 0 : {
10690 0 : tree _o1[2], _r1;
10691 0 : _o1[0] = unshare_expr (captures[0]);
10692 0 : _o1[1] = captures[3];
10693 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
10694 0 : if (EXPR_P (_r1))
10695 0 : goto next_after_fail1734;
10696 0 : res_op1 = _r1;
10697 : }
10698 0 : tree res_op2;
10699 0 : {
10700 0 : tree _o1[2], _r1;
10701 0 : _o1[0] = captures[0];
10702 0 : _o1[1] = captures[4];
10703 0 : _r1 = fold_build2_loc (loc, MAX_EXPR, type, _o1[0], _o1[1]);
10704 0 : if (EXPR_P (_r1))
10705 0 : goto next_after_fail1734;
10706 0 : res_op2 = _r1;
10707 : }
10708 0 : tree _r;
10709 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10710 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
10711 0 : return _r;
10712 : }
10713 0 : next_after_fail1734:;
10714 : }
10715 : }
10716 0 : break;
10717 : }
10718 378805 : default:;
10719 : }
10720 378805 : if (tree_zero_one_valued_p (_p0))
10721 : {
10722 9 : if (tree_zero_one_valued_p (_p1))
10723 : {
10724 0 : {
10725 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
10726 0 : tree res = generic_simplify_520 (loc, type, _p0, _p1, captures, MAX_EXPR, BIT_IOR_EXPR);
10727 0 : if (res) return res;
10728 : }
10729 : }
10730 : }
10731 : return NULL_TREE;
10732 : }
10733 :
10734 : tree
10735 2845078 : generic_simplify_UNGT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
10736 : {
10737 2845078 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10738 2845078 : switch (TREE_CODE (_p0))
10739 : {
10740 0 : case VEC_COND_EXPR:
10741 0 : {
10742 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10743 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10744 0 : tree _q22 = TREE_OPERAND (_p0, 2);
10745 0 : switch (TREE_CODE (_p1))
10746 : {
10747 0 : case VEC_COND_EXPR:
10748 0 : {
10749 0 : tree _q60 = TREE_OPERAND (_p1, 0);
10750 0 : tree _q61 = TREE_OPERAND (_p1, 1);
10751 0 : tree _q62 = TREE_OPERAND (_p1, 2);
10752 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
10753 : {
10754 0 : {
10755 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
10756 0 : if (VECTOR_TYPE_P (type)
10757 0 : && (TREE_CODE_CLASS (UNGT_EXPR) != tcc_comparison
10758 0 : || types_match (type, TREE_TYPE (captures[2]))
10759 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10760 : || (optimize_vectors_before_lowering_p ()
10761 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10762 : )
10763 : {
10764 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1753;
10765 0 : {
10766 0 : tree res_op0;
10767 0 : res_op0 = captures[1];
10768 0 : tree res_op1;
10769 0 : {
10770 0 : tree _o1[2], _r1;
10771 0 : _o1[0] = captures[2];
10772 0 : _o1[1] = captures[5];
10773 0 : _r1 = fold_build2_loc (loc, UNGT_EXPR, type, _o1[0], _o1[1]);
10774 0 : if (EXPR_P (_r1))
10775 0 : goto next_after_fail1753;
10776 0 : res_op1 = _r1;
10777 : }
10778 0 : tree res_op2;
10779 0 : {
10780 0 : tree _o1[2], _r1;
10781 0 : _o1[0] = captures[3];
10782 0 : _o1[1] = captures[6];
10783 0 : _r1 = fold_build2_loc (loc, UNGT_EXPR, type, _o1[0], _o1[1]);
10784 0 : if (EXPR_P (_r1))
10785 0 : goto next_after_fail1753;
10786 0 : res_op2 = _r1;
10787 : }
10788 0 : tree _r;
10789 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10790 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
10791 0 : return _r;
10792 : }
10793 0 : next_after_fail1753:;
10794 : }
10795 : }
10796 : }
10797 : break;
10798 : }
10799 0 : default:;
10800 : }
10801 0 : {
10802 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
10803 0 : if (VECTOR_TYPE_P (type)
10804 0 : && (TREE_CODE_CLASS (UNGT_EXPR) != tcc_comparison
10805 0 : || types_match (type, TREE_TYPE (captures[2]))
10806 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10807 : || (optimize_vectors_before_lowering_p ()
10808 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10809 : )
10810 : {
10811 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1754;
10812 0 : {
10813 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1754;
10814 0 : tree res_op0;
10815 0 : res_op0 = captures[1];
10816 0 : tree res_op1;
10817 0 : {
10818 0 : tree _o1[2], _r1;
10819 0 : _o1[0] = captures[2];
10820 0 : _o1[1] = unshare_expr (captures[4]);
10821 0 : _r1 = fold_build2_loc (loc, UNGT_EXPR, type, _o1[0], _o1[1]);
10822 0 : if (EXPR_P (_r1))
10823 0 : goto next_after_fail1754;
10824 0 : res_op1 = _r1;
10825 : }
10826 0 : tree res_op2;
10827 0 : {
10828 0 : tree _o1[2], _r1;
10829 0 : _o1[0] = captures[3];
10830 0 : _o1[1] = captures[4];
10831 0 : _r1 = fold_build2_loc (loc, UNGT_EXPR, type, _o1[0], _o1[1]);
10832 0 : if (EXPR_P (_r1))
10833 0 : goto next_after_fail1754;
10834 0 : res_op2 = _r1;
10835 : }
10836 0 : tree _r;
10837 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10838 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
10839 0 : return _r;
10840 : }
10841 0 : next_after_fail1754:;
10842 : }
10843 : }
10844 0 : break;
10845 : }
10846 2845078 : default:;
10847 : }
10848 2845078 : switch (TREE_CODE (_p1))
10849 : {
10850 0 : case VEC_COND_EXPR:
10851 0 : {
10852 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10853 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10854 0 : tree _q32 = TREE_OPERAND (_p1, 2);
10855 0 : {
10856 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
10857 0 : if (VECTOR_TYPE_P (type)
10858 0 : && (TREE_CODE_CLASS (UNGT_EXPR) != tcc_comparison
10859 0 : || types_match (type, TREE_TYPE (captures[3]))
10860 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
10861 : || (optimize_vectors_before_lowering_p ()
10862 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
10863 : )
10864 : {
10865 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1755;
10866 0 : {
10867 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1755;
10868 0 : tree res_op0;
10869 0 : res_op0 = captures[2];
10870 0 : tree res_op1;
10871 0 : {
10872 0 : tree _o1[2], _r1;
10873 0 : _o1[0] = unshare_expr (captures[0]);
10874 0 : _o1[1] = captures[3];
10875 0 : _r1 = fold_build2_loc (loc, UNGT_EXPR, type, _o1[0], _o1[1]);
10876 0 : if (EXPR_P (_r1))
10877 0 : goto next_after_fail1755;
10878 0 : res_op1 = _r1;
10879 : }
10880 0 : tree res_op2;
10881 0 : {
10882 0 : tree _o1[2], _r1;
10883 0 : _o1[0] = captures[0];
10884 0 : _o1[1] = captures[4];
10885 0 : _r1 = fold_build2_loc (loc, UNGT_EXPR, type, _o1[0], _o1[1]);
10886 0 : if (EXPR_P (_r1))
10887 0 : goto next_after_fail1755;
10888 0 : res_op2 = _r1;
10889 : }
10890 0 : tree _r;
10891 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10892 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
10893 0 : return _r;
10894 : }
10895 0 : next_after_fail1755:;
10896 : }
10897 : }
10898 0 : break;
10899 : }
10900 2845078 : default:;
10901 : }
10902 2845078 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
10903 : {
10904 0 : {
10905 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10906 0 : tree res = generic_simplify_550 (loc, type, _p0, _p1, captures, UNGT_EXPR);
10907 0 : if (res) return res;
10908 : }
10909 : }
10910 2845078 : switch (TREE_CODE (_p0))
10911 : {
10912 339 : case FLOAT_EXPR:
10913 339 : {
10914 339 : tree _q20 = TREE_OPERAND (_p0, 0);
10915 339 : switch (TREE_CODE (_p1))
10916 : {
10917 0 : case FLOAT_EXPR:
10918 0 : {
10919 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10920 0 : {
10921 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
10922 0 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, UNGT_EXPR, GT_EXPR);
10923 0 : if (res) return res;
10924 : }
10925 0 : break;
10926 : }
10927 : default:;
10928 : }
10929 : break;
10930 : }
10931 0 : case NEGATE_EXPR:
10932 0 : {
10933 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10934 0 : switch (TREE_CODE (_p1))
10935 : {
10936 0 : case NEGATE_EXPR:
10937 0 : {
10938 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10939 0 : {
10940 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
10941 0 : tree res = generic_simplify_262 (loc, type, _p0, _p1, captures, UNGT_EXPR, UNLT_EXPR);
10942 0 : if (res) return res;
10943 : }
10944 0 : break;
10945 : }
10946 0 : default:;
10947 : }
10948 0 : if (CONSTANT_CLASS_P (_p1))
10949 : {
10950 0 : {
10951 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
10952 0 : tree res = generic_simplify_263 (loc, type, _p0, _p1, captures, UNGT_EXPR, UNLT_EXPR);
10953 0 : if (res) return res;
10954 : }
10955 : }
10956 : break;
10957 : }
10958 2845078 : default:;
10959 : }
10960 2845078 : switch (TREE_CODE (_p1))
10961 : {
10962 2498748 : case REAL_CST:
10963 2498748 : {
10964 2498748 : {
10965 2498748 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
10966 2498748 : tree res = generic_simplify_549 (loc, type, _p0, _p1, captures, UNGT_EXPR);
10967 2498748 : if (res) return res;
10968 : }
10969 2498746 : break;
10970 : }
10971 : default:;
10972 : }
10973 : return NULL_TREE;
10974 : }
10975 :
10976 : tree
10977 9406301 : generic_simplify_TRUTH_OR_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
10978 : {
10979 9406301 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10980 9406301 : switch (TREE_CODE (_p0))
10981 : {
10982 1334627 : case LE_EXPR:
10983 1334627 : {
10984 1334627 : tree _q20 = TREE_OPERAND (_p0, 0);
10985 1334627 : tree _q21 = TREE_OPERAND (_p0, 1);
10986 1334627 : switch (TREE_CODE (_q20))
10987 : {
10988 3904 : case POINTER_PLUS_EXPR:
10989 3904 : {
10990 3904 : tree _q30 = TREE_OPERAND (_q20, 0);
10991 3904 : tree _q31 = TREE_OPERAND (_q20, 1);
10992 3904 : switch (TREE_CODE (_q31))
10993 : {
10994 3671 : case INTEGER_CST:
10995 3671 : {
10996 3671 : switch (TREE_CODE (_p1))
10997 : {
10998 1086 : case LE_EXPR:
10999 1086 : {
11000 1086 : tree _q70 = TREE_OPERAND (_p1, 0);
11001 1086 : tree _q71 = TREE_OPERAND (_p1, 1);
11002 1086 : switch (TREE_CODE (_q70))
11003 : {
11004 800 : case POINTER_PLUS_EXPR:
11005 800 : {
11006 800 : tree _q80 = TREE_OPERAND (_q70, 0);
11007 800 : tree _q81 = TREE_OPERAND (_q70, 1);
11008 800 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
11009 : {
11010 514 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
11011 : {
11012 395 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
11013 : {
11014 395 : {
11015 395 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70 };
11016 395 : const enum tree_code cmp = LE_EXPR;
11017 395 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11018 394 : && TYPE_OVERFLOW_WRAPS (sizetype)
11019 789 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11020 : )
11021 : {
11022 394 : {
11023 394 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11024 394 : offset_int rhs = off * 2;
11025 394 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11026 : )
11027 : {
11028 394 : {
11029 394 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11030 394 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11031 394 : if (cmp == LT_EXPR
11032 : )
11033 : {
11034 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1782;
11035 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1782;
11036 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1782;
11037 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1782;
11038 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1782;
11039 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1782;
11040 : {
11041 : tree res_op0;
11042 : {
11043 : tree _o1[1], _r1;
11044 : {
11045 : tree _o2[2], _r2;
11046 : _o2[0] = swap_p ? captures[6] : captures[1];
11047 : _o2[1] = swap_p ? captures[2] : captures[4];
11048 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11049 : _o1[0] = _r2;
11050 : }
11051 : if (TREE_TYPE (_o1[0]) != sizetype)
11052 : {
11053 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11054 : }
11055 : else
11056 : _r1 = _o1[0];
11057 : res_op0 = _r1;
11058 : }
11059 : tree res_op1;
11060 : res_op1 = rhs_tree;
11061 : tree _r;
11062 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11063 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 922, __FILE__, __LINE__, true);
11064 394 : return _r;
11065 : }
11066 : next_after_fail1782:;
11067 : }
11068 : else
11069 : {
11070 394 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1783;
11071 394 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1783;
11072 394 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1783;
11073 394 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1783;
11074 394 : {
11075 394 : tree res_op0;
11076 394 : {
11077 394 : tree _o1[1], _r1;
11078 394 : {
11079 394 : tree _o2[2], _r2;
11080 394 : {
11081 394 : tree _o3[2], _r3;
11082 394 : _o3[0] = swap_p ? captures[4] : captures[2];
11083 394 : _o3[1] = wide_int_to_tree (sizetype, off);
11084 394 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11085 394 : _o2[0] = _r3;
11086 : }
11087 394 : _o2[1] = swap_p ? captures[2] : captures[4];
11088 394 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11089 394 : _o1[0] = _r2;
11090 : }
11091 394 : if (TREE_TYPE (_o1[0]) != sizetype)
11092 : {
11093 394 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11094 : }
11095 : else
11096 : _r1 = _o1[0];
11097 394 : res_op0 = _r1;
11098 : }
11099 394 : tree res_op1;
11100 394 : res_op1 = rhs_tree;
11101 394 : tree _r;
11102 394 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11103 394 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 923, __FILE__, __LINE__, true);
11104 394 : return _r;
11105 : }
11106 0 : next_after_fail1783:;
11107 : }
11108 : }
11109 : }
11110 : }
11111 : }
11112 : }
11113 : }
11114 : }
11115 : }
11116 : break;
11117 : }
11118 : default:;
11119 : }
11120 : break;
11121 : }
11122 117 : case GE_EXPR:
11123 117 : {
11124 117 : tree _q70 = TREE_OPERAND (_p1, 0);
11125 117 : tree _q71 = TREE_OPERAND (_p1, 1);
11126 117 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
11127 : {
11128 18 : switch (TREE_CODE (_q71))
11129 : {
11130 18 : case POINTER_PLUS_EXPR:
11131 18 : {
11132 18 : tree _q90 = TREE_OPERAND (_q71, 0);
11133 18 : tree _q91 = TREE_OPERAND (_q71, 1);
11134 18 : if ((_q90 == _q21 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q21, 0) && types_match (_q90, _q21)))
11135 : {
11136 16 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
11137 : {
11138 11 : {
11139 11 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q71 };
11140 11 : const enum tree_code cmp = LE_EXPR;
11141 11 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11142 11 : && TYPE_OVERFLOW_WRAPS (sizetype)
11143 22 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11144 : )
11145 : {
11146 11 : {
11147 11 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11148 11 : offset_int rhs = off * 2;
11149 11 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11150 : )
11151 : {
11152 11 : {
11153 11 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11154 11 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11155 11 : if (cmp == LT_EXPR
11156 : )
11157 : {
11158 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1784;
11159 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1784;
11160 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1784;
11161 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1784;
11162 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1784;
11163 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1784;
11164 : {
11165 : tree res_op0;
11166 : {
11167 : tree _o1[1], _r1;
11168 : {
11169 : tree _o2[2], _r2;
11170 : _o2[0] = swap_p ? captures[6] : captures[1];
11171 : _o2[1] = swap_p ? captures[2] : captures[4];
11172 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11173 : _o1[0] = _r2;
11174 : }
11175 : if (TREE_TYPE (_o1[0]) != sizetype)
11176 : {
11177 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11178 : }
11179 : else
11180 : _r1 = _o1[0];
11181 : res_op0 = _r1;
11182 : }
11183 : tree res_op1;
11184 : res_op1 = rhs_tree;
11185 : tree _r;
11186 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11187 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 922, __FILE__, __LINE__, true);
11188 11 : return _r;
11189 : }
11190 : next_after_fail1784:;
11191 : }
11192 : else
11193 : {
11194 11 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1785;
11195 11 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1785;
11196 11 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1785;
11197 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1785;
11198 11 : {
11199 11 : tree res_op0;
11200 11 : {
11201 11 : tree _o1[1], _r1;
11202 11 : {
11203 11 : tree _o2[2], _r2;
11204 11 : {
11205 11 : tree _o3[2], _r3;
11206 11 : _o3[0] = swap_p ? captures[4] : captures[2];
11207 11 : _o3[1] = wide_int_to_tree (sizetype, off);
11208 11 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11209 11 : _o2[0] = _r3;
11210 : }
11211 11 : _o2[1] = swap_p ? captures[2] : captures[4];
11212 11 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11213 11 : _o1[0] = _r2;
11214 : }
11215 11 : if (TREE_TYPE (_o1[0]) != sizetype)
11216 : {
11217 11 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11218 : }
11219 : else
11220 : _r1 = _o1[0];
11221 11 : res_op0 = _r1;
11222 : }
11223 11 : tree res_op1;
11224 11 : res_op1 = rhs_tree;
11225 11 : tree _r;
11226 11 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11227 11 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 923, __FILE__, __LINE__, true);
11228 11 : return _r;
11229 : }
11230 0 : next_after_fail1785:;
11231 : }
11232 : }
11233 : }
11234 : }
11235 : }
11236 : }
11237 : }
11238 : }
11239 : break;
11240 : }
11241 : default:;
11242 : }
11243 : }
11244 : break;
11245 : }
11246 : default:;
11247 : }
11248 : break;
11249 : }
11250 : default:;
11251 : }
11252 : break;
11253 : }
11254 : default:;
11255 : }
11256 : break;
11257 : }
11258 1061189 : case LT_EXPR:
11259 1061189 : {
11260 1061189 : tree _q20 = TREE_OPERAND (_p0, 0);
11261 1061189 : tree _q21 = TREE_OPERAND (_p0, 1);
11262 1061189 : switch (TREE_CODE (_q20))
11263 : {
11264 2393 : case POINTER_PLUS_EXPR:
11265 2393 : {
11266 2393 : tree _q30 = TREE_OPERAND (_q20, 0);
11267 2393 : tree _q31 = TREE_OPERAND (_q20, 1);
11268 2393 : switch (TREE_CODE (_q31))
11269 : {
11270 2197 : case INTEGER_CST:
11271 2197 : {
11272 2197 : switch (TREE_CODE (_p1))
11273 : {
11274 158 : case LT_EXPR:
11275 158 : {
11276 158 : tree _q70 = TREE_OPERAND (_p1, 0);
11277 158 : tree _q71 = TREE_OPERAND (_p1, 1);
11278 158 : switch (TREE_CODE (_q70))
11279 : {
11280 10 : case POINTER_PLUS_EXPR:
11281 10 : {
11282 10 : tree _q80 = TREE_OPERAND (_q70, 0);
11283 10 : tree _q81 = TREE_OPERAND (_q70, 1);
11284 10 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
11285 : {
11286 1 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
11287 : {
11288 1 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
11289 : {
11290 1 : {
11291 1 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70 };
11292 1 : const enum tree_code cmp = LT_EXPR;
11293 1 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11294 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
11295 1 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11296 : )
11297 : {
11298 0 : {
11299 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11300 0 : offset_int rhs = off * 2;
11301 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11302 : )
11303 : {
11304 0 : {
11305 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11306 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11307 0 : if (cmp == LT_EXPR
11308 : )
11309 : {
11310 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1786;
11311 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1786;
11312 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1786;
11313 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1786;
11314 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1786;
11315 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1786;
11316 0 : {
11317 0 : tree res_op0;
11318 0 : {
11319 0 : tree _o1[1], _r1;
11320 0 : {
11321 0 : tree _o2[2], _r2;
11322 0 : _o2[0] = swap_p ? captures[6] : captures[1];
11323 0 : _o2[1] = swap_p ? captures[2] : captures[4];
11324 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11325 0 : _o1[0] = _r2;
11326 : }
11327 0 : if (TREE_TYPE (_o1[0]) != sizetype)
11328 : {
11329 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11330 : }
11331 : else
11332 : _r1 = _o1[0];
11333 0 : res_op0 = _r1;
11334 : }
11335 0 : tree res_op1;
11336 0 : res_op1 = rhs_tree;
11337 0 : tree _r;
11338 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11339 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 922, __FILE__, __LINE__, true);
11340 0 : return _r;
11341 : }
11342 0 : next_after_fail1786:;
11343 : }
11344 : else
11345 : {
11346 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1787;
11347 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1787;
11348 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1787;
11349 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1787;
11350 : {
11351 : tree res_op0;
11352 : {
11353 : tree _o1[1], _r1;
11354 : {
11355 : tree _o2[2], _r2;
11356 : {
11357 : tree _o3[2], _r3;
11358 : _o3[0] = swap_p ? captures[4] : captures[2];
11359 : _o3[1] = wide_int_to_tree (sizetype, off);
11360 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11361 : _o2[0] = _r3;
11362 : }
11363 : _o2[1] = swap_p ? captures[2] : captures[4];
11364 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11365 : _o1[0] = _r2;
11366 : }
11367 : if (TREE_TYPE (_o1[0]) != sizetype)
11368 : {
11369 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11370 : }
11371 : else
11372 : _r1 = _o1[0];
11373 : res_op0 = _r1;
11374 : }
11375 : tree res_op1;
11376 : res_op1 = rhs_tree;
11377 : tree _r;
11378 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11379 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 923, __FILE__, __LINE__, true);
11380 : return _r;
11381 : }
11382 : next_after_fail1787:;
11383 : }
11384 : }
11385 : }
11386 : }
11387 : }
11388 : }
11389 : }
11390 : }
11391 : }
11392 : break;
11393 : }
11394 : default:;
11395 : }
11396 : break;
11397 : }
11398 778 : case GT_EXPR:
11399 778 : {
11400 778 : tree _q70 = TREE_OPERAND (_p1, 0);
11401 778 : tree _q71 = TREE_OPERAND (_p1, 1);
11402 778 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
11403 : {
11404 0 : switch (TREE_CODE (_q71))
11405 : {
11406 0 : case POINTER_PLUS_EXPR:
11407 0 : {
11408 0 : tree _q90 = TREE_OPERAND (_q71, 0);
11409 0 : tree _q91 = TREE_OPERAND (_q71, 1);
11410 0 : if ((_q90 == _q21 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q21, 0) && types_match (_q90, _q21)))
11411 : {
11412 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
11413 : {
11414 0 : {
11415 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q71 };
11416 0 : const enum tree_code cmp = LT_EXPR;
11417 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11418 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
11419 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11420 : )
11421 : {
11422 0 : {
11423 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11424 0 : offset_int rhs = off * 2;
11425 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11426 : )
11427 : {
11428 0 : {
11429 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11430 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11431 0 : if (cmp == LT_EXPR
11432 : )
11433 : {
11434 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1788;
11435 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1788;
11436 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1788;
11437 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1788;
11438 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1788;
11439 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1788;
11440 0 : {
11441 0 : tree res_op0;
11442 0 : {
11443 0 : tree _o1[1], _r1;
11444 0 : {
11445 0 : tree _o2[2], _r2;
11446 0 : _o2[0] = swap_p ? captures[6] : captures[1];
11447 0 : _o2[1] = swap_p ? captures[2] : captures[4];
11448 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11449 0 : _o1[0] = _r2;
11450 : }
11451 0 : if (TREE_TYPE (_o1[0]) != sizetype)
11452 : {
11453 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11454 : }
11455 : else
11456 : _r1 = _o1[0];
11457 0 : res_op0 = _r1;
11458 : }
11459 0 : tree res_op1;
11460 0 : res_op1 = rhs_tree;
11461 0 : tree _r;
11462 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11463 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 922, __FILE__, __LINE__, true);
11464 0 : return _r;
11465 : }
11466 0 : next_after_fail1788:;
11467 : }
11468 : else
11469 : {
11470 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1789;
11471 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1789;
11472 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1789;
11473 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1789;
11474 : {
11475 : tree res_op0;
11476 : {
11477 : tree _o1[1], _r1;
11478 : {
11479 : tree _o2[2], _r2;
11480 : {
11481 : tree _o3[2], _r3;
11482 : _o3[0] = swap_p ? captures[4] : captures[2];
11483 : _o3[1] = wide_int_to_tree (sizetype, off);
11484 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11485 : _o2[0] = _r3;
11486 : }
11487 : _o2[1] = swap_p ? captures[2] : captures[4];
11488 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11489 : _o1[0] = _r2;
11490 : }
11491 : if (TREE_TYPE (_o1[0]) != sizetype)
11492 : {
11493 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11494 : }
11495 : else
11496 : _r1 = _o1[0];
11497 : res_op0 = _r1;
11498 : }
11499 : tree res_op1;
11500 : res_op1 = rhs_tree;
11501 : tree _r;
11502 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11503 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 923, __FILE__, __LINE__, true);
11504 : return _r;
11505 : }
11506 : next_after_fail1789:;
11507 : }
11508 : }
11509 : }
11510 : }
11511 : }
11512 : }
11513 : }
11514 : }
11515 : break;
11516 : }
11517 : default:;
11518 : }
11519 : }
11520 : break;
11521 : }
11522 : default:;
11523 : }
11524 : break;
11525 : }
11526 : default:;
11527 : }
11528 : break;
11529 : }
11530 : default:;
11531 : }
11532 : break;
11533 : }
11534 796072 : case GE_EXPR:
11535 796072 : {
11536 796072 : tree _q20 = TREE_OPERAND (_p0, 0);
11537 796072 : tree _q21 = TREE_OPERAND (_p0, 1);
11538 796072 : switch (TREE_CODE (_q21))
11539 : {
11540 52 : case POINTER_PLUS_EXPR:
11541 52 : {
11542 52 : tree _q40 = TREE_OPERAND (_q21, 0);
11543 52 : tree _q41 = TREE_OPERAND (_q21, 1);
11544 52 : switch (TREE_CODE (_q41))
11545 : {
11546 52 : case INTEGER_CST:
11547 52 : {
11548 52 : switch (TREE_CODE (_p1))
11549 : {
11550 52 : case LE_EXPR:
11551 52 : {
11552 52 : tree _q70 = TREE_OPERAND (_p1, 0);
11553 52 : tree _q71 = TREE_OPERAND (_p1, 1);
11554 52 : switch (TREE_CODE (_q70))
11555 : {
11556 42 : case POINTER_PLUS_EXPR:
11557 42 : {
11558 42 : tree _q80 = TREE_OPERAND (_q70, 0);
11559 42 : tree _q81 = TREE_OPERAND (_q70, 1);
11560 42 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
11561 : {
11562 27 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
11563 : {
11564 3 : if ((_q71 == _q40 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q40, 0) && types_match (_q71, _q40)))
11565 : {
11566 3 : {
11567 3 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q70 };
11568 3 : const enum tree_code cmp = LE_EXPR;
11569 3 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11570 3 : && TYPE_OVERFLOW_WRAPS (sizetype)
11571 6 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11572 : )
11573 : {
11574 3 : {
11575 3 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11576 3 : offset_int rhs = off * 2;
11577 3 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11578 : )
11579 : {
11580 3 : {
11581 3 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11582 3 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11583 3 : if (cmp == LT_EXPR
11584 : )
11585 : {
11586 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1790;
11587 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1790;
11588 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1790;
11589 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1790;
11590 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1790;
11591 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1790;
11592 : {
11593 : tree res_op0;
11594 : {
11595 : tree _o1[1], _r1;
11596 : {
11597 : tree _o2[2], _r2;
11598 : _o2[0] = swap_p ? captures[6] : captures[1];
11599 : _o2[1] = swap_p ? captures[2] : captures[4];
11600 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11601 : _o1[0] = _r2;
11602 : }
11603 : if (TREE_TYPE (_o1[0]) != sizetype)
11604 : {
11605 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11606 : }
11607 : else
11608 : _r1 = _o1[0];
11609 : res_op0 = _r1;
11610 : }
11611 : tree res_op1;
11612 : res_op1 = rhs_tree;
11613 : tree _r;
11614 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11615 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 922, __FILE__, __LINE__, true);
11616 3 : return _r;
11617 : }
11618 : next_after_fail1790:;
11619 : }
11620 : else
11621 : {
11622 3 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1791;
11623 3 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1791;
11624 3 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1791;
11625 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1791;
11626 3 : {
11627 3 : tree res_op0;
11628 3 : {
11629 3 : tree _o1[1], _r1;
11630 3 : {
11631 3 : tree _o2[2], _r2;
11632 3 : {
11633 3 : tree _o3[2], _r3;
11634 3 : _o3[0] = swap_p ? captures[4] : captures[2];
11635 3 : _o3[1] = wide_int_to_tree (sizetype, off);
11636 3 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11637 3 : _o2[0] = _r3;
11638 : }
11639 3 : _o2[1] = swap_p ? captures[2] : captures[4];
11640 3 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11641 3 : _o1[0] = _r2;
11642 : }
11643 3 : if (TREE_TYPE (_o1[0]) != sizetype)
11644 : {
11645 3 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11646 : }
11647 : else
11648 : _r1 = _o1[0];
11649 3 : res_op0 = _r1;
11650 : }
11651 3 : tree res_op1;
11652 3 : res_op1 = rhs_tree;
11653 3 : tree _r;
11654 3 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11655 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 923, __FILE__, __LINE__, true);
11656 3 : return _r;
11657 : }
11658 0 : next_after_fail1791:;
11659 : }
11660 : }
11661 : }
11662 : }
11663 : }
11664 : }
11665 : }
11666 : }
11667 : }
11668 : break;
11669 : }
11670 : default:;
11671 : }
11672 : break;
11673 : }
11674 0 : case GE_EXPR:
11675 0 : {
11676 0 : tree _q70 = TREE_OPERAND (_p1, 0);
11677 0 : tree _q71 = TREE_OPERAND (_p1, 1);
11678 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
11679 : {
11680 0 : switch (TREE_CODE (_q71))
11681 : {
11682 0 : case POINTER_PLUS_EXPR:
11683 0 : {
11684 0 : tree _q90 = TREE_OPERAND (_q71, 0);
11685 0 : tree _q91 = TREE_OPERAND (_q71, 1);
11686 0 : if ((_q90 == _q20 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q20, 0) && types_match (_q90, _q20)))
11687 : {
11688 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
11689 : {
11690 0 : {
11691 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q71 };
11692 0 : const enum tree_code cmp = LE_EXPR;
11693 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11694 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
11695 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11696 : )
11697 : {
11698 0 : {
11699 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11700 0 : offset_int rhs = off * 2;
11701 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11702 : )
11703 : {
11704 0 : {
11705 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11706 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11707 0 : if (cmp == LT_EXPR
11708 : )
11709 : {
11710 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1792;
11711 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1792;
11712 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1792;
11713 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1792;
11714 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1792;
11715 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1792;
11716 : {
11717 : tree res_op0;
11718 : {
11719 : tree _o1[1], _r1;
11720 : {
11721 : tree _o2[2], _r2;
11722 : _o2[0] = swap_p ? captures[6] : captures[1];
11723 : _o2[1] = swap_p ? captures[2] : captures[4];
11724 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11725 : _o1[0] = _r2;
11726 : }
11727 : if (TREE_TYPE (_o1[0]) != sizetype)
11728 : {
11729 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11730 : }
11731 : else
11732 : _r1 = _o1[0];
11733 : res_op0 = _r1;
11734 : }
11735 : tree res_op1;
11736 : res_op1 = rhs_tree;
11737 : tree _r;
11738 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11739 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 922, __FILE__, __LINE__, true);
11740 0 : return _r;
11741 : }
11742 : next_after_fail1792:;
11743 : }
11744 : else
11745 : {
11746 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1793;
11747 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1793;
11748 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1793;
11749 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1793;
11750 0 : {
11751 0 : tree res_op0;
11752 0 : {
11753 0 : tree _o1[1], _r1;
11754 0 : {
11755 0 : tree _o2[2], _r2;
11756 0 : {
11757 0 : tree _o3[2], _r3;
11758 0 : _o3[0] = swap_p ? captures[4] : captures[2];
11759 0 : _o3[1] = wide_int_to_tree (sizetype, off);
11760 0 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11761 0 : _o2[0] = _r3;
11762 : }
11763 0 : _o2[1] = swap_p ? captures[2] : captures[4];
11764 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11765 0 : _o1[0] = _r2;
11766 : }
11767 0 : if (TREE_TYPE (_o1[0]) != sizetype)
11768 : {
11769 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11770 : }
11771 : else
11772 : _r1 = _o1[0];
11773 0 : res_op0 = _r1;
11774 : }
11775 0 : tree res_op1;
11776 0 : res_op1 = rhs_tree;
11777 0 : tree _r;
11778 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11779 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 923, __FILE__, __LINE__, true);
11780 0 : return _r;
11781 : }
11782 0 : next_after_fail1793:;
11783 : }
11784 : }
11785 : }
11786 : }
11787 : }
11788 : }
11789 : }
11790 : }
11791 : break;
11792 : }
11793 : default:;
11794 : }
11795 : }
11796 : break;
11797 : }
11798 : default:;
11799 : }
11800 : break;
11801 : }
11802 : default:;
11803 : }
11804 : break;
11805 : }
11806 : default:;
11807 : }
11808 : break;
11809 : }
11810 1176074 : case GT_EXPR:
11811 1176074 : {
11812 1176074 : tree _q20 = TREE_OPERAND (_p0, 0);
11813 1176074 : tree _q21 = TREE_OPERAND (_p0, 1);
11814 1176074 : switch (TREE_CODE (_q21))
11815 : {
11816 46 : case POINTER_PLUS_EXPR:
11817 46 : {
11818 46 : tree _q40 = TREE_OPERAND (_q21, 0);
11819 46 : tree _q41 = TREE_OPERAND (_q21, 1);
11820 46 : switch (TREE_CODE (_q41))
11821 : {
11822 46 : case INTEGER_CST:
11823 46 : {
11824 46 : switch (TREE_CODE (_p1))
11825 : {
11826 0 : case LT_EXPR:
11827 0 : {
11828 0 : tree _q70 = TREE_OPERAND (_p1, 0);
11829 0 : tree _q71 = TREE_OPERAND (_p1, 1);
11830 0 : switch (TREE_CODE (_q70))
11831 : {
11832 0 : case POINTER_PLUS_EXPR:
11833 0 : {
11834 0 : tree _q80 = TREE_OPERAND (_q70, 0);
11835 0 : tree _q81 = TREE_OPERAND (_q70, 1);
11836 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
11837 : {
11838 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
11839 : {
11840 0 : if ((_q71 == _q40 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q40, 0) && types_match (_q71, _q40)))
11841 : {
11842 0 : {
11843 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q70 };
11844 0 : const enum tree_code cmp = LT_EXPR;
11845 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11846 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
11847 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11848 : )
11849 : {
11850 0 : {
11851 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11852 0 : offset_int rhs = off * 2;
11853 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11854 : )
11855 : {
11856 0 : {
11857 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11858 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11859 0 : if (cmp == LT_EXPR
11860 : )
11861 : {
11862 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1794;
11863 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1794;
11864 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1794;
11865 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1794;
11866 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1794;
11867 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1794;
11868 0 : {
11869 0 : tree res_op0;
11870 0 : {
11871 0 : tree _o1[1], _r1;
11872 0 : {
11873 0 : tree _o2[2], _r2;
11874 0 : _o2[0] = swap_p ? captures[6] : captures[1];
11875 0 : _o2[1] = swap_p ? captures[2] : captures[4];
11876 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11877 0 : _o1[0] = _r2;
11878 : }
11879 0 : if (TREE_TYPE (_o1[0]) != sizetype)
11880 : {
11881 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11882 : }
11883 : else
11884 : _r1 = _o1[0];
11885 0 : res_op0 = _r1;
11886 : }
11887 0 : tree res_op1;
11888 0 : res_op1 = rhs_tree;
11889 0 : tree _r;
11890 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11891 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 922, __FILE__, __LINE__, true);
11892 0 : return _r;
11893 : }
11894 0 : next_after_fail1794:;
11895 : }
11896 : else
11897 : {
11898 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1795;
11899 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1795;
11900 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1795;
11901 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1795;
11902 : {
11903 : tree res_op0;
11904 : {
11905 : tree _o1[1], _r1;
11906 : {
11907 : tree _o2[2], _r2;
11908 : {
11909 : tree _o3[2], _r3;
11910 : _o3[0] = swap_p ? captures[4] : captures[2];
11911 : _o3[1] = wide_int_to_tree (sizetype, off);
11912 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11913 : _o2[0] = _r3;
11914 : }
11915 : _o2[1] = swap_p ? captures[2] : captures[4];
11916 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11917 : _o1[0] = _r2;
11918 : }
11919 : if (TREE_TYPE (_o1[0]) != sizetype)
11920 : {
11921 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11922 : }
11923 : else
11924 : _r1 = _o1[0];
11925 : res_op0 = _r1;
11926 : }
11927 : tree res_op1;
11928 : res_op1 = rhs_tree;
11929 : tree _r;
11930 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11931 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 923, __FILE__, __LINE__, true);
11932 : return _r;
11933 : }
11934 : next_after_fail1795:;
11935 : }
11936 : }
11937 : }
11938 : }
11939 : }
11940 : }
11941 : }
11942 : }
11943 : }
11944 : break;
11945 : }
11946 : default:;
11947 : }
11948 : break;
11949 : }
11950 18 : case GT_EXPR:
11951 18 : {
11952 18 : tree _q70 = TREE_OPERAND (_p1, 0);
11953 18 : tree _q71 = TREE_OPERAND (_p1, 1);
11954 18 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
11955 : {
11956 0 : switch (TREE_CODE (_q71))
11957 : {
11958 0 : case POINTER_PLUS_EXPR:
11959 0 : {
11960 0 : tree _q90 = TREE_OPERAND (_q71, 0);
11961 0 : tree _q91 = TREE_OPERAND (_q71, 1);
11962 0 : if ((_q90 == _q20 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q20, 0) && types_match (_q90, _q20)))
11963 : {
11964 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
11965 : {
11966 0 : {
11967 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q71 };
11968 0 : const enum tree_code cmp = LT_EXPR;
11969 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11970 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
11971 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11972 : )
11973 : {
11974 0 : {
11975 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11976 0 : offset_int rhs = off * 2;
11977 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11978 : )
11979 : {
11980 0 : {
11981 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11982 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11983 0 : if (cmp == LT_EXPR
11984 : )
11985 : {
11986 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1796;
11987 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1796;
11988 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1796;
11989 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1796;
11990 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1796;
11991 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1796;
11992 0 : {
11993 0 : tree res_op0;
11994 0 : {
11995 0 : tree _o1[1], _r1;
11996 0 : {
11997 0 : tree _o2[2], _r2;
11998 0 : _o2[0] = swap_p ? captures[6] : captures[1];
11999 0 : _o2[1] = swap_p ? captures[2] : captures[4];
12000 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12001 0 : _o1[0] = _r2;
12002 : }
12003 0 : if (TREE_TYPE (_o1[0]) != sizetype)
12004 : {
12005 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12006 : }
12007 : else
12008 : _r1 = _o1[0];
12009 0 : res_op0 = _r1;
12010 : }
12011 0 : tree res_op1;
12012 0 : res_op1 = rhs_tree;
12013 0 : tree _r;
12014 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12015 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 922, __FILE__, __LINE__, true);
12016 0 : return _r;
12017 : }
12018 0 : next_after_fail1796:;
12019 : }
12020 : else
12021 : {
12022 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1797;
12023 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1797;
12024 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1797;
12025 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1797;
12026 : {
12027 : tree res_op0;
12028 : {
12029 : tree _o1[1], _r1;
12030 : {
12031 : tree _o2[2], _r2;
12032 : {
12033 : tree _o3[2], _r3;
12034 : _o3[0] = swap_p ? captures[4] : captures[2];
12035 : _o3[1] = wide_int_to_tree (sizetype, off);
12036 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
12037 : _o2[0] = _r3;
12038 : }
12039 : _o2[1] = swap_p ? captures[2] : captures[4];
12040 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12041 : _o1[0] = _r2;
12042 : }
12043 : if (TREE_TYPE (_o1[0]) != sizetype)
12044 : {
12045 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12046 : }
12047 : else
12048 : _r1 = _o1[0];
12049 : res_op0 = _r1;
12050 : }
12051 : tree res_op1;
12052 : res_op1 = rhs_tree;
12053 : tree _r;
12054 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12055 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 923, __FILE__, __LINE__, true);
12056 : return _r;
12057 : }
12058 : next_after_fail1797:;
12059 : }
12060 : }
12061 : }
12062 : }
12063 : }
12064 : }
12065 : }
12066 : }
12067 : break;
12068 : }
12069 : default:;
12070 : }
12071 : }
12072 : break;
12073 : }
12074 : default:;
12075 : }
12076 : break;
12077 : }
12078 : default:;
12079 : }
12080 : break;
12081 : }
12082 : default:;
12083 : }
12084 : break;
12085 : }
12086 : default:;
12087 : }
12088 : return NULL_TREE;
12089 : }
12090 : #pragma GCC diagnostic pop
|
