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 132472144 : tree_negate_expr_p (tree t)
11 : {
12 132472144 : const tree type = TREE_TYPE (t);
13 132472144 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 132472144 : if (TREE_SIDE_EFFECTS (t)) return false;
15 127141841 : switch (TREE_CODE (t))
16 : {
17 7732130 : case INTEGER_CST:
18 7732130 : {
19 7732130 : {
20 7732130 : if ((INTEGRAL_TYPE_P (type)
21 7732130 : && TYPE_UNSIGNED (type))
22 9919377 : || (!TYPE_OVERFLOW_SANITIZED (type)
23 2184512 : && may_negate_without_overflow_p (t))
24 : )
25 : {
26 7716286 : {
27 7716286 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 14, __FILE__, __LINE__, false);
28 7716286 : return true;
29 : }
30 : }
31 : }
32 : break;
33 : }
34 0 : case FIXED_CST:
35 0 : {
36 0 : {
37 0 : {
38 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 15, __FILE__, __LINE__, false);
39 : return true;
40 : }
41 : }
42 464364 : break;
43 : }
44 464364 : case NEGATE_EXPR:
45 464364 : {
46 464364 : tree _p0 = TREE_OPERAND (t, 0);
47 464364 : {
48 464364 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
49 464364 : if (!TYPE_OVERFLOW_SANITIZED (type)
50 : )
51 : {
52 464344 : {
53 464344 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 16, __FILE__, __LINE__, false);
54 464344 : return true;
55 : }
56 : }
57 : }
58 : break;
59 : }
60 727363 : case REAL_CST:
61 727363 : {
62 727363 : {
63 727363 : if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (t))
64 : )
65 : {
66 639 : {
67 639 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 17, __FILE__, __LINE__, false);
68 639 : return true;
69 : }
70 : }
71 : }
72 : break;
73 : }
74 429 : case VECTOR_CST:
75 429 : {
76 429 : {
77 429 : if (FLOAT_TYPE_P (TREE_TYPE (type)) || TYPE_OVERFLOW_WRAPS (type)
78 : )
79 : {
80 320 : {
81 320 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 18, __FILE__, __LINE__, false);
82 320 : return true;
83 : }
84 : }
85 : }
86 : break;
87 : }
88 1216091 : case MINUS_EXPR:
89 1216091 : {
90 1216091 : tree _p0 = TREE_OPERAND (t, 0);
91 1216091 : tree _p1 = TREE_OPERAND (t, 1);
92 1216091 : {
93 1216091 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
94 1216091 : if ((ANY_INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_WRAPS (type))
95 2116276 : || (FLOAT_TYPE_P (type)
96 633504 : && !HONOR_SIGN_DEPENDENT_ROUNDING (type)
97 633504 : && !HONOR_SIGNED_ZEROS (type))
98 : )
99 : {
100 316479 : {
101 316479 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 19, __FILE__, __LINE__, false);
102 316479 : return true;
103 : }
104 : }
105 : }
106 899612 : break;
107 : }
108 : default:;
109 : }
110 : return false;
111 : }
112 :
113 : bool
114 0 : tree_double_value_p (tree t)
115 : {
116 0 : const tree type = TREE_TYPE (t);
117 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
118 0 : if (TREE_SIDE_EFFECTS (t)) return false;
119 0 : {
120 0 : tree captures[1] ATTRIBUTE_UNUSED = { t };
121 0 : if (TYPE_MAIN_VARIANT (TREE_TYPE (captures[0])) == double_type_node
122 : )
123 : {
124 0 : {
125 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 44, __FILE__, __LINE__, false);
126 0 : return true;
127 : }
128 : }
129 : }
130 : return false;
131 : }
132 :
133 : tree
134 7 : generic_simplify_6 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
135 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
136 : const enum tree_code ARG_UNUSED (op))
137 : {
138 7 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
139 7 : if (INTEGRAL_TYPE_P (type)
140 7 : && TYPE_OVERFLOW_WRAPS (type)
141 14 : && !TYPE_SATURATING (type)
142 : )
143 : {
144 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail78;
145 7 : {
146 7 : tree res_op0;
147 7 : {
148 7 : tree _o1[2], _r1;
149 7 : _o1[0] = captures[1];
150 7 : _o1[1] = captures[4];
151 7 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
152 7 : res_op0 = _r1;
153 : }
154 7 : tree res_op1;
155 7 : res_op1 = captures[2];
156 7 : tree _r;
157 7 : _r = fold_build2_loc (loc, LSHIFT_EXPR, type, res_op0, res_op1);
158 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 55, __FILE__, __LINE__, true);
159 7 : return _r;
160 : }
161 0 : next_after_fail78:;
162 : }
163 : return NULL_TREE;
164 : }
165 :
166 : tree
167 219726 : generic_simplify_14 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
168 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
169 : {
170 219726 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
171 219726 : if (!TYPE_SATURATING (type)
172 : )
173 : {
174 219726 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[1]))
175 219726 : && !TYPE_OVERFLOW_SANITIZED (type)
176 : )
177 : {
178 217589 : {
179 217589 : tree t1 = type;
180 217589 : if (INTEGRAL_TYPE_P (type)
181 365780 : && TYPE_OVERFLOW_WRAPS (type) != TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1])))
182 2323 : t1 = TYPE_OVERFLOW_WRAPS (type) ? type : TREE_TYPE (captures[1]);
183 217589 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail86;
184 217589 : {
185 217589 : tree res_op0;
186 217589 : {
187 217589 : tree _o1[2], _r1;
188 217589 : {
189 217589 : tree _o2[1], _r2;
190 217589 : _o2[0] = captures[0];
191 217589 : if (TREE_TYPE (_o2[0]) != t1)
192 : {
193 2022 : _r2 = fold_build1_loc (loc, NOP_EXPR, t1, _o2[0]);
194 : }
195 : else
196 : _r2 = _o2[0];
197 217589 : _o1[0] = _r2;
198 : }
199 217589 : {
200 217589 : tree _o2[1], _r2;
201 217589 : _o2[0] = captures[1];
202 217589 : if (TREE_TYPE (_o2[0]) != t1)
203 : {
204 1813 : _r2 = fold_build1_loc (loc, NOP_EXPR, t1, _o2[0]);
205 : }
206 : else
207 : _r2 = _o2[0];
208 217589 : _o1[1] = _r2;
209 : }
210 217589 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
211 217589 : res_op0 = _r1;
212 : }
213 217589 : tree _r;
214 217589 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
215 217589 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 63, __FILE__, __LINE__, true);
216 217589 : return _r;
217 : }
218 0 : next_after_fail86:;
219 : }
220 : }
221 : }
222 : return NULL_TREE;
223 : }
224 :
225 : tree
226 9079 : generic_simplify_26 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
227 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
228 : const enum tree_code ARG_UNUSED (plusminus))
229 : {
230 9079 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
231 9079 : if (!TYPE_SATURATING (type)
232 9079 : && (!FLOAT_TYPE_P (type) || flag_associative_math)
233 : )
234 : {
235 8913 : if (!ALL_FRACT_MODE_P (TYPE_MODE (type))
236 : )
237 : {
238 4 : if ((!ANY_INTEGRAL_TYPE_P (type)
239 8909 : || TYPE_OVERFLOW_WRAPS (type)
240 3310 : || (INTEGRAL_TYPE_P (type)
241 3310 : && ((tree_expr_nonzero_p (captures[0])
242 136 : && expr_not_equal_to (captures[0],
243 9049 : wi::minus_one (TYPE_PRECISION (type)),
244 : gimple_match_ctx (captures[1])))
245 : || (plusminus == PLUS_EXPR
246 3174 : ? expr_not_equal_to (captures[2],
247 8931 : wi::max_value (TYPE_PRECISION (type), SIGNED),
248 : gimple_match_ctx (captures[1]))
249 3156 : : (expr_not_equal_to (captures[2],
250 12069 : wi::min_value (TYPE_PRECISION (type), SIGNED),
251 : gimple_match_ctx (captures[1]))
252 3102 : && expr_not_equal_to (captures[2],
253 6204 : wi::min_value (TYPE_PRECISION (type), SIGNED)
254 18219 : + 1, gimple_match_ctx (captures[1])))))))
255 12087 : && single_use (captures[1])
256 : )
257 : {
258 8859 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail107;
259 8859 : {
260 8859 : tree res_op0;
261 8859 : {
262 8859 : tree _o1[2], _r1;
263 8859 : _o1[0] = build_one_cst (type);
264 8859 : _o1[1] = captures[2];
265 8859 : _r1 = fold_build2_loc (loc, plusminus, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
266 8859 : res_op0 = _r1;
267 : }
268 8859 : tree res_op1;
269 8859 : res_op1 = captures[0];
270 8859 : tree _r;
271 8859 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
272 8859 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 84, __FILE__, __LINE__, true);
273 8859 : return _r;
274 : }
275 0 : next_after_fail107:;
276 : }
277 : }
278 : }
279 : return NULL_TREE;
280 : }
281 :
282 : tree
283 4 : generic_simplify_36 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
284 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
285 : const combined_fn ARG_UNUSED (POPCOUNT))
286 : {
287 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
288 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail118;
289 4 : {
290 4 : tree res_op0;
291 4 : {
292 4 : tree _o1[1], _r1;
293 4 : _o1[0] = captures[2];
294 4 : _r1 = maybe_build_call_expr_loc (loc, POPCOUNT, type, 1, _o1[0]);
295 4 : if (!_r1)
296 0 : goto next_after_fail118;
297 4 : res_op0 = _r1;
298 : }
299 4 : tree res_op1;
300 4 : {
301 4 : tree _o1[1], _r1;
302 4 : _o1[0] = captures[3];
303 4 : _r1 = maybe_build_call_expr_loc (loc, POPCOUNT, type, 1, _o1[0]);
304 4 : if (!_r1)
305 0 : goto next_after_fail118;
306 4 : res_op1 = _r1;
307 : }
308 4 : tree _r;
309 4 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
310 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 95, __FILE__, __LINE__, true);
311 : return _r;
312 : }
313 : next_after_fail118:;
314 : return NULL_TREE;
315 : }
316 :
317 : tree
318 2 : generic_simplify_44 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
319 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
320 : {
321 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
322 2 : if (!TYPE_OVERFLOW_SANITIZED (type) && !TYPE_OVERFLOW_TRAPS (type)
323 2 : && !TYPE_SATURATING (type) && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[2]))
324 2 : && !TYPE_OVERFLOW_TRAPS (TREE_TYPE (captures[2]))
325 4 : && !TYPE_SATURATING (TREE_TYPE (captures[2]))
326 : )
327 : {
328 2 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail126;
329 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail126;
330 2 : {
331 2 : tree res_op0;
332 2 : {
333 2 : tree _o1[1], _r1;
334 2 : {
335 2 : tree _o2[2], _r2;
336 2 : _o2[0] = captures[0];
337 2 : _o2[1] = captures[1];
338 2 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
339 2 : _o1[0] = _r2;
340 : }
341 2 : if (TREE_TYPE (_o1[0]) != type)
342 : {
343 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
344 : }
345 : else
346 : _r1 = _o1[0];
347 2 : res_op0 = _r1;
348 : }
349 2 : tree _r;
350 2 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
351 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 103, __FILE__, __LINE__, true);
352 2 : return _r;
353 : }
354 : next_after_fail126:;
355 : }
356 : return NULL_TREE;
357 : }
358 :
359 : tree
360 0 : generic_simplify_54 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
361 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
362 : {
363 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
364 0 : if (!TYPE_SATURATING (type)
365 : )
366 : {
367 0 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
368 0 : && !FIXED_POINT_TYPE_P (type)
369 : )
370 : {
371 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail138;
372 0 : {
373 0 : tree res_op0;
374 0 : res_op0 = captures[1];
375 0 : tree res_op1;
376 0 : res_op1 = captures[2];
377 0 : tree _r;
378 0 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
379 0 : if (TREE_SIDE_EFFECTS (captures[0]))
380 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
381 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 114, __FILE__, __LINE__, true);
382 0 : return _r;
383 : }
384 0 : next_after_fail138:;
385 : }
386 : }
387 : return NULL_TREE;
388 : }
389 :
390 : tree
391 9 : generic_simplify_60 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
392 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
393 : {
394 9 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
395 9 : if (INTEGRAL_TYPE_P (type)
396 9 : && (
397 :
398 9 : || !TREE_SIDE_EFFECTS (captures[1]))
399 : )
400 : {
401 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail148;
402 2 : {
403 2 : tree res_op0;
404 2 : {
405 2 : tree _o1[1], _r1;
406 2 : _o1[0] = captures[2];
407 2 : if (TREE_TYPE (_o1[0]) != boolean_type_node)
408 : {
409 2 : _r1 = fold_build1_loc (loc, NOP_EXPR, boolean_type_node, _o1[0]);
410 : }
411 : else
412 : _r1 = _o1[0];
413 2 : res_op0 = _r1;
414 : }
415 2 : tree res_op1;
416 2 : res_op1 = captures[1];
417 2 : tree res_op2;
418 2 : res_op2 = captures[0];
419 2 : tree _r;
420 2 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
421 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 124, __FILE__, __LINE__, true);
422 2 : return _r;
423 : }
424 0 : next_after_fail148:;
425 : }
426 : return NULL_TREE;
427 : }
428 :
429 : tree
430 15 : generic_simplify_66 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
431 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
432 : const enum tree_code ARG_UNUSED (op))
433 : {
434 15 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
435 15 : if (INTEGRAL_TYPE_P (type)
436 : )
437 : {
438 15 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail154;
439 15 : {
440 15 : tree res_op0;
441 15 : {
442 15 : tree _o1[2], _r1;
443 15 : _o1[0] = captures[1];
444 15 : _o1[1] = captures[4];
445 15 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
446 15 : res_op0 = _r1;
447 : }
448 15 : tree res_op1;
449 15 : res_op1 = captures[2];
450 15 : tree _r;
451 15 : _r = fold_build2_loc (loc, RSHIFT_EXPR, type, res_op0, res_op1);
452 15 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 130, __FILE__, __LINE__, true);
453 15 : return _r;
454 : }
455 0 : next_after_fail154:;
456 : }
457 : return NULL_TREE;
458 : }
459 :
460 : tree
461 0 : generic_simplify_72 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
462 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
463 : {
464 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
465 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail160;
466 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail160;
467 0 : {
468 0 : tree _r;
469 0 : _r = captures[2];
470 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 134, __FILE__, __LINE__, true);
471 : return _r;
472 : }
473 : next_after_fail160:;
474 : return NULL_TREE;
475 : }
476 :
477 : tree
478 0 : generic_simplify_77 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
479 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
480 : const enum tree_code ARG_UNUSED (bit_op))
481 : {
482 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
483 0 : if (bit_op == BIT_AND_EXPR
484 : )
485 : {
486 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail167;
487 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail167;
488 0 : {
489 0 : tree _r;
490 0 : _r = build_zero_cst (type);
491 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 140, __FILE__, __LINE__, true);
492 0 : return _r;
493 : }
494 : next_after_fail167:;
495 : }
496 : else
497 : {
498 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail168;
499 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail168;
500 0 : {
501 0 : tree _r;
502 0 : _r = build_minus_one_cst (type);
503 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 141, __FILE__, __LINE__, true);
504 0 : return _r;
505 : }
506 : next_after_fail168:;
507 : }
508 : return NULL_TREE;
509 : }
510 :
511 : tree
512 0 : generic_simplify_87 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
513 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
514 : {
515 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
516 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
517 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
518 : )
519 : {
520 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail179;
521 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail179;
522 0 : {
523 0 : tree _r;
524 0 : _r = captures[2];
525 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 145, __FILE__, __LINE__, true);
526 0 : return _r;
527 : }
528 : next_after_fail179:;
529 : }
530 : return NULL_TREE;
531 : }
532 :
533 : tree
534 0 : generic_simplify_99 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
535 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
536 : const enum tree_code ARG_UNUSED (op))
537 : {
538 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
539 0 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[3]))
540 0 : && tree_nop_conversion_p (type, TREE_TYPE (captures[6]))
541 : )
542 : {
543 0 : if (single_use (captures[4]) && single_use (captures[5])
544 : )
545 : {
546 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail191;
547 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail191;
548 0 : {
549 0 : tree res_op0;
550 0 : res_op0 = captures[0];
551 0 : tree res_op1;
552 0 : {
553 0 : tree _o1[1], _r1;
554 0 : _o1[0] = captures[6];
555 0 : if (TREE_TYPE (_o1[0]) != type)
556 : {
557 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
558 : }
559 : else
560 : _r1 = _o1[0];
561 0 : res_op1 = _r1;
562 : }
563 0 : tree _r;
564 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
565 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 156, __FILE__, __LINE__, true);
566 0 : return _r;
567 : }
568 : next_after_fail191:;
569 : }
570 : else
571 : {
572 : if (single_use (captures[0]) && single_use (captures[1])
573 : )
574 : {
575 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail192;
576 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail192;
577 : {
578 : tree res_op0;
579 : {
580 : tree _o1[1], _r1;
581 : _o1[0] = captures[3];
582 : if (TREE_TYPE (_o1[0]) != type)
583 : {
584 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
585 : }
586 : else
587 : _r1 = _o1[0];
588 : res_op0 = _r1;
589 : }
590 : tree res_op1;
591 : res_op1 = captures[4];
592 : tree _r;
593 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
594 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 157, __FILE__, __LINE__, true);
595 : return _r;
596 : }
597 : next_after_fail192:;
598 : }
599 : }
600 : }
601 : return NULL_TREE;
602 : }
603 :
604 : tree
605 700 : generic_simplify_110 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
606 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
607 : const enum tree_code ARG_UNUSED (op))
608 : {
609 700 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
610 700 : if (bitwise_equal_p (captures[4], captures[7])
611 : )
612 : {
613 40 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail206;
614 40 : {
615 40 : tree res_op0;
616 40 : {
617 40 : tree _o1[2], _r1;
618 40 : {
619 40 : tree _o2[2], _r2;
620 40 : _o2[0] = captures[5];
621 40 : {
622 40 : tree _o3[1], _r3;
623 40 : _o3[0] = captures[6];
624 40 : if (TREE_TYPE (_o3[0]) != TREE_TYPE (_o2[0]))
625 : {
626 0 : _r3 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o2[0]), _o3[0]);
627 : }
628 : else
629 : _r3 = _o3[0];
630 40 : _o2[1] = _r3;
631 : }
632 40 : _r2 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
633 40 : _o1[0] = _r2;
634 : }
635 40 : {
636 40 : tree _o2[1], _r2;
637 40 : _o2[0] = captures[4];
638 40 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
639 : {
640 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
641 : }
642 : else
643 : _r2 = _o2[0];
644 40 : _o1[1] = _r2;
645 : }
646 40 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
647 40 : res_op0 = _r1;
648 : }
649 40 : tree _r;
650 40 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
651 40 : if (TREE_SIDE_EFFECTS (captures[7]))
652 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[7]), _r);
653 40 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 163, __FILE__, __LINE__, true);
654 40 : return _r;
655 : }
656 0 : next_after_fail206:;
657 : }
658 : return NULL_TREE;
659 : }
660 :
661 : tree
662 300 : generic_simplify_123 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
663 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
664 : {
665 300 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
666 300 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail225;
667 300 : {
668 300 : if (! tree_invariant_p (captures[1])) goto next_after_fail225;
669 0 : tree res_op0;
670 0 : {
671 0 : tree _o1[2], _r1;
672 0 : {
673 0 : tree _o2[2], _r2;
674 0 : _o2[0] = unshare_expr (captures[1]);
675 0 : _o2[1] = captures[4];
676 0 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
677 0 : _o1[0] = _r2;
678 : }
679 0 : _o1[1] = captures[2];
680 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
681 0 : res_op0 = _r1;
682 : }
683 0 : tree res_op1;
684 0 : res_op1 = captures[1];
685 0 : tree _r;
686 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
687 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 178, __FILE__, __LINE__, true);
688 : return _r;
689 : }
690 : next_after_fail225:;
691 : return NULL_TREE;
692 : }
693 :
694 : tree
695 0 : generic_simplify_133 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
696 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
697 : {
698 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
699 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail254;
700 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail254;
701 0 : {
702 0 : tree _r;
703 0 : _r = captures[2];
704 0 : if (TREE_SIDE_EFFECTS (captures[1]))
705 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
706 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 181, __FILE__, __LINE__, true);
707 : return _r;
708 : }
709 : next_after_fail254:;
710 : return NULL_TREE;
711 : }
712 :
713 : tree
714 0 : generic_simplify_136 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
715 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
716 : const enum tree_code ARG_UNUSED (eqne))
717 : {
718 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
719 0 : if (eqne == EQ_EXPR
720 : )
721 : {
722 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail257;
723 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail257;
724 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail257;
725 0 : {
726 0 : tree _r;
727 0 : _r = captures[0];
728 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 201, __FILE__, __LINE__, true);
729 0 : return _r;
730 : }
731 : next_after_fail257:;
732 : }
733 : else
734 : {
735 0 : if (eqne == NE_EXPR
736 : )
737 : {
738 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail258;
739 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail258;
740 0 : {
741 0 : tree _r;
742 0 : _r = constant_boolean_node (true, type);
743 0 : if (TREE_SIDE_EFFECTS (captures[2]))
744 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
745 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 202, __FILE__, __LINE__, true);
746 0 : return _r;
747 : }
748 : next_after_fail258:;
749 : }
750 : }
751 : return NULL_TREE;
752 : }
753 :
754 : tree
755 0 : generic_simplify_144 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
756 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
757 : const enum tree_code ARG_UNUSED (op))
758 : {
759 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
760 0 : if (INTEGRAL_TYPE_P (type)
761 0 : && tree_int_cst_sgn (captures[5]) > 0
762 0 : && (tree_nonzero_bits (captures[0]) & tree_nonzero_bits (captures[4])) == 0
763 : )
764 : {
765 0 : {
766 0 : tree t = type;
767 0 : if (!TYPE_OVERFLOW_WRAPS (t))
768 0 : t = unsigned_type_for (t);
769 0 : wide_int wone = wi::one (TYPE_PRECISION (type));
770 0 : wide_int c = wi::add (wi::to_wide (captures[3]),
771 0 : wi::lshift (wone, wi::to_wide (captures[5])));
772 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail279;
773 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail279;
774 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail279;
775 0 : {
776 0 : tree res_op0;
777 0 : {
778 0 : tree _o1[2], _r1;
779 0 : {
780 0 : tree _o2[1], _r2;
781 0 : _o2[0] = captures[2];
782 0 : if (TREE_TYPE (_o2[0]) != t)
783 : {
784 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, t, _o2[0]);
785 : }
786 : else
787 : _r2 = _o2[0];
788 0 : _o1[0] = _r2;
789 : }
790 0 : _o1[1] = wide_int_to_tree (t, c);
791 0 : _r1 = fold_build2_loc (loc, MULT_EXPR, t, _o1[0], _o1[1]);
792 0 : res_op0 = _r1;
793 : }
794 0 : tree _r;
795 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
796 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 167, __FILE__, __LINE__, true);
797 0 : return _r;
798 : }
799 0 : next_after_fail279:;
800 0 : }
801 : }
802 : return NULL_TREE;
803 : }
804 :
805 : tree
806 46 : generic_simplify_150 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
807 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
808 : const enum tree_code ARG_UNUSED (logic),
809 : const enum tree_code ARG_UNUSED (op),
810 : const enum tree_code ARG_UNUSED (ext))
811 : {
812 46 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
813 92 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
814 92 : && TREE_CODE (captures[1]) != INTEGER_CST
815 : )
816 : {
817 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail285;
818 0 : {
819 0 : tree res_op0;
820 0 : res_op0 = captures[1];
821 0 : tree res_op1;
822 0 : {
823 0 : tree _o1[2], _r1;
824 0 : _o1[0] = captures[2];
825 0 : _o1[1] = captures[4];
826 0 : _r1 = fold_build2_loc (loc, ext, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
827 0 : res_op1 = _r1;
828 : }
829 0 : tree _r;
830 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
831 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 207, __FILE__, __LINE__, true);
832 0 : return _r;
833 : }
834 0 : next_after_fail285:;
835 : }
836 : return NULL_TREE;
837 : }
838 :
839 : tree
840 196 : generic_simplify_156 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
841 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
842 : {
843 196 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
844 196 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail291;
845 196 : {
846 196 : if (! tree_invariant_p (captures[3])) goto next_after_fail291;
847 15 : tree res_op0;
848 15 : {
849 15 : tree _o1[2], _r1;
850 15 : _o1[0] = captures[2];
851 15 : _o1[1] = unshare_expr (captures[3]);
852 15 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
853 15 : res_op0 = _r1;
854 : }
855 15 : tree res_op1;
856 15 : {
857 15 : tree _o1[2], _r1;
858 15 : _o1[0] = captures[4];
859 15 : _o1[1] = captures[3];
860 15 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
861 15 : if (EXPR_P (_r1))
862 14 : goto next_after_fail291;
863 1 : res_op1 = _r1;
864 : }
865 1 : tree _r;
866 1 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
867 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 213, __FILE__, __LINE__, true);
868 : return _r;
869 : }
870 : next_after_fail291:;
871 : return NULL_TREE;
872 : }
873 :
874 : tree
875 8 : generic_simplify_163 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
876 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
877 : {
878 8 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
879 8 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
880 : )
881 : {
882 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail298;
883 8 : {
884 8 : tree res_op0;
885 8 : {
886 8 : tree _o1[2], _r1;
887 8 : _o1[0] = captures[1];
888 8 : {
889 8 : tree _o2[1], _r2;
890 8 : _o2[0] = captures[0];
891 8 : _r2 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
892 8 : _o1[1] = _r2;
893 : }
894 8 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
895 8 : res_op0 = _r1;
896 : }
897 8 : tree _r;
898 8 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
899 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 220, __FILE__, __LINE__, true);
900 8 : return _r;
901 : }
902 0 : next_after_fail298:;
903 : }
904 : return NULL_TREE;
905 : }
906 :
907 : tree
908 2 : generic_simplify_171 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
909 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
910 : {
911 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
912 2 : if (INTEGRAL_TYPE_P (type)
913 2 : && (
914 :
915 2 : || !TREE_SIDE_EFFECTS (captures[1]))
916 : )
917 : {
918 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail306;
919 2 : {
920 2 : tree res_op0;
921 2 : {
922 2 : tree _o1[1], _r1;
923 2 : _o1[0] = captures[2];
924 2 : if (TREE_TYPE (_o1[0]) != boolean_type_node)
925 : {
926 2 : _r1 = fold_build1_loc (loc, NOP_EXPR, boolean_type_node, _o1[0]);
927 : }
928 : else
929 : _r1 = _o1[0];
930 2 : res_op0 = _r1;
931 : }
932 2 : tree res_op1;
933 2 : res_op1 = captures[1];
934 2 : tree res_op2;
935 2 : res_op2 = captures[0];
936 2 : tree _r;
937 2 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
938 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 227, __FILE__, __LINE__, true);
939 2 : return _r;
940 : }
941 0 : next_after_fail306:;
942 : }
943 : return NULL_TREE;
944 : }
945 :
946 : tree
947 0 : generic_simplify_178 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
948 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
949 : const combined_fn ARG_UNUSED (COPYSIGN_ALL))
950 : {
951 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
952 0 : if (!tree_expr_maybe_nan_p (captures[0]) && !HONOR_SIGNED_ZEROS (type)
953 : )
954 : {
955 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail315;
956 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail315;
957 0 : {
958 0 : tree res_op0;
959 0 : {
960 0 : tree _o1[1], _r1;
961 0 : _o1[0] = captures[0];
962 0 : _r1 = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
963 0 : res_op0 = _r1;
964 : }
965 0 : tree _r;
966 0 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
967 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 235, __FILE__, __LINE__, true);
968 0 : return _r;
969 : }
970 : next_after_fail315:;
971 : }
972 : return NULL_TREE;
973 : }
974 :
975 : tree
976 1206 : generic_simplify_188 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
977 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
978 : const enum tree_code ARG_UNUSED (cmp))
979 : {
980 1206 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
981 1206 : if (fold_before_rtl_expansion_p ()
982 : )
983 : {
984 0 : if (INTEGRAL_TYPE_P (type)
985 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
986 : )
987 : {
988 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail327;
989 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail327;
990 0 : {
991 0 : tree res_op0;
992 0 : res_op0 = captures[0];
993 0 : tree res_op1;
994 0 : res_op1 = captures[3];
995 0 : tree res_op2;
996 0 : res_op2 = build_zero_cst (type);
997 0 : tree _r;
998 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
999 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 243, __FILE__, __LINE__, true);
1000 0 : return _r;
1001 : }
1002 : next_after_fail327:;
1003 : }
1004 : }
1005 : return NULL_TREE;
1006 : }
1007 :
1008 : tree
1009 2 : generic_simplify_195 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1010 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1011 : const combined_fn ARG_UNUSED (SQRT_ALL))
1012 : {
1013 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1014 2 : if (flag_unsafe_math_optimizations
1015 : )
1016 : {
1017 2 : if (!tree_expr_maybe_signaling_nan_p (captures[1])
1018 : )
1019 : {
1020 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail335;
1021 2 : {
1022 2 : tree _r;
1023 2 : _r = captures[1];
1024 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 250, __FILE__, __LINE__, true);
1025 2 : return _r;
1026 : }
1027 0 : next_after_fail335:;
1028 : }
1029 : }
1030 : return NULL_TREE;
1031 : }
1032 :
1033 : tree
1034 2 : generic_simplify_201 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1035 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1036 : const combined_fn ARG_UNUSED (POW))
1037 : {
1038 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1039 2 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1040 : )
1041 : {
1042 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail341;
1043 2 : {
1044 2 : tree res_op0;
1045 2 : {
1046 2 : tree _o1[2], _r1;
1047 2 : _o1[0] = captures[1];
1048 2 : _o1[1] = captures[4];
1049 2 : _r1 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1050 2 : res_op0 = _r1;
1051 : }
1052 2 : tree res_op1;
1053 2 : res_op1 = captures[2];
1054 2 : tree _r;
1055 2 : _r = maybe_build_call_expr_loc (loc, POW, type, 2, res_op0, res_op1);
1056 2 : if (!_r)
1057 0 : goto next_after_fail341;
1058 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 256, __FILE__, __LINE__, true);
1059 2 : return _r;
1060 : }
1061 : next_after_fail341:;
1062 : }
1063 : return NULL_TREE;
1064 : }
1065 :
1066 : tree
1067 2528 : generic_simplify_211 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1068 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1069 : const enum tree_code ARG_UNUSED (cmp))
1070 : {
1071 2528 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1072 5056 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1073 3274 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
1074 4194 : && tree_expr_nonzero_p (captures[1])
1075 : )
1076 : {
1077 20 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail354;
1078 20 : {
1079 20 : tree res_op0;
1080 20 : res_op0 = captures[0];
1081 20 : tree res_op1;
1082 20 : res_op1 = captures[2];
1083 20 : tree _r;
1084 20 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1085 20 : if (TREE_SIDE_EFFECTS (captures[1]))
1086 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1087 20 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 268, __FILE__, __LINE__, true);
1088 20 : return _r;
1089 : }
1090 0 : next_after_fail354:;
1091 : }
1092 : return NULL_TREE;
1093 : }
1094 :
1095 : tree
1096 0 : generic_simplify_219 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1097 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1098 : const enum tree_code ARG_UNUSED (op))
1099 : {
1100 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1101 0 : if (!TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[1]))
1102 : )
1103 : {
1104 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail375;
1105 0 : {
1106 0 : tree res_op0;
1107 0 : res_op0 = captures[3];
1108 0 : tree res_op1;
1109 0 : res_op1 = captures[2];
1110 0 : tree _r;
1111 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1112 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1113 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1114 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 289, __FILE__, __LINE__, true);
1115 0 : return _r;
1116 : }
1117 0 : next_after_fail375:;
1118 : }
1119 : return NULL_TREE;
1120 : }
1121 :
1122 : tree
1123 1365 : generic_simplify_223 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1124 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1125 : const enum tree_code ARG_UNUSED (cmp),
1126 : const enum tree_code ARG_UNUSED (ocmp))
1127 : {
1128 1365 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1129 1365 : if (TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1130 374 : && TREE_CODE (TREE_TYPE (captures[0])) != COMPLEX_TYPE
1131 1717 : && (VECTOR_TYPE_P (type) || !VECTOR_TYPE_P (TREE_TYPE (captures[0])))
1132 : )
1133 : {
1134 352 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail379;
1135 352 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail379;
1136 352 : {
1137 352 : tree res_op0;
1138 352 : res_op0 = captures[0];
1139 352 : tree res_op1;
1140 352 : res_op1 = captures[1];
1141 352 : tree _r;
1142 352 : _r = fold_build2_loc (loc, ocmp, type, res_op0, res_op1);
1143 352 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 292, __FILE__, __LINE__, true);
1144 352 : return _r;
1145 : }
1146 : next_after_fail379:;
1147 : }
1148 : return NULL_TREE;
1149 : }
1150 :
1151 : tree
1152 6 : generic_simplify_231 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1153 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1154 : const enum tree_code ARG_UNUSED (cmp),
1155 : const enum tree_code ARG_UNUSED (icmp))
1156 : {
1157 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1158 6 : {
1159 6 : int c1 = wi::clz (wi::to_wide (captures[0]));
1160 6 : int c2 = wi::clz (wi::to_wide (captures[2]));
1161 6 : if (c1 < c2
1162 : )
1163 : {
1164 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail389;
1165 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail389;
1166 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail389;
1167 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail389;
1168 0 : {
1169 0 : tree _r;
1170 0 : _r = constant_boolean_node (cmp == NE_EXPR ? false : true, type);
1171 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1172 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1173 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 302, __FILE__, __LINE__, true);
1174 0 : return _r;
1175 : }
1176 : next_after_fail389:;
1177 : }
1178 : else
1179 : {
1180 6 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail390;
1181 6 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail390;
1182 6 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail390;
1183 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail390;
1184 6 : {
1185 6 : tree res_op0;
1186 6 : res_op0 = captures[1];
1187 6 : tree res_op1;
1188 6 : res_op1 = build_int_cst (TREE_TYPE (captures[1]), c1 - c2);
1189 6 : tree _r;
1190 6 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
1191 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 303, __FILE__, __LINE__, true);
1192 6 : return _r;
1193 : }
1194 : next_after_fail390:;
1195 : }
1196 : }
1197 : return NULL_TREE;
1198 : }
1199 :
1200 : tree
1201 14 : generic_simplify_241 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1202 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1203 : const enum tree_code ARG_UNUSED (cmp),
1204 : const combined_fn ARG_UNUSED (bswap))
1205 : {
1206 14 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1207 14 : {
1208 14 : tree ctype = TREE_TYPE (captures[0]);
1209 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail409;
1210 14 : {
1211 14 : tree res_op0;
1212 14 : {
1213 14 : tree _o1[1], _r1;
1214 14 : _o1[0] = captures[1];
1215 14 : if (TREE_TYPE (_o1[0]) != ctype)
1216 : {
1217 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, ctype, _o1[0]);
1218 : }
1219 : else
1220 : _r1 = _o1[0];
1221 14 : res_op0 = _r1;
1222 : }
1223 14 : tree res_op1;
1224 14 : {
1225 14 : tree _o1[1], _r1;
1226 14 : _o1[0] = captures[2];
1227 14 : if (TREE_TYPE (_o1[0]) != ctype)
1228 : {
1229 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, ctype, _o1[0]);
1230 : }
1231 : else
1232 : _r1 = _o1[0];
1233 14 : res_op1 = _r1;
1234 : }
1235 14 : tree _r;
1236 14 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1237 14 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 322, __FILE__, __LINE__, true);
1238 : return _r;
1239 : }
1240 0 : next_after_fail409:;
1241 : }
1242 0 : return NULL_TREE;
1243 : }
1244 :
1245 : tree
1246 133664 : generic_simplify_249 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1247 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1248 : const enum tree_code ARG_UNUSED (cmp))
1249 : {
1250 133664 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1251 262506 : if (! FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1252 133701 : || ! tree_expr_maybe_nan_p (captures[0])
1253 : )
1254 : {
1255 128879 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail422;
1256 128879 : {
1257 128879 : tree _r;
1258 128879 : _r = constant_boolean_node (true, type);
1259 128879 : if (TREE_SIDE_EFFECTS (captures[0]))
1260 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1261 128879 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 334, __FILE__, __LINE__, true);
1262 128879 : return _r;
1263 : }
1264 0 : next_after_fail422:;
1265 : }
1266 : else
1267 : {
1268 4785 : if (cmp != EQ_EXPR
1269 4785 : && (! FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1270 79 : || ! flag_trapping_math)
1271 : )
1272 : {
1273 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail423;
1274 0 : {
1275 0 : tree res_op0;
1276 0 : res_op0 = unshare_expr (captures[0]);
1277 0 : tree res_op1;
1278 0 : res_op1 = captures[0];
1279 0 : tree _r;
1280 0 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
1281 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 335, __FILE__, __LINE__, true);
1282 0 : return _r;
1283 : }
1284 0 : next_after_fail423:;
1285 : }
1286 : }
1287 : return NULL_TREE;
1288 : }
1289 :
1290 : tree
1291 18944 : generic_simplify_256 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1292 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1293 : const enum tree_code ARG_UNUSED (cmp))
1294 : {
1295 18944 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1296 18944 : if (flag_associative_math
1297 : )
1298 : {
1299 13 : {
1300 13 : tree tem = const_binop (MINUS_EXPR, TREE_TYPE (captures[1]), captures[0], captures[2]);
1301 13 : if (tem && !TREE_OVERFLOW (tem)
1302 : )
1303 : {
1304 13 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail444;
1305 13 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail444;
1306 13 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail444;
1307 13 : {
1308 13 : tree res_op0;
1309 13 : res_op0 = tem;
1310 13 : tree res_op1;
1311 13 : res_op1 = captures[1];
1312 13 : tree _r;
1313 13 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1314 13 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 355, __FILE__, __LINE__, true);
1315 13 : return _r;
1316 : }
1317 : next_after_fail444:;
1318 : }
1319 : }
1320 : }
1321 : return NULL_TREE;
1322 : }
1323 :
1324 : tree
1325 59 : generic_simplify_262 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1326 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1327 : const enum tree_code ARG_UNUSED (cmp),
1328 : const enum tree_code ARG_UNUSED (scmp))
1329 : {
1330 59 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1331 96 : if (FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1332 96 : || (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1333 37 : && (cmp == EQ_EXPR
1334 37 : || cmp == NE_EXPR
1335 36 : || TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))))
1336 : )
1337 : {
1338 23 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail477;
1339 23 : {
1340 23 : tree res_op0;
1341 23 : res_op0 = captures[0];
1342 23 : tree res_op1;
1343 23 : res_op1 = captures[1];
1344 23 : tree _r;
1345 23 : _r = fold_build2_loc (loc, scmp, type, res_op0, res_op1);
1346 23 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 388, __FILE__, __LINE__, true);
1347 23 : return _r;
1348 : }
1349 0 : next_after_fail477:;
1350 : }
1351 : return NULL_TREE;
1352 : }
1353 :
1354 : tree
1355 21532672 : generic_simplify_265 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1356 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1357 : const enum tree_code ARG_UNUSED (cmp))
1358 : {
1359 21532672 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1360 41918483 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1361 15211033 : && !(targetm.have_canonicalize_funcptr_for_compare ()
1362 0 : && ((POINTER_TYPE_P (TREE_TYPE (captures[1]))
1363 0 : && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (captures[1]))))
1364 0 : || (POINTER_TYPE_P (TREE_TYPE (captures[3]))
1365 0 : && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (captures[3]))))))
1366 21532672 : && single_use (captures[0])
1367 : )
1368 : {
1369 15211033 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (TREE_TYPE (captures[0]))
1370 5724577 : && (TREE_CODE (captures[3]) == INTEGER_CST
1371 1971185 : || captures[2] != captures[3])
1372 3753392 : && (TYPE_UNSIGNED (TREE_TYPE (captures[1])) == TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1373 : || cmp == NE_EXPR
1374 1523417 : || cmp == EQ_EXPR)
1375 2696133 : && !POINTER_TYPE_P (TREE_TYPE (captures[1]))
1376 17875165 : && (TREE_CODE (TREE_TYPE (captures[1])) != BOOLEAN_TYPE
1377 1646 : || TREE_CODE (TREE_TYPE (captures[3])) == BOOLEAN_TYPE)
1378 : )
1379 : {
1380 2664104 : if (TREE_CODE (captures[2]) == INTEGER_CST
1381 : )
1382 : {
1383 2664104 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail486;
1384 2664104 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail486;
1385 2664104 : {
1386 2664104 : tree res_op0;
1387 2664104 : res_op0 = captures[1];
1388 2664104 : tree res_op1;
1389 2664104 : res_op1 = force_fit_type (TREE_TYPE (captures[1]),
1390 2664104 : wide_int::from (wi::to_wide (captures[2]),
1391 2664104 : MAX (TYPE_PRECISION (TREE_TYPE (captures[2])),
1392 : TYPE_PRECISION (TREE_TYPE (captures[1]))),
1393 2664104 : TYPE_SIGN (TREE_TYPE (captures[2]))),
1394 2664104 : 0, TREE_OVERFLOW (captures[2]));
1395 2664104 : tree _r;
1396 2664104 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1397 2664104 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 390, __FILE__, __LINE__, true);
1398 2664104 : return _r;
1399 : }
1400 : next_after_fail486:;
1401 : }
1402 : else
1403 : {
1404 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail487;
1405 0 : {
1406 0 : tree res_op0;
1407 0 : res_op0 = captures[1];
1408 0 : tree res_op1;
1409 0 : {
1410 0 : tree _o1[1], _r1;
1411 0 : _o1[0] = captures[2];
1412 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
1413 : {
1414 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
1415 : }
1416 : else
1417 : _r1 = _o1[0];
1418 0 : res_op1 = _r1;
1419 : }
1420 0 : tree _r;
1421 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1422 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 391, __FILE__, __LINE__, true);
1423 0 : return _r;
1424 : }
1425 0 : next_after_fail487:;
1426 : }
1427 : }
1428 : else
1429 : {
1430 12546929 : if (TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (TREE_TYPE (captures[1]))
1431 : )
1432 : {
1433 8549637 : if ((cmp == EQ_EXPR || cmp == NE_EXPR
1434 3299357 : || TYPE_UNSIGNED (TREE_TYPE (captures[0])) == TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1435 570369 : || (!TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1436 485357 : && TYPE_UNSIGNED (TREE_TYPE (captures[1]))))
1437 11763982 : && (types_match (TREE_TYPE (captures[3]), TREE_TYPE (captures[1]))
1438 8464607 : || ((TYPE_PRECISION (TREE_TYPE (captures[1]))
1439 8464607 : >= TYPE_PRECISION (TREE_TYPE (captures[3])))
1440 0 : && (TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1441 0 : == TYPE_UNSIGNED (TREE_TYPE (captures[3]))))
1442 8464607 : || (TREE_CODE (captures[2]) == INTEGER_CST
1443 7338721 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1444 7338721 : && int_fits_type_p (captures[2], TREE_TYPE (captures[1]))))
1445 : )
1446 : {
1447 7298271 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail488;
1448 7298271 : {
1449 7298271 : tree res_op0;
1450 7298271 : res_op0 = captures[1];
1451 7298271 : tree res_op1;
1452 7298271 : {
1453 7298271 : tree _o1[1], _r1;
1454 7298271 : _o1[0] = captures[3];
1455 7298271 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
1456 : {
1457 7298253 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
1458 : }
1459 : else
1460 : _r1 = _o1[0];
1461 7298271 : res_op1 = _r1;
1462 : }
1463 7298271 : tree _r;
1464 7298271 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1465 7298271 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 392, __FILE__, __LINE__, true);
1466 7298271 : return _r;
1467 : }
1468 0 : next_after_fail488:;
1469 : }
1470 : else
1471 : {
1472 1251366 : if (TREE_CODE (captures[2]) == INTEGER_CST
1473 89823 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1474 1341189 : && !int_fits_type_p (captures[2], TREE_TYPE (captures[1]))
1475 : )
1476 : {
1477 43890 : {
1478 43890 : tree min = lower_bound_in_type (TREE_TYPE (captures[3]), TREE_TYPE (captures[1]));
1479 43890 : tree max = upper_bound_in_type (TREE_TYPE (captures[3]), TREE_TYPE (captures[1]));
1480 43890 : bool above = integer_nonzerop (const_binop (LT_EXPR, type, max, captures[2]));
1481 43890 : bool below = integer_nonzerop (const_binop (LT_EXPR, type, captures[2], min));
1482 43890 : if (above || below
1483 : )
1484 : {
1485 37808 : if (cmp == EQ_EXPR || cmp == NE_EXPR
1486 : )
1487 : {
1488 24898 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail489;
1489 24898 : {
1490 24898 : tree _r;
1491 24898 : _r = constant_boolean_node (cmp == EQ_EXPR ? false : true, type);
1492 24898 : if (TREE_SIDE_EFFECTS (captures[1]))
1493 10 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1494 24898 : if (TREE_SIDE_EFFECTS (captures[2]))
1495 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1496 24898 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 393, __FILE__, __LINE__, true);
1497 24898 : return _r;
1498 : }
1499 0 : next_after_fail489:;
1500 : }
1501 : else
1502 : {
1503 12910 : if (cmp == LT_EXPR || cmp == LE_EXPR
1504 : )
1505 : {
1506 12238 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail490;
1507 12238 : {
1508 12238 : tree _r;
1509 12238 : _r = constant_boolean_node (above ? true : false, type);
1510 12238 : if (TREE_SIDE_EFFECTS (captures[1]))
1511 10 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1512 12238 : if (TREE_SIDE_EFFECTS (captures[2]))
1513 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1514 12238 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 394, __FILE__, __LINE__, true);
1515 12238 : return _r;
1516 : }
1517 0 : next_after_fail490:;
1518 : }
1519 : else
1520 : {
1521 672 : if (cmp == GT_EXPR || cmp == GE_EXPR
1522 : )
1523 : {
1524 672 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail491;
1525 672 : {
1526 672 : tree _r;
1527 926 : _r = constant_boolean_node (above ? false : true, type);
1528 672 : if (TREE_SIDE_EFFECTS (captures[1]))
1529 4 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1530 672 : if (TREE_SIDE_EFFECTS (captures[2]))
1531 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1532 672 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 395, __FILE__, __LINE__, true);
1533 672 : return _r;
1534 : }
1535 0 : next_after_fail491:;
1536 : }
1537 : }
1538 : }
1539 : }
1540 : }
1541 : }
1542 : }
1543 : }
1544 : }
1545 : }
1546 : else
1547 : {
1548 12114356 : if (FLOAT_TYPE_P (TREE_TYPE (captures[1]))
1549 1084782 : && (DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1550 542391 : == DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[1])))
1551 7406183 : && (DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1552 542272 : == DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[3])))
1553 : )
1554 : {
1555 542272 : {
1556 542272 : tree type1 = TREE_TYPE (captures[3]);
1557 542272 : if (TREE_CODE (captures[3]) == REAL_CST && !DECIMAL_FLOAT_TYPE_P (type1))
1558 : {
1559 340177 : REAL_VALUE_TYPE orig = TREE_REAL_CST (captures[3]);
1560 340177 : if (TYPE_PRECISION (type1) > TYPE_PRECISION (float_type_node)
1561 340177 : && exact_real_truncate (TYPE_MODE (float_type_node), &orig))
1562 176033 : type1 = float_type_node;
1563 340177 : if (TYPE_PRECISION (type1) > TYPE_PRECISION (double_type_node)
1564 340177 : && exact_real_truncate (TYPE_MODE (double_type_node), &orig))
1565 292 : type1 = double_type_node;
1566 : }
1567 542272 : tree newtype
1568 542272 : = (element_precision (TREE_TYPE (captures[1])) > element_precision (type1)
1569 542272 : ? TREE_TYPE (captures[1]) : type1);
1570 542272 : if (element_precision (TREE_TYPE (captures[0])) > element_precision (newtype)
1571 542272 : && (!VECTOR_TYPE_P (type) || is_truth_type_for (newtype, type))
1572 : )
1573 : {
1574 44498 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail492;
1575 44498 : {
1576 44498 : tree res_op0;
1577 44498 : {
1578 44498 : tree _o1[1], _r1;
1579 44498 : _o1[0] = captures[1];
1580 44498 : if (TREE_TYPE (_o1[0]) != newtype)
1581 : {
1582 11436 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
1583 : }
1584 : else
1585 : _r1 = _o1[0];
1586 44498 : res_op0 = _r1;
1587 : }
1588 44498 : tree res_op1;
1589 44498 : {
1590 44498 : tree _o1[1], _r1;
1591 44498 : _o1[0] = captures[3];
1592 44498 : if (TREE_TYPE (_o1[0]) != newtype)
1593 : {
1594 44498 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
1595 : }
1596 : else
1597 : _r1 = _o1[0];
1598 44498 : res_op1 = _r1;
1599 : }
1600 44498 : tree _r;
1601 44498 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1602 44498 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 396, __FILE__, __LINE__, true);
1603 44498 : return _r;
1604 : }
1605 0 : next_after_fail492:;
1606 : }
1607 : }
1608 : }
1609 : }
1610 : return NULL_TREE;
1611 : }
1612 :
1613 : tree
1614 0 : generic_simplify_294 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1615 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1616 : const enum tree_code ARG_UNUSED (op))
1617 : {
1618 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1619 0 : {
1620 0 : HOST_WIDE_INT zero_val = tree_to_shwi (captures[2]);
1621 0 : tree type0 = TREE_TYPE (captures[1]);
1622 0 : int prec = TYPE_PRECISION (type0);
1623 0 : if (prec <= MAX_FIXED_MODE_SIZE
1624 : )
1625 : {
1626 0 : if (tree_int_cst_sgn (captures[3]) < 0 || wi::to_widest (captures[3]) >= prec
1627 : )
1628 : {
1629 0 : if (zero_val != wi::to_widest (captures[3])
1630 : )
1631 : {
1632 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail554;
1633 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail554;
1634 0 : {
1635 0 : tree _r;
1636 0 : _r = constant_boolean_node (op == EQ_EXPR ? false : true, type);
1637 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1638 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1639 0 : if (TREE_SIDE_EFFECTS (captures[3]))
1640 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
1641 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 448, __FILE__, __LINE__, true);
1642 0 : return _r;
1643 : }
1644 0 : next_after_fail554:;
1645 : }
1646 : }
1647 : else
1648 : {
1649 0 : if (zero_val < 0 || zero_val >= prec
1650 : )
1651 : {
1652 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail555;
1653 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail555;
1654 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail555;
1655 0 : {
1656 0 : tree res_op0;
1657 0 : {
1658 0 : tree _o1[2], _r1;
1659 0 : _o1[0] = captures[1];
1660 0 : _o1[1] = wide_int_to_tree (type0,
1661 0 : wi::mask (tree_to_uhwi (captures[3]) + 1,
1662 : false, prec));
1663 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1664 0 : res_op0 = _r1;
1665 : }
1666 0 : tree res_op1;
1667 0 : res_op1 = wide_int_to_tree (type0,
1668 0 : wi::shifted_mask (tree_to_uhwi (captures[3]), 1,
1669 : false, prec));
1670 0 : tree _r;
1671 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1672 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 449, __FILE__, __LINE__, true);
1673 0 : return _r;
1674 : }
1675 0 : next_after_fail555:;
1676 : }
1677 : }
1678 : }
1679 : }
1680 0 : return NULL_TREE;
1681 : }
1682 :
1683 : tree
1684 0 : generic_simplify_306 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1685 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1686 : const combined_fn ARG_UNUSED (COPYSIGN_ALL))
1687 : {
1688 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1689 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail570;
1690 0 : {
1691 0 : tree res_op0;
1692 0 : res_op0 = captures[0];
1693 0 : tree _r;
1694 0 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
1695 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1696 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1697 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 464, __FILE__, __LINE__, true);
1698 : return _r;
1699 : }
1700 0 : next_after_fail570:;
1701 0 : return NULL_TREE;
1702 : }
1703 :
1704 : tree
1705 1 : generic_simplify_313 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1706 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1707 : const enum tree_code ARG_UNUSED (div))
1708 : {
1709 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1710 1 : if (INTEGRAL_TYPE_P (type)
1711 1 : && TYPE_OVERFLOW_UNDEFINED (type)
1712 1 : && !integer_zerop (captures[0])
1713 2 : && (!flag_non_call_exceptions || tree_expr_nonzero_p (captures[0]))
1714 : )
1715 : {
1716 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail579;
1717 1 : {
1718 1 : tree res_op0;
1719 1 : {
1720 1 : tree _o1[2], _r1;
1721 1 : _o1[0] = captures[0];
1722 1 : _o1[1] = build_zero_cst (type);
1723 1 : _r1 = fold_build2_loc (loc, LT_EXPR, boolean_type_node, _o1[0], _o1[1]);
1724 1 : res_op0 = _r1;
1725 : }
1726 1 : tree res_op1;
1727 1 : res_op1 = build_minus_one_cst (type);
1728 1 : tree res_op2;
1729 1 : res_op2 = build_one_cst (type);
1730 1 : tree _r;
1731 1 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
1732 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 471, __FILE__, __LINE__, true);
1733 1 : return _r;
1734 : }
1735 0 : next_after_fail579:;
1736 : }
1737 : return NULL_TREE;
1738 : }
1739 :
1740 : tree
1741 2360336 : generic_simplify_320 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1742 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1743 : const enum tree_code ARG_UNUSED (floor_divmod),
1744 : const enum tree_code ARG_UNUSED (trunc_divmod))
1745 : {
1746 2360336 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1747 0 : if ((INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
1748 2360336 : && TYPE_UNSIGNED (type)
1749 : )
1750 : {
1751 2351175 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail587;
1752 2351175 : {
1753 2351175 : tree res_op0;
1754 2351175 : res_op0 = captures[0];
1755 2351175 : tree res_op1;
1756 2351175 : res_op1 = captures[1];
1757 2351175 : tree _r;
1758 2351175 : _r = fold_build2_loc (loc, trunc_divmod, type, res_op0, res_op1);
1759 2351175 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 479, __FILE__, __LINE__, true);
1760 2351175 : return _r;
1761 : }
1762 0 : next_after_fail587:;
1763 : }
1764 : return NULL_TREE;
1765 : }
1766 :
1767 : tree
1768 52 : generic_simplify_325 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1769 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1770 : const enum tree_code ARG_UNUSED (mod))
1771 : {
1772 52 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1773 52 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail592;
1774 52 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail592;
1775 52 : {
1776 52 : tree _r;
1777 52 : _r = captures[0];
1778 52 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 484, __FILE__, __LINE__, true);
1779 : return _r;
1780 : }
1781 : next_after_fail592:;
1782 : return NULL_TREE;
1783 : }
1784 :
1785 : tree
1786 5 : generic_simplify_333 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1787 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1788 : const combined_fn ARG_UNUSED (SINH),
1789 : const combined_fn ARG_UNUSED (COSH),
1790 : const combined_fn ARG_UNUSED (TANH))
1791 : {
1792 5 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1793 5 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1794 : )
1795 : {
1796 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail602;
1797 3 : {
1798 3 : tree res_op0;
1799 3 : res_op0 = captures[1];
1800 3 : tree _r;
1801 3 : _r = maybe_build_call_expr_loc (loc, TANH, type, 1, res_op0);
1802 3 : if (!_r)
1803 0 : goto next_after_fail602;
1804 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 494, __FILE__, __LINE__, true);
1805 3 : return _r;
1806 : }
1807 : next_after_fail602:;
1808 : }
1809 : return NULL_TREE;
1810 : }
1811 :
1812 : tree
1813 155769 : generic_simplify_340 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1814 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1815 : const enum tree_code ARG_UNUSED (cmp))
1816 : {
1817 155769 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1818 155769 : {
1819 155769 : tree from_type = TREE_TYPE (captures[0]);
1820 155769 : tree c1_type = TREE_TYPE (captures[1]), c2_type = TREE_TYPE (captures[2]);
1821 155769 : enum tree_code code = ERROR_MARK;
1822 155769 : if (integer_zerop (captures[1])
1823 61283 : && INTEGRAL_TYPE_P (from_type)
1824 60793 : && (cmp == GE_EXPR || cmp == LT_EXPR)
1825 16111 : && TYPE_UNSIGNED (from_type)
1826 2064 : && !TYPE_UNSIGNED (c1_type)
1827 2064 : && TYPE_PRECISION (from_type) == TYPE_PRECISION (c1_type)
1828 587 : && int_fits_type_p (captures[2], from_type)
1829 156356 : && (types_match (c2_type, from_type)
1830 0 : || (TYPE_PRECISION (c2_type) > TYPE_PRECISION (from_type)
1831 0 : && (TYPE_UNSIGNED (from_type)
1832 0 : || TYPE_SIGN (c2_type) == TYPE_SIGN (from_type)))))
1833 : {
1834 587 : tree_code ncmp = cmp == GE_EXPR ? LE_EXPR : GT_EXPR;
1835 587 : widest_int c1 = wi::mask<widest_int>(TYPE_PRECISION (type) - 1, 0);
1836 587 : code = minmax_from_comparison (ncmp, captures[0], c1, wi::to_widest (captures[2]));
1837 587 : }
1838 587 : if (code == ERROR_MARK
1839 155764 : && INTEGRAL_TYPE_P (from_type)
1840 155274 : && int_fits_type_p (captures[2], from_type)
1841 155273 : && (types_match (c1_type, from_type)
1842 5916 : || (TYPE_PRECISION (c1_type) > TYPE_PRECISION (from_type)
1843 0 : && (TYPE_UNSIGNED (from_type)
1844 0 : || TYPE_SIGN (c1_type) == TYPE_SIGN (from_type))))
1845 149944 : && (types_match (c2_type, from_type)
1846 58080 : || (TYPE_PRECISION (c2_type) > TYPE_PRECISION (from_type)
1847 18759 : && (TYPE_UNSIGNED (from_type)
1848 698 : || TYPE_SIGN (c2_type) == TYPE_SIGN (from_type)))))
1849 : {
1850 109426 : if (cmp != EQ_EXPR)
1851 109414 : code = minmax_from_comparison (cmp, captures[0], captures[1], captures[0], captures[2]);
1852 12 : else if (int_fits_type_p (captures[1], from_type))
1853 : code = EQ_EXPR;
1854 : }
1855 155757 : if (code == MAX_EXPR
1856 : )
1857 : {
1858 19344 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail609;
1859 19344 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail609;
1860 19344 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail609;
1861 19344 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail609;
1862 19344 : {
1863 19344 : tree res_op0;
1864 19344 : {
1865 19344 : tree _o1[2], _r1;
1866 19344 : _o1[0] = captures[0];
1867 19344 : {
1868 19344 : tree _o2[1], _r2;
1869 19344 : _o2[0] = captures[2];
1870 19344 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
1871 : {
1872 266 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
1873 : }
1874 : else
1875 : _r2 = _o2[0];
1876 19344 : _o1[1] = _r2;
1877 : }
1878 19344 : _r1 = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1879 19344 : res_op0 = _r1;
1880 : }
1881 19344 : tree _r;
1882 19344 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1883 19344 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 501, __FILE__, __LINE__, true);
1884 19344 : return _r;
1885 : }
1886 : next_after_fail609:;
1887 : }
1888 : else
1889 : {
1890 136425 : if (code == MIN_EXPR
1891 : )
1892 : {
1893 255 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail610;
1894 255 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail610;
1895 255 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail610;
1896 255 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail610;
1897 255 : {
1898 255 : tree res_op0;
1899 255 : {
1900 255 : tree _o1[2], _r1;
1901 255 : _o1[0] = captures[0];
1902 255 : {
1903 255 : tree _o2[1], _r2;
1904 255 : _o2[0] = captures[2];
1905 255 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
1906 : {
1907 100 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
1908 : }
1909 : else
1910 : _r2 = _o2[0];
1911 255 : _o1[1] = _r2;
1912 : }
1913 255 : _r1 = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1914 255 : res_op0 = _r1;
1915 : }
1916 255 : tree _r;
1917 255 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1918 255 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 502, __FILE__, __LINE__, true);
1919 255 : return _r;
1920 : }
1921 : next_after_fail610:;
1922 : }
1923 : else
1924 : {
1925 136170 : if (code == EQ_EXPR
1926 : )
1927 : {
1928 12 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail611;
1929 12 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail611;
1930 12 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail611;
1931 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail611;
1932 12 : {
1933 12 : if (! tree_invariant_p (captures[1])) goto next_after_fail611;
1934 12 : tree res_op0;
1935 12 : {
1936 12 : tree _o1[3], _r1;
1937 12 : {
1938 12 : tree _o2[2], _r2;
1939 12 : _o2[0] = captures[0];
1940 12 : {
1941 12 : tree _o3[1], _r3;
1942 12 : _o3[0] = unshare_expr (captures[1]);
1943 12 : if (TREE_TYPE (_o3[0]) != TREE_TYPE (_o2[0]))
1944 : {
1945 0 : _r3 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o2[0]), _o3[0]);
1946 : }
1947 : else
1948 : _r3 = _o3[0];
1949 12 : _o2[1] = _r3;
1950 : }
1951 12 : _r2 = fold_build2_loc (loc, EQ_EXPR, boolean_type_node, _o2[0], _o2[1]);
1952 12 : _o1[0] = _r2;
1953 : }
1954 12 : {
1955 12 : tree _o2[1], _r2;
1956 12 : _o2[0] = captures[1];
1957 12 : if (TREE_TYPE (_o2[0]) != from_type)
1958 : {
1959 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, from_type, _o2[0]);
1960 : }
1961 : else
1962 : _r2 = _o2[0];
1963 12 : _o1[1] = _r2;
1964 : }
1965 12 : {
1966 12 : tree _o2[1], _r2;
1967 12 : _o2[0] = captures[2];
1968 12 : if (TREE_TYPE (_o2[0]) != from_type)
1969 : {
1970 7 : _r2 = fold_build1_loc (loc, NOP_EXPR, from_type, _o2[0]);
1971 : }
1972 : else
1973 : _r2 = _o2[0];
1974 12 : _o1[2] = _r2;
1975 : }
1976 12 : _r1 = fold_build3_loc (loc, COND_EXPR, TREE_TYPE (_o1[1]), _o1[0], _o1[1], _o1[2]);
1977 12 : res_op0 = _r1;
1978 : }
1979 12 : tree _r;
1980 12 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1981 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 503, __FILE__, __LINE__, true);
1982 12 : return _r;
1983 : }
1984 : next_after_fail611:;
1985 : }
1986 : }
1987 : }
1988 : }
1989 : return NULL_TREE;
1990 : }
1991 :
1992 : tree
1993 10154292 : generic_simplify_381 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1994 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1995 : const enum tree_code ARG_UNUSED (cmp),
1996 : const enum tree_code ARG_UNUSED (acmp))
1997 : {
1998 10154292 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1999 10154292 : {
2000 10154292 : tree cst = uniform_integer_cst_p (captures[1]);
2001 10154292 : if (tree_int_cst_sgn (cst) == 1
2002 : )
2003 : {
2004 4102549 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail662;
2005 4102549 : {
2006 4102549 : tree res_op0;
2007 4102549 : res_op0 = captures[0];
2008 4102549 : tree res_op1;
2009 4102549 : res_op1 = build_uniform_cst (TREE_TYPE (captures[1]),
2010 4102549 : wide_int_to_tree (TREE_TYPE (cst),
2011 4102549 : wi::to_wide (cst) - 1));
2012 4102549 : tree _r;
2013 4102549 : _r = fold_build2_loc (loc, acmp, type, res_op0, res_op1);
2014 4102549 : if (TREE_SIDE_EFFECTS (captures[1]))
2015 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2016 4102549 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 552, __FILE__, __LINE__, true);
2017 4102549 : return _r;
2018 : }
2019 0 : next_after_fail662:;
2020 : }
2021 : }
2022 : return NULL_TREE;
2023 : }
2024 :
2025 : tree
2026 2 : generic_simplify_389 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2027 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2028 : const enum tree_code ARG_UNUSED (cmp))
2029 : {
2030 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2031 4 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2032 4 : && TYPE_UNSIGNED (TREE_TYPE (captures[0]))
2033 : )
2034 : {
2035 2 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail702;
2036 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail702;
2037 2 : {
2038 2 : tree res_op0;
2039 2 : res_op0 = captures[1];
2040 2 : tree res_op1;
2041 2 : res_op1 = captures[0];
2042 2 : tree _r;
2043 2 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2044 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 575, __FILE__, __LINE__, true);
2045 2 : return _r;
2046 : }
2047 : next_after_fail702:;
2048 : }
2049 : return NULL_TREE;
2050 : }
2051 :
2052 : tree
2053 2582241 : generic_simplify_394 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2054 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2055 : const enum tree_code ARG_UNUSED (op),
2056 : const enum tree_code ARG_UNUSED (rop),
2057 : const enum tree_code ARG_UNUSED (cmp),
2058 : const enum tree_code ARG_UNUSED (rcmp))
2059 : {
2060 2582241 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2061 5164468 : if (!TREE_OVERFLOW (captures[2]) && !TREE_OVERFLOW (captures[3])
2062 5164456 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
2063 : )
2064 : {
2065 877809 : {
2066 877809 : tree res = int_const_binop (rop, captures[3], captures[2]);
2067 877809 : if (TREE_OVERFLOW (res)
2068 : )
2069 : {
2070 12613 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail708;
2071 12613 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail708;
2072 12613 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail708;
2073 12613 : {
2074 12613 : tree _r;
2075 12613 : bool less = cmp == LE_EXPR || cmp == LT_EXPR;
2076 12613 : bool ovf_high = wi::lt_p (wi::to_wide (captures[2]), 0,
2077 12613 : TYPE_SIGN (TREE_TYPE (captures[2])))
2078 12613 : != (op == MINUS_EXPR); _r =
2079 12613 : constant_boolean_node (less == ovf_high, type);
2080 12613 : if (TREE_SIDE_EFFECTS (captures[1]))
2081 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2082 12613 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 581, __FILE__, __LINE__, true);
2083 12613 : return _r;
2084 : }
2085 : next_after_fail708:;
2086 : }
2087 : else
2088 : {
2089 865196 : if (single_use (captures[0])
2090 : )
2091 : {
2092 865196 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail709;
2093 865196 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail709;
2094 865196 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail709;
2095 865196 : {
2096 865196 : tree res_op0;
2097 865196 : res_op0 = captures[1];
2098 865196 : tree res_op1;
2099 865196 : res_op1 = res;
2100 865196 : tree _r;
2101 865196 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2102 865196 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 582, __FILE__, __LINE__, true);
2103 865196 : return _r;
2104 : }
2105 : next_after_fail709:;
2106 : }
2107 : }
2108 : }
2109 : }
2110 : else
2111 : {
2112 1704432 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))
2113 : )
2114 : {
2115 1704309 : {
2116 1704309 : wide_int max = wi::max_value (TREE_TYPE (captures[1]));
2117 1704309 : wide_int min = wi::min_value (TREE_TYPE (captures[1]));
2118 1704309 : wide_int c2 = rop == PLUS_EXPR
2119 1704309 : ? wi::add (wi::to_wide (captures[3]), wi::to_wide (captures[2]))
2120 1704309 : : wi::sub (wi::to_wide (captures[3]), wi::to_wide (captures[2]));
2121 1632061 : if (((cmp == LE_EXPR || cmp == GT_EXPR) && wi::eq_p (c2, max))
2122 3317531 : || ((cmp == LT_EXPR || cmp == GE_EXPR) && wi::eq_p (c2, min))
2123 : )
2124 : {
2125 18997 : {
2126 18997 : wide_int c1 = rop == PLUS_EXPR
2127 18997 : ? wi::add (wi::bit_not (c2), wi::to_wide (captures[2]))
2128 37994 : : wi::sub (wi::bit_not (c2), wi::to_wide (captures[2]));
2129 18997 : tree c1_cst = wide_int_to_tree (TREE_TYPE (captures[1]), c1);
2130 18997 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail710;
2131 18997 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail710;
2132 18997 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail710;
2133 18997 : {
2134 18997 : tree res_op0;
2135 18997 : res_op0 = captures[1];
2136 18997 : tree res_op1;
2137 18997 : res_op1 = c1_cst;
2138 18997 : tree _r;
2139 18997 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
2140 18997 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 583, __FILE__, __LINE__, true);
2141 18997 : return _r;
2142 : }
2143 0 : next_after_fail710:;
2144 18997 : }
2145 : }
2146 1704311 : }
2147 : }
2148 : }
2149 : return NULL_TREE;
2150 : }
2151 :
2152 : tree
2153 330 : generic_simplify_412 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2154 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2155 : const enum tree_code ARG_UNUSED (shiftrotate))
2156 : {
2157 330 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2158 330 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail736;
2159 330 : {
2160 330 : tree _r;
2161 330 : _r = captures[0];
2162 330 : if (TREE_SIDE_EFFECTS (captures[1]))
2163 42 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2164 330 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 605, __FILE__, __LINE__, true);
2165 : return _r;
2166 : }
2167 0 : next_after_fail736:;
2168 0 : return NULL_TREE;
2169 : }
2170 :
2171 : tree
2172 27318 : generic_simplify_417 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2173 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2174 : const enum tree_code ARG_UNUSED (bit_op),
2175 : const enum tree_code ARG_UNUSED (shift))
2176 : {
2177 27318 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2178 27318 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[2]))
2179 : )
2180 : {
2181 27318 : {
2182 27318 : tree mask = int_const_binop (shift, fold_convert (type, captures[3]), captures[4]);
2183 27318 : if (mask
2184 : )
2185 : {
2186 27311 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail744;
2187 27311 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail744;
2188 27311 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail744;
2189 27311 : {
2190 27311 : tree res_op0;
2191 27311 : {
2192 27311 : tree _o1[2], _r1;
2193 27311 : {
2194 27311 : tree _o2[1], _r2;
2195 27311 : _o2[0] = captures[2];
2196 27311 : if (TREE_TYPE (_o2[0]) != type)
2197 : {
2198 70 : _r2 = fold_build1_loc (loc, NOP_EXPR, type, _o2[0]);
2199 : }
2200 : else
2201 : _r2 = _o2[0];
2202 27311 : _o1[0] = _r2;
2203 : }
2204 27311 : _o1[1] = captures[4];
2205 27311 : _r1 = fold_build2_loc (loc, shift, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2206 27311 : res_op0 = _r1;
2207 : }
2208 27311 : tree res_op1;
2209 27311 : res_op1 = mask;
2210 27311 : tree _r;
2211 27311 : _r = fold_build2_loc (loc, bit_op, type, res_op0, res_op1);
2212 27311 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 611, __FILE__, __LINE__, true);
2213 27311 : return _r;
2214 : }
2215 : next_after_fail744:;
2216 : }
2217 : }
2218 : }
2219 : return NULL_TREE;
2220 : }
2221 :
2222 : tree
2223 7083 : generic_simplify_423 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2224 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2225 : const enum tree_code ARG_UNUSED (minmax))
2226 : {
2227 7083 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2228 7083 : if (INTEGRAL_TYPE_P (type)
2229 7083 : && types_match (captures[1], type) && int_fits_type_p (captures[2], type)
2230 624 : && TYPE_SIGN (TREE_TYPE (captures[0])) == TYPE_SIGN (type)
2231 7083 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (type)
2232 : )
2233 : {
2234 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail756;
2235 0 : {
2236 0 : tree res_op0;
2237 0 : res_op0 = captures[1];
2238 0 : tree res_op1;
2239 0 : {
2240 0 : tree _o1[1], _r1;
2241 0 : _o1[0] = captures[2];
2242 0 : if (TREE_TYPE (_o1[0]) != type)
2243 : {
2244 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2245 : }
2246 : else
2247 : _r1 = _o1[0];
2248 0 : res_op1 = _r1;
2249 : }
2250 0 : tree _r;
2251 0 : _r = fold_build2_loc (loc, minmax, type, res_op0, res_op1);
2252 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 623, __FILE__, __LINE__, true);
2253 0 : return _r;
2254 : }
2255 0 : next_after_fail756:;
2256 : }
2257 : return NULL_TREE;
2258 : }
2259 :
2260 : tree
2261 2505508 : generic_simplify_426 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2262 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2263 : const enum tree_code ARG_UNUSED (op))
2264 : {
2265 2505508 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2266 2505508 : if (INTEGRAL_TYPE_P (type)
2267 2052851 : && op != MULT_EXPR
2268 2052851 : && op != RDIV_EXPR
2269 1363307 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2270 1363307 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2271 1363307 : && type_has_mode_precision_p (TREE_TYPE (captures[2]))
2272 1362932 : && type_has_mode_precision_p (TREE_TYPE (captures[4]))
2273 1362178 : && type_has_mode_precision_p (type)
2274 1358325 : && TYPE_PRECISION (TREE_TYPE (captures[1])) > TYPE_PRECISION (TREE_TYPE (captures[2]))
2275 0 : && types_match (captures[2], type)
2276 2505508 : && (types_match (captures[2], captures[4])
2277 0 : || poly_int_tree_p (captures[3]))
2278 : )
2279 : {
2280 0 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))
2281 : )
2282 : {
2283 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail765;
2284 0 : {
2285 0 : tree res_op0;
2286 0 : res_op0 = captures[2];
2287 0 : tree res_op1;
2288 0 : {
2289 0 : tree _o1[1], _r1;
2290 0 : _o1[0] = captures[4];
2291 0 : if (TREE_TYPE (_o1[0]) != type)
2292 : {
2293 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2294 : }
2295 : else
2296 : _r1 = _o1[0];
2297 0 : res_op1 = _r1;
2298 : }
2299 0 : tree _r;
2300 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2301 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 624, __FILE__, __LINE__, true);
2302 0 : return _r;
2303 : }
2304 0 : next_after_fail765:;
2305 : }
2306 : else
2307 : {
2308 0 : {
2309 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
2310 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail766;
2311 0 : {
2312 0 : tree res_op0;
2313 0 : {
2314 0 : tree _o1[2], _r1;
2315 0 : {
2316 0 : tree _o2[1], _r2;
2317 0 : _o2[0] = captures[2];
2318 0 : if (TREE_TYPE (_o2[0]) != utype)
2319 : {
2320 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2321 : }
2322 : else
2323 : _r2 = _o2[0];
2324 0 : _o1[0] = _r2;
2325 : }
2326 0 : {
2327 0 : tree _o2[1], _r2;
2328 0 : _o2[0] = captures[4];
2329 0 : if (TREE_TYPE (_o2[0]) != utype)
2330 : {
2331 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2332 : }
2333 : else
2334 : _r2 = _o2[0];
2335 0 : _o1[1] = _r2;
2336 : }
2337 0 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2338 0 : res_op0 = _r1;
2339 : }
2340 0 : tree _r;
2341 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2342 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 625, __FILE__, __LINE__, true);
2343 0 : return _r;
2344 : }
2345 0 : next_after_fail766:;
2346 : }
2347 : }
2348 : }
2349 : else
2350 : {
2351 2493445 : if (FLOAT_TYPE_P (type)
2352 2517571 : && DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
2353 12063 : == DECIMAL_FLOAT_TYPE_P (type)
2354 : )
2355 : {
2356 12040 : {
2357 12040 : tree arg0 = strip_float_extensions (captures[2]);
2358 12040 : tree arg1 = strip_float_extensions (captures[4]);
2359 12040 : tree itype = TREE_TYPE (captures[0]);
2360 12040 : tree ty1 = TREE_TYPE (arg0);
2361 12040 : tree ty2 = TREE_TYPE (arg1);
2362 12040 : enum tree_code code = TREE_CODE (itype);
2363 0 : if (FLOAT_TYPE_P (ty1)
2364 12040 : && FLOAT_TYPE_P (ty2)
2365 : )
2366 : {
2367 12040 : {
2368 12040 : tree newtype = type;
2369 12040 : if (TYPE_MODE (ty1) == SDmode
2370 12031 : || TYPE_MODE (ty2) == SDmode
2371 24071 : || TYPE_MODE (type) == SDmode)
2372 9 : newtype = dfloat32_type_node;
2373 12040 : if (TYPE_MODE (ty1) == DDmode
2374 12034 : || TYPE_MODE (ty2) == DDmode
2375 24074 : || TYPE_MODE (type) == DDmode)
2376 6 : newtype = dfloat64_type_node;
2377 12040 : if (TYPE_MODE (ty1) == TDmode
2378 12040 : || TYPE_MODE (ty2) == TDmode
2379 24080 : || TYPE_MODE (type) == TDmode)
2380 15 : newtype = dfloat128_type_node;
2381 12040 : if ((newtype == dfloat32_type_node
2382 12040 : || newtype == dfloat64_type_node
2383 12040 : || newtype == dfloat128_type_node)
2384 15 : && newtype == type
2385 12046 : && types_match (newtype, type)
2386 : )
2387 : {
2388 6 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail767;
2389 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail767;
2390 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail767;
2391 0 : {
2392 0 : tree res_op0;
2393 0 : {
2394 0 : tree _o1[1], _r1;
2395 0 : _o1[0] = captures[2];
2396 0 : if (TREE_TYPE (_o1[0]) != newtype)
2397 : {
2398 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
2399 : }
2400 : else
2401 : _r1 = _o1[0];
2402 0 : res_op0 = _r1;
2403 : }
2404 0 : tree res_op1;
2405 0 : {
2406 0 : tree _o1[1], _r1;
2407 0 : _o1[0] = captures[4];
2408 0 : if (TREE_TYPE (_o1[0]) != newtype)
2409 : {
2410 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
2411 : }
2412 : else
2413 : _r1 = _o1[0];
2414 0 : res_op1 = _r1;
2415 : }
2416 0 : tree _r;
2417 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2418 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 626, __FILE__, __LINE__, true);
2419 0 : return _r;
2420 : }
2421 : next_after_fail767:;
2422 : }
2423 : else
2424 : {
2425 12034 : {
2426 12034 : if (element_precision (ty1) > element_precision (newtype))
2427 745 : newtype = ty1;
2428 12034 : if (element_precision (ty2) > element_precision (newtype))
2429 1 : newtype = ty2;
2430 12034 : if (element_precision (newtype) < element_precision (itype)
2431 10736 : && (!VECTOR_MODE_P (TYPE_MODE (newtype))
2432 0 : || target_supports_op_p (newtype, op, optab_default))
2433 10736 : && (flag_unsafe_math_optimizations
2434 10724 : || (element_precision (newtype) == element_precision (type)
2435 10720 : && real_can_shorten_arithmetic (element_mode (itype),
2436 : element_mode (type))
2437 3878 : && !excess_precision_type (newtype)))
2438 12707 : && !types_match (itype, newtype)
2439 : )
2440 : {
2441 673 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail768;
2442 673 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail768;
2443 655 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail768;
2444 655 : {
2445 655 : tree res_op0;
2446 655 : {
2447 655 : tree _o1[2], _r1;
2448 655 : {
2449 655 : tree _o2[1], _r2;
2450 655 : _o2[0] = captures[2];
2451 655 : if (TREE_TYPE (_o2[0]) != newtype)
2452 : {
2453 655 : _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
2454 : }
2455 : else
2456 : _r2 = _o2[0];
2457 655 : _o1[0] = _r2;
2458 : }
2459 655 : {
2460 655 : tree _o2[1], _r2;
2461 655 : _o2[0] = captures[4];
2462 655 : if (TREE_TYPE (_o2[0]) != newtype)
2463 : {
2464 604 : _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
2465 : }
2466 : else
2467 : _r2 = _o2[0];
2468 655 : _o1[1] = _r2;
2469 : }
2470 655 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2471 655 : res_op0 = _r1;
2472 : }
2473 655 : tree _r;
2474 655 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2475 655 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 627, __FILE__, __LINE__, true);
2476 655 : return _r;
2477 : }
2478 : next_after_fail768:;
2479 : }
2480 : }
2481 : }
2482 : }
2483 : }
2484 : }
2485 : }
2486 : }
2487 : return NULL_TREE;
2488 : }
2489 :
2490 : tree
2491 1667 : generic_simplify_457 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2492 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2493 : {
2494 1667 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2495 1667 : {
2496 1667 : bool wascmp;
2497 1667 : if (bitwise_inverted_equal_p (captures[0], captures[2], wascmp)
2498 1667 : || bitwise_inverted_equal_p (captures[1], captures[2], wascmp)
2499 : )
2500 : {
2501 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail802;
2502 8 : {
2503 8 : tree _r;
2504 8 : _r = wascmp ? constant_boolean_node (false, type) : build_zero_cst (type);
2505 8 : if (TREE_SIDE_EFFECTS (captures[0]))
2506 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2507 8 : if (TREE_SIDE_EFFECTS (captures[1]))
2508 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2509 8 : if (TREE_SIDE_EFFECTS (captures[2]))
2510 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2511 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 656, __FILE__, __LINE__, true);
2512 8 : return _r;
2513 : }
2514 0 : next_after_fail802:;
2515 : }
2516 : }
2517 1659 : return NULL_TREE;
2518 : }
2519 :
2520 : tree
2521 0 : generic_simplify_468 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2522 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2523 : {
2524 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2525 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail834;
2526 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail834;
2527 0 : {
2528 0 : tree _r;
2529 0 : _r = captures[2];
2530 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2531 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2532 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 678, __FILE__, __LINE__, true);
2533 : return _r;
2534 : }
2535 : next_after_fail834:;
2536 : return NULL_TREE;
2537 : }
2538 :
2539 : tree
2540 3 : generic_simplify_473 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2541 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2542 : {
2543 3 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2544 6 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2545 6 : && TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))
2546 : )
2547 : {
2548 3 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail852;
2549 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail852;
2550 3 : {
2551 3 : tree res_op0;
2552 3 : res_op0 = captures[3];
2553 3 : tree res_op1;
2554 3 : {
2555 3 : tree _o1[2], _r1;
2556 3 : _o1[0] = captures[1];
2557 3 : _o1[1] = build_int_cst (TREE_TYPE (captures[1]), 1);
2558 3 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2559 3 : res_op1 = _r1;
2560 : }
2561 3 : tree _r;
2562 3 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
2563 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 680, __FILE__, __LINE__, true);
2564 3 : return _r;
2565 : }
2566 : next_after_fail852:;
2567 : }
2568 : return NULL_TREE;
2569 : }
2570 :
2571 : tree
2572 98310 : generic_simplify_480 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2573 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2574 : const enum tree_code ARG_UNUSED (shift))
2575 : {
2576 98310 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2577 98310 : if (tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
2578 22344 : && TYPE_PRECISION (type) <= HOST_BITS_PER_WIDE_INT
2579 22344 : && tree_fits_uhwi_p (captures[4])
2580 22344 : && tree_to_uhwi (captures[4]) > 0
2581 120654 : && tree_to_uhwi (captures[4]) < TYPE_PRECISION (type)
2582 : )
2583 : {
2584 22344 : {
2585 22344 : unsigned int shiftc = tree_to_uhwi (captures[4]);
2586 22344 : unsigned HOST_WIDE_INT mask = TREE_INT_CST_LOW (captures[5]);
2587 22344 : unsigned HOST_WIDE_INT newmask, zerobits = 0;
2588 22344 : tree shift_type = TREE_TYPE (captures[2]);
2589 22344 : unsigned int prec;
2590 22344 : if (shift == LSHIFT_EXPR)
2591 0 : zerobits = ((HOST_WIDE_INT_1U << shiftc) - 1);
2592 22344 : else if (shift == RSHIFT_EXPR
2593 22344 : && type_has_mode_precision_p (shift_type))
2594 : {
2595 22344 : prec = TYPE_PRECISION (TREE_TYPE (captures[2]));
2596 22344 : tree arg00 = captures[3];
2597 22344 : if (captures[2] != captures[3]
2598 22344 : && TYPE_UNSIGNED (TREE_TYPE (captures[3])))
2599 : {
2600 21937 : tree inner_type = TREE_TYPE (captures[3]);
2601 21937 : if (type_has_mode_precision_p (inner_type)
2602 21937 : && TYPE_PRECISION (inner_type) < prec)
2603 : {
2604 34 : prec = TYPE_PRECISION (inner_type);
2605 34 : if (shiftc < prec)
2606 34 : shift_type = inner_type;
2607 : }
2608 : }
2609 22344 : zerobits = HOST_WIDE_INT_M1U;
2610 22344 : if (shiftc < prec)
2611 : {
2612 22344 : zerobits >>= HOST_BITS_PER_WIDE_INT - shiftc;
2613 22344 : zerobits <<= prec - shiftc;
2614 : }
2615 22344 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[2]))
2616 22344 : && prec == TYPE_PRECISION (TREE_TYPE (captures[2])))
2617 : {
2618 73 : if ((mask & zerobits) == 0)
2619 59 : shift_type = unsigned_type_for (TREE_TYPE (captures[2]));
2620 : else
2621 : zerobits = 0;
2622 : }
2623 : }
2624 22330 : if ((mask & zerobits) == mask
2625 : )
2626 : {
2627 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail863;
2628 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail863;
2629 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail863;
2630 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail863;
2631 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail863;
2632 0 : {
2633 0 : tree _r;
2634 0 : _r = build_int_cst (type, 0);
2635 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 682, __FILE__, __LINE__, true);
2636 0 : return _r;
2637 : }
2638 : next_after_fail863:;
2639 : }
2640 : else
2641 : {
2642 22344 : {
2643 22344 : newmask = mask | zerobits;
2644 22344 : if (newmask != mask && (newmask & (newmask + 1)) == 0
2645 : )
2646 : {
2647 : {
2648 65 : for (prec = BITS_PER_UNIT;
2649 122 : prec < HOST_BITS_PER_WIDE_INT; prec <<= 1)
2650 118 : if (newmask == (HOST_WIDE_INT_1U << prec) - 1)
2651 : break;
2652 57 : if (prec < HOST_BITS_PER_WIDE_INT
2653 4 : || newmask == HOST_WIDE_INT_M1U
2654 : )
2655 : {
2656 57 : {
2657 57 : tree newmaskt = build_int_cst_type (TREE_TYPE (captures[5]), newmask);
2658 57 : if (!tree_int_cst_equal (newmaskt, captures[5])
2659 : )
2660 : {
2661 57 : if (shift_type != TREE_TYPE (captures[2])
2662 : )
2663 : {
2664 47 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail864;
2665 47 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail864;
2666 47 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail864;
2667 47 : {
2668 47 : tree res_op0;
2669 47 : {
2670 47 : tree _o1[1], _r1;
2671 47 : {
2672 47 : tree _o2[2], _r2;
2673 47 : {
2674 47 : tree _o3[1], _r3;
2675 47 : _o3[0] = captures[2];
2676 47 : if (TREE_TYPE (_o3[0]) != shift_type)
2677 : {
2678 47 : _r3 = fold_build1_loc (loc, NOP_EXPR, shift_type, _o3[0]);
2679 : }
2680 : else
2681 : _r3 = _o3[0];
2682 47 : _o2[0] = _r3;
2683 : }
2684 47 : _o2[1] = captures[4];
2685 47 : _r2 = fold_build2_loc (loc, shift, shift_type, _o2[0], _o2[1]);
2686 47 : _o1[0] = _r2;
2687 : }
2688 47 : if (TREE_TYPE (_o1[0]) != type)
2689 : {
2690 47 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2691 : }
2692 : else
2693 : _r1 = _o1[0];
2694 47 : res_op0 = _r1;
2695 : }
2696 47 : tree res_op1;
2697 47 : res_op1 = newmaskt;
2698 47 : tree _r;
2699 47 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2700 47 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 683, __FILE__, __LINE__, true);
2701 47 : return _r;
2702 : }
2703 : next_after_fail864:;
2704 : }
2705 : else
2706 : {
2707 10 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail865;
2708 10 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail865;
2709 10 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail865;
2710 10 : {
2711 10 : tree res_op0;
2712 10 : res_op0 = captures[0];
2713 10 : tree res_op1;
2714 10 : res_op1 = newmaskt;
2715 10 : tree _r;
2716 10 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2717 10 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 684, __FILE__, __LINE__, true);
2718 10 : return _r;
2719 : }
2720 : next_after_fail865:;
2721 : }
2722 : }
2723 : }
2724 : }
2725 : }
2726 : }
2727 : }
2728 : }
2729 : }
2730 : }
2731 : return NULL_TREE;
2732 : }
2733 :
2734 : tree
2735 108 : generic_simplify_490 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2736 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2737 : {
2738 108 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2739 108 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail879;
2740 108 : {
2741 108 : tree res_op0;
2742 108 : res_op0 = captures[1];
2743 108 : tree res_op1;
2744 108 : {
2745 108 : tree _o1[1], _r1;
2746 108 : _o1[0] = captures[2];
2747 108 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2748 108 : res_op1 = _r1;
2749 : }
2750 108 : tree _r;
2751 108 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2752 108 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 694, __FILE__, __LINE__, true);
2753 : return _r;
2754 : }
2755 0 : next_after_fail879:;
2756 0 : return NULL_TREE;
2757 : }
2758 :
2759 : tree
2760 29 : generic_simplify_496 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2761 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2762 : {
2763 29 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2764 29 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
2765 : )
2766 : {
2767 29 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail885;
2768 29 : {
2769 29 : tree res_op0;
2770 29 : {
2771 29 : tree _o1[2], _r1;
2772 29 : _o1[0] = captures[0];
2773 29 : {
2774 29 : tree _o2[1], _r2;
2775 29 : _o2[0] = captures[1];
2776 29 : _r2 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
2777 29 : _o1[1] = _r2;
2778 : }
2779 29 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2780 29 : res_op0 = _r1;
2781 : }
2782 29 : tree _r;
2783 29 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2784 29 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 700, __FILE__, __LINE__, true);
2785 29 : return _r;
2786 : }
2787 0 : next_after_fail885:;
2788 : }
2789 : return NULL_TREE;
2790 : }
2791 :
2792 : tree
2793 38974 : generic_simplify_503 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2794 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2795 : {
2796 38974 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2797 38974 : if (!HONOR_SIGN_DEPENDENT_ROUNDING (type)
2798 38974 : && !HONOR_SIGNED_ZEROS (type)
2799 : )
2800 : {
2801 38974 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail893;
2802 38974 : {
2803 38974 : tree res_op0;
2804 38974 : {
2805 38974 : tree _o1[1], _r1;
2806 38974 : _o1[0] = captures[1];
2807 38974 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2808 38974 : res_op0 = _r1;
2809 : }
2810 38974 : tree res_op1;
2811 38974 : res_op1 = captures[0];
2812 38974 : tree _r;
2813 38974 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
2814 38974 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 706, __FILE__, __LINE__, true);
2815 38974 : return _r;
2816 : }
2817 0 : next_after_fail893:;
2818 : }
2819 : return NULL_TREE;
2820 : }
2821 :
2822 : tree
2823 16 : generic_simplify_509 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2824 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2825 : const combined_fn ARG_UNUSED (fmas))
2826 : {
2827 16 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2828 16 : if (canonicalize_math_after_vectorization_p ()
2829 : )
2830 : {
2831 : if (!HONOR_SIGN_DEPENDENT_ROUNDING (type) && single_use (captures[0])
2832 : )
2833 : {
2834 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail900;
2835 : {
2836 : tree res_op0;
2837 : res_op0 = captures[1];
2838 : tree res_op1;
2839 : res_op1 = captures[2];
2840 : tree res_op2;
2841 : res_op2 = captures[3];
2842 : tree _r;
2843 : _r = maybe_build_call_expr_loc (loc, CFN_FNMS, type, 3, res_op0, res_op1, res_op2);
2844 : if (!_r)
2845 : goto next_after_fail900;
2846 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 713, __FILE__, __LINE__, true);
2847 : return _r;
2848 : }
2849 16 : next_after_fail900:;
2850 : }
2851 : }
2852 16 : return NULL_TREE;
2853 : }
2854 :
2855 : tree
2856 2 : generic_simplify_521 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2857 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2858 : {
2859 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2860 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail924;
2861 2 : {
2862 2 : tree _r;
2863 2 : _r = captures[1];
2864 2 : if (TREE_SIDE_EFFECTS (captures[0]))
2865 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2866 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 724, __FILE__, __LINE__, true);
2867 : return _r;
2868 : }
2869 0 : next_after_fail924:;
2870 0 : return NULL_TREE;
2871 : }
2872 :
2873 : tree
2874 0 : generic_simplify_525 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2875 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2876 : const combined_fn ARG_UNUSED (FMIN_ALL))
2877 : {
2878 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2879 0 : if (flag_finite_math_only
2880 : )
2881 : {
2882 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail928;
2883 0 : {
2884 0 : tree res_op0;
2885 0 : res_op0 = captures[0];
2886 0 : tree res_op1;
2887 0 : res_op1 = captures[1];
2888 0 : tree _r;
2889 0 : _r = fold_build2_loc (loc, MIN_EXPR, type, res_op0, res_op1);
2890 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 728, __FILE__, __LINE__, true);
2891 0 : return _r;
2892 : }
2893 0 : next_after_fail928:;
2894 : }
2895 : return NULL_TREE;
2896 : }
2897 :
2898 : tree
2899 1 : generic_simplify_530 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2900 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2901 : {
2902 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2903 1 : if (tree_nop_conversion_p (TREE_TYPE (captures[0]), type)
2904 : )
2905 : {
2906 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail936;
2907 1 : {
2908 1 : tree res_op0;
2909 1 : {
2910 1 : tree _o1[1], _r1;
2911 1 : _o1[0] = captures[0];
2912 1 : if (TREE_TYPE (_o1[0]) != type)
2913 : {
2914 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2915 : }
2916 : else
2917 : _r1 = _o1[0];
2918 1 : res_op0 = _r1;
2919 : }
2920 1 : tree _r;
2921 1 : _r = non_lvalue_loc (loc, res_op0);
2922 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 736, __FILE__, __LINE__, true);
2923 1 : return _r;
2924 : }
2925 0 : next_after_fail936:;
2926 : }
2927 : return NULL_TREE;
2928 : }
2929 :
2930 : tree
2931 0 : generic_simplify_539 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2932 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
2933 : const combined_fn ARG_UNUSED (cond_op))
2934 : {
2935 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2936 0 : {
2937 0 : tree op_type = TREE_TYPE (captures[3]);
2938 0 : if (element_precision (type) == element_precision (op_type)
2939 : )
2940 : {
2941 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail945;
2942 0 : {
2943 0 : tree res_op0;
2944 0 : {
2945 0 : tree _o1[4], _r1;
2946 0 : _o1[0] = captures[0];
2947 0 : _o1[1] = captures[1];
2948 0 : _o1[2] = captures[2];
2949 0 : {
2950 0 : tree _o2[1], _r2;
2951 0 : _o2[0] = captures[4];
2952 0 : if (TREE_TYPE (_o2[0]) != op_type)
2953 : {
2954 0 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
2955 : }
2956 : else
2957 : _r2 = _o2[0];
2958 0 : _o1[3] = _r2;
2959 : }
2960 0 : _r1 = maybe_build_call_expr_loc (loc, cond_op, TREE_TYPE (_o1[1]), 4, _o1[0], _o1[1], _o1[2], _o1[3]);
2961 0 : if (!_r1)
2962 0 : goto next_after_fail945;
2963 0 : res_op0 = _r1;
2964 : }
2965 0 : tree _r;
2966 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
2967 0 : if (TREE_SIDE_EFFECTS (captures[3]))
2968 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
2969 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 740, __FILE__, __LINE__, true);
2970 0 : return _r;
2971 : }
2972 : next_after_fail945:;
2973 : }
2974 : }
2975 : return NULL_TREE;
2976 : }
2977 :
2978 : tree
2979 0 : generic_simplify_548 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2980 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
2981 : const combined_fn ARG_UNUSED (cond_op))
2982 : {
2983 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2984 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail954;
2985 0 : {
2986 0 : tree res_op0;
2987 0 : {
2988 0 : tree _o1[2], _r1;
2989 0 : _o1[0] = captures[2];
2990 0 : _o1[1] = captures[0];
2991 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2992 0 : res_op0 = _r1;
2993 : }
2994 0 : tree res_op1;
2995 0 : res_op1 = captures[3];
2996 0 : tree res_op2;
2997 0 : res_op2 = captures[4];
2998 0 : tree res_op3;
2999 0 : res_op3 = captures[5];
3000 0 : tree res_op4;
3001 0 : res_op4 = captures[6];
3002 0 : tree _r;
3003 0 : _r = maybe_build_call_expr_loc (loc, cond_op, type, 5, res_op0, res_op1, res_op2, res_op3, res_op4);
3004 0 : if (!_r)
3005 0 : goto next_after_fail954;
3006 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 749, __FILE__, __LINE__, true);
3007 : return _r;
3008 : }
3009 : next_after_fail954:;
3010 : return NULL_TREE;
3011 : }
3012 :
3013 : tree
3014 0 : generic_simplify_559 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3015 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3016 : const combined_fn ARG_UNUSED (sinhs),
3017 : const combined_fn ARG_UNUSED (atanhs),
3018 : const combined_fn ARG_UNUSED (sqrts))
3019 : {
3020 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3021 0 : if (!flag_errno_math
3022 : )
3023 : {
3024 0 : {
3025 0 : tree t_one = build_one_cst (type);
3026 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail965;
3027 0 : {
3028 0 : if (! tree_invariant_p (captures[1])) goto next_after_fail965;
3029 0 : tree res_op0;
3030 0 : res_op0 = unshare_expr (captures[1]);
3031 0 : tree res_op1;
3032 0 : {
3033 0 : tree _o1[1], _r1;
3034 0 : {
3035 0 : tree _o2[2], _r2;
3036 0 : {
3037 0 : tree _o3[2], _r3;
3038 0 : _o3[0] = t_one;
3039 0 : _o3[1] = unshare_expr (captures[1]);
3040 0 : _r3 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
3041 0 : _o2[0] = _r3;
3042 : }
3043 0 : {
3044 0 : tree _o3[2], _r3;
3045 0 : _o3[0] = t_one;
3046 0 : _o3[1] = captures[1];
3047 0 : _r3 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
3048 0 : _o2[1] = _r3;
3049 : }
3050 0 : _r2 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
3051 0 : _o1[0] = _r2;
3052 : }
3053 0 : _r1 = maybe_build_call_expr_loc (loc, sqrts, TREE_TYPE (_o1[0]), 1, _o1[0]);
3054 0 : if (!_r1)
3055 0 : goto next_after_fail965;
3056 0 : res_op1 = _r1;
3057 : }
3058 0 : tree _r;
3059 0 : _r = fold_build2_loc (loc, RDIV_EXPR, type, res_op0, res_op1);
3060 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 760, __FILE__, __LINE__, true);
3061 0 : return _r;
3062 : }
3063 : next_after_fail965:;
3064 : }
3065 : }
3066 : return NULL_TREE;
3067 : }
3068 :
3069 : tree
3070 0 : generic_simplify_577 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3071 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
3072 : const combined_fn ARG_UNUSED (fmas))
3073 : {
3074 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3075 0 : if (canonicalize_math_after_vectorization_p ()
3076 : )
3077 : {
3078 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail983;
3079 : {
3080 : tree res_op0;
3081 : res_op0 = captures[0];
3082 : tree res_op1;
3083 : res_op1 = captures[1];
3084 : tree res_op2;
3085 : res_op2 = captures[2];
3086 : tree _r;
3087 : _r = maybe_build_call_expr_loc (loc, CFN_FNMS, type, 3, res_op0, res_op1, res_op2);
3088 : if (!_r)
3089 : goto next_after_fail983;
3090 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 778, __FILE__, __LINE__, true);
3091 : return _r;
3092 : }
3093 0 : next_after_fail983:;
3094 : }
3095 0 : return NULL_TREE;
3096 : }
3097 :
3098 : tree
3099 0 : generic_simplify_587 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3100 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree ARG_UNUSED (_p3), tree ARG_UNUSED (_p4), tree *ARG_UNUSED (captures))
3101 : {
3102 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3103 0 : if (canonicalize_math_after_vectorization_p ()
3104 : )
3105 : {
3106 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail993;
3107 : {
3108 : tree res_op0;
3109 : res_op0 = captures[0];
3110 : tree res_op1;
3111 : res_op1 = captures[1];
3112 : tree res_op2;
3113 : res_op2 = captures[2];
3114 : tree res_op3;
3115 : res_op3 = captures[3];
3116 : tree res_op4;
3117 : res_op4 = captures[4];
3118 : tree _r;
3119 : _r = maybe_build_call_expr_loc (loc, CFN_COND_FNMS, type, 5, res_op0, res_op1, res_op2, res_op3, res_op4);
3120 : if (!_r)
3121 : goto next_after_fail993;
3122 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 788, __FILE__, __LINE__, true);
3123 : return _r;
3124 : }
3125 0 : next_after_fail993:;
3126 : }
3127 0 : return NULL_TREE;
3128 : }
3129 :
3130 : tree
3131 0 : generic_simplify_597 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3132 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3133 : const combined_fn ARG_UNUSED (bswap),
3134 : const combined_fn ARG_UNUSED (popcount))
3135 : {
3136 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3137 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3138 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
3139 : )
3140 : {
3141 0 : {
3142 0 : tree type0 = TREE_TYPE (captures[0]);
3143 0 : tree type1 = TREE_TYPE (captures[1]);
3144 0 : unsigned int prec0 = TYPE_PRECISION (type0);
3145 0 : unsigned int prec1 = TYPE_PRECISION (type1);
3146 0 : if (prec0 == prec1 || (prec0 > prec1 && TYPE_UNSIGNED (type1))
3147 : )
3148 : {
3149 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1003;
3150 0 : {
3151 0 : tree res_op0;
3152 0 : {
3153 0 : tree _o1[1], _r1;
3154 0 : {
3155 0 : tree _o2[1], _r2;
3156 0 : _o2[0] = captures[2];
3157 0 : if (TREE_TYPE (_o2[0]) != type1)
3158 : {
3159 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, type1, _o2[0]);
3160 : }
3161 : else
3162 : _r2 = _o2[0];
3163 0 : _o1[0] = _r2;
3164 : }
3165 0 : if (TREE_TYPE (_o1[0]) != type0)
3166 : {
3167 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type0, _o1[0]);
3168 : }
3169 : else
3170 : _r1 = _o1[0];
3171 0 : res_op0 = _r1;
3172 : }
3173 0 : tree _r;
3174 0 : _r = maybe_build_call_expr_loc (loc, popcount, type, 1, res_op0);
3175 0 : if (!_r)
3176 0 : goto next_after_fail1003;
3177 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 795, __FILE__, __LINE__, true);
3178 0 : return _r;
3179 : }
3180 : next_after_fail1003:;
3181 : }
3182 : }
3183 : }
3184 : return NULL_TREE;
3185 : }
3186 :
3187 : tree
3188 0 : generic_simplify_610 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3189 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
3190 : const enum tree_code ARG_UNUSED (plusminus),
3191 : const enum tree_code ARG_UNUSED (minusplus))
3192 : {
3193 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3194 0 : if (!VECTOR_INTEGER_TYPE_P (type)
3195 : && !FLOAT_WORDS_BIG_ENDIAN
3196 0 : && (operand_equal_p (captures[0], captures[2], 0)
3197 0 : ? operand_equal_p (captures[1], captures[3], 0)
3198 0 : : operand_equal_p (captures[0], captures[3], 0) && operand_equal_p (captures[1], captures[2], 0))
3199 : )
3200 : {
3201 0 : {
3202 0 : vec_perm_builder builder;
3203 0 : if (tree_to_vec_perm_builder (&builder, captures[4])
3204 : )
3205 : {
3206 0 : {
3207 0 : poly_uint64 nelts = TYPE_VECTOR_SUBPARTS (type);
3208 0 : vec_perm_indices sel (builder, 2, nelts);
3209 0 : machine_mode vec_mode = TYPE_MODE (type);
3210 0 : machine_mode wide_mode;
3211 0 : scalar_mode wide_elt_mode;
3212 0 : poly_uint64 wide_nunits;
3213 0 : scalar_mode inner_mode = GET_MODE_INNER (vec_mode);
3214 0 : if (VECTOR_MODE_P (vec_mode)
3215 0 : && sel.series_p (0, 2, 0, 2)
3216 0 : && sel.series_p (1, 2, nelts + 1, 2)
3217 0 : && GET_MODE_2XWIDER_MODE (inner_mode).exists (&wide_elt_mode)
3218 0 : && multiple_p (GET_MODE_NUNITS (vec_mode), 2, &wide_nunits)
3219 0 : && related_vector_mode (vec_mode, wide_elt_mode,
3220 0 : wide_nunits).exists (&wide_mode)
3221 : )
3222 : {
3223 0 : {
3224 0 : tree stype
3225 0 : = lang_hooks.types.type_for_mode (GET_MODE_INNER (wide_mode),
3226 0 : TYPE_UNSIGNED (type));
3227 0 : tree ntype = build_vector_type_for_mode (stype, wide_mode);
3228 0 : const struct real_format *fmt_old = FLOAT_MODE_FORMAT (vec_mode);
3229 0 : const struct real_format *fmt_new = FLOAT_MODE_FORMAT (wide_mode);
3230 0 : if (TYPE_MODE (stype) != BLKmode
3231 0 : && VECTOR_TYPE_P (ntype)
3232 0 : && fmt_old != NULL
3233 0 : && fmt_new != NULL
3234 : )
3235 : {
3236 0 : {
3237 0 : if (known_eq (GET_MODE_NUNITS (wide_mode), 1)
3238 0 : && !target_supports_op_p (ntype, NEGATE_EXPR, optab_vector))
3239 : ntype = stype;
3240 0 : if (fmt_new->signbit_rw
3241 0 : == fmt_old->signbit_rw + GET_MODE_UNIT_BITSIZE (vec_mode)
3242 0 : && fmt_new->signbit_rw == fmt_new->signbit_ro
3243 0 : && targetm.can_change_mode_class (TYPE_MODE (ntype),
3244 0 : TYPE_MODE (type), ALL_REGS)
3245 0 : && ((optimize_vectors_before_lowering_p ()
3246 0 : && VECTOR_TYPE_P (ntype))
3247 0 : || target_supports_op_p (ntype, NEGATE_EXPR, optab_vector))
3248 : )
3249 : {
3250 0 : if (plusminus == PLUS_EXPR
3251 : )
3252 : {
3253 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1017;
3254 0 : {
3255 0 : tree res_op0;
3256 0 : {
3257 0 : tree _o1[1], _r1;
3258 0 : {
3259 0 : tree _o2[1], _r2;
3260 0 : {
3261 0 : tree _o3[1], _r3;
3262 0 : _o3[0] = captures[3];
3263 0 : if (TREE_TYPE (_o3[0]) != ntype)
3264 : {
3265 0 : _r3 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, ntype, _o3[0]);
3266 : }
3267 : else
3268 : _r3 = _o3[0];
3269 0 : _o2[0] = _r3;
3270 : }
3271 0 : _r2 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
3272 0 : _o1[0] = _r2;
3273 : }
3274 0 : if (TREE_TYPE (_o1[0]) != type)
3275 : {
3276 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
3277 : }
3278 : else
3279 : _r1 = _o1[0];
3280 0 : res_op0 = _r1;
3281 : }
3282 0 : tree res_op1;
3283 0 : res_op1 = captures[2];
3284 0 : tree _r;
3285 0 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
3286 0 : if (TREE_SIDE_EFFECTS (captures[0]))
3287 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3288 0 : if (TREE_SIDE_EFFECTS (captures[1]))
3289 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3290 0 : if (TREE_SIDE_EFFECTS (captures[4]))
3291 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
3292 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 805, __FILE__, __LINE__, true);
3293 0 : return _r;
3294 : }
3295 0 : next_after_fail1017:;
3296 : }
3297 : else
3298 : {
3299 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1018;
3300 0 : {
3301 0 : tree res_op0;
3302 0 : res_op0 = captures[0];
3303 0 : tree res_op1;
3304 0 : {
3305 0 : tree _o1[1], _r1;
3306 0 : {
3307 0 : tree _o2[1], _r2;
3308 0 : {
3309 0 : tree _o3[1], _r3;
3310 0 : _o3[0] = captures[1];
3311 0 : if (TREE_TYPE (_o3[0]) != ntype)
3312 : {
3313 0 : _r3 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, ntype, _o3[0]);
3314 : }
3315 : else
3316 : _r3 = _o3[0];
3317 0 : _o2[0] = _r3;
3318 : }
3319 0 : _r2 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
3320 0 : _o1[0] = _r2;
3321 : }
3322 0 : if (TREE_TYPE (_o1[0]) != type)
3323 : {
3324 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
3325 : }
3326 : else
3327 : _r1 = _o1[0];
3328 0 : res_op1 = _r1;
3329 : }
3330 0 : tree _r;
3331 0 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
3332 0 : if (TREE_SIDE_EFFECTS (captures[2]))
3333 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
3334 0 : if (TREE_SIDE_EFFECTS (captures[3]))
3335 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
3336 0 : if (TREE_SIDE_EFFECTS (captures[4]))
3337 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
3338 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 806, __FILE__, __LINE__, true);
3339 0 : return _r;
3340 : }
3341 0 : next_after_fail1018:;
3342 : }
3343 : }
3344 : }
3345 : }
3346 : }
3347 : }
3348 0 : }
3349 : }
3350 0 : }
3351 : }
3352 : return NULL_TREE;
3353 : }
3354 :
3355 : tree
3356 1330 : generic_simplify_CONJ_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0)
3357 : {
3358 1330 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3359 1330 : switch (TREE_CODE (_p0))
3360 : {
3361 0 : CASE_CONVERT:
3362 0 : {
3363 0 : tree _q20 = TREE_OPERAND (_p0, 0);
3364 0 : switch (TREE_CODE (_q20))
3365 : {
3366 0 : case CONJ_EXPR:
3367 0 : {
3368 0 : tree _q30 = TREE_OPERAND (_q20, 0);
3369 0 : {
3370 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
3371 0 : tree res = generic_simplify_530 (loc, type, _p0, captures);
3372 0 : if (res) return res;
3373 : }
3374 0 : break;
3375 : }
3376 0 : case COMPLEX_EXPR:
3377 0 : {
3378 0 : tree _q30 = TREE_OPERAND (_q20, 0);
3379 0 : tree _q31 = TREE_OPERAND (_q20, 1);
3380 0 : {
3381 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
3382 0 : {
3383 0 : tree itype = TREE_TYPE (type);
3384 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1141;
3385 0 : {
3386 0 : tree res_op0;
3387 0 : {
3388 0 : tree _o1[1], _r1;
3389 0 : _o1[0] = captures[2];
3390 0 : if (TREE_TYPE (_o1[0]) != itype)
3391 : {
3392 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, itype, _o1[0]);
3393 : }
3394 : else
3395 : _r1 = _o1[0];
3396 0 : res_op0 = _r1;
3397 : }
3398 0 : tree res_op1;
3399 0 : {
3400 0 : tree _o1[1], _r1;
3401 0 : {
3402 0 : tree _o2[1], _r2;
3403 0 : _o2[0] = captures[3];
3404 0 : if (TREE_TYPE (_o2[0]) != itype)
3405 : {
3406 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, itype, _o2[0]);
3407 : }
3408 : else
3409 : _r2 = _o2[0];
3410 0 : _o1[0] = _r2;
3411 : }
3412 0 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
3413 0 : res_op1 = _r1;
3414 : }
3415 0 : tree _r;
3416 0 : _r = fold_build2_loc (loc, COMPLEX_EXPR, type, res_op0, res_op1);
3417 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 868, __FILE__, __LINE__, true);
3418 0 : return _r;
3419 : }
3420 0 : next_after_fail1141:;
3421 : }
3422 : }
3423 0 : break;
3424 : }
3425 : default:;
3426 : }
3427 : break;
3428 : }
3429 1 : case CONJ_EXPR:
3430 1 : {
3431 1 : tree _q20 = TREE_OPERAND (_p0, 0);
3432 1 : {
3433 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3434 1 : tree res = generic_simplify_530 (loc, type, _p0, captures);
3435 1 : if (res) return res;
3436 : }
3437 0 : break;
3438 : }
3439 12 : case COMPLEX_EXPR:
3440 12 : {
3441 12 : tree _q20 = TREE_OPERAND (_p0, 0);
3442 12 : tree _q21 = TREE_OPERAND (_p0, 1);
3443 12 : {
3444 12 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
3445 12 : {
3446 12 : tree itype = TREE_TYPE (type);
3447 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1142;
3448 12 : {
3449 12 : tree res_op0;
3450 12 : {
3451 12 : tree _o1[1], _r1;
3452 12 : _o1[0] = captures[2];
3453 12 : if (TREE_TYPE (_o1[0]) != itype)
3454 : {
3455 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, itype, _o1[0]);
3456 : }
3457 : else
3458 : _r1 = _o1[0];
3459 12 : res_op0 = _r1;
3460 : }
3461 12 : tree res_op1;
3462 12 : {
3463 12 : tree _o1[1], _r1;
3464 12 : {
3465 12 : tree _o2[1], _r2;
3466 12 : _o2[0] = captures[3];
3467 12 : if (TREE_TYPE (_o2[0]) != itype)
3468 : {
3469 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, itype, _o2[0]);
3470 : }
3471 : else
3472 : _r2 = _o2[0];
3473 12 : _o1[0] = _r2;
3474 : }
3475 12 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
3476 12 : res_op1 = _r1;
3477 : }
3478 12 : tree _r;
3479 12 : _r = fold_build2_loc (loc, COMPLEX_EXPR, type, res_op0, res_op1);
3480 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 868, __FILE__, __LINE__, true);
3481 12 : return _r;
3482 : }
3483 0 : next_after_fail1142:;
3484 : }
3485 : }
3486 0 : break;
3487 : }
3488 : default:;
3489 : }
3490 : return NULL_TREE;
3491 : }
3492 :
3493 : tree
3494 60059973 : generic_simplify_POINTER_PLUS_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
3495 : {
3496 60059973 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3497 60059973 : if (integer_zerop (_p1))
3498 : {
3499 3307811 : {
3500 3307811 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3501 3307811 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1160;
3502 3307811 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1160;
3503 3307811 : {
3504 3307811 : tree res_op0;
3505 3307811 : res_op0 = captures[0];
3506 3307811 : tree _r;
3507 3307811 : _r = non_lvalue_loc (loc, res_op0);
3508 3307811 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 869, __FILE__, __LINE__, true);
3509 3307811 : return _r;
3510 : }
3511 : next_after_fail1160:;
3512 : }
3513 : }
3514 56752162 : switch (TREE_CODE (_p0))
3515 : {
3516 4034786 : case POINTER_PLUS_EXPR:
3517 4034786 : {
3518 4034786 : tree _q20 = TREE_OPERAND (_p0, 0);
3519 4034786 : tree _q21 = TREE_OPERAND (_p0, 1);
3520 4034786 : {
3521 4034786 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
3522 4034786 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1161;
3523 4034786 : {
3524 4034786 : tree res_op0;
3525 4034786 : res_op0 = captures[1];
3526 4034786 : tree res_op1;
3527 4034786 : {
3528 4034786 : tree _o1[2], _r1;
3529 4034786 : _o1[0] = captures[2];
3530 4034786 : _o1[1] = captures[3];
3531 4034786 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3532 4034786 : res_op1 = _r1;
3533 : }
3534 4034786 : tree _r;
3535 4034786 : _r = fold_build2_loc (loc, POINTER_PLUS_EXPR, type, res_op0, res_op1);
3536 4034786 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 880, __FILE__, __LINE__, true);
3537 4034786 : return _r;
3538 : }
3539 0 : next_after_fail1161:;
3540 : }
3541 0 : break;
3542 : }
3543 25485428 : CASE_CONVERT:
3544 25485428 : {
3545 25485428 : tree _q20 = TREE_OPERAND (_p0, 0);
3546 25485428 : switch (TREE_CODE (_q20))
3547 : {
3548 23350 : case POINTER_PLUS_EXPR:
3549 23350 : {
3550 23350 : tree _q30 = TREE_OPERAND (_q20, 0);
3551 23350 : tree _q31 = TREE_OPERAND (_q20, 1);
3552 23350 : {
3553 23350 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
3554 23350 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1162;
3555 23350 : {
3556 23350 : tree res_op0;
3557 23350 : {
3558 23350 : tree _o1[2], _r1;
3559 23350 : _o1[0] = captures[2];
3560 23350 : {
3561 23350 : tree _o2[2], _r2;
3562 23350 : _o2[0] = captures[3];
3563 23350 : _o2[1] = captures[4];
3564 23350 : _r2 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
3565 23350 : _o1[1] = _r2;
3566 : }
3567 23350 : _r1 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3568 23350 : res_op0 = _r1;
3569 : }
3570 23350 : tree _r;
3571 23350 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3572 23350 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 881, __FILE__, __LINE__, true);
3573 23350 : return _r;
3574 : }
3575 0 : next_after_fail1162:;
3576 : }
3577 0 : break;
3578 : }
3579 : default:;
3580 : }
3581 : break;
3582 : }
3583 52694026 : default:;
3584 : }
3585 52694026 : if (integer_zerop (_p0))
3586 : {
3587 646 : {
3588 646 : tree captures[1] ATTRIBUTE_UNUSED = { _p1 };
3589 646 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1163;
3590 646 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1163;
3591 646 : {
3592 646 : tree res_op0;
3593 646 : {
3594 646 : tree _o1[1], _r1;
3595 646 : _o1[0] = captures[0];
3596 646 : if (TREE_TYPE (_o1[0]) != type)
3597 : {
3598 646 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3599 : }
3600 : else
3601 : _r1 = _o1[0];
3602 646 : res_op0 = _r1;
3603 : }
3604 646 : tree _r;
3605 646 : _r = non_lvalue_loc (loc, res_op0);
3606 646 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 882, __FILE__, __LINE__, true);
3607 646 : return _r;
3608 : }
3609 : next_after_fail1163:;
3610 : }
3611 : }
3612 52693380 : switch (TREE_CODE (_p1))
3613 : {
3614 11696946 : CASE_CONVERT:
3615 11696946 : {
3616 11696946 : tree _q30 = TREE_OPERAND (_p1, 0);
3617 11696946 : switch (TREE_CODE (_q30))
3618 : {
3619 195710 : case MINUS_EXPR:
3620 195710 : {
3621 195710 : tree _q40 = TREE_OPERAND (_q30, 0);
3622 195710 : tree _q41 = TREE_OPERAND (_q30, 1);
3623 195710 : switch (TREE_CODE (_q40))
3624 : {
3625 91132 : CASE_CONVERT:
3626 91132 : {
3627 91132 : tree _q50 = TREE_OPERAND (_q40, 0);
3628 91132 : switch (TREE_CODE (_q41))
3629 : {
3630 7973 : CASE_CONVERT:
3631 7973 : {
3632 7973 : tree _q70 = TREE_OPERAND (_q41, 0);
3633 7973 : if ((_q70 == _p0 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _p0, 0) && types_match (_q70, _p0)))
3634 : {
3635 4760 : {
3636 4760 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q50 };
3637 4760 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (TREE_TYPE (captures[2]))
3638 4760 : && ((
3639 :
3640 : && useless_type_conversion_p (type, TREE_TYPE (captures[3])))
3641 : || (
3642 : 1
3643 4760 : && type == TREE_TYPE (captures[3])))
3644 : )
3645 : {
3646 3371 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1164;
3647 3371 : {
3648 3371 : tree _r;
3649 3371 : _r = captures[3];
3650 3371 : if (TREE_SIDE_EFFECTS (captures[0]))
3651 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3652 3371 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 883, __FILE__, __LINE__, true);
3653 3371 : return _r;
3654 : }
3655 0 : next_after_fail1164:;
3656 : }
3657 : }
3658 : }
3659 : break;
3660 : }
3661 : default:;
3662 : }
3663 : break;
3664 : }
3665 : default:;
3666 : }
3667 : break;
3668 : }
3669 568 : case POINTER_DIFF_EXPR:
3670 568 : {
3671 568 : tree _q40 = TREE_OPERAND (_q30, 0);
3672 568 : tree _q41 = TREE_OPERAND (_q30, 1);
3673 568 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _p0, 0))
3674 : {
3675 7 : {
3676 7 : tree captures[5] ATTRIBUTE_UNUSED = { _q41, _p1, _q30, _q40, _p0 };
3677 7 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) >= TYPE_PRECISION (TREE_TYPE (captures[2]))
3678 : )
3679 : {
3680 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1165;
3681 7 : {
3682 7 : tree res_op0;
3683 7 : res_op0 = captures[3];
3684 7 : tree _r;
3685 7 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3686 7 : if (TREE_SIDE_EFFECTS (captures[4]))
3687 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
3688 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 884, __FILE__, __LINE__, true);
3689 7 : return _r;
3690 : }
3691 0 : next_after_fail1165:;
3692 : }
3693 : }
3694 : }
3695 : break;
3696 : }
3697 : default:;
3698 : }
3699 : break;
3700 : }
3701 27465 : case MINUS_EXPR:
3702 27465 : {
3703 27465 : tree _q30 = TREE_OPERAND (_p1, 0);
3704 27465 : tree _q31 = TREE_OPERAND (_p1, 1);
3705 27465 : switch (TREE_CODE (_q30))
3706 : {
3707 23574 : CASE_CONVERT:
3708 23574 : {
3709 23574 : tree _q40 = TREE_OPERAND (_q30, 0);
3710 23574 : switch (TREE_CODE (_q31))
3711 : {
3712 7562 : CASE_CONVERT:
3713 7562 : {
3714 7562 : tree _q60 = TREE_OPERAND (_q31, 0);
3715 7562 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
3716 : {
3717 20 : {
3718 20 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p1, _p1, _q40 };
3719 20 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (TREE_TYPE (captures[2]))
3720 20 : && ((
3721 :
3722 : && useless_type_conversion_p (type, TREE_TYPE (captures[3])))
3723 : || (
3724 : 1
3725 20 : && type == TREE_TYPE (captures[3])))
3726 : )
3727 : {
3728 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1166;
3729 0 : {
3730 0 : tree _r;
3731 0 : _r = captures[3];
3732 0 : if (TREE_SIDE_EFFECTS (captures[0]))
3733 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3734 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 883, __FILE__, __LINE__, true);
3735 0 : return _r;
3736 : }
3737 0 : next_after_fail1166:;
3738 : }
3739 : }
3740 : }
3741 : break;
3742 : }
3743 : default:;
3744 : }
3745 : break;
3746 : }
3747 972 : case INTEGER_CST:
3748 972 : {
3749 972 : switch (TREE_CODE (_q31))
3750 : {
3751 16 : case BIT_AND_EXPR:
3752 16 : {
3753 16 : tree _q50 = TREE_OPERAND (_q31, 0);
3754 16 : tree _q51 = TREE_OPERAND (_q31, 1);
3755 16 : switch (TREE_CODE (_q50))
3756 : {
3757 16 : CASE_CONVERT:
3758 16 : {
3759 16 : tree _q60 = TREE_OPERAND (_q50, 0);
3760 16 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
3761 : {
3762 0 : switch (TREE_CODE (_q51))
3763 : {
3764 0 : case INTEGER_CST:
3765 0 : {
3766 0 : {
3767 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q51 };
3768 0 : if (tree_int_cst_min_precision (captures[3], UNSIGNED) <= tree_ctz (captures[2])
3769 : )
3770 : {
3771 0 : {
3772 0 : tree algn = wide_int_to_tree (TREE_TYPE (captures[0]), ~wi::to_wide (captures[3]));
3773 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1167;
3774 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1167;
3775 0 : {
3776 0 : tree res_op0;
3777 0 : {
3778 0 : tree _o1[2], _r1;
3779 0 : _o1[0] = captures[0];
3780 0 : _o1[1] = algn;
3781 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3782 0 : res_op0 = _r1;
3783 : }
3784 0 : tree res_op1;
3785 0 : res_op1 = captures[2];
3786 0 : tree _r;
3787 0 : _r = fold_build2_loc (loc, POINTER_PLUS_EXPR, type, res_op0, res_op1);
3788 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 885, __FILE__, __LINE__, true);
3789 0 : return _r;
3790 : }
3791 0 : next_after_fail1167:;
3792 : }
3793 : }
3794 : }
3795 0 : break;
3796 : }
3797 : default:;
3798 : }
3799 : }
3800 16 : switch (TREE_CODE (_q60))
3801 : {
3802 0 : case POINTER_PLUS_EXPR:
3803 0 : {
3804 0 : tree _q70 = TREE_OPERAND (_q60, 0);
3805 0 : tree _q71 = TREE_OPERAND (_q60, 1);
3806 0 : if ((_q70 == _p0 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _p0, 0) && types_match (_q70, _p0)))
3807 : {
3808 0 : switch (TREE_CODE (_q71))
3809 : {
3810 0 : case INTEGER_CST:
3811 0 : {
3812 0 : switch (TREE_CODE (_q51))
3813 : {
3814 0 : case INTEGER_CST:
3815 0 : {
3816 0 : {
3817 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q71, _q51 };
3818 0 : {
3819 0 : auto mask_width = tree_int_cst_min_precision (captures[4], UNSIGNED);
3820 0 : if (mask_width <= tree_ctz (captures[2]) && mask_width <= tree_ctz (captures[3])
3821 : )
3822 : {
3823 0 : {
3824 0 : tree algn = wide_int_to_tree (TREE_TYPE (captures[0]), ~wi::to_wide (captures[4]));
3825 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1168;
3826 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1168;
3827 0 : {
3828 0 : tree res_op0;
3829 0 : {
3830 0 : tree _o1[2], _r1;
3831 0 : _o1[0] = captures[0];
3832 0 : _o1[1] = algn;
3833 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3834 0 : res_op0 = _r1;
3835 : }
3836 0 : tree res_op1;
3837 0 : res_op1 = captures[2];
3838 0 : tree _r;
3839 0 : _r = fold_build2_loc (loc, POINTER_PLUS_EXPR, type, res_op0, res_op1);
3840 0 : if (TREE_SIDE_EFFECTS (captures[3]))
3841 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
3842 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 886, __FILE__, __LINE__, true);
3843 0 : return _r;
3844 : }
3845 0 : next_after_fail1168:;
3846 : }
3847 : }
3848 : }
3849 : }
3850 0 : break;
3851 : }
3852 : default:;
3853 : }
3854 : break;
3855 : }
3856 : default:;
3857 : }
3858 : }
3859 : break;
3860 : }
3861 : default:;
3862 : }
3863 : break;
3864 : }
3865 : default:;
3866 : }
3867 : break;
3868 : }
3869 : default:;
3870 : }
3871 : break;
3872 : }
3873 : default:;
3874 : }
3875 : break;
3876 : }
3877 0 : case POINTER_DIFF_EXPR:
3878 0 : {
3879 0 : tree _q30 = TREE_OPERAND (_p1, 0);
3880 0 : tree _q31 = TREE_OPERAND (_p1, 1);
3881 0 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || operand_equal_p (_q31, _p0, 0))
3882 : {
3883 0 : {
3884 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q31, _p1, _p1, _q30, _p0 };
3885 0 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) >= TYPE_PRECISION (TREE_TYPE (captures[2]))
3886 : )
3887 : {
3888 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1169;
3889 0 : {
3890 0 : tree res_op0;
3891 0 : res_op0 = captures[3];
3892 0 : tree _r;
3893 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3894 0 : if (TREE_SIDE_EFFECTS (captures[4]))
3895 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
3896 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 884, __FILE__, __LINE__, true);
3897 0 : return _r;
3898 : }
3899 0 : next_after_fail1169:;
3900 : }
3901 : }
3902 : }
3903 : break;
3904 : }
3905 639632 : case NEGATE_EXPR:
3906 639632 : {
3907 639632 : tree _q30 = TREE_OPERAND (_p1, 0);
3908 639632 : switch (TREE_CODE (_q30))
3909 : {
3910 22 : case BIT_AND_EXPR:
3911 22 : {
3912 22 : tree _q40 = TREE_OPERAND (_q30, 0);
3913 22 : tree _q41 = TREE_OPERAND (_q30, 1);
3914 22 : switch (TREE_CODE (_q40))
3915 : {
3916 22 : CASE_CONVERT:
3917 22 : {
3918 22 : tree _q50 = TREE_OPERAND (_q40, 0);
3919 22 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
3920 : {
3921 1 : switch (TREE_CODE (_q41))
3922 : {
3923 1 : case INTEGER_CST:
3924 1 : {
3925 1 : {
3926 1 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
3927 1 : {
3928 1 : tree algn = wide_int_to_tree (TREE_TYPE (captures[0]), ~wi::to_wide (captures[1]));
3929 1 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1170;
3930 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1170;
3931 1 : {
3932 1 : tree res_op0;
3933 1 : res_op0 = captures[0];
3934 1 : tree res_op1;
3935 1 : res_op1 = algn;
3936 1 : tree _r;
3937 1 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
3938 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 887, __FILE__, __LINE__, true);
3939 1 : return _r;
3940 : }
3941 0 : next_after_fail1170:;
3942 : }
3943 : }
3944 0 : break;
3945 : }
3946 : default:;
3947 : }
3948 : }
3949 21 : switch (TREE_CODE (_q50))
3950 : {
3951 0 : case POINTER_PLUS_EXPR:
3952 0 : {
3953 0 : tree _q60 = TREE_OPERAND (_q50, 0);
3954 0 : tree _q61 = TREE_OPERAND (_q50, 1);
3955 0 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
3956 : {
3957 0 : switch (TREE_CODE (_q61))
3958 : {
3959 0 : case INTEGER_CST:
3960 0 : {
3961 0 : switch (TREE_CODE (_q41))
3962 : {
3963 0 : case INTEGER_CST:
3964 0 : {
3965 0 : {
3966 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q61, _q41 };
3967 0 : if (tree_int_cst_min_precision (captures[2], UNSIGNED) <= tree_ctz (captures[1])
3968 : )
3969 : {
3970 0 : {
3971 0 : tree algn = wide_int_to_tree (TREE_TYPE (captures[0]), ~wi::to_wide (captures[2]));
3972 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1171;
3973 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1171;
3974 0 : {
3975 0 : tree res_op0;
3976 0 : res_op0 = captures[0];
3977 0 : tree res_op1;
3978 0 : res_op1 = algn;
3979 0 : tree _r;
3980 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
3981 0 : if (TREE_SIDE_EFFECTS (captures[1]))
3982 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3983 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 888, __FILE__, __LINE__, true);
3984 0 : return _r;
3985 : }
3986 0 : next_after_fail1171:;
3987 : }
3988 : }
3989 : }
3990 0 : break;
3991 : }
3992 : default:;
3993 : }
3994 : break;
3995 : }
3996 : default:;
3997 : }
3998 : }
3999 : break;
4000 : }
4001 : default:;
4002 : }
4003 : break;
4004 : }
4005 : default:;
4006 : }
4007 : break;
4008 : }
4009 : default:;
4010 : }
4011 : break;
4012 : }
4013 : default:;
4014 : }
4015 : return NULL_TREE;
4016 : }
4017 :
4018 : tree
4019 40891298 : generic_simplify_NE_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
4020 : {
4021 40891298 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4022 40891298 : switch (TREE_CODE (_p1))
4023 : {
4024 2251 : case NEGATE_EXPR:
4025 2251 : {
4026 2251 : tree _q30 = TREE_OPERAND (_p1, 0);
4027 2251 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
4028 : {
4029 0 : {
4030 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4031 0 : tree res = generic_simplify_202 (loc, type, _p0, _p1, captures, NE_EXPR);
4032 0 : if (res) return res;
4033 : }
4034 : }
4035 : break;
4036 : }
4037 40891298 : default:;
4038 : }
4039 40891298 : switch (TREE_CODE (_p0))
4040 : {
4041 6151 : case NEGATE_EXPR:
4042 6151 : {
4043 6151 : tree _q20 = TREE_OPERAND (_p0, 0);
4044 6151 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4045 : {
4046 88 : {
4047 88 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4048 88 : tree res = generic_simplify_202 (loc, type, _p0, _p1, captures, NE_EXPR);
4049 88 : if (res) return res;
4050 : }
4051 : }
4052 : break;
4053 : }
4054 0 : case CEIL_MOD_EXPR:
4055 0 : {
4056 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4057 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4058 0 : if (integer_pow2p (_q21))
4059 : {
4060 0 : if (integer_zerop (_p1))
4061 : {
4062 0 : {
4063 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4064 0 : tree res = generic_simplify_203 (loc, type, _p0, _p1, captures, NE_EXPR, CEIL_MOD_EXPR);
4065 0 : if (res) return res;
4066 : }
4067 : }
4068 : }
4069 : break;
4070 : }
4071 1623 : case FLOOR_MOD_EXPR:
4072 1623 : {
4073 1623 : tree _q20 = TREE_OPERAND (_p0, 0);
4074 1623 : tree _q21 = TREE_OPERAND (_p0, 1);
4075 1623 : if (integer_pow2p (_q21))
4076 : {
4077 20 : if (integer_zerop (_p1))
4078 : {
4079 20 : {
4080 20 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4081 20 : tree res = generic_simplify_203 (loc, type, _p0, _p1, captures, NE_EXPR, FLOOR_MOD_EXPR);
4082 20 : if (res) return res;
4083 : }
4084 : }
4085 : }
4086 : break;
4087 : }
4088 0 : case ROUND_MOD_EXPR:
4089 0 : {
4090 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4091 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4092 0 : if (integer_pow2p (_q21))
4093 : {
4094 0 : if (integer_zerop (_p1))
4095 : {
4096 0 : {
4097 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4098 0 : tree res = generic_simplify_203 (loc, type, _p0, _p1, captures, NE_EXPR, ROUND_MOD_EXPR);
4099 0 : if (res) return res;
4100 : }
4101 : }
4102 : }
4103 : break;
4104 : }
4105 80551 : case TRUNC_MOD_EXPR:
4106 80551 : {
4107 80551 : tree _q20 = TREE_OPERAND (_p0, 0);
4108 80551 : tree _q21 = TREE_OPERAND (_p0, 1);
4109 80551 : if (integer_pow2p (_q21))
4110 : {
4111 20804 : if (integer_zerop (_p1))
4112 : {
4113 19362 : {
4114 19362 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4115 19362 : tree res = generic_simplify_203 (loc, type, _p0, _p1, captures, NE_EXPR, TRUNC_MOD_EXPR);
4116 19362 : if (res) return res;
4117 : }
4118 : }
4119 : }
4120 : break;
4121 : }
4122 8301138 : CASE_CONVERT:
4123 8301138 : {
4124 8301138 : tree _q20 = TREE_OPERAND (_p0, 0);
4125 8301138 : switch (TREE_CODE (_p1))
4126 : {
4127 69 : case LSHIFT_EXPR:
4128 69 : {
4129 69 : tree _q40 = TREE_OPERAND (_p1, 0);
4130 69 : tree _q41 = TREE_OPERAND (_p1, 1);
4131 69 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
4132 : {
4133 0 : {
4134 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
4135 0 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR);
4136 0 : if (res) return res;
4137 : }
4138 : }
4139 : break;
4140 : }
4141 8301138 : default:;
4142 : }
4143 8301138 : {
4144 8301138 : tree _p1_pops[1];
4145 8301138 : if (tree_nop_convert (_p1, _p1_pops))
4146 : {
4147 3063107 : tree _q40 = _p1_pops[0];
4148 3063107 : switch (TREE_CODE (_q40))
4149 : {
4150 0 : case LSHIFT_EXPR:
4151 0 : {
4152 0 : tree _q50 = TREE_OPERAND (_q40, 0);
4153 0 : tree _q51 = TREE_OPERAND (_q40, 1);
4154 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4155 : {
4156 0 : {
4157 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q20 };
4158 0 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR);
4159 0 : if (res) return res;
4160 : }
4161 : }
4162 : break;
4163 : }
4164 : default:;
4165 : }
4166 : }
4167 : }
4168 8301138 : switch (TREE_CODE (_q20))
4169 : {
4170 0 : case EXACT_DIV_EXPR:
4171 0 : {
4172 0 : tree _q30 = TREE_OPERAND (_q20, 0);
4173 0 : tree _q31 = TREE_OPERAND (_q20, 1);
4174 0 : switch (TREE_CODE (_q31))
4175 : {
4176 0 : case INTEGER_CST:
4177 0 : {
4178 0 : switch (TREE_CODE (_p1))
4179 : {
4180 0 : CASE_CONVERT:
4181 0 : {
4182 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4183 0 : switch (TREE_CODE (_q60))
4184 : {
4185 0 : case EXACT_DIV_EXPR:
4186 0 : {
4187 0 : tree _q70 = TREE_OPERAND (_q60, 0);
4188 0 : tree _q71 = TREE_OPERAND (_q60, 1);
4189 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
4190 : {
4191 0 : {
4192 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q70 };
4193 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
4194 0 : if (res) return res;
4195 : }
4196 : }
4197 : break;
4198 : }
4199 : default:;
4200 : }
4201 : break;
4202 : }
4203 : default:;
4204 : }
4205 : break;
4206 : }
4207 : default:;
4208 : }
4209 : break;
4210 : }
4211 8301138 : default:;
4212 : }
4213 8301138 : switch (TREE_CODE (_p1))
4214 : {
4215 20303 : case PLUS_EXPR:
4216 20303 : {
4217 20303 : tree _q40 = TREE_OPERAND (_p1, 0);
4218 20303 : tree _q41 = TREE_OPERAND (_p1, 1);
4219 20303 : switch (TREE_CODE (_q41))
4220 : {
4221 203 : CASE_CONVERT:
4222 203 : {
4223 203 : tree _q60 = TREE_OPERAND (_q41, 0);
4224 203 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4225 : {
4226 0 : {
4227 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q40, _q20 };
4228 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4229 0 : if (res) return res;
4230 : }
4231 : }
4232 : break;
4233 : }
4234 20303 : default:;
4235 : }
4236 20303 : switch (TREE_CODE (_q40))
4237 : {
4238 796 : CASE_CONVERT:
4239 796 : {
4240 796 : tree _q50 = TREE_OPERAND (_q40, 0);
4241 796 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4242 : {
4243 13 : {
4244 13 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q41, _q20 };
4245 13 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4246 13 : if (res) return res;
4247 : }
4248 : }
4249 : break;
4250 : }
4251 20298 : default:;
4252 : }
4253 20298 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
4254 : {
4255 0 : {
4256 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q40, _q20 };
4257 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4258 0 : if (res) return res;
4259 : }
4260 : }
4261 20298 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
4262 : {
4263 0 : {
4264 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q41, _q20 };
4265 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4266 0 : if (res) return res;
4267 : }
4268 : }
4269 : break;
4270 : }
4271 8301133 : default:;
4272 : }
4273 8301133 : {
4274 8301133 : tree _p1_pops[1];
4275 8301133 : if (tree_nop_convert (_p1, _p1_pops))
4276 : {
4277 3063107 : tree _q40 = _p1_pops[0];
4278 3063107 : switch (TREE_CODE (_q40))
4279 : {
4280 140 : case PLUS_EXPR:
4281 140 : {
4282 140 : tree _q50 = TREE_OPERAND (_q40, 0);
4283 140 : tree _q51 = TREE_OPERAND (_q40, 1);
4284 140 : switch (TREE_CODE (_q51))
4285 : {
4286 0 : CASE_CONVERT:
4287 0 : {
4288 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4289 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4290 : {
4291 0 : {
4292 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q20 };
4293 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4294 0 : if (res) return res;
4295 : }
4296 : }
4297 : break;
4298 : }
4299 140 : default:;
4300 : }
4301 140 : switch (TREE_CODE (_q50))
4302 : {
4303 73 : CASE_CONVERT:
4304 73 : {
4305 73 : tree _q60 = TREE_OPERAND (_q50, 0);
4306 73 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4307 : {
4308 0 : {
4309 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q51, _q20 };
4310 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4311 0 : if (res) return res;
4312 : }
4313 : }
4314 : break;
4315 : }
4316 140 : default:;
4317 : }
4318 140 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4319 : {
4320 0 : {
4321 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q20 };
4322 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4323 0 : if (res) return res;
4324 : }
4325 : }
4326 140 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4327 : {
4328 0 : {
4329 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q51, _q20 };
4330 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4331 0 : if (res) return res;
4332 : }
4333 : }
4334 : break;
4335 : }
4336 : default:;
4337 : }
4338 : }
4339 : }
4340 8301133 : break;
4341 : }
4342 40871911 : default:;
4343 : }
4344 40871911 : {
4345 40871911 : tree _p0_pops[1];
4346 40871911 : if (tree_nop_convert (_p0, _p0_pops))
4347 : {
4348 4902200 : tree _q20 = _p0_pops[0];
4349 4902200 : switch (TREE_CODE (_q20))
4350 : {
4351 15 : case LSHIFT_EXPR:
4352 15 : {
4353 15 : tree _q30 = TREE_OPERAND (_q20, 0);
4354 15 : tree _q31 = TREE_OPERAND (_q20, 1);
4355 15 : switch (TREE_CODE (_p1))
4356 : {
4357 1 : CASE_CONVERT:
4358 1 : {
4359 1 : tree _q60 = TREE_OPERAND (_p1, 0);
4360 1 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
4361 : {
4362 0 : {
4363 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
4364 0 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR);
4365 0 : if (res) return res;
4366 : }
4367 : }
4368 : break;
4369 : }
4370 15 : default:;
4371 : }
4372 15 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
4373 : {
4374 1 : {
4375 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
4376 1 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR);
4377 1 : if (res) return res;
4378 : }
4379 : }
4380 : break;
4381 : }
4382 33388 : case PLUS_EXPR:
4383 33388 : {
4384 33388 : tree _q30 = TREE_OPERAND (_q20, 0);
4385 33388 : tree _q31 = TREE_OPERAND (_q20, 1);
4386 33388 : switch (TREE_CODE (_q31))
4387 : {
4388 37 : CASE_CONVERT:
4389 37 : {
4390 37 : tree _q50 = TREE_OPERAND (_q31, 0);
4391 37 : switch (TREE_CODE (_p1))
4392 : {
4393 0 : CASE_CONVERT:
4394 0 : {
4395 0 : tree _q70 = TREE_OPERAND (_p1, 0);
4396 0 : if ((_q70 == _q50 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q50, 0) && types_match (_q70, _q50)))
4397 : {
4398 0 : {
4399 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50 };
4400 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4401 0 : if (res) return res;
4402 : }
4403 : }
4404 : break;
4405 : }
4406 : default:;
4407 : }
4408 : break;
4409 : }
4410 33388 : default:;
4411 : }
4412 33388 : switch (TREE_CODE (_q30))
4413 : {
4414 28657 : CASE_CONVERT:
4415 28657 : {
4416 28657 : tree _q40 = TREE_OPERAND (_q30, 0);
4417 28657 : switch (TREE_CODE (_p1))
4418 : {
4419 415 : CASE_CONVERT:
4420 415 : {
4421 415 : tree _q70 = TREE_OPERAND (_p1, 0);
4422 415 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
4423 : {
4424 90 : {
4425 90 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q40 };
4426 90 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4427 90 : if (res) return res;
4428 : }
4429 : }
4430 : break;
4431 : }
4432 28567 : default:;
4433 : }
4434 28567 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
4435 : {
4436 11 : {
4437 11 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q40 };
4438 11 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4439 11 : if (res) return res;
4440 : }
4441 : }
4442 : break;
4443 : }
4444 33287 : default:;
4445 : }
4446 33287 : switch (TREE_CODE (_q31))
4447 : {
4448 37 : CASE_CONVERT:
4449 37 : {
4450 37 : tree _q50 = TREE_OPERAND (_q31, 0);
4451 37 : if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
4452 : {
4453 0 : {
4454 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50 };
4455 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4456 0 : if (res) return res;
4457 : }
4458 : }
4459 : break;
4460 : }
4461 33287 : default:;
4462 : }
4463 33287 : switch (TREE_CODE (_p1))
4464 : {
4465 400 : CASE_CONVERT:
4466 400 : {
4467 400 : tree _q60 = TREE_OPERAND (_p1, 0);
4468 400 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
4469 : {
4470 0 : {
4471 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
4472 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4473 0 : if (res) return res;
4474 : }
4475 : }
4476 400 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
4477 : {
4478 68 : {
4479 68 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q30 };
4480 68 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4481 68 : if (res) return res;
4482 : }
4483 : }
4484 : break;
4485 : }
4486 33219 : default:;
4487 : }
4488 33219 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
4489 : {
4490 0 : {
4491 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
4492 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4493 0 : if (res) return res;
4494 : }
4495 : }
4496 33219 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
4497 : {
4498 0 : {
4499 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q30 };
4500 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4501 0 : if (res) return res;
4502 : }
4503 : }
4504 : break;
4505 : }
4506 : default:;
4507 : }
4508 : }
4509 : }
4510 40871741 : {
4511 40871741 : tree _p1_pops[1];
4512 40871741 : if (tree_nop_convert (_p1, _p1_pops))
4513 : {
4514 3436594 : tree _q30 = _p1_pops[0];
4515 3436594 : switch (TREE_CODE (_q30))
4516 : {
4517 0 : case LSHIFT_EXPR:
4518 0 : {
4519 0 : tree _q40 = TREE_OPERAND (_q30, 0);
4520 0 : tree _q41 = TREE_OPERAND (_q30, 1);
4521 0 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
4522 : {
4523 0 : {
4524 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _p0 };
4525 0 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR);
4526 0 : if (res) return res;
4527 : }
4528 : }
4529 : break;
4530 : }
4531 : default:;
4532 : }
4533 : }
4534 : }
4535 40871741 : switch (TREE_CODE (_p0))
4536 : {
4537 5212 : case LSHIFT_EXPR:
4538 5212 : {
4539 5212 : tree _q20 = TREE_OPERAND (_p0, 0);
4540 5212 : tree _q21 = TREE_OPERAND (_p0, 1);
4541 5212 : switch (TREE_CODE (_p1))
4542 : {
4543 35 : CASE_CONVERT:
4544 35 : {
4545 35 : tree _q50 = TREE_OPERAND (_p1, 0);
4546 35 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4547 : {
4548 4 : {
4549 4 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4550 4 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR);
4551 4 : if (res) return res;
4552 : }
4553 : }
4554 : break;
4555 : }
4556 5211 : default:;
4557 : }
4558 5211 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
4559 : {
4560 27 : {
4561 27 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4562 27 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR);
4563 27 : if (res) return res;
4564 : }
4565 : }
4566 5207 : if (tree_zero_one_valued_p (_q20))
4567 : {
4568 484 : switch (TREE_CODE (_q21))
4569 : {
4570 120 : case INTEGER_CST:
4571 120 : {
4572 120 : if (integer_zerop (_p1))
4573 : {
4574 5 : {
4575 5 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4576 5 : if (tree_fits_shwi_p (captures[1])
4577 5 : && tree_to_shwi (captures[1]) > 0
4578 10 : && tree_to_shwi (captures[1]) < TYPE_PRECISION (TREE_TYPE (captures[0]))
4579 : )
4580 : {
4581 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1501;
4582 5 : {
4583 5 : tree res_op0;
4584 5 : res_op0 = captures[0];
4585 5 : tree _r;
4586 5 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4587 5 : if (TREE_SIDE_EFFECTS (captures[1]))
4588 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4589 5 : if (TREE_SIDE_EFFECTS (captures[2]))
4590 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4591 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 970, __FILE__, __LINE__, true);
4592 5 : return _r;
4593 : }
4594 0 : next_after_fail1501:;
4595 : }
4596 : }
4597 : }
4598 : break;
4599 : }
4600 : default:;
4601 : }
4602 : }
4603 : break;
4604 : }
4605 40871731 : default:;
4606 : }
4607 40871731 : switch (TREE_CODE (_p1))
4608 : {
4609 268 : case LSHIFT_EXPR:
4610 268 : {
4611 268 : tree _q30 = TREE_OPERAND (_p1, 0);
4612 268 : tree _q31 = TREE_OPERAND (_p1, 1);
4613 268 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
4614 : {
4615 0 : {
4616 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
4617 0 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR);
4618 0 : if (res) return res;
4619 : }
4620 : }
4621 : break;
4622 : }
4623 40871731 : default:;
4624 : }
4625 40871731 : switch (TREE_CODE (_p0))
4626 : {
4627 55 : case VIEW_CONVERT_EXPR:
4628 55 : {
4629 55 : tree _q20 = TREE_OPERAND (_p0, 0);
4630 55 : if (tree_zero_one_valued_p (_q20))
4631 : {
4632 0 : if (integer_zerop (_p1))
4633 : {
4634 0 : {
4635 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
4636 0 : tree res = generic_simplify_210 (loc, type, _p0, _p1, captures, NE_EXPR);
4637 0 : if (res) return res;
4638 : }
4639 : }
4640 : }
4641 : break;
4642 : }
4643 94963 : case MULT_EXPR:
4644 94963 : {
4645 94963 : tree _q20 = TREE_OPERAND (_p0, 0);
4646 94963 : tree _q21 = TREE_OPERAND (_p0, 1);
4647 94963 : switch (TREE_CODE (_p1))
4648 : {
4649 2891 : case MULT_EXPR:
4650 2891 : {
4651 2891 : tree _q50 = TREE_OPERAND (_p1, 0);
4652 2891 : tree _q51 = TREE_OPERAND (_p1, 1);
4653 2891 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4654 : {
4655 1636 : {
4656 1636 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4657 1636 : tree res = generic_simplify_211 (loc, type, _p0, _p1, captures, NE_EXPR);
4658 1636 : if (res) return res;
4659 : }
4660 : }
4661 2887 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4662 : {
4663 53 : {
4664 53 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
4665 53 : tree res = generic_simplify_211 (loc, type, _p0, _p1, captures, NE_EXPR);
4666 53 : if (res) return res;
4667 : }
4668 : }
4669 2887 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4670 : {
4671 22 : {
4672 22 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
4673 22 : tree res = generic_simplify_211 (loc, type, _p0, _p1, captures, NE_EXPR);
4674 22 : if (res) return res;
4675 : }
4676 : }
4677 2887 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4678 : {
4679 257 : {
4680 257 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
4681 257 : tree res = generic_simplify_211 (loc, type, _p0, _p1, captures, NE_EXPR);
4682 257 : if (res) return res;
4683 : }
4684 : }
4685 : break;
4686 : }
4687 94959 : default:;
4688 : }
4689 94959 : switch (TREE_CODE (_q21))
4690 : {
4691 77452 : case INTEGER_CST:
4692 77452 : {
4693 77452 : switch (TREE_CODE (_p1))
4694 : {
4695 2032 : case MULT_EXPR:
4696 2032 : {
4697 2032 : tree _q50 = TREE_OPERAND (_p1, 0);
4698 2032 : tree _q51 = TREE_OPERAND (_p1, 1);
4699 2032 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4700 : {
4701 1107 : {
4702 1107 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4703 1107 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR);
4704 1107 : if (res) return res;
4705 : }
4706 : }
4707 : break;
4708 : }
4709 : default:;
4710 : }
4711 : break;
4712 : }
4713 : default:;
4714 : }
4715 : break;
4716 : }
4717 2049 : case EXACT_DIV_EXPR:
4718 2049 : {
4719 2049 : tree _q20 = TREE_OPERAND (_p0, 0);
4720 2049 : tree _q21 = TREE_OPERAND (_p0, 1);
4721 2049 : switch (TREE_CODE (_q21))
4722 : {
4723 2049 : case INTEGER_CST:
4724 2049 : {
4725 2049 : switch (TREE_CODE (_p1))
4726 : {
4727 22 : case EXACT_DIV_EXPR:
4728 22 : {
4729 22 : tree _q50 = TREE_OPERAND (_p1, 0);
4730 22 : tree _q51 = TREE_OPERAND (_p1, 1);
4731 22 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4732 : {
4733 12 : {
4734 12 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
4735 12 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
4736 12 : if (res) return res;
4737 : }
4738 : }
4739 : break;
4740 : }
4741 : default:;
4742 : }
4743 : break;
4744 : }
4745 : default:;
4746 : }
4747 : break;
4748 : }
4749 11310 : case TRUNC_DIV_EXPR:
4750 11310 : {
4751 11310 : tree _q20 = TREE_OPERAND (_p0, 0);
4752 11310 : tree _q21 = TREE_OPERAND (_p0, 1);
4753 11310 : switch (TREE_CODE (_q21))
4754 : {
4755 8559 : case INTEGER_CST:
4756 8559 : {
4757 8559 : switch (TREE_CODE (_p1))
4758 : {
4759 2431 : case INTEGER_CST:
4760 2431 : {
4761 2431 : {
4762 2431 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
4763 2431 : tree res = generic_simplify_213 (loc, type, _p0, _p1, captures, NE_EXPR);
4764 2431 : if (res) return res;
4765 : }
4766 326 : break;
4767 : }
4768 : default:;
4769 : }
4770 : break;
4771 : }
4772 : default:;
4773 : }
4774 : break;
4775 : }
4776 20953 : case RSHIFT_EXPR:
4777 20953 : {
4778 20953 : tree _q20 = TREE_OPERAND (_p0, 0);
4779 20953 : tree _q21 = TREE_OPERAND (_p0, 1);
4780 20953 : switch (TREE_CODE (_q21))
4781 : {
4782 18631 : case INTEGER_CST:
4783 18631 : {
4784 18631 : if (integer_zerop (_p1))
4785 : {
4786 7708 : {
4787 7708 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
4788 7708 : tree res = generic_simplify_214 (loc, type, _p0, _p1, captures, NE_EXPR, LT_EXPR);
4789 7708 : if (res) return res;
4790 : }
4791 : }
4792 : break;
4793 : }
4794 : default:;
4795 : }
4796 : break;
4797 : }
4798 1557920 : case PLUS_EXPR:
4799 1557920 : {
4800 1557920 : tree _q20 = TREE_OPERAND (_p0, 0);
4801 1557920 : tree _q21 = TREE_OPERAND (_p0, 1);
4802 1557920 : switch (TREE_CODE (_p1))
4803 : {
4804 188674 : case PLUS_EXPR:
4805 188674 : {
4806 188674 : tree _q50 = TREE_OPERAND (_p1, 0);
4807 188674 : tree _q51 = TREE_OPERAND (_p1, 1);
4808 188674 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4809 : {
4810 857 : {
4811 857 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4812 1714 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4813 1685 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
4814 745 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
4815 : )
4816 : {
4817 828 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1502;
4818 828 : {
4819 828 : tree res_op0;
4820 828 : res_op0 = captures[0];
4821 828 : tree res_op1;
4822 828 : res_op1 = captures[2];
4823 828 : tree _r;
4824 828 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
4825 828 : if (TREE_SIDE_EFFECTS (captures[1]))
4826 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4827 828 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 903, __FILE__, __LINE__, true);
4828 828 : return _r;
4829 : }
4830 0 : next_after_fail1502:;
4831 : }
4832 : }
4833 : }
4834 187846 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4835 : {
4836 0 : {
4837 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
4838 0 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4839 0 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
4840 0 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
4841 : )
4842 : {
4843 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1503;
4844 0 : {
4845 0 : tree res_op0;
4846 0 : res_op0 = captures[0];
4847 0 : tree res_op1;
4848 0 : res_op1 = captures[2];
4849 0 : tree _r;
4850 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
4851 0 : if (TREE_SIDE_EFFECTS (captures[1]))
4852 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4853 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 903, __FILE__, __LINE__, true);
4854 0 : return _r;
4855 : }
4856 0 : next_after_fail1503:;
4857 : }
4858 : }
4859 : }
4860 187846 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4861 : {
4862 132 : {
4863 132 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
4864 264 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4865 264 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
4866 132 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
4867 : )
4868 : {
4869 132 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1504;
4870 132 : {
4871 132 : tree res_op0;
4872 132 : res_op0 = captures[0];
4873 132 : tree res_op1;
4874 132 : res_op1 = captures[2];
4875 132 : tree _r;
4876 132 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
4877 132 : if (TREE_SIDE_EFFECTS (captures[1]))
4878 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4879 132 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 903, __FILE__, __LINE__, true);
4880 132 : return _r;
4881 : }
4882 0 : next_after_fail1504:;
4883 : }
4884 : }
4885 : }
4886 187714 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4887 : {
4888 106576 : {
4889 106576 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
4890 213152 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4891 213131 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
4892 106555 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
4893 : )
4894 : {
4895 106555 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1505;
4896 106555 : {
4897 106555 : tree res_op0;
4898 106555 : res_op0 = captures[0];
4899 106555 : tree res_op1;
4900 106555 : res_op1 = captures[2];
4901 106555 : tree _r;
4902 106555 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
4903 106555 : if (TREE_SIDE_EFFECTS (captures[1]))
4904 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4905 106555 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 903, __FILE__, __LINE__, true);
4906 106555 : return _r;
4907 : }
4908 0 : next_after_fail1505:;
4909 : }
4910 : }
4911 : }
4912 : break;
4913 : }
4914 1450405 : default:;
4915 : }
4916 1450405 : switch (TREE_CODE (_q21))
4917 : {
4918 747 : CASE_CONVERT:
4919 747 : {
4920 747 : tree _q40 = TREE_OPERAND (_q21, 0);
4921 747 : switch (TREE_CODE (_p1))
4922 : {
4923 88 : CASE_CONVERT:
4924 88 : {
4925 88 : tree _q60 = TREE_OPERAND (_p1, 0);
4926 88 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
4927 : {
4928 0 : {
4929 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40 };
4930 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4931 0 : if (res) return res;
4932 : }
4933 : }
4934 : break;
4935 : }
4936 : default:;
4937 : }
4938 : break;
4939 : }
4940 1450405 : default:;
4941 : }
4942 1450405 : switch (TREE_CODE (_q20))
4943 : {
4944 147049 : CASE_CONVERT:
4945 147049 : {
4946 147049 : tree _q30 = TREE_OPERAND (_q20, 0);
4947 147049 : switch (TREE_CODE (_p1))
4948 : {
4949 3733 : CASE_CONVERT:
4950 3733 : {
4951 3733 : tree _q60 = TREE_OPERAND (_p1, 0);
4952 3733 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
4953 : {
4954 399 : {
4955 399 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q30 };
4956 399 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4957 399 : if (res) return res;
4958 : }
4959 : }
4960 : break;
4961 : }
4962 146650 : default:;
4963 : }
4964 146650 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
4965 : {
4966 0 : {
4967 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q30 };
4968 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4969 0 : if (res) return res;
4970 : }
4971 : }
4972 : break;
4973 : }
4974 1450006 : default:;
4975 : }
4976 1450006 : switch (TREE_CODE (_q21))
4977 : {
4978 747 : CASE_CONVERT:
4979 747 : {
4980 747 : tree _q40 = TREE_OPERAND (_q21, 0);
4981 747 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
4982 : {
4983 0 : {
4984 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40 };
4985 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4986 0 : if (res) return res;
4987 : }
4988 : }
4989 : break;
4990 : }
4991 1450006 : default:;
4992 : }
4993 1450006 : switch (TREE_CODE (_p1))
4994 : {
4995 43612 : CASE_CONVERT:
4996 43612 : {
4997 43612 : tree _q50 = TREE_OPERAND (_p1, 0);
4998 43612 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4999 : {
5000 0 : {
5001 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
5002 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
5003 0 : if (res) return res;
5004 : }
5005 : }
5006 43612 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5007 : {
5008 0 : {
5009 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q20 };
5010 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
5011 0 : if (res) return res;
5012 : }
5013 : }
5014 : break;
5015 : }
5016 1450006 : default:;
5017 : }
5018 1450006 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5019 : {
5020 105829 : {
5021 105829 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
5022 105829 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
5023 105829 : if (res) return res;
5024 : }
5025 : }
5026 1344877 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5027 : {
5028 19183 : {
5029 19183 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q20 };
5030 19183 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
5031 19183 : if (res) return res;
5032 : }
5033 : }
5034 : break;
5035 : }
5036 548591 : case POINTER_PLUS_EXPR:
5037 548591 : {
5038 548591 : tree _q20 = TREE_OPERAND (_p0, 0);
5039 548591 : tree _q21 = TREE_OPERAND (_p0, 1);
5040 548591 : switch (TREE_CODE (_p1))
5041 : {
5042 34611 : case POINTER_PLUS_EXPR:
5043 34611 : {
5044 34611 : tree _q50 = TREE_OPERAND (_p1, 0);
5045 34611 : tree _q51 = TREE_OPERAND (_p1, 1);
5046 34611 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5047 : {
5048 8502 : {
5049 8502 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5050 8502 : tree res = generic_simplify_215 (loc, type, _p0, _p1, captures, NE_EXPR);
5051 8502 : if (res) return res;
5052 : }
5053 : }
5054 : break;
5055 : }
5056 540089 : default:;
5057 : }
5058 540089 : switch (TREE_CODE (_q20))
5059 : {
5060 77098 : CASE_CONVERT:
5061 77098 : {
5062 77098 : tree _q30 = TREE_OPERAND (_q20, 0);
5063 77098 : switch (TREE_CODE (_p1))
5064 : {
5065 95 : CASE_CONVERT:
5066 95 : {
5067 95 : tree _q60 = TREE_OPERAND (_p1, 0);
5068 95 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
5069 : {
5070 0 : {
5071 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q30, _q21 };
5072 0 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, NE_EXPR);
5073 0 : if (res) return res;
5074 : }
5075 : }
5076 : break;
5077 : }
5078 77098 : default:;
5079 : }
5080 77098 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
5081 : {
5082 71 : {
5083 71 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q30, _q21 };
5084 71 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, NE_EXPR);
5085 71 : if (res) return res;
5086 : }
5087 : }
5088 : break;
5089 : }
5090 540018 : default:;
5091 : }
5092 540018 : switch (TREE_CODE (_p1))
5093 : {
5094 3555 : CASE_CONVERT:
5095 3555 : {
5096 3555 : tree _q50 = TREE_OPERAND (_p1, 0);
5097 3555 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5098 : {
5099 0 : {
5100 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
5101 0 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, NE_EXPR);
5102 0 : if (res) return res;
5103 : }
5104 : }
5105 : break;
5106 : }
5107 540018 : default:;
5108 : }
5109 540018 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5110 : {
5111 10771 : {
5112 10771 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
5113 10771 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, NE_EXPR);
5114 10771 : if (res) return res;
5115 : }
5116 : }
5117 : break;
5118 : }
5119 107563 : case MINUS_EXPR:
5120 107563 : {
5121 107563 : tree _q20 = TREE_OPERAND (_p0, 0);
5122 107563 : tree _q21 = TREE_OPERAND (_p0, 1);
5123 107563 : switch (TREE_CODE (_p1))
5124 : {
5125 5881 : case MINUS_EXPR:
5126 5881 : {
5127 5881 : tree _q50 = TREE_OPERAND (_p1, 0);
5128 5881 : tree _q51 = TREE_OPERAND (_p1, 1);
5129 5881 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5130 : {
5131 173 : {
5132 173 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5133 346 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
5134 176 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5135 0 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
5136 : )
5137 : {
5138 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1506;
5139 3 : {
5140 3 : tree res_op0;
5141 3 : res_op0 = captures[0];
5142 3 : tree res_op1;
5143 3 : res_op1 = captures[2];
5144 3 : tree _r;
5145 3 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
5146 3 : if (TREE_SIDE_EFFECTS (captures[1]))
5147 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5148 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 904, __FILE__, __LINE__, true);
5149 3 : return _r;
5150 : }
5151 0 : next_after_fail1506:;
5152 : }
5153 : }
5154 : }
5155 5878 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5156 : {
5157 169 : {
5158 169 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5159 338 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
5160 169 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
5161 0 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1])))
5162 : )
5163 : {
5164 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1507;
5165 0 : {
5166 0 : tree res_op0;
5167 0 : res_op0 = captures[2];
5168 0 : tree res_op1;
5169 0 : res_op1 = captures[1];
5170 0 : tree _r;
5171 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
5172 0 : if (TREE_SIDE_EFFECTS (captures[0]))
5173 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
5174 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 905, __FILE__, __LINE__, true);
5175 0 : return _r;
5176 : }
5177 0 : next_after_fail1507:;
5178 : }
5179 : }
5180 : }
5181 : break;
5182 : }
5183 107560 : default:;
5184 : }
5185 107560 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5186 : {
5187 1748 : {
5188 1748 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
5189 1748 : tree res = generic_simplify_217 (loc, type, _p0, _p1, captures, NE_EXPR);
5190 1748 : if (res) return res;
5191 : }
5192 : }
5193 : break;
5194 : }
5195 26658 : case POINTER_DIFF_EXPR:
5196 26658 : {
5197 26658 : tree _q20 = TREE_OPERAND (_p0, 0);
5198 26658 : tree _q21 = TREE_OPERAND (_p0, 1);
5199 26658 : switch (TREE_CODE (_p1))
5200 : {
5201 2269 : case POINTER_DIFF_EXPR:
5202 2269 : {
5203 2269 : tree _q50 = TREE_OPERAND (_p1, 0);
5204 2269 : tree _q51 = TREE_OPERAND (_p1, 1);
5205 2269 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5206 : {
5207 0 : {
5208 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
5209 0 : tree res = generic_simplify_218 (loc, type, _p0, _p1, captures, NE_EXPR);
5210 0 : if (res) return res;
5211 : }
5212 : }
5213 2269 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5214 : {
5215 0 : {
5216 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
5217 0 : tree res = generic_simplify_219 (loc, type, _p0, _p1, captures, NE_EXPR);
5218 0 : if (res) return res;
5219 : }
5220 : }
5221 : break;
5222 : }
5223 : default:;
5224 : }
5225 : break;
5226 : }
5227 40616150 : default:;
5228 : }
5229 40616150 : {
5230 40616150 : tree _p0_pops[1];
5231 40616150 : if (tree_logical_inverted_value (_p0, _p0_pops))
5232 : {
5233 727463 : tree _q20 = _p0_pops[0];
5234 727463 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5235 : {
5236 24 : if (tree_truth_valued_p (_p1))
5237 : {
5238 0 : {
5239 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
5240 0 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
5241 0 : if (res) return res;
5242 : }
5243 : }
5244 : }
5245 : }
5246 : }
5247 40616150 : if (tree_truth_valued_p (_p0))
5248 : {
5249 6375695 : {
5250 6375695 : tree _p1_pops[1];
5251 6375695 : if (tree_logical_inverted_value (_p1, _p1_pops))
5252 : {
5253 1115 : tree _q30 = _p1_pops[0];
5254 1115 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5255 : {
5256 0 : {
5257 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
5258 0 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
5259 0 : if (res) return res;
5260 : }
5261 : }
5262 : }
5263 : }
5264 : }
5265 40616150 : switch (TREE_CODE (_p1))
5266 : {
5267 122113 : case PLUS_EXPR:
5268 122113 : {
5269 122113 : tree _q30 = TREE_OPERAND (_p1, 0);
5270 122113 : tree _q31 = TREE_OPERAND (_p1, 1);
5271 122113 : switch (TREE_CODE (_q31))
5272 : {
5273 346 : CASE_CONVERT:
5274 346 : {
5275 346 : tree _q50 = TREE_OPERAND (_q31, 0);
5276 346 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
5277 : {
5278 0 : {
5279 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0 };
5280 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
5281 0 : if (res) return res;
5282 : }
5283 : }
5284 : break;
5285 : }
5286 122113 : default:;
5287 : }
5288 122113 : switch (TREE_CODE (_q30))
5289 : {
5290 6010 : CASE_CONVERT:
5291 6010 : {
5292 6010 : tree _q40 = TREE_OPERAND (_q30, 0);
5293 6010 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
5294 : {
5295 0 : {
5296 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q31, _p0 };
5297 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
5298 0 : if (res) return res;
5299 : }
5300 : }
5301 : break;
5302 : }
5303 122113 : default:;
5304 : }
5305 122113 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5306 : {
5307 0 : {
5308 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0 };
5309 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
5310 0 : if (res) return res;
5311 : }
5312 : }
5313 122113 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5314 : {
5315 8 : {
5316 8 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q31, _p0 };
5317 8 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
5318 8 : if (res) return res;
5319 : }
5320 : }
5321 : break;
5322 : }
5323 40616142 : default:;
5324 : }
5325 40616142 : {
5326 40616142 : tree _p1_pops[1];
5327 40616142 : if (tree_nop_convert (_p1, _p1_pops))
5328 : {
5329 3436193 : tree _q30 = _p1_pops[0];
5330 3436193 : switch (TREE_CODE (_q30))
5331 : {
5332 1109 : case PLUS_EXPR:
5333 1109 : {
5334 1109 : tree _q40 = TREE_OPERAND (_q30, 0);
5335 1109 : tree _q41 = TREE_OPERAND (_q30, 1);
5336 1109 : switch (TREE_CODE (_q41))
5337 : {
5338 3 : CASE_CONVERT:
5339 3 : {
5340 3 : tree _q60 = TREE_OPERAND (_q41, 0);
5341 3 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
5342 : {
5343 0 : {
5344 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0 };
5345 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
5346 0 : if (res) return res;
5347 : }
5348 : }
5349 : break;
5350 : }
5351 1109 : default:;
5352 : }
5353 1109 : switch (TREE_CODE (_q40))
5354 : {
5355 553 : CASE_CONVERT:
5356 553 : {
5357 553 : tree _q50 = TREE_OPERAND (_q40, 0);
5358 553 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
5359 : {
5360 0 : {
5361 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q41, _p0 };
5362 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
5363 0 : if (res) return res;
5364 : }
5365 : }
5366 : break;
5367 : }
5368 1109 : default:;
5369 : }
5370 1109 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
5371 : {
5372 0 : {
5373 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0 };
5374 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
5375 0 : if (res) return res;
5376 : }
5377 : }
5378 1109 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
5379 : {
5380 0 : {
5381 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q41, _p0 };
5382 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
5383 0 : if (res) return res;
5384 : }
5385 : }
5386 : break;
5387 : }
5388 : default:;
5389 : }
5390 : }
5391 : }
5392 40616142 : switch (TREE_CODE (_p0))
5393 : {
5394 8300955 : CASE_CONVERT:
5395 8300955 : {
5396 8300955 : tree _q20 = TREE_OPERAND (_p0, 0);
5397 8300955 : switch (TREE_CODE (_p1))
5398 : {
5399 334 : case POINTER_PLUS_EXPR:
5400 334 : {
5401 334 : tree _q40 = TREE_OPERAND (_p1, 0);
5402 334 : tree _q41 = TREE_OPERAND (_p1, 1);
5403 334 : switch (TREE_CODE (_q40))
5404 : {
5405 48 : CASE_CONVERT:
5406 48 : {
5407 48 : tree _q50 = TREE_OPERAND (_q40, 0);
5408 48 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5409 : {
5410 0 : {
5411 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q20, _q41 };
5412 0 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, NE_EXPR);
5413 0 : if (res) return res;
5414 : }
5415 : }
5416 : break;
5417 : }
5418 334 : default:;
5419 : }
5420 334 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
5421 : {
5422 0 : {
5423 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q20, _q41 };
5424 0 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, NE_EXPR);
5425 0 : if (res) return res;
5426 : }
5427 : }
5428 : break;
5429 : }
5430 8300955 : default:;
5431 : }
5432 8300955 : {
5433 8300955 : tree _p1_pops[1];
5434 8300955 : if (tree_nop_convert (_p1, _p1_pops))
5435 : {
5436 3062949 : tree _q40 = _p1_pops[0];
5437 3062949 : switch (TREE_CODE (_q40))
5438 : {
5439 50 : case POINTER_PLUS_EXPR:
5440 50 : {
5441 50 : tree _q50 = TREE_OPERAND (_q40, 0);
5442 50 : tree _q51 = TREE_OPERAND (_q40, 1);
5443 50 : switch (TREE_CODE (_q50))
5444 : {
5445 8 : CASE_CONVERT:
5446 8 : {
5447 8 : tree _q60 = TREE_OPERAND (_q50, 0);
5448 8 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
5449 : {
5450 0 : {
5451 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q20, _q51 };
5452 0 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, NE_EXPR);
5453 0 : if (res) return res;
5454 : }
5455 : }
5456 : break;
5457 : }
5458 50 : default:;
5459 : }
5460 50 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5461 : {
5462 0 : {
5463 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q20, _q51 };
5464 0 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, NE_EXPR);
5465 0 : if (res) return res;
5466 : }
5467 : }
5468 : break;
5469 : }
5470 : default:;
5471 : }
5472 : }
5473 : }
5474 8300955 : break;
5475 : }
5476 40616142 : default:;
5477 : }
5478 40616142 : {
5479 40616142 : tree _p0_pops[1];
5480 40616142 : if (tree_nop_convert (_p0, _p0_pops))
5481 : {
5482 4902030 : tree _q20 = _p0_pops[0];
5483 4902030 : switch (TREE_CODE (_q20))
5484 : {
5485 1845 : case POINTER_PLUS_EXPR:
5486 1845 : {
5487 1845 : tree _q30 = TREE_OPERAND (_q20, 0);
5488 1845 : tree _q31 = TREE_OPERAND (_q20, 1);
5489 1845 : switch (TREE_CODE (_q30))
5490 : {
5491 52 : CASE_CONVERT:
5492 52 : {
5493 52 : tree _q40 = TREE_OPERAND (_q30, 0);
5494 52 : switch (TREE_CODE (_p1))
5495 : {
5496 36 : CASE_CONVERT:
5497 36 : {
5498 36 : tree _q70 = TREE_OPERAND (_p1, 0);
5499 36 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
5500 : {
5501 0 : {
5502 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31 };
5503 0 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, NE_EXPR);
5504 0 : if (res) return res;
5505 : }
5506 : }
5507 : break;
5508 : }
5509 52 : default:;
5510 : }
5511 52 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
5512 : {
5513 0 : {
5514 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31 };
5515 0 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, NE_EXPR);
5516 0 : if (res) return res;
5517 : }
5518 : }
5519 : break;
5520 : }
5521 1845 : default:;
5522 : }
5523 1845 : switch (TREE_CODE (_p1))
5524 : {
5525 52 : CASE_CONVERT:
5526 52 : {
5527 52 : tree _q60 = TREE_OPERAND (_p1, 0);
5528 52 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
5529 : {
5530 0 : {
5531 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
5532 0 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, NE_EXPR);
5533 0 : if (res) return res;
5534 : }
5535 : }
5536 : break;
5537 : }
5538 1845 : default:;
5539 : }
5540 1845 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
5541 : {
5542 3 : {
5543 3 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
5544 3 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, NE_EXPR);
5545 3 : if (res) return res;
5546 : }
5547 : }
5548 : break;
5549 : }
5550 : default:;
5551 : }
5552 : }
5553 : }
5554 40616139 : switch (TREE_CODE (_p1))
5555 : {
5556 30219 : case POINTER_PLUS_EXPR:
5557 30219 : {
5558 30219 : tree _q30 = TREE_OPERAND (_p1, 0);
5559 30219 : tree _q31 = TREE_OPERAND (_p1, 1);
5560 30219 : switch (TREE_CODE (_q30))
5561 : {
5562 2714 : CASE_CONVERT:
5563 2714 : {
5564 2714 : tree _q40 = TREE_OPERAND (_q30, 0);
5565 2714 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
5566 : {
5567 0 : {
5568 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _p0, _q31 };
5569 0 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, NE_EXPR);
5570 0 : if (res) return res;
5571 : }
5572 : }
5573 : break;
5574 : }
5575 30219 : default:;
5576 : }
5577 30219 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5578 : {
5579 0 : {
5580 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _p0, _q31 };
5581 0 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, NE_EXPR);
5582 0 : if (res) return res;
5583 : }
5584 : }
5585 : break;
5586 : }
5587 40616139 : default:;
5588 : }
5589 40616139 : {
5590 40616139 : tree _p1_pops[1];
5591 40616139 : if (tree_nop_convert (_p1, _p1_pops))
5592 : {
5593 3436193 : tree _q30 = _p1_pops[0];
5594 3436193 : switch (TREE_CODE (_q30))
5595 : {
5596 389 : case POINTER_PLUS_EXPR:
5597 389 : {
5598 389 : tree _q40 = TREE_OPERAND (_q30, 0);
5599 389 : tree _q41 = TREE_OPERAND (_q30, 1);
5600 389 : switch (TREE_CODE (_q40))
5601 : {
5602 8 : CASE_CONVERT:
5603 8 : {
5604 8 : tree _q50 = TREE_OPERAND (_q40, 0);
5605 8 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
5606 : {
5607 0 : {
5608 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _p0, _q41 };
5609 0 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, NE_EXPR);
5610 0 : if (res) return res;
5611 : }
5612 : }
5613 : break;
5614 : }
5615 389 : default:;
5616 : }
5617 389 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
5618 : {
5619 0 : {
5620 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _p0, _q41 };
5621 0 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, NE_EXPR);
5622 0 : if (res) return res;
5623 : }
5624 : }
5625 : break;
5626 : }
5627 : default:;
5628 : }
5629 : }
5630 : }
5631 40616139 : switch (TREE_CODE (_p0))
5632 : {
5633 529247 : case POINTER_PLUS_EXPR:
5634 529247 : {
5635 529247 : tree _q20 = TREE_OPERAND (_p0, 0);
5636 529247 : tree _q21 = TREE_OPERAND (_p0, 1);
5637 529247 : switch (TREE_CODE (_p1))
5638 : {
5639 45066 : case ADDR_EXPR:
5640 45066 : {
5641 45066 : {
5642 45066 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5643 45066 : tree res = generic_simplify_221 (loc, type, _p0, _p1, captures, NE_EXPR);
5644 45066 : if (res) return res;
5645 : }
5646 33683 : break;
5647 : }
5648 517864 : default:;
5649 : }
5650 517864 : switch (TREE_CODE (_q20))
5651 : {
5652 4883 : case ADDR_EXPR:
5653 4883 : {
5654 4883 : switch (TREE_CODE (_p1))
5655 : {
5656 264 : case POINTER_PLUS_EXPR:
5657 264 : {
5658 264 : tree _q50 = TREE_OPERAND (_p1, 0);
5659 264 : tree _q51 = TREE_OPERAND (_p1, 1);
5660 264 : switch (TREE_CODE (_q50))
5661 : {
5662 0 : case ADDR_EXPR:
5663 0 : {
5664 0 : {
5665 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51 };
5666 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, NE_EXPR);
5667 0 : if (res) return res;
5668 : }
5669 0 : break;
5670 : }
5671 : default:;
5672 : }
5673 : break;
5674 : }
5675 : default:;
5676 : }
5677 : break;
5678 : }
5679 : default:;
5680 : }
5681 : break;
5682 : }
5683 197938 : case ADDR_EXPR:
5684 197938 : {
5685 197938 : switch (TREE_CODE (_p1))
5686 : {
5687 0 : case POINTER_PLUS_EXPR:
5688 0 : {
5689 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5690 0 : tree _q31 = TREE_OPERAND (_p1, 1);
5691 0 : {
5692 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
5693 0 : tree res = generic_simplify_221 (loc, type, _p0, _p1, captures, NE_EXPR);
5694 0 : if (res) return res;
5695 : }
5696 0 : break;
5697 : }
5698 : default:;
5699 : }
5700 : break;
5701 : }
5702 40604756 : default:;
5703 : }
5704 40604756 : switch (TREE_CODE (_p1))
5705 : {
5706 30841 : case MINUS_EXPR:
5707 30841 : {
5708 30841 : tree _q30 = TREE_OPERAND (_p1, 0);
5709 30841 : tree _q31 = TREE_OPERAND (_p1, 1);
5710 30841 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5711 : {
5712 0 : {
5713 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
5714 0 : tree res = generic_simplify_217 (loc, type, _p0, _p1, captures, NE_EXPR);
5715 0 : if (res) return res;
5716 : }
5717 : }
5718 : break;
5719 : }
5720 40604756 : default:;
5721 : }
5722 40604756 : switch (TREE_CODE (_p0))
5723 : {
5724 9205 : case TRUNC_DIV_EXPR:
5725 9205 : {
5726 9205 : tree _q20 = TREE_OPERAND (_p0, 0);
5727 9205 : tree _q21 = TREE_OPERAND (_p0, 1);
5728 9205 : if (integer_zerop (_p1))
5729 : {
5730 1037 : {
5731 1037 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5732 1037 : tree res = generic_simplify_223 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR);
5733 1037 : if (res) return res;
5734 : }
5735 : }
5736 : break;
5737 : }
5738 8300952 : CASE_CONVERT:
5739 8300952 : {
5740 8300952 : tree _q20 = TREE_OPERAND (_p0, 0);
5741 8300952 : switch (TREE_CODE (_p1))
5742 : {
5743 3204202 : CASE_CONVERT:
5744 3204202 : {
5745 3204202 : tree _q40 = TREE_OPERAND (_p1, 0);
5746 3204202 : switch (TREE_CODE (_q40))
5747 : {
5748 0 : case MINUS_EXPR:
5749 0 : {
5750 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5751 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5752 0 : switch (TREE_CODE (_q50))
5753 : {
5754 0 : case INTEGER_CST:
5755 0 : {
5756 0 : switch (TREE_CODE (_q51))
5757 : {
5758 0 : CASE_CONVERT:
5759 0 : {
5760 0 : tree _q70 = TREE_OPERAND (_q51, 0);
5761 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
5762 : {
5763 0 : {
5764 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
5765 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5766 0 : if (res) return res;
5767 : }
5768 : }
5769 : break;
5770 : }
5771 : default:;
5772 : }
5773 : break;
5774 : }
5775 : default:;
5776 : }
5777 : break;
5778 : }
5779 : default:;
5780 : }
5781 : break;
5782 : }
5783 8300952 : default:;
5784 : }
5785 8300952 : switch (TREE_CODE (_q20))
5786 : {
5787 99 : case MINUS_EXPR:
5788 99 : {
5789 99 : tree _q30 = TREE_OPERAND (_q20, 0);
5790 99 : tree _q31 = TREE_OPERAND (_q20, 1);
5791 99 : switch (TREE_CODE (_q30))
5792 : {
5793 49 : case INTEGER_CST:
5794 49 : {
5795 49 : switch (TREE_CODE (_q31))
5796 : {
5797 0 : CASE_CONVERT:
5798 0 : {
5799 0 : tree _q50 = TREE_OPERAND (_q31, 0);
5800 0 : switch (TREE_CODE (_p1))
5801 : {
5802 0 : CASE_CONVERT:
5803 0 : {
5804 0 : tree _q70 = TREE_OPERAND (_p1, 0);
5805 0 : if ((_q70 == _q50 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q50, 0) && types_match (_q70, _q50)))
5806 : {
5807 0 : {
5808 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
5809 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5810 0 : if (res) return res;
5811 : }
5812 : }
5813 : break;
5814 : }
5815 0 : default:;
5816 : }
5817 0 : if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
5818 : {
5819 0 : {
5820 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
5821 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5822 0 : if (res) return res;
5823 : }
5824 : }
5825 : break;
5826 : }
5827 49 : default:;
5828 : }
5829 49 : switch (TREE_CODE (_p1))
5830 : {
5831 0 : CASE_CONVERT:
5832 0 : {
5833 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5834 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
5835 : {
5836 0 : {
5837 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q30 };
5838 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5839 0 : if (res) return res;
5840 : }
5841 : }
5842 : break;
5843 : }
5844 49 : default:;
5845 : }
5846 49 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
5847 : {
5848 0 : {
5849 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q30 };
5850 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5851 0 : if (res) return res;
5852 : }
5853 : }
5854 : break;
5855 : }
5856 : default:;
5857 : }
5858 : break;
5859 : }
5860 8300952 : default:;
5861 : }
5862 8300952 : switch (TREE_CODE (_p1))
5863 : {
5864 3204202 : CASE_CONVERT:
5865 3204202 : {
5866 3204202 : tree _q40 = TREE_OPERAND (_p1, 0);
5867 3204202 : switch (TREE_CODE (_q40))
5868 : {
5869 0 : case MINUS_EXPR:
5870 0 : {
5871 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5872 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5873 0 : switch (TREE_CODE (_q50))
5874 : {
5875 0 : case INTEGER_CST:
5876 0 : {
5877 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5878 : {
5879 0 : {
5880 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
5881 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5882 0 : if (res) return res;
5883 : }
5884 : }
5885 : break;
5886 : }
5887 : default:;
5888 : }
5889 : break;
5890 : }
5891 : default:;
5892 : }
5893 : break;
5894 : }
5895 21676 : case MINUS_EXPR:
5896 21676 : {
5897 21676 : tree _q40 = TREE_OPERAND (_p1, 0);
5898 21676 : tree _q41 = TREE_OPERAND (_p1, 1);
5899 21676 : switch (TREE_CODE (_q40))
5900 : {
5901 401 : case INTEGER_CST:
5902 401 : {
5903 401 : switch (TREE_CODE (_q41))
5904 : {
5905 20 : CASE_CONVERT:
5906 20 : {
5907 20 : tree _q60 = TREE_OPERAND (_q41, 0);
5908 20 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
5909 : {
5910 0 : {
5911 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
5912 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5913 0 : if (res) return res;
5914 : }
5915 : }
5916 : break;
5917 : }
5918 401 : default:;
5919 : }
5920 401 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
5921 : {
5922 0 : {
5923 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
5924 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5925 0 : if (res) return res;
5926 : }
5927 : }
5928 : break;
5929 : }
5930 : default:;
5931 : }
5932 : break;
5933 : }
5934 : default:;
5935 : }
5936 : break;
5937 : }
5938 105852 : case MINUS_EXPR:
5939 105852 : {
5940 105852 : tree _q20 = TREE_OPERAND (_p0, 0);
5941 105852 : tree _q21 = TREE_OPERAND (_p0, 1);
5942 105852 : switch (TREE_CODE (_q20))
5943 : {
5944 2119 : case INTEGER_CST:
5945 2119 : {
5946 2119 : switch (TREE_CODE (_q21))
5947 : {
5948 182 : CASE_CONVERT:
5949 182 : {
5950 182 : tree _q40 = TREE_OPERAND (_q21, 0);
5951 182 : switch (TREE_CODE (_p1))
5952 : {
5953 0 : CASE_CONVERT:
5954 0 : {
5955 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5956 0 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
5957 : {
5958 0 : {
5959 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
5960 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5961 0 : if (res) return res;
5962 : }
5963 : }
5964 : break;
5965 : }
5966 182 : default:;
5967 : }
5968 182 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
5969 : {
5970 0 : {
5971 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
5972 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5973 0 : if (res) return res;
5974 : }
5975 : }
5976 : break;
5977 : }
5978 2119 : default:;
5979 : }
5980 2119 : switch (TREE_CODE (_p1))
5981 : {
5982 306 : CASE_CONVERT:
5983 306 : {
5984 306 : tree _q50 = TREE_OPERAND (_p1, 0);
5985 306 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5986 : {
5987 0 : {
5988 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
5989 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5990 0 : if (res) return res;
5991 : }
5992 : }
5993 : break;
5994 : }
5995 2119 : default:;
5996 : }
5997 2119 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5998 : {
5999 1 : {
6000 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6001 1 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
6002 1 : if (res) return res;
6003 : }
6004 : }
6005 : break;
6006 : }
6007 : default:;
6008 : }
6009 : break;
6010 : }
6011 40604640 : default:;
6012 : }
6013 40604640 : switch (TREE_CODE (_p1))
6014 : {
6015 3604497 : CASE_CONVERT:
6016 3604497 : {
6017 3604497 : tree _q30 = TREE_OPERAND (_p1, 0);
6018 3604497 : switch (TREE_CODE (_q30))
6019 : {
6020 556 : case MINUS_EXPR:
6021 556 : {
6022 556 : tree _q40 = TREE_OPERAND (_q30, 0);
6023 556 : tree _q41 = TREE_OPERAND (_q30, 1);
6024 556 : switch (TREE_CODE (_q40))
6025 : {
6026 17 : case INTEGER_CST:
6027 17 : {
6028 17 : switch (TREE_CODE (_q41))
6029 : {
6030 0 : CASE_CONVERT:
6031 0 : {
6032 0 : tree _q60 = TREE_OPERAND (_q41, 0);
6033 0 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
6034 : {
6035 0 : {
6036 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
6037 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
6038 0 : if (res) return res;
6039 : }
6040 : }
6041 : break;
6042 : }
6043 17 : default:;
6044 : }
6045 17 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
6046 : {
6047 0 : {
6048 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
6049 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
6050 0 : if (res) return res;
6051 : }
6052 : }
6053 : break;
6054 : }
6055 : default:;
6056 : }
6057 : break;
6058 : }
6059 : default:;
6060 : }
6061 : break;
6062 : }
6063 30841 : case MINUS_EXPR:
6064 30841 : {
6065 30841 : tree _q30 = TREE_OPERAND (_p1, 0);
6066 30841 : tree _q31 = TREE_OPERAND (_p1, 1);
6067 30841 : switch (TREE_CODE (_q30))
6068 : {
6069 600 : case INTEGER_CST:
6070 600 : {
6071 600 : switch (TREE_CODE (_q31))
6072 : {
6073 32 : CASE_CONVERT:
6074 32 : {
6075 32 : tree _q50 = TREE_OPERAND (_q31, 0);
6076 32 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
6077 : {
6078 0 : {
6079 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
6080 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
6081 0 : if (res) return res;
6082 : }
6083 : }
6084 : break;
6085 : }
6086 600 : default:;
6087 : }
6088 600 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6089 : {
6090 0 : {
6091 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
6092 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
6093 0 : if (res) return res;
6094 : }
6095 : }
6096 : break;
6097 : }
6098 : default:;
6099 : }
6100 : break;
6101 : }
6102 40604640 : default:;
6103 : }
6104 40604640 : switch (TREE_CODE (_p0))
6105 : {
6106 18024 : case LT_EXPR:
6107 18024 : {
6108 18024 : tree _q20 = TREE_OPERAND (_p0, 0);
6109 18024 : tree _q21 = TREE_OPERAND (_p0, 1);
6110 18024 : switch (TREE_CODE (_p1))
6111 : {
6112 18 : case GT_EXPR:
6113 18 : {
6114 18 : tree _q50 = TREE_OPERAND (_p1, 0);
6115 18 : tree _q51 = TREE_OPERAND (_p1, 1);
6116 18 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6117 : {
6118 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6119 : {
6120 0 : {
6121 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6122 0 : const enum tree_code cmp1 = LT_EXPR;
6123 0 : const enum tree_code cmp2 = GT_EXPR;
6124 0 : const enum tree_code rcmp = NE_EXPR;
6125 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6126 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6127 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6128 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6129 : )
6130 : {
6131 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1508;
6132 0 : {
6133 0 : tree res_op0;
6134 0 : res_op0 = captures[0];
6135 0 : tree res_op1;
6136 0 : res_op1 = captures[1];
6137 0 : tree _r;
6138 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6139 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6140 0 : return _r;
6141 : }
6142 0 : next_after_fail1508:;
6143 : }
6144 : }
6145 : }
6146 : }
6147 : break;
6148 : }
6149 23 : case EQ_EXPR:
6150 23 : {
6151 23 : tree _q50 = TREE_OPERAND (_p1, 0);
6152 23 : tree _q51 = TREE_OPERAND (_p1, 1);
6153 23 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6154 : {
6155 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6156 : {
6157 0 : {
6158 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6159 0 : const enum tree_code cmp1 = LT_EXPR;
6160 0 : const enum tree_code cmp2 = EQ_EXPR;
6161 0 : const enum tree_code rcmp = LE_EXPR;
6162 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6163 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6164 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6165 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6166 : )
6167 : {
6168 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1509;
6169 0 : {
6170 0 : tree res_op0;
6171 0 : res_op0 = captures[0];
6172 0 : tree res_op1;
6173 0 : res_op1 = captures[1];
6174 0 : tree _r;
6175 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6176 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6177 0 : return _r;
6178 : }
6179 0 : next_after_fail1509:;
6180 : }
6181 : }
6182 : }
6183 : }
6184 : break;
6185 : }
6186 23 : case NE_EXPR:
6187 23 : {
6188 23 : tree _q50 = TREE_OPERAND (_p1, 0);
6189 23 : tree _q51 = TREE_OPERAND (_p1, 1);
6190 23 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6191 : {
6192 9 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6193 : {
6194 0 : {
6195 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6196 0 : const enum tree_code cmp1 = LT_EXPR;
6197 0 : const enum tree_code cmp2 = NE_EXPR;
6198 0 : const enum tree_code rcmp = GT_EXPR;
6199 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6200 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6201 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6202 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6203 : )
6204 : {
6205 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1510;
6206 0 : {
6207 0 : tree res_op0;
6208 0 : res_op0 = captures[0];
6209 0 : tree res_op1;
6210 0 : res_op1 = captures[1];
6211 0 : tree _r;
6212 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6213 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6214 0 : return _r;
6215 : }
6216 0 : next_after_fail1510:;
6217 : }
6218 : }
6219 : }
6220 : }
6221 : break;
6222 : }
6223 : default:;
6224 : }
6225 : break;
6226 : }
6227 11848 : case LE_EXPR:
6228 11848 : {
6229 11848 : tree _q20 = TREE_OPERAND (_p0, 0);
6230 11848 : tree _q21 = TREE_OPERAND (_p0, 1);
6231 11848 : switch (TREE_CODE (_p1))
6232 : {
6233 25 : case GE_EXPR:
6234 25 : {
6235 25 : tree _q50 = TREE_OPERAND (_p1, 0);
6236 25 : tree _q51 = TREE_OPERAND (_p1, 1);
6237 25 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6238 : {
6239 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6240 : {
6241 0 : {
6242 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6243 0 : const enum tree_code cmp1 = LE_EXPR;
6244 0 : const enum tree_code cmp2 = GE_EXPR;
6245 0 : const enum tree_code rcmp = NE_EXPR;
6246 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6247 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6248 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6249 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6250 : )
6251 : {
6252 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1511;
6253 0 : {
6254 0 : tree res_op0;
6255 0 : res_op0 = captures[0];
6256 0 : tree res_op1;
6257 0 : res_op1 = captures[1];
6258 0 : tree _r;
6259 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6260 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6261 0 : return _r;
6262 : }
6263 0 : next_after_fail1511:;
6264 : }
6265 : }
6266 : }
6267 : }
6268 : break;
6269 : }
6270 41 : case EQ_EXPR:
6271 41 : {
6272 41 : tree _q50 = TREE_OPERAND (_p1, 0);
6273 41 : tree _q51 = TREE_OPERAND (_p1, 1);
6274 41 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6275 : {
6276 9 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6277 : {
6278 0 : {
6279 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6280 0 : const enum tree_code cmp1 = LE_EXPR;
6281 0 : const enum tree_code cmp2 = EQ_EXPR;
6282 0 : const enum tree_code rcmp = LT_EXPR;
6283 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6284 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6285 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6286 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6287 : )
6288 : {
6289 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1512;
6290 0 : {
6291 0 : tree res_op0;
6292 0 : res_op0 = captures[0];
6293 0 : tree res_op1;
6294 0 : res_op1 = captures[1];
6295 0 : tree _r;
6296 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6297 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6298 0 : return _r;
6299 : }
6300 0 : next_after_fail1512:;
6301 : }
6302 : }
6303 : }
6304 : }
6305 : break;
6306 : }
6307 13 : case NE_EXPR:
6308 13 : {
6309 13 : tree _q50 = TREE_OPERAND (_p1, 0);
6310 13 : tree _q51 = TREE_OPERAND (_p1, 1);
6311 13 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6312 : {
6313 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6314 : {
6315 0 : {
6316 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6317 0 : const enum tree_code cmp1 = LE_EXPR;
6318 0 : const enum tree_code cmp2 = NE_EXPR;
6319 0 : const enum tree_code rcmp = GE_EXPR;
6320 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6321 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6322 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6323 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6324 : )
6325 : {
6326 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1513;
6327 0 : {
6328 0 : tree res_op0;
6329 0 : res_op0 = captures[0];
6330 0 : tree res_op1;
6331 0 : res_op1 = captures[1];
6332 0 : tree _r;
6333 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6334 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6335 0 : return _r;
6336 : }
6337 0 : next_after_fail1513:;
6338 : }
6339 : }
6340 : }
6341 : }
6342 : break;
6343 : }
6344 : default:;
6345 : }
6346 : break;
6347 : }
6348 35311 : case GT_EXPR:
6349 35311 : {
6350 35311 : tree _q20 = TREE_OPERAND (_p0, 0);
6351 35311 : tree _q21 = TREE_OPERAND (_p0, 1);
6352 35311 : switch (TREE_CODE (_p1))
6353 : {
6354 77 : case GT_EXPR:
6355 77 : {
6356 77 : tree _q50 = TREE_OPERAND (_p1, 0);
6357 77 : tree _q51 = TREE_OPERAND (_p1, 1);
6358 77 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6359 : {
6360 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6361 : {
6362 0 : {
6363 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6364 0 : const enum tree_code cmp1 = LT_EXPR;
6365 0 : const enum tree_code cmp2 = GT_EXPR;
6366 0 : const enum tree_code rcmp = NE_EXPR;
6367 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6368 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6369 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6370 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6371 : )
6372 : {
6373 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1514;
6374 0 : {
6375 0 : tree res_op0;
6376 0 : res_op0 = captures[0];
6377 0 : tree res_op1;
6378 0 : res_op1 = captures[1];
6379 0 : tree _r;
6380 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6381 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6382 0 : return _r;
6383 : }
6384 0 : next_after_fail1514:;
6385 : }
6386 : }
6387 0 : {
6388 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6389 0 : const enum tree_code cmp1 = LT_EXPR;
6390 0 : const enum tree_code cmp2 = GT_EXPR;
6391 0 : const enum tree_code rcmp = NE_EXPR;
6392 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6393 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6394 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6395 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6396 : )
6397 : {
6398 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1515;
6399 0 : {
6400 0 : tree res_op0;
6401 0 : res_op0 = captures[0];
6402 0 : tree res_op1;
6403 0 : res_op1 = captures[1];
6404 0 : tree _r;
6405 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6406 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6407 0 : return _r;
6408 : }
6409 0 : next_after_fail1515:;
6410 : }
6411 : }
6412 : }
6413 : }
6414 : break;
6415 : }
6416 29 : case EQ_EXPR:
6417 29 : {
6418 29 : tree _q50 = TREE_OPERAND (_p1, 0);
6419 29 : tree _q51 = TREE_OPERAND (_p1, 1);
6420 29 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6421 : {
6422 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6423 : {
6424 0 : {
6425 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6426 0 : const enum tree_code cmp1 = LT_EXPR;
6427 0 : const enum tree_code cmp2 = EQ_EXPR;
6428 0 : const enum tree_code rcmp = LE_EXPR;
6429 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6430 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6431 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6432 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6433 : )
6434 : {
6435 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1516;
6436 0 : {
6437 0 : tree res_op0;
6438 0 : res_op0 = captures[0];
6439 0 : tree res_op1;
6440 0 : res_op1 = captures[1];
6441 0 : tree _r;
6442 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6443 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6444 0 : return _r;
6445 : }
6446 0 : next_after_fail1516:;
6447 : }
6448 : }
6449 : }
6450 : }
6451 : break;
6452 : }
6453 53 : case NE_EXPR:
6454 53 : {
6455 53 : tree _q50 = TREE_OPERAND (_p1, 0);
6456 53 : tree _q51 = TREE_OPERAND (_p1, 1);
6457 53 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6458 : {
6459 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6460 : {
6461 0 : {
6462 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6463 0 : const enum tree_code cmp1 = LT_EXPR;
6464 0 : const enum tree_code cmp2 = NE_EXPR;
6465 0 : const enum tree_code rcmp = GT_EXPR;
6466 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6467 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6468 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6469 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6470 : )
6471 : {
6472 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1517;
6473 0 : {
6474 0 : tree res_op0;
6475 0 : res_op0 = captures[0];
6476 0 : tree res_op1;
6477 0 : res_op1 = captures[1];
6478 0 : tree _r;
6479 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6480 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6481 0 : return _r;
6482 : }
6483 0 : next_after_fail1517:;
6484 : }
6485 : }
6486 : }
6487 : }
6488 : break;
6489 : }
6490 32 : case LT_EXPR:
6491 32 : {
6492 32 : tree _q50 = TREE_OPERAND (_p1, 0);
6493 32 : tree _q51 = TREE_OPERAND (_p1, 1);
6494 32 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6495 : {
6496 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6497 : {
6498 0 : {
6499 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6500 0 : const enum tree_code cmp1 = LT_EXPR;
6501 0 : const enum tree_code cmp2 = GT_EXPR;
6502 0 : const enum tree_code rcmp = NE_EXPR;
6503 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6504 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6505 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6506 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6507 : )
6508 : {
6509 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1518;
6510 0 : {
6511 0 : tree res_op0;
6512 0 : res_op0 = captures[0];
6513 0 : tree res_op1;
6514 0 : res_op1 = captures[1];
6515 0 : tree _r;
6516 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6517 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6518 0 : return _r;
6519 : }
6520 0 : next_after_fail1518:;
6521 : }
6522 : }
6523 : }
6524 : }
6525 : break;
6526 : }
6527 : default:;
6528 : }
6529 : break;
6530 : }
6531 6123 : case GE_EXPR:
6532 6123 : {
6533 6123 : tree _q20 = TREE_OPERAND (_p0, 0);
6534 6123 : tree _q21 = TREE_OPERAND (_p0, 1);
6535 6123 : switch (TREE_CODE (_p1))
6536 : {
6537 76 : case GE_EXPR:
6538 76 : {
6539 76 : tree _q50 = TREE_OPERAND (_p1, 0);
6540 76 : tree _q51 = TREE_OPERAND (_p1, 1);
6541 76 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6542 : {
6543 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6544 : {
6545 0 : {
6546 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6547 0 : const enum tree_code cmp1 = LE_EXPR;
6548 0 : const enum tree_code cmp2 = GE_EXPR;
6549 0 : const enum tree_code rcmp = NE_EXPR;
6550 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6551 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6552 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6553 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6554 : )
6555 : {
6556 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1519;
6557 0 : {
6558 0 : tree res_op0;
6559 0 : res_op0 = captures[0];
6560 0 : tree res_op1;
6561 0 : res_op1 = captures[1];
6562 0 : tree _r;
6563 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6564 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6565 0 : return _r;
6566 : }
6567 0 : next_after_fail1519:;
6568 : }
6569 : }
6570 0 : {
6571 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6572 0 : const enum tree_code cmp1 = LE_EXPR;
6573 0 : const enum tree_code cmp2 = GE_EXPR;
6574 0 : const enum tree_code rcmp = NE_EXPR;
6575 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6576 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6577 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6578 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6579 : )
6580 : {
6581 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1520;
6582 0 : {
6583 0 : tree res_op0;
6584 0 : res_op0 = captures[0];
6585 0 : tree res_op1;
6586 0 : res_op1 = captures[1];
6587 0 : tree _r;
6588 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6589 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6590 0 : return _r;
6591 : }
6592 0 : next_after_fail1520:;
6593 : }
6594 : }
6595 : }
6596 : }
6597 : break;
6598 : }
6599 52 : case EQ_EXPR:
6600 52 : {
6601 52 : tree _q50 = TREE_OPERAND (_p1, 0);
6602 52 : tree _q51 = TREE_OPERAND (_p1, 1);
6603 52 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6604 : {
6605 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6606 : {
6607 0 : {
6608 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6609 0 : const enum tree_code cmp1 = LE_EXPR;
6610 0 : const enum tree_code cmp2 = EQ_EXPR;
6611 0 : const enum tree_code rcmp = LT_EXPR;
6612 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6613 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6614 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6615 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6616 : )
6617 : {
6618 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1521;
6619 0 : {
6620 0 : tree res_op0;
6621 0 : res_op0 = captures[0];
6622 0 : tree res_op1;
6623 0 : res_op1 = captures[1];
6624 0 : tree _r;
6625 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6626 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6627 0 : return _r;
6628 : }
6629 0 : next_after_fail1521:;
6630 : }
6631 : }
6632 : }
6633 : }
6634 : break;
6635 : }
6636 11 : case NE_EXPR:
6637 11 : {
6638 11 : tree _q50 = TREE_OPERAND (_p1, 0);
6639 11 : tree _q51 = TREE_OPERAND (_p1, 1);
6640 11 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6641 : {
6642 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6643 : {
6644 0 : {
6645 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6646 0 : const enum tree_code cmp1 = LE_EXPR;
6647 0 : const enum tree_code cmp2 = NE_EXPR;
6648 0 : const enum tree_code rcmp = GE_EXPR;
6649 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6650 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6651 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6652 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6653 : )
6654 : {
6655 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1522;
6656 0 : {
6657 0 : tree res_op0;
6658 0 : res_op0 = captures[0];
6659 0 : tree res_op1;
6660 0 : res_op1 = captures[1];
6661 0 : tree _r;
6662 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6663 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6664 0 : return _r;
6665 : }
6666 0 : next_after_fail1522:;
6667 : }
6668 : }
6669 : }
6670 : }
6671 : break;
6672 : }
6673 16 : case LE_EXPR:
6674 16 : {
6675 16 : tree _q50 = TREE_OPERAND (_p1, 0);
6676 16 : tree _q51 = TREE_OPERAND (_p1, 1);
6677 16 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6678 : {
6679 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6680 : {
6681 0 : {
6682 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6683 0 : const enum tree_code cmp1 = LE_EXPR;
6684 0 : const enum tree_code cmp2 = GE_EXPR;
6685 0 : const enum tree_code rcmp = NE_EXPR;
6686 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6687 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6688 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6689 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6690 : )
6691 : {
6692 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1523;
6693 0 : {
6694 0 : tree res_op0;
6695 0 : res_op0 = captures[0];
6696 0 : tree res_op1;
6697 0 : res_op1 = captures[1];
6698 0 : tree _r;
6699 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6700 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6701 0 : return _r;
6702 : }
6703 0 : next_after_fail1523:;
6704 : }
6705 : }
6706 : }
6707 : }
6708 : break;
6709 : }
6710 : default:;
6711 : }
6712 : break;
6713 : }
6714 64321 : case EQ_EXPR:
6715 64321 : {
6716 64321 : tree _q20 = TREE_OPERAND (_p0, 0);
6717 64321 : tree _q21 = TREE_OPERAND (_p0, 1);
6718 64321 : switch (TREE_CODE (_p1))
6719 : {
6720 5 : case LT_EXPR:
6721 5 : {
6722 5 : tree _q50 = TREE_OPERAND (_p1, 0);
6723 5 : tree _q51 = TREE_OPERAND (_p1, 1);
6724 5 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6725 : {
6726 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6727 : {
6728 0 : {
6729 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6730 0 : const enum tree_code cmp1 = LT_EXPR;
6731 0 : const enum tree_code cmp2 = EQ_EXPR;
6732 0 : const enum tree_code rcmp = LE_EXPR;
6733 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6734 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6735 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6736 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6737 : )
6738 : {
6739 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1524;
6740 0 : {
6741 0 : tree res_op0;
6742 0 : res_op0 = captures[0];
6743 0 : tree res_op1;
6744 0 : res_op1 = captures[1];
6745 0 : tree _r;
6746 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6747 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6748 0 : return _r;
6749 : }
6750 0 : next_after_fail1524:;
6751 : }
6752 : }
6753 : }
6754 : }
6755 : break;
6756 : }
6757 42 : case LE_EXPR:
6758 42 : {
6759 42 : tree _q50 = TREE_OPERAND (_p1, 0);
6760 42 : tree _q51 = TREE_OPERAND (_p1, 1);
6761 42 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6762 : {
6763 7 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6764 : {
6765 0 : {
6766 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6767 0 : const enum tree_code cmp1 = LE_EXPR;
6768 0 : const enum tree_code cmp2 = EQ_EXPR;
6769 0 : const enum tree_code rcmp = LT_EXPR;
6770 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6771 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6772 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6773 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6774 : )
6775 : {
6776 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1525;
6777 0 : {
6778 0 : tree res_op0;
6779 0 : res_op0 = captures[0];
6780 0 : tree res_op1;
6781 0 : res_op1 = captures[1];
6782 0 : tree _r;
6783 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6784 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6785 0 : return _r;
6786 : }
6787 0 : next_after_fail1525:;
6788 : }
6789 : }
6790 : }
6791 : }
6792 : break;
6793 : }
6794 7 : case GT_EXPR:
6795 7 : {
6796 7 : tree _q50 = TREE_OPERAND (_p1, 0);
6797 7 : tree _q51 = TREE_OPERAND (_p1, 1);
6798 7 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6799 : {
6800 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6801 : {
6802 0 : {
6803 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6804 0 : const enum tree_code cmp1 = LT_EXPR;
6805 0 : const enum tree_code cmp2 = EQ_EXPR;
6806 0 : const enum tree_code rcmp = LE_EXPR;
6807 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6808 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6809 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6810 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6811 : )
6812 : {
6813 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1526;
6814 0 : {
6815 0 : tree res_op0;
6816 0 : res_op0 = captures[0];
6817 0 : tree res_op1;
6818 0 : res_op1 = captures[1];
6819 0 : tree _r;
6820 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6821 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6822 0 : return _r;
6823 : }
6824 0 : next_after_fail1526:;
6825 : }
6826 : }
6827 : }
6828 : }
6829 : break;
6830 : }
6831 14 : case GE_EXPR:
6832 14 : {
6833 14 : tree _q50 = TREE_OPERAND (_p1, 0);
6834 14 : tree _q51 = TREE_OPERAND (_p1, 1);
6835 14 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6836 : {
6837 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6838 : {
6839 0 : {
6840 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6841 0 : const enum tree_code cmp1 = LE_EXPR;
6842 0 : const enum tree_code cmp2 = EQ_EXPR;
6843 0 : const enum tree_code rcmp = LT_EXPR;
6844 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6845 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6846 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6847 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6848 : )
6849 : {
6850 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1527;
6851 0 : {
6852 0 : tree res_op0;
6853 0 : res_op0 = captures[0];
6854 0 : tree res_op1;
6855 0 : res_op1 = captures[1];
6856 0 : tree _r;
6857 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6858 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6859 0 : return _r;
6860 : }
6861 0 : next_after_fail1527:;
6862 : }
6863 : }
6864 : }
6865 : }
6866 : break;
6867 : }
6868 : default:;
6869 : }
6870 : break;
6871 : }
6872 68290 : case NE_EXPR:
6873 68290 : {
6874 68290 : tree _q20 = TREE_OPERAND (_p0, 0);
6875 68290 : tree _q21 = TREE_OPERAND (_p0, 1);
6876 68290 : switch (TREE_CODE (_p1))
6877 : {
6878 7 : case LT_EXPR:
6879 7 : {
6880 7 : tree _q50 = TREE_OPERAND (_p1, 0);
6881 7 : tree _q51 = TREE_OPERAND (_p1, 1);
6882 7 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6883 : {
6884 7 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6885 : {
6886 0 : {
6887 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6888 0 : const enum tree_code cmp1 = LT_EXPR;
6889 0 : const enum tree_code cmp2 = NE_EXPR;
6890 0 : const enum tree_code rcmp = GT_EXPR;
6891 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6892 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6893 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6894 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6895 : )
6896 : {
6897 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1528;
6898 0 : {
6899 0 : tree res_op0;
6900 0 : res_op0 = captures[0];
6901 0 : tree res_op1;
6902 0 : res_op1 = captures[1];
6903 0 : tree _r;
6904 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6905 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6906 0 : return _r;
6907 : }
6908 0 : next_after_fail1528:;
6909 : }
6910 : }
6911 : }
6912 : }
6913 : break;
6914 : }
6915 302 : case LE_EXPR:
6916 302 : {
6917 302 : tree _q50 = TREE_OPERAND (_p1, 0);
6918 302 : tree _q51 = TREE_OPERAND (_p1, 1);
6919 302 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6920 : {
6921 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6922 : {
6923 0 : {
6924 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6925 0 : const enum tree_code cmp1 = LE_EXPR;
6926 0 : const enum tree_code cmp2 = NE_EXPR;
6927 0 : const enum tree_code rcmp = GE_EXPR;
6928 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6929 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6930 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6931 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6932 : )
6933 : {
6934 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1529;
6935 0 : {
6936 0 : tree res_op0;
6937 0 : res_op0 = captures[0];
6938 0 : tree res_op1;
6939 0 : res_op1 = captures[1];
6940 0 : tree _r;
6941 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6942 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6943 0 : return _r;
6944 : }
6945 0 : next_after_fail1529:;
6946 : }
6947 : }
6948 : }
6949 : }
6950 : break;
6951 : }
6952 323 : case GT_EXPR:
6953 323 : {
6954 323 : tree _q50 = TREE_OPERAND (_p1, 0);
6955 323 : tree _q51 = TREE_OPERAND (_p1, 1);
6956 323 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6957 : {
6958 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6959 : {
6960 0 : {
6961 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6962 0 : const enum tree_code cmp1 = LT_EXPR;
6963 0 : const enum tree_code cmp2 = NE_EXPR;
6964 0 : const enum tree_code rcmp = GT_EXPR;
6965 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6966 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6967 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6968 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6969 : )
6970 : {
6971 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1530;
6972 0 : {
6973 0 : tree res_op0;
6974 0 : res_op0 = captures[0];
6975 0 : tree res_op1;
6976 0 : res_op1 = captures[1];
6977 0 : tree _r;
6978 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6979 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6980 0 : return _r;
6981 : }
6982 0 : next_after_fail1530:;
6983 : }
6984 : }
6985 : }
6986 : }
6987 : break;
6988 : }
6989 2 : case GE_EXPR:
6990 2 : {
6991 2 : tree _q50 = TREE_OPERAND (_p1, 0);
6992 2 : tree _q51 = TREE_OPERAND (_p1, 1);
6993 2 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6994 : {
6995 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6996 : {
6997 0 : {
6998 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6999 0 : const enum tree_code cmp1 = LE_EXPR;
7000 0 : const enum tree_code cmp2 = NE_EXPR;
7001 0 : const enum tree_code rcmp = GE_EXPR;
7002 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
7003 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
7004 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
7005 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
7006 : )
7007 : {
7008 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1531;
7009 0 : {
7010 0 : tree res_op0;
7011 0 : res_op0 = captures[0];
7012 0 : tree res_op1;
7013 0 : res_op1 = captures[1];
7014 0 : tree _r;
7015 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
7016 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
7017 0 : return _r;
7018 : }
7019 0 : next_after_fail1531:;
7020 : }
7021 : }
7022 : }
7023 : }
7024 : break;
7025 : }
7026 : default:;
7027 : }
7028 : break;
7029 : }
7030 8644 : case MIN_EXPR:
7031 8644 : {
7032 8644 : tree _q20 = TREE_OPERAND (_p0, 0);
7033 8644 : tree _q21 = TREE_OPERAND (_p0, 1);
7034 8644 : switch (TREE_CODE (_p1))
7035 : {
7036 0 : case MAX_EXPR:
7037 0 : {
7038 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7039 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7040 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7041 : {
7042 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7043 : {
7044 0 : {
7045 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7046 0 : if (!HONOR_NANS (captures[0])
7047 : )
7048 : {
7049 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1532;
7050 0 : {
7051 0 : tree res_op0;
7052 0 : res_op0 = captures[0];
7053 0 : tree res_op1;
7054 0 : res_op1 = captures[1];
7055 0 : tree _r;
7056 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
7057 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
7058 0 : return _r;
7059 : }
7060 0 : next_after_fail1532:;
7061 : }
7062 : }
7063 : }
7064 : }
7065 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7066 : {
7067 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7068 : {
7069 0 : {
7070 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
7071 0 : if (!HONOR_NANS (captures[0])
7072 : )
7073 : {
7074 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1533;
7075 0 : {
7076 0 : tree res_op0;
7077 0 : res_op0 = captures[0];
7078 0 : tree res_op1;
7079 0 : res_op1 = captures[1];
7080 0 : tree _r;
7081 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
7082 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
7083 0 : return _r;
7084 : }
7085 0 : next_after_fail1533:;
7086 : }
7087 : }
7088 : }
7089 : }
7090 : break;
7091 : }
7092 8644 : default:;
7093 : }
7094 8644 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
7095 : {
7096 0 : {
7097 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7098 0 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MIN_EXPR, NE_EXPR, GT_EXPR);
7099 0 : if (res) return res;
7100 : }
7101 : }
7102 8644 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
7103 : {
7104 616 : {
7105 616 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
7106 616 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MIN_EXPR, NE_EXPR, GT_EXPR);
7107 616 : if (res) return res;
7108 : }
7109 : }
7110 : break;
7111 : }
7112 8146 : case MAX_EXPR:
7113 8146 : {
7114 8146 : tree _q20 = TREE_OPERAND (_p0, 0);
7115 8146 : tree _q21 = TREE_OPERAND (_p0, 1);
7116 8146 : switch (TREE_CODE (_p1))
7117 : {
7118 0 : case MIN_EXPR:
7119 0 : {
7120 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7121 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7122 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7123 : {
7124 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7125 : {
7126 0 : {
7127 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7128 0 : if (!HONOR_NANS (captures[0])
7129 : )
7130 : {
7131 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1534;
7132 0 : {
7133 0 : tree res_op0;
7134 0 : res_op0 = captures[0];
7135 0 : tree res_op1;
7136 0 : res_op1 = captures[1];
7137 0 : tree _r;
7138 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
7139 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
7140 0 : return _r;
7141 : }
7142 0 : next_after_fail1534:;
7143 : }
7144 : }
7145 : }
7146 : }
7147 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7148 : {
7149 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7150 : {
7151 0 : {
7152 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7153 0 : if (!HONOR_NANS (captures[0])
7154 : )
7155 : {
7156 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1535;
7157 0 : {
7158 0 : tree res_op0;
7159 0 : res_op0 = captures[0];
7160 0 : tree res_op1;
7161 0 : res_op1 = captures[1];
7162 0 : tree _r;
7163 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
7164 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
7165 0 : return _r;
7166 : }
7167 0 : next_after_fail1535:;
7168 : }
7169 : }
7170 : }
7171 : }
7172 : break;
7173 : }
7174 8146 : default:;
7175 : }
7176 8146 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
7177 : {
7178 0 : {
7179 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7180 0 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MAX_EXPR, NE_EXPR, LT_EXPR);
7181 0 : if (res) return res;
7182 : }
7183 : }
7184 8146 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
7185 : {
7186 425 : {
7187 425 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
7188 425 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MAX_EXPR, NE_EXPR, LT_EXPR);
7189 425 : if (res) return res;
7190 : }
7191 : }
7192 : break;
7193 : }
7194 40604511 : default:;
7195 : }
7196 40604511 : if (tree_with_possible_nonzero_bits (_p0))
7197 : {
7198 15730151 : if (tree_with_known_nonzero_bits (_p1))
7199 : {
7200 14206371 : {
7201 14206371 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
7202 14206371 : tree res = generic_simplify_225 (loc, type, _p0, _p1, captures, NE_EXPR);
7203 14206371 : if (res) return res;
7204 : }
7205 : }
7206 : }
7207 40542209 : if (tree_with_known_nonzero_bits (_p0))
7208 : {
7209 11477418 : if (tree_with_possible_nonzero_bits (_p1))
7210 : {
7211 11427424 : {
7212 11427424 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _p0 };
7213 11427424 : tree res = generic_simplify_225 (loc, type, _p0, _p1, captures, NE_EXPR);
7214 11427424 : if (res) return res;
7215 : }
7216 : }
7217 : }
7218 40540809 : switch (TREE_CODE (_p1))
7219 : {
7220 164 : case MIN_EXPR:
7221 164 : {
7222 164 : tree _q30 = TREE_OPERAND (_p1, 0);
7223 164 : tree _q31 = TREE_OPERAND (_p1, 1);
7224 164 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
7225 : {
7226 0 : {
7227 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
7228 0 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MIN_EXPR, NE_EXPR, GT_EXPR);
7229 0 : if (res) return res;
7230 : }
7231 : }
7232 164 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
7233 : {
7234 0 : {
7235 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
7236 0 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MIN_EXPR, NE_EXPR, GT_EXPR);
7237 0 : if (res) return res;
7238 : }
7239 : }
7240 : break;
7241 : }
7242 1673 : case MAX_EXPR:
7243 1673 : {
7244 1673 : tree _q30 = TREE_OPERAND (_p1, 0);
7245 1673 : tree _q31 = TREE_OPERAND (_p1, 1);
7246 1673 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
7247 : {
7248 0 : {
7249 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
7250 0 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MAX_EXPR, NE_EXPR, LT_EXPR);
7251 0 : if (res) return res;
7252 : }
7253 : }
7254 1673 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
7255 : {
7256 0 : {
7257 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
7258 0 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MAX_EXPR, NE_EXPR, LT_EXPR);
7259 0 : if (res) return res;
7260 : }
7261 : }
7262 : break;
7263 : }
7264 40540809 : default:;
7265 : }
7266 40540809 : switch (TREE_CODE (_p0))
7267 : {
7268 8644 : case MIN_EXPR:
7269 8644 : {
7270 8644 : tree _q20 = TREE_OPERAND (_p0, 0);
7271 8644 : tree _q21 = TREE_OPERAND (_p0, 1);
7272 8644 : switch (TREE_CODE (_q21))
7273 : {
7274 683 : case INTEGER_CST:
7275 683 : {
7276 683 : switch (TREE_CODE (_p1))
7277 : {
7278 0 : case INTEGER_CST:
7279 0 : {
7280 0 : {
7281 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7282 0 : tree res = generic_simplify_228 (loc, type, _p0, _p1, captures, NE_EXPR);
7283 0 : if (res) return res;
7284 : }
7285 0 : break;
7286 : }
7287 : default:;
7288 : }
7289 : break;
7290 : }
7291 : default:;
7292 : }
7293 : break;
7294 : }
7295 8017 : case MAX_EXPR:
7296 8017 : {
7297 8017 : tree _q20 = TREE_OPERAND (_p0, 0);
7298 8017 : tree _q21 = TREE_OPERAND (_p0, 1);
7299 8017 : switch (TREE_CODE (_q21))
7300 : {
7301 6959 : case INTEGER_CST:
7302 6959 : {
7303 6959 : switch (TREE_CODE (_p1))
7304 : {
7305 683 : case INTEGER_CST:
7306 683 : {
7307 683 : {
7308 683 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7309 683 : tree res = generic_simplify_229 (loc, type, _p0, _p1, captures, NE_EXPR);
7310 683 : if (res) return res;
7311 : }
7312 0 : break;
7313 : }
7314 : default:;
7315 : }
7316 : break;
7317 : }
7318 7334 : default:;
7319 : }
7320 7334 : if (integer_zerop (_p1))
7321 : {
7322 34 : {
7323 34 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7324 34 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
7325 34 : if (res) return res;
7326 : }
7327 : }
7328 : break;
7329 : }
7330 1336723 : case BIT_AND_EXPR:
7331 1336723 : {
7332 1336723 : tree _q20 = TREE_OPERAND (_p0, 0);
7333 1336723 : tree _q21 = TREE_OPERAND (_p0, 1);
7334 1336723 : switch (TREE_CODE (_q20))
7335 : {
7336 3686 : case LSHIFT_EXPR:
7337 3686 : {
7338 3686 : tree _q30 = TREE_OPERAND (_q20, 0);
7339 3686 : tree _q31 = TREE_OPERAND (_q20, 1);
7340 3686 : if (integer_pow2p (_q30))
7341 : {
7342 3666 : if (integer_pow2p (_q21))
7343 : {
7344 5 : if (integer_zerop (_p1))
7345 : {
7346 5 : {
7347 5 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q21 };
7348 5 : tree res = generic_simplify_231 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
7349 5 : if (res) return res;
7350 : }
7351 : }
7352 : }
7353 : }
7354 3681 : switch (TREE_CODE (_q31))
7355 : {
7356 13 : case INTEGER_CST:
7357 13 : {
7358 13 : switch (TREE_CODE (_q21))
7359 : {
7360 13 : case INTEGER_CST:
7361 13 : {
7362 13 : switch (TREE_CODE (_p1))
7363 : {
7364 13 : case INTEGER_CST:
7365 13 : {
7366 13 : {
7367 13 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1 };
7368 13 : tree res = generic_simplify_232 (loc, type, _p0, _p1, captures, NE_EXPR);
7369 13 : if (res) return res;
7370 : }
7371 0 : break;
7372 : }
7373 : default:;
7374 : }
7375 : break;
7376 : }
7377 : default:;
7378 : }
7379 : break;
7380 : }
7381 3668 : default:;
7382 : }
7383 3668 : if (integer_onep (_q30))
7384 : {
7385 3660 : if (integer_pow2p (_q21))
7386 : {
7387 0 : if (integer_zerop (_p1))
7388 : {
7389 0 : {
7390 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q21 };
7391 0 : tree res = generic_simplify_233 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
7392 0 : if (res) return res;
7393 : }
7394 : }
7395 : }
7396 : }
7397 : break;
7398 : }
7399 4831 : case RSHIFT_EXPR:
7400 4831 : {
7401 4831 : tree _q30 = TREE_OPERAND (_q20, 0);
7402 4831 : tree _q31 = TREE_OPERAND (_q20, 1);
7403 4831 : if (integer_pow2p (_q30))
7404 : {
7405 33 : if (integer_pow2p (_q21))
7406 : {
7407 1 : if (integer_zerop (_p1))
7408 : {
7409 1 : {
7410 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q21 };
7411 1 : tree res = generic_simplify_234 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
7412 1 : if (res) return res;
7413 : }
7414 : }
7415 : }
7416 : }
7417 4830 : switch (TREE_CODE (_q31))
7418 : {
7419 329 : case INTEGER_CST:
7420 329 : {
7421 329 : switch (TREE_CODE (_q21))
7422 : {
7423 305 : case INTEGER_CST:
7424 305 : {
7425 305 : switch (TREE_CODE (_p1))
7426 : {
7427 280 : case INTEGER_CST:
7428 280 : {
7429 280 : {
7430 280 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1 };
7431 280 : tree res = generic_simplify_235 (loc, type, _p0, _p1, captures, NE_EXPR);
7432 280 : if (res) return res;
7433 : }
7434 14 : break;
7435 : }
7436 : default:;
7437 : }
7438 : break;
7439 : }
7440 : default:;
7441 : }
7442 : break;
7443 : }
7444 : default:;
7445 : }
7446 : break;
7447 : }
7448 1336438 : default:;
7449 : }
7450 1336438 : {
7451 1336438 : tree _q20_pops[1];
7452 1336438 : if (tree_nop_convert (_q20, _q20_pops))
7453 : {
7454 137632 : tree _q30 = _q20_pops[0];
7455 137632 : switch (TREE_CODE (_q30))
7456 : {
7457 37188 : case LSHIFT_EXPR:
7458 37188 : {
7459 37188 : tree _q40 = TREE_OPERAND (_q30, 0);
7460 37188 : tree _q41 = TREE_OPERAND (_q30, 1);
7461 37188 : if (integer_onep (_q40))
7462 : {
7463 37188 : if (integer_pow2p (_q21))
7464 : {
7465 0 : if (integer_zerop (_p1))
7466 : {
7467 0 : {
7468 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q41, _q21 };
7469 0 : tree res = generic_simplify_233 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
7470 0 : if (res) return res;
7471 : }
7472 : }
7473 : }
7474 : }
7475 : break;
7476 : }
7477 : default:;
7478 : }
7479 : }
7480 : }
7481 1336438 : break;
7482 : }
7483 5202 : case LSHIFT_EXPR:
7484 5202 : {
7485 5202 : tree _q20 = TREE_OPERAND (_p0, 0);
7486 5202 : tree _q21 = TREE_OPERAND (_p0, 1);
7487 5202 : switch (TREE_CODE (_q20))
7488 : {
7489 538 : case INTEGER_CST:
7490 538 : {
7491 538 : switch (TREE_CODE (_p1))
7492 : {
7493 159 : case INTEGER_CST:
7494 159 : {
7495 159 : {
7496 159 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7497 159 : tree res = generic_simplify_236 (loc, type, _p0, _p1, captures, NE_EXPR);
7498 159 : if (res) return res;
7499 : }
7500 88 : break;
7501 : }
7502 : default:;
7503 : }
7504 : break;
7505 : }
7506 : default:;
7507 : }
7508 : break;
7509 : }
7510 414 : case LROTATE_EXPR:
7511 414 : {
7512 414 : tree _q20 = TREE_OPERAND (_p0, 0);
7513 414 : tree _q21 = TREE_OPERAND (_p0, 1);
7514 414 : switch (TREE_CODE (_p1))
7515 : {
7516 0 : case LROTATE_EXPR:
7517 0 : {
7518 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7519 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7520 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7521 : {
7522 0 : {
7523 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
7524 0 : tree res = generic_simplify_237 (loc, type, _p0, _p1, captures, LROTATE_EXPR, RROTATE_EXPR, NE_EXPR);
7525 0 : if (res) return res;
7526 : }
7527 : }
7528 : break;
7529 : }
7530 414 : default:;
7531 : }
7532 414 : switch (TREE_CODE (_q21))
7533 : {
7534 112 : case INTEGER_CST:
7535 112 : {
7536 112 : switch (TREE_CODE (_p1))
7537 : {
7538 112 : case INTEGER_CST:
7539 112 : {
7540 112 : {
7541 112 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7542 112 : tree res = generic_simplify_238 (loc, type, _p0, _p1, captures, LROTATE_EXPR, RROTATE_EXPR, NE_EXPR);
7543 112 : if (res) return res;
7544 : }
7545 0 : break;
7546 : }
7547 : default:;
7548 : }
7549 : break;
7550 : }
7551 302 : default:;
7552 : }
7553 302 : switch (TREE_CODE (_p1))
7554 : {
7555 197 : case INTEGER_CST:
7556 197 : {
7557 197 : {
7558 197 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7559 197 : tree res = generic_simplify_239 (loc, type, _p0, _p1, captures, LROTATE_EXPR, RROTATE_EXPR, NE_EXPR);
7560 197 : if (res) return res;
7561 : }
7562 197 : break;
7563 : }
7564 : default:;
7565 : }
7566 : break;
7567 : }
7568 491 : case RROTATE_EXPR:
7569 491 : {
7570 491 : tree _q20 = TREE_OPERAND (_p0, 0);
7571 491 : tree _q21 = TREE_OPERAND (_p0, 1);
7572 491 : switch (TREE_CODE (_p1))
7573 : {
7574 0 : case RROTATE_EXPR:
7575 0 : {
7576 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7577 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7578 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7579 : {
7580 0 : {
7581 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
7582 0 : tree res = generic_simplify_237 (loc, type, _p0, _p1, captures, RROTATE_EXPR, LROTATE_EXPR, NE_EXPR);
7583 0 : if (res) return res;
7584 : }
7585 : }
7586 : break;
7587 : }
7588 491 : default:;
7589 : }
7590 491 : switch (TREE_CODE (_q21))
7591 : {
7592 281 : case INTEGER_CST:
7593 281 : {
7594 281 : switch (TREE_CODE (_p1))
7595 : {
7596 12 : case INTEGER_CST:
7597 12 : {
7598 12 : {
7599 12 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7600 12 : tree res = generic_simplify_238 (loc, type, _p0, _p1, captures, RROTATE_EXPR, LROTATE_EXPR, NE_EXPR);
7601 12 : if (res) return res;
7602 : }
7603 0 : break;
7604 : }
7605 : default:;
7606 : }
7607 : break;
7608 : }
7609 479 : default:;
7610 : }
7611 479 : switch (TREE_CODE (_p1))
7612 : {
7613 194 : case INTEGER_CST:
7614 194 : {
7615 194 : {
7616 194 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7617 194 : tree res = generic_simplify_239 (loc, type, _p0, _p1, captures, RROTATE_EXPR, LROTATE_EXPR, NE_EXPR);
7618 194 : if (res) return res;
7619 : }
7620 194 : break;
7621 : }
7622 : default:;
7623 : }
7624 : break;
7625 : }
7626 176 : case VEC_COND_EXPR:
7627 176 : {
7628 176 : tree _q20 = TREE_OPERAND (_p0, 0);
7629 176 : tree _q21 = TREE_OPERAND (_p0, 1);
7630 176 : tree _q22 = TREE_OPERAND (_p0, 2);
7631 176 : switch (TREE_CODE (_p1))
7632 : {
7633 0 : case VEC_COND_EXPR:
7634 0 : {
7635 0 : tree _q60 = TREE_OPERAND (_p1, 0);
7636 0 : tree _q61 = TREE_OPERAND (_p1, 1);
7637 0 : tree _q62 = TREE_OPERAND (_p1, 2);
7638 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7639 : {
7640 0 : {
7641 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
7642 0 : if (VECTOR_TYPE_P (type)
7643 0 : && (TREE_CODE_CLASS (NE_EXPR) != tcc_comparison
7644 0 : || types_match (type, TREE_TYPE (captures[2]))
7645 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
7646 : || (optimize_vectors_before_lowering_p ()
7647 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
7648 : )
7649 : {
7650 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1536;
7651 0 : {
7652 0 : tree res_op0;
7653 0 : res_op0 = captures[1];
7654 0 : tree res_op1;
7655 0 : {
7656 0 : tree _o1[2], _r1;
7657 0 : _o1[0] = captures[2];
7658 0 : _o1[1] = captures[5];
7659 0 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7660 0 : if (EXPR_P (_r1))
7661 0 : goto next_after_fail1536;
7662 0 : res_op1 = _r1;
7663 : }
7664 0 : tree res_op2;
7665 0 : {
7666 0 : tree _o1[2], _r1;
7667 0 : _o1[0] = captures[3];
7668 0 : _o1[1] = captures[6];
7669 0 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7670 0 : if (EXPR_P (_r1))
7671 0 : goto next_after_fail1536;
7672 0 : res_op2 = _r1;
7673 : }
7674 0 : tree _r;
7675 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7676 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
7677 0 : return _r;
7678 : }
7679 0 : next_after_fail1536:;
7680 : }
7681 : }
7682 : }
7683 : break;
7684 : }
7685 176 : default:;
7686 : }
7687 176 : {
7688 176 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
7689 176 : if (VECTOR_TYPE_P (type)
7690 176 : && (TREE_CODE_CLASS (NE_EXPR) != tcc_comparison
7691 174 : || types_match (type, TREE_TYPE (captures[2]))
7692 174 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
7693 : || (optimize_vectors_before_lowering_p ()
7694 27 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
7695 : )
7696 : {
7697 174 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1537;
7698 174 : {
7699 174 : if (! tree_invariant_p (captures[4])) goto next_after_fail1537;
7700 72 : tree res_op0;
7701 72 : res_op0 = captures[1];
7702 72 : tree res_op1;
7703 72 : {
7704 72 : tree _o1[2], _r1;
7705 72 : _o1[0] = captures[2];
7706 72 : _o1[1] = unshare_expr (captures[4]);
7707 72 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7708 72 : if (EXPR_P (_r1))
7709 0 : goto next_after_fail1537;
7710 72 : res_op1 = _r1;
7711 : }
7712 72 : tree res_op2;
7713 72 : {
7714 72 : tree _o1[2], _r1;
7715 72 : _o1[0] = captures[3];
7716 72 : _o1[1] = captures[4];
7717 72 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7718 72 : if (EXPR_P (_r1))
7719 0 : goto next_after_fail1537;
7720 72 : res_op2 = _r1;
7721 : }
7722 72 : tree _r;
7723 72 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7724 72 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
7725 72 : return _r;
7726 : }
7727 104 : next_after_fail1537:;
7728 : }
7729 : }
7730 104 : break;
7731 : }
7732 2747787 : case CALL_EXPR:
7733 2747787 : switch (get_call_combined_fn (_p0))
7734 : {
7735 2 : case CFN_BUILT_IN_BSWAP128:
7736 2 : if (call_expr_nargs (_p0) == 1)
7737 : {
7738 2 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7739 2 : switch (TREE_CODE (_p1))
7740 : {
7741 0 : case INTEGER_CST:
7742 0 : {
7743 0 : {
7744 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7745 0 : tree res = generic_simplify_242 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP128);
7746 0 : if (res) return res;
7747 : }
7748 0 : break;
7749 : }
7750 1 : case CALL_EXPR:
7751 1 : switch (get_call_combined_fn (_p1))
7752 : {
7753 0 : case CFN_BUILT_IN_BSWAP128:
7754 0 : if (call_expr_nargs (_p1) == 1)
7755 : {
7756 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7757 0 : {
7758 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7759 0 : tree res = generic_simplify_241 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP128);
7760 0 : if (res) return res;
7761 : }
7762 : }
7763 : break;
7764 : default:;
7765 : }
7766 : break;
7767 : default:;
7768 : }
7769 : }
7770 : break;
7771 11 : case CFN_BUILT_IN_BSWAP16:
7772 11 : if (call_expr_nargs (_p0) == 1)
7773 : {
7774 11 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7775 11 : switch (TREE_CODE (_p1))
7776 : {
7777 9 : case INTEGER_CST:
7778 9 : {
7779 9 : {
7780 9 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7781 9 : tree res = generic_simplify_242 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP16);
7782 9 : if (res) return res;
7783 : }
7784 9 : break;
7785 : }
7786 1 : case CALL_EXPR:
7787 1 : switch (get_call_combined_fn (_p1))
7788 : {
7789 1 : case CFN_BUILT_IN_BSWAP16:
7790 1 : if (call_expr_nargs (_p1) == 1)
7791 : {
7792 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7793 1 : {
7794 1 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7795 1 : tree res = generic_simplify_241 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP16);
7796 1 : if (res) return res;
7797 : }
7798 : }
7799 : break;
7800 : default:;
7801 : }
7802 : break;
7803 : default:;
7804 : }
7805 : }
7806 : break;
7807 7 : case CFN_BUILT_IN_BSWAP32:
7808 7 : if (call_expr_nargs (_p0) == 1)
7809 : {
7810 7 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7811 7 : switch (TREE_CODE (_p1))
7812 : {
7813 3 : case INTEGER_CST:
7814 3 : {
7815 3 : {
7816 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7817 3 : tree res = generic_simplify_242 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP32);
7818 3 : if (res) return res;
7819 : }
7820 3 : break;
7821 : }
7822 3 : case CALL_EXPR:
7823 3 : switch (get_call_combined_fn (_p1))
7824 : {
7825 3 : case CFN_BUILT_IN_BSWAP32:
7826 3 : if (call_expr_nargs (_p1) == 1)
7827 : {
7828 3 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7829 3 : {
7830 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7831 3 : tree res = generic_simplify_241 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP32);
7832 3 : if (res) return res;
7833 : }
7834 : }
7835 : break;
7836 : default:;
7837 : }
7838 : break;
7839 : default:;
7840 : }
7841 : }
7842 : break;
7843 7 : case CFN_BUILT_IN_BSWAP64:
7844 7 : if (call_expr_nargs (_p0) == 1)
7845 : {
7846 7 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7847 7 : switch (TREE_CODE (_p1))
7848 : {
7849 3 : case INTEGER_CST:
7850 3 : {
7851 3 : {
7852 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7853 3 : tree res = generic_simplify_242 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP64);
7854 3 : if (res) return res;
7855 : }
7856 3 : break;
7857 : }
7858 3 : case CALL_EXPR:
7859 3 : switch (get_call_combined_fn (_p1))
7860 : {
7861 3 : case CFN_BUILT_IN_BSWAP64:
7862 3 : if (call_expr_nargs (_p1) == 1)
7863 : {
7864 3 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7865 3 : {
7866 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7867 3 : tree res = generic_simplify_241 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP64);
7868 3 : if (res) return res;
7869 : }
7870 : }
7871 : break;
7872 : default:;
7873 : }
7874 : break;
7875 : default:;
7876 : }
7877 : }
7878 : break;
7879 : default:;
7880 : }
7881 : break;
7882 40539567 : default:;
7883 : }
7884 40539567 : switch (TREE_CODE (_p1))
7885 : {
7886 0 : case VEC_COND_EXPR:
7887 0 : {
7888 0 : tree _q30 = TREE_OPERAND (_p1, 0);
7889 0 : tree _q31 = TREE_OPERAND (_p1, 1);
7890 0 : tree _q32 = TREE_OPERAND (_p1, 2);
7891 0 : {
7892 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
7893 0 : if (VECTOR_TYPE_P (type)
7894 0 : && (TREE_CODE_CLASS (NE_EXPR) != tcc_comparison
7895 0 : || types_match (type, TREE_TYPE (captures[3]))
7896 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
7897 : || (optimize_vectors_before_lowering_p ()
7898 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
7899 : )
7900 : {
7901 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1538;
7902 0 : {
7903 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1538;
7904 0 : tree res_op0;
7905 0 : res_op0 = captures[2];
7906 0 : tree res_op1;
7907 0 : {
7908 0 : tree _o1[2], _r1;
7909 0 : _o1[0] = unshare_expr (captures[0]);
7910 0 : _o1[1] = captures[3];
7911 0 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7912 0 : if (EXPR_P (_r1))
7913 0 : goto next_after_fail1538;
7914 0 : res_op1 = _r1;
7915 : }
7916 0 : tree res_op2;
7917 0 : {
7918 0 : tree _o1[2], _r1;
7919 0 : _o1[0] = captures[0];
7920 0 : _o1[1] = captures[4];
7921 0 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7922 0 : if (EXPR_P (_r1))
7923 0 : goto next_after_fail1538;
7924 0 : res_op2 = _r1;
7925 : }
7926 0 : tree _r;
7927 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7928 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
7929 0 : return _r;
7930 : }
7931 0 : next_after_fail1538:;
7932 : }
7933 : }
7934 0 : break;
7935 : }
7936 40539567 : default:;
7937 : }
7938 40539567 : switch (TREE_CODE (_p0))
7939 : {
7940 96622 : case COND_EXPR:
7941 96622 : {
7942 96622 : tree _q20 = TREE_OPERAND (_p0, 0);
7943 96622 : tree _q21 = TREE_OPERAND (_p0, 1);
7944 96622 : tree _q22 = TREE_OPERAND (_p0, 2);
7945 96622 : switch (TREE_CODE (_p1))
7946 : {
7947 276 : case COND_EXPR:
7948 276 : {
7949 276 : tree _q60 = TREE_OPERAND (_p1, 0);
7950 276 : tree _q61 = TREE_OPERAND (_p1, 1);
7951 276 : tree _q62 = TREE_OPERAND (_p1, 2);
7952 276 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
7953 : {
7954 72 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
7955 : {
7956 72 : {
7957 72 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
7958 72 : const enum tree_code eqne = NE_EXPR;
7959 72 : if (!HONOR_NANS (captures[1])
7960 56 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
7961 49 : && types_match (type, TREE_TYPE (captures[0]))
7962 49 : && expr_no_side_effects_p (captures[1])
7963 114 : && expr_no_side_effects_p (captures[2])
7964 : )
7965 : {
7966 42 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1539;
7967 42 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1539;
7968 42 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1539;
7969 42 : {
7970 42 : tree res_op0;
7971 42 : {
7972 42 : tree _o1[2], _r1;
7973 42 : {
7974 42 : tree _o2[2], _r2;
7975 42 : _o2[0] = captures[0];
7976 42 : _o2[1] = captures[3];
7977 42 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
7978 42 : _o1[0] = _r2;
7979 : }
7980 42 : {
7981 42 : tree _o2[2], _r2;
7982 42 : _o2[0] = captures[1];
7983 42 : _o2[1] = captures[2];
7984 42 : _r2 = fold_build2_loc (loc, NE_EXPR, type, _o2[0], _o2[1]);
7985 42 : _o1[1] = _r2;
7986 : }
7987 42 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
7988 42 : res_op0 = _r1;
7989 : }
7990 42 : tree res_op1;
7991 42 : res_op1 = constant_boolean_node (eqne == NE_EXPR, type);
7992 42 : tree res_op2;
7993 42 : res_op2 = constant_boolean_node (eqne != NE_EXPR, type);
7994 42 : tree _r;
7995 42 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
7996 42 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 964, __FILE__, __LINE__, true);
7997 42 : return _r;
7998 : }
7999 30 : next_after_fail1539:;
8000 : }
8001 : }
8002 : }
8003 : }
8004 234 : if ((_q61 == _q22 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q22, 0) && types_match (_q61, _q22)))
8005 : {
8006 0 : if ((_q62 == _q21 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q21, 0) && types_match (_q62, _q21)))
8007 : {
8008 0 : {
8009 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
8010 0 : const enum tree_code eqne = NE_EXPR;
8011 0 : if (!HONOR_NANS (captures[1])
8012 0 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
8013 0 : && types_match (type, TREE_TYPE (captures[0]))
8014 0 : && expr_no_side_effects_p (captures[1])
8015 0 : && expr_no_side_effects_p (captures[2])
8016 : )
8017 : {
8018 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1540;
8019 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1540;
8020 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1540;
8021 0 : {
8022 0 : tree res_op0;
8023 0 : {
8024 0 : tree _o1[2], _r1;
8025 0 : {
8026 0 : tree _o2[2], _r2;
8027 0 : _o2[0] = captures[0];
8028 0 : _o2[1] = captures[3];
8029 0 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8030 0 : _o1[0] = _r2;
8031 : }
8032 0 : {
8033 0 : tree _o2[2], _r2;
8034 0 : _o2[0] = captures[1];
8035 0 : _o2[1] = captures[2];
8036 0 : _r2 = fold_build2_loc (loc, EQ_EXPR, type, _o2[0], _o2[1]);
8037 0 : _o1[1] = _r2;
8038 : }
8039 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8040 0 : res_op0 = _r1;
8041 : }
8042 0 : tree res_op1;
8043 0 : res_op1 = constant_boolean_node (eqne != NE_EXPR, type);
8044 0 : tree res_op2;
8045 0 : res_op2 = constant_boolean_node (eqne == NE_EXPR, type);
8046 0 : tree _r;
8047 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
8048 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 965, __FILE__, __LINE__, true);
8049 0 : return _r;
8050 : }
8051 0 : next_after_fail1540:;
8052 : }
8053 : }
8054 : }
8055 : }
8056 : break;
8057 : }
8058 : default:;
8059 : }
8060 : break;
8061 : }
8062 104 : case VEC_COND_EXPR:
8063 104 : {
8064 104 : tree _q20 = TREE_OPERAND (_p0, 0);
8065 104 : tree _q21 = TREE_OPERAND (_p0, 1);
8066 104 : tree _q22 = TREE_OPERAND (_p0, 2);
8067 104 : switch (TREE_CODE (_p1))
8068 : {
8069 0 : case VEC_COND_EXPR:
8070 0 : {
8071 0 : tree _q60 = TREE_OPERAND (_p1, 0);
8072 0 : tree _q61 = TREE_OPERAND (_p1, 1);
8073 0 : tree _q62 = TREE_OPERAND (_p1, 2);
8074 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
8075 : {
8076 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
8077 : {
8078 0 : {
8079 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
8080 0 : const enum tree_code eqne = NE_EXPR;
8081 0 : if (!HONOR_NANS (captures[1])
8082 0 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
8083 0 : && types_match (type, TREE_TYPE (captures[0]))
8084 0 : && expr_no_side_effects_p (captures[1])
8085 0 : && expr_no_side_effects_p (captures[2])
8086 : )
8087 : {
8088 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1541;
8089 0 : {
8090 0 : tree res_op0;
8091 0 : {
8092 0 : tree _o1[2], _r1;
8093 0 : {
8094 0 : tree _o2[2], _r2;
8095 0 : _o2[0] = captures[0];
8096 0 : _o2[1] = captures[3];
8097 0 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8098 0 : _o1[0] = _r2;
8099 : }
8100 0 : {
8101 0 : tree _o2[2], _r2;
8102 0 : _o2[0] = captures[1];
8103 0 : _o2[1] = captures[2];
8104 0 : _r2 = fold_build2_loc (loc, NE_EXPR, type, _o2[0], _o2[1]);
8105 0 : _o1[1] = _r2;
8106 : }
8107 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8108 0 : res_op0 = _r1;
8109 : }
8110 0 : tree res_op1;
8111 0 : res_op1 = constant_boolean_node (eqne == NE_EXPR, type);
8112 0 : tree res_op2;
8113 0 : res_op2 = constant_boolean_node (eqne != NE_EXPR, type);
8114 0 : tree _r;
8115 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8116 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 964, __FILE__, __LINE__, true);
8117 0 : return _r;
8118 : }
8119 0 : next_after_fail1541:;
8120 : }
8121 : }
8122 : }
8123 : }
8124 0 : if ((_q61 == _q22 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q22, 0) && types_match (_q61, _q22)))
8125 : {
8126 0 : if ((_q62 == _q21 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q21, 0) && types_match (_q62, _q21)))
8127 : {
8128 0 : {
8129 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
8130 0 : const enum tree_code eqne = NE_EXPR;
8131 0 : if (!HONOR_NANS (captures[1])
8132 0 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
8133 0 : && types_match (type, TREE_TYPE (captures[0]))
8134 0 : && expr_no_side_effects_p (captures[1])
8135 0 : && expr_no_side_effects_p (captures[2])
8136 : )
8137 : {
8138 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1542;
8139 0 : {
8140 0 : tree res_op0;
8141 0 : {
8142 0 : tree _o1[2], _r1;
8143 0 : {
8144 0 : tree _o2[2], _r2;
8145 0 : _o2[0] = captures[0];
8146 0 : _o2[1] = captures[3];
8147 0 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8148 0 : _o1[0] = _r2;
8149 : }
8150 0 : {
8151 0 : tree _o2[2], _r2;
8152 0 : _o2[0] = captures[1];
8153 0 : _o2[1] = captures[2];
8154 0 : _r2 = fold_build2_loc (loc, EQ_EXPR, type, _o2[0], _o2[1]);
8155 0 : _o1[1] = _r2;
8156 : }
8157 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8158 0 : res_op0 = _r1;
8159 : }
8160 0 : tree res_op1;
8161 0 : res_op1 = constant_boolean_node (eqne != NE_EXPR, type);
8162 0 : tree res_op2;
8163 0 : res_op2 = constant_boolean_node (eqne == NE_EXPR, type);
8164 0 : tree _r;
8165 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8166 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 965, __FILE__, __LINE__, true);
8167 0 : return _r;
8168 : }
8169 0 : next_after_fail1542:;
8170 : }
8171 : }
8172 : }
8173 : }
8174 : break;
8175 : }
8176 : default:;
8177 : }
8178 : break;
8179 : }
8180 18024 : case LT_EXPR:
8181 18024 : {
8182 18024 : tree _q20 = TREE_OPERAND (_p0, 0);
8183 18024 : tree _q21 = TREE_OPERAND (_p0, 1);
8184 18024 : if (integer_zerop (_p1))
8185 : {
8186 16524 : {
8187 16524 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8188 16524 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, LT_EXPR, GE_EXPR, UNGE_EXPR);
8189 16524 : if (res) return res;
8190 : }
8191 : }
8192 15087 : if (integer_truep (_p1))
8193 : {
8194 547 : {
8195 547 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8196 547 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, LT_EXPR, GE_EXPR, UNGE_EXPR);
8197 547 : if (res) return res;
8198 : }
8199 : }
8200 : break;
8201 : }
8202 11848 : case LE_EXPR:
8203 11848 : {
8204 11848 : tree _q20 = TREE_OPERAND (_p0, 0);
8205 11848 : tree _q21 = TREE_OPERAND (_p0, 1);
8206 11848 : if (integer_zerop (_p1))
8207 : {
8208 9287 : {
8209 9287 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8210 9287 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR, UNGT_EXPR);
8211 9287 : if (res) return res;
8212 : }
8213 : }
8214 11056 : if (integer_truep (_p1))
8215 : {
8216 461 : {
8217 461 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8218 461 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR, UNGT_EXPR);
8219 461 : if (res) return res;
8220 : }
8221 : }
8222 : break;
8223 : }
8224 64321 : case EQ_EXPR:
8225 64321 : {
8226 64321 : tree _q20 = TREE_OPERAND (_p0, 0);
8227 64321 : tree _q21 = TREE_OPERAND (_p0, 1);
8228 64321 : if (integer_zerop (_p1))
8229 : {
8230 36754 : {
8231 36754 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8232 36754 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR, NE_EXPR);
8233 36754 : if (res) return res;
8234 : }
8235 : }
8236 63456 : if (integer_truep (_p1))
8237 : {
8238 21941 : {
8239 21941 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8240 21941 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR, NE_EXPR);
8241 21941 : if (res) return res;
8242 : }
8243 : }
8244 : break;
8245 : }
8246 68290 : case NE_EXPR:
8247 68290 : {
8248 68290 : tree _q20 = TREE_OPERAND (_p0, 0);
8249 68290 : tree _q21 = TREE_OPERAND (_p0, 1);
8250 68290 : if (integer_zerop (_p1))
8251 : {
8252 56671 : {
8253 56671 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8254 56671 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR, EQ_EXPR);
8255 56671 : if (res) return res;
8256 : }
8257 : }
8258 34161 : if (integer_truep (_p1))
8259 : {
8260 141 : {
8261 141 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8262 141 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR, EQ_EXPR);
8263 141 : if (res) return res;
8264 : }
8265 : }
8266 : break;
8267 : }
8268 6123 : case GE_EXPR:
8269 6123 : {
8270 6123 : tree _q20 = TREE_OPERAND (_p0, 0);
8271 6123 : tree _q21 = TREE_OPERAND (_p0, 1);
8272 6123 : if (integer_zerop (_p1))
8273 : {
8274 4174 : {
8275 4174 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8276 4174 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, GE_EXPR, LT_EXPR, UNLT_EXPR);
8277 4174 : if (res) return res;
8278 : }
8279 : }
8280 5465 : if (integer_truep (_p1))
8281 : {
8282 478 : {
8283 478 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8284 478 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, GE_EXPR, LT_EXPR, UNLT_EXPR);
8285 478 : if (res) return res;
8286 : }
8287 : }
8288 : break;
8289 : }
8290 35311 : case GT_EXPR:
8291 35311 : {
8292 35311 : tree _q20 = TREE_OPERAND (_p0, 0);
8293 35311 : tree _q21 = TREE_OPERAND (_p0, 1);
8294 35311 : if (integer_zerop (_p1))
8295 : {
8296 33245 : {
8297 33245 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8298 33245 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, GT_EXPR, LE_EXPR, UNLE_EXPR);
8299 33245 : if (res) return res;
8300 : }
8301 : }
8302 29343 : if (integer_truep (_p1))
8303 : {
8304 320 : {
8305 320 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8306 320 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, GT_EXPR, LE_EXPR, UNLE_EXPR);
8307 320 : if (res) return res;
8308 : }
8309 : }
8310 : break;
8311 : }
8312 127805 : case UNORDERED_EXPR:
8313 127805 : {
8314 127805 : tree _q20 = TREE_OPERAND (_p0, 0);
8315 127805 : tree _q21 = TREE_OPERAND (_p0, 1);
8316 127805 : if (integer_zerop (_p1))
8317 : {
8318 125597 : {
8319 125597 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8320 125597 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR);
8321 125597 : if (res) return res;
8322 : }
8323 : }
8324 127415 : if (integer_truep (_p1))
8325 : {
8326 42 : {
8327 42 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8328 42 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR);
8329 42 : if (res) return res;
8330 : }
8331 : }
8332 : break;
8333 : }
8334 125 : case ORDERED_EXPR:
8335 125 : {
8336 125 : tree _q20 = TREE_OPERAND (_p0, 0);
8337 125 : tree _q21 = TREE_OPERAND (_p0, 1);
8338 125 : if (integer_zerop (_p1))
8339 : {
8340 42 : {
8341 42 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8342 42 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR);
8343 42 : if (res) return res;
8344 : }
8345 : }
8346 83 : if (integer_truep (_p1))
8347 : {
8348 0 : {
8349 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8350 0 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR);
8351 0 : if (res) return res;
8352 : }
8353 : }
8354 : break;
8355 : }
8356 225 : case UNLT_EXPR:
8357 225 : {
8358 225 : tree _q20 = TREE_OPERAND (_p0, 0);
8359 225 : tree _q21 = TREE_OPERAND (_p0, 1);
8360 225 : if (integer_zerop (_p1))
8361 : {
8362 28 : {
8363 28 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8364 28 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, UNLT_EXPR, GE_EXPR, GE_EXPR);
8365 28 : if (res) return res;
8366 : }
8367 : }
8368 197 : if (integer_truep (_p1))
8369 : {
8370 169 : {
8371 169 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8372 169 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, UNLT_EXPR, GE_EXPR, GE_EXPR);
8373 169 : if (res) return res;
8374 : }
8375 : }
8376 : break;
8377 : }
8378 1438 : case UNLE_EXPR:
8379 1438 : {
8380 1438 : tree _q20 = TREE_OPERAND (_p0, 0);
8381 1438 : tree _q21 = TREE_OPERAND (_p0, 1);
8382 1438 : if (integer_zerop (_p1))
8383 : {
8384 104 : {
8385 104 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8386 104 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, UNLE_EXPR, GT_EXPR, GT_EXPR);
8387 104 : if (res) return res;
8388 : }
8389 : }
8390 1334 : if (integer_truep (_p1))
8391 : {
8392 1306 : {
8393 1306 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8394 1306 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, UNLE_EXPR, GT_EXPR, GT_EXPR);
8395 1306 : if (res) return res;
8396 : }
8397 : }
8398 : break;
8399 : }
8400 2800 : case UNGT_EXPR:
8401 2800 : {
8402 2800 : tree _q20 = TREE_OPERAND (_p0, 0);
8403 2800 : tree _q21 = TREE_OPERAND (_p0, 1);
8404 2800 : if (integer_zerop (_p1))
8405 : {
8406 96 : {
8407 96 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8408 96 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, UNGT_EXPR, LE_EXPR, LE_EXPR);
8409 96 : if (res) return res;
8410 : }
8411 : }
8412 2704 : if (integer_truep (_p1))
8413 : {
8414 2556 : {
8415 2556 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8416 2556 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, UNGT_EXPR, LE_EXPR, LE_EXPR);
8417 2556 : if (res) return res;
8418 : }
8419 : }
8420 : break;
8421 : }
8422 403 : case UNGE_EXPR:
8423 403 : {
8424 403 : tree _q20 = TREE_OPERAND (_p0, 0);
8425 403 : tree _q21 = TREE_OPERAND (_p0, 1);
8426 403 : if (integer_zerop (_p1))
8427 : {
8428 16 : {
8429 16 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8430 16 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, UNGE_EXPR, LT_EXPR, LT_EXPR);
8431 16 : if (res) return res;
8432 : }
8433 : }
8434 387 : if (integer_truep (_p1))
8435 : {
8436 219 : {
8437 219 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8438 219 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, UNGE_EXPR, LT_EXPR, LT_EXPR);
8439 219 : if (res) return res;
8440 : }
8441 : }
8442 : break;
8443 : }
8444 175 : case UNEQ_EXPR:
8445 175 : {
8446 175 : tree _q20 = TREE_OPERAND (_p0, 0);
8447 175 : tree _q21 = TREE_OPERAND (_p0, 1);
8448 175 : if (integer_zerop (_p1))
8449 : {
8450 0 : {
8451 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8452 0 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR);
8453 0 : if (res) return res;
8454 : }
8455 : }
8456 175 : if (integer_truep (_p1))
8457 : {
8458 132 : {
8459 132 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8460 132 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR);
8461 132 : if (res) return res;
8462 : }
8463 : }
8464 : break;
8465 : }
8466 27 : case LTGT_EXPR:
8467 27 : {
8468 27 : tree _q20 = TREE_OPERAND (_p0, 0);
8469 27 : tree _q21 = TREE_OPERAND (_p0, 1);
8470 27 : if (integer_zerop (_p1))
8471 : {
8472 6 : {
8473 6 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8474 6 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR);
8475 6 : if (res) return res;
8476 : }
8477 : }
8478 27 : if (integer_truep (_p1))
8479 : {
8480 0 : {
8481 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8482 0 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR);
8483 0 : if (res) return res;
8484 : }
8485 : }
8486 : break;
8487 : }
8488 105851 : case MINUS_EXPR:
8489 105851 : {
8490 105851 : tree _q20 = TREE_OPERAND (_p0, 0);
8491 105851 : tree _q21 = TREE_OPERAND (_p0, 1);
8492 105851 : if (integer_zerop (_p1))
8493 : {
8494 36564 : {
8495 36564 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8496 36564 : tree res = generic_simplify_245 (loc, type, _p0, _p1, captures, NE_EXPR);
8497 36564 : if (res) return res;
8498 : }
8499 : }
8500 : break;
8501 : }
8502 26658 : case POINTER_DIFF_EXPR:
8503 26658 : {
8504 26658 : tree _q20 = TREE_OPERAND (_p0, 0);
8505 26658 : tree _q21 = TREE_OPERAND (_p0, 1);
8506 26658 : if (integer_zerop (_p1))
8507 : {
8508 14576 : {
8509 14576 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8510 14576 : tree res = generic_simplify_246 (loc, type, _p0, _p1, captures, NE_EXPR);
8511 14576 : if (res) return res;
8512 : }
8513 : }
8514 : break;
8515 : }
8516 94949 : case MULT_EXPR:
8517 94949 : {
8518 94949 : tree _q20 = TREE_OPERAND (_p0, 0);
8519 94949 : tree _q21 = TREE_OPERAND (_p0, 1);
8520 94949 : switch (TREE_CODE (_q21))
8521 : {
8522 77442 : case INTEGER_CST:
8523 77442 : {
8524 77442 : switch (TREE_CODE (_p1))
8525 : {
8526 51705 : case INTEGER_CST:
8527 51705 : {
8528 51705 : {
8529 51705 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8530 51705 : tree res = generic_simplify_248 (loc, type, _p0, _p1, captures, NE_EXPR);
8531 51705 : if (res) return res;
8532 : }
8533 35172 : break;
8534 : }
8535 60909 : default:;
8536 : }
8537 60909 : if (integer_zerop (_p1))
8538 : {
8539 12565 : {
8540 12565 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
8541 12565 : tree res = generic_simplify_247 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
8542 12565 : if (res) return res;
8543 : }
8544 : }
8545 : break;
8546 : }
8547 : default:;
8548 : }
8549 : break;
8550 : }
8551 40403791 : default:;
8552 : }
8553 40403791 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
8554 : {
8555 123802 : {
8556 123802 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8557 123802 : tree res = generic_simplify_300 (loc, type, _p0, _p1, captures, NE_EXPR);
8558 123802 : if (res) return res;
8559 : }
8560 : }
8561 40286634 : switch (TREE_CODE (_p0))
8562 : {
8563 8203728 : CASE_CONVERT:
8564 8203728 : {
8565 8203728 : tree _q20 = TREE_OPERAND (_p0, 0);
8566 8203728 : switch (TREE_CODE (_p1))
8567 : {
8568 3107039 : CASE_CONVERT:
8569 3107039 : {
8570 3107039 : tree _q40 = TREE_OPERAND (_p1, 0);
8571 3107039 : {
8572 3107039 : tree _q40_pops[1];
8573 3107039 : if (tree_maybe_bit_not (_q40, _q40_pops))
8574 : {
8575 0 : tree _q50 = _q40_pops[0];
8576 0 : {
8577 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
8578 0 : tree res = generic_simplify_250 (loc, type, _p0, _p1, captures, NE_EXPR);
8579 0 : if (res) return res;
8580 : }
8581 : }
8582 : }
8583 3107039 : break;
8584 : }
8585 8203728 : default:;
8586 : }
8587 8203728 : {
8588 8203728 : tree _q20_pops[1];
8589 8203728 : if (tree_maybe_bit_not (_q20, _q20_pops))
8590 : {
8591 12642 : tree _q30 = _q20_pops[0];
8592 12642 : switch (TREE_CODE (_p1))
8593 : {
8594 0 : CASE_CONVERT:
8595 0 : {
8596 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8597 0 : {
8598 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
8599 0 : tree res = generic_simplify_250 (loc, type, _p0, _p1, captures, NE_EXPR);
8600 0 : if (res) return res;
8601 : }
8602 0 : break;
8603 : }
8604 : default:;
8605 : }
8606 : }
8607 : }
8608 8203728 : break;
8609 : }
8610 40286634 : default:;
8611 : }
8612 40286634 : {
8613 40286634 : tree _p1_pops[1];
8614 40286634 : if (tree_maybe_bit_not (_p1, _p1_pops))
8615 : {
8616 30071543 : tree _q30 = _p1_pops[0];
8617 30071543 : {
8618 30071543 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
8619 30071543 : tree res = generic_simplify_250 (loc, type, _p0, _p1, captures, NE_EXPR);
8620 30071543 : if (res) return res;
8621 : }
8622 : }
8623 : }
8624 40286634 : switch (TREE_CODE (_p0))
8625 : {
8626 13414 : case BIT_NOT_EXPR:
8627 13414 : {
8628 13414 : tree _q20 = TREE_OPERAND (_p0, 0);
8629 13414 : switch (TREE_CODE (_p1))
8630 : {
8631 11 : case BIT_NOT_EXPR:
8632 11 : {
8633 11 : tree _q40 = TREE_OPERAND (_p1, 0);
8634 11 : {
8635 11 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _p1, _q40 };
8636 11 : tree res = generic_simplify_253 (loc, type, _p0, _p1, captures, NE_EXPR);
8637 11 : if (res) return res;
8638 : }
8639 0 : break;
8640 : }
8641 13403 : default:;
8642 : }
8643 13403 : {
8644 13403 : tree _p1_pops[1];
8645 13403 : if (tree_nop_convert (_p1, _p1_pops))
8646 : {
8647 80 : tree _q40 = _p1_pops[0];
8648 80 : switch (TREE_CODE (_q40))
8649 : {
8650 0 : case BIT_NOT_EXPR:
8651 0 : {
8652 0 : tree _q50 = TREE_OPERAND (_q40, 0);
8653 0 : {
8654 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40, _q50 };
8655 0 : tree res = generic_simplify_253 (loc, type, _p0, _p1, captures, NE_EXPR);
8656 0 : if (res) return res;
8657 : }
8658 0 : break;
8659 : }
8660 : default:;
8661 : }
8662 : }
8663 : }
8664 13403 : if (CONSTANT_CLASS_P (_p1))
8665 : {
8666 12217 : {
8667 12217 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8668 12217 : tree res = generic_simplify_252 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
8669 12217 : if (res) return res;
8670 : }
8671 : }
8672 : break;
8673 : }
8674 40274406 : default:;
8675 : }
8676 40274406 : {
8677 40274406 : tree _p0_pops[1];
8678 40274406 : if (tree_maybe_bit_not (_p0, _p0_pops))
8679 : {
8680 283990 : tree _q20 = _p0_pops[0];
8681 283990 : {
8682 283990 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _q20 };
8683 283990 : tree res = generic_simplify_250 (loc, type, _p0, _p1, captures, NE_EXPR);
8684 283990 : if (res) return res;
8685 : }
8686 : }
8687 : }
8688 40274404 : {
8689 40274404 : tree _p0_pops[1];
8690 40274404 : if (tree_nop_convert (_p0, _p0_pops))
8691 : {
8692 4804894 : tree _q20 = _p0_pops[0];
8693 4804894 : switch (TREE_CODE (_q20))
8694 : {
8695 1 : case BIT_NOT_EXPR:
8696 1 : {
8697 1 : tree _q30 = TREE_OPERAND (_q20, 0);
8698 1 : switch (TREE_CODE (_p1))
8699 : {
8700 0 : case BIT_NOT_EXPR:
8701 0 : {
8702 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8703 0 : {
8704 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _p1, _q50 };
8705 0 : tree res = generic_simplify_251 (loc, type, _p0, _p1, captures, NE_EXPR);
8706 0 : if (res) return res;
8707 : }
8708 0 : break;
8709 : }
8710 1 : default:;
8711 : }
8712 1 : {
8713 1 : tree _p1_pops[1];
8714 1 : if (tree_nop_convert (_p1, _p1_pops))
8715 : {
8716 0 : tree _q50 = _p1_pops[0];
8717 0 : switch (TREE_CODE (_q50))
8718 : {
8719 0 : case BIT_NOT_EXPR:
8720 0 : {
8721 0 : tree _q60 = TREE_OPERAND (_q50, 0);
8722 0 : {
8723 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50, _q60 };
8724 0 : tree res = generic_simplify_251 (loc, type, _p0, _p1, captures, NE_EXPR);
8725 0 : if (res) return res;
8726 : }
8727 0 : break;
8728 : }
8729 : default:;
8730 : }
8731 : }
8732 : }
8733 1 : if (CONSTANT_CLASS_P (_p1))
8734 : {
8735 1 : {
8736 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
8737 1 : tree res = generic_simplify_252 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
8738 1 : if (res) return res;
8739 : }
8740 : }
8741 : break;
8742 : }
8743 : default:;
8744 : }
8745 : }
8746 : }
8747 40274403 : switch (TREE_CODE (_p1))
8748 : {
8749 693955 : case REAL_CST:
8750 693955 : {
8751 693955 : {
8752 693955 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8753 693955 : tree res = generic_simplify_254 (loc, type, _p0, _p1, captures, NE_EXPR);
8754 693955 : if (res) return res;
8755 : }
8756 626869 : break;
8757 : }
8758 40207317 : default:;
8759 : }
8760 40207317 : switch (TREE_CODE (_p0))
8761 : {
8762 1325686 : case PLUS_EXPR:
8763 1325686 : {
8764 1325686 : tree _q20 = TREE_OPERAND (_p0, 0);
8765 1325686 : tree _q21 = TREE_OPERAND (_p0, 1);
8766 1325686 : switch (TREE_CODE (_q21))
8767 : {
8768 3850 : case REAL_CST:
8769 3850 : {
8770 3850 : switch (TREE_CODE (_p1))
8771 : {
8772 3069 : case REAL_CST:
8773 3069 : {
8774 3069 : {
8775 3069 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8776 3069 : tree res = generic_simplify_255 (loc, type, _p0, _p1, captures, PLUS_EXPR, NE_EXPR);
8777 3069 : if (res) return res;
8778 : }
8779 3069 : break;
8780 : }
8781 : default:;
8782 : }
8783 : break;
8784 : }
8785 : default:;
8786 : }
8787 : break;
8788 : }
8789 69283 : case MINUS_EXPR:
8790 69283 : {
8791 69283 : tree _q20 = TREE_OPERAND (_p0, 0);
8792 69283 : tree _q21 = TREE_OPERAND (_p0, 1);
8793 69283 : switch (TREE_CODE (_q21))
8794 : {
8795 3215 : case REAL_CST:
8796 3215 : {
8797 3215 : switch (TREE_CODE (_p1))
8798 : {
8799 2849 : case REAL_CST:
8800 2849 : {
8801 2849 : {
8802 2849 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8803 2849 : tree res = generic_simplify_255 (loc, type, _p0, _p1, captures, MINUS_EXPR, NE_EXPR);
8804 2849 : if (res) return res;
8805 : }
8806 2849 : break;
8807 : }
8808 : default:;
8809 : }
8810 : break;
8811 : }
8812 69283 : default:;
8813 : }
8814 69283 : switch (TREE_CODE (_q20))
8815 : {
8816 87 : case REAL_CST:
8817 87 : {
8818 87 : switch (TREE_CODE (_p1))
8819 : {
8820 44 : case REAL_CST:
8821 44 : {
8822 44 : {
8823 44 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8824 44 : tree res = generic_simplify_256 (loc, type, _p0, _p1, captures, NE_EXPR);
8825 44 : if (res) return res;
8826 : }
8827 44 : break;
8828 : }
8829 : default:;
8830 : }
8831 : break;
8832 : }
8833 : default:;
8834 : }
8835 : break;
8836 : }
8837 10012 : case FLOAT_EXPR:
8838 10012 : {
8839 10012 : tree _q20 = TREE_OPERAND (_p0, 0);
8840 10012 : switch (TREE_CODE (_p1))
8841 : {
8842 1115 : case FLOAT_EXPR:
8843 1115 : {
8844 1115 : tree _q40 = TREE_OPERAND (_p1, 0);
8845 1115 : {
8846 1115 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
8847 1115 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
8848 1115 : if (res) return res;
8849 : }
8850 971 : break;
8851 : }
8852 1808 : case REAL_CST:
8853 1808 : {
8854 1808 : {
8855 1808 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
8856 1808 : tree res = generic_simplify_260 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
8857 1808 : if (res) return res;
8858 : }
8859 1687 : break;
8860 : }
8861 : default:;
8862 : }
8863 : break;
8864 : }
8865 2037 : case EXACT_DIV_EXPR:
8866 2037 : {
8867 2037 : tree _q20 = TREE_OPERAND (_p0, 0);
8868 2037 : tree _q21 = TREE_OPERAND (_p0, 1);
8869 2037 : switch (TREE_CODE (_p1))
8870 : {
8871 36 : case INTEGER_CST:
8872 36 : {
8873 36 : {
8874 36 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8875 36 : tree res = generic_simplify_261 (loc, type, _p0, _p1, captures, NE_EXPR);
8876 36 : if (res) return res;
8877 : }
8878 0 : break;
8879 : }
8880 : default:;
8881 : }
8882 : break;
8883 : }
8884 6151 : case NEGATE_EXPR:
8885 6151 : {
8886 6151 : tree _q20 = TREE_OPERAND (_p0, 0);
8887 6151 : switch (TREE_CODE (_p1))
8888 : {
8889 4 : case NEGATE_EXPR:
8890 4 : {
8891 4 : tree _q40 = TREE_OPERAND (_p1, 0);
8892 4 : {
8893 4 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
8894 4 : tree res = generic_simplify_262 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
8895 4 : if (res) return res;
8896 : }
8897 0 : break;
8898 : }
8899 6147 : default:;
8900 : }
8901 6147 : if (CONSTANT_CLASS_P (_p1))
8902 : {
8903 580 : {
8904 580 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
8905 580 : tree res = generic_simplify_263 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
8906 580 : if (res) return res;
8907 : }
8908 : }
8909 : break;
8910 : }
8911 1940 : case ABS_EXPR:
8912 1940 : {
8913 1940 : tree _q20 = TREE_OPERAND (_p0, 0);
8914 1940 : if (zerop (_p1))
8915 : {
8916 72 : {
8917 72 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
8918 72 : const enum tree_code eqne = NE_EXPR;
8919 72 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1543;
8920 72 : {
8921 72 : tree res_op0;
8922 72 : res_op0 = captures[0];
8923 72 : tree res_op1;
8924 72 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
8925 72 : tree _r;
8926 72 : _r = fold_build2_loc (loc, eqne, type, res_op0, res_op1);
8927 72 : if (TREE_SIDE_EFFECTS (captures[1]))
8928 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
8929 72 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 966, __FILE__, __LINE__, true);
8930 72 : return _r;
8931 : }
8932 0 : next_after_fail1543:;
8933 : }
8934 : }
8935 : break;
8936 : }
8937 1698 : case ABSU_EXPR:
8938 1698 : {
8939 1698 : tree _q20 = TREE_OPERAND (_p0, 0);
8940 1698 : if (zerop (_p1))
8941 : {
8942 65 : {
8943 65 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
8944 65 : const enum tree_code eqne = NE_EXPR;
8945 65 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1544;
8946 65 : {
8947 65 : tree res_op0;
8948 65 : res_op0 = captures[0];
8949 65 : tree res_op1;
8950 65 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
8951 65 : tree _r;
8952 65 : _r = fold_build2_loc (loc, eqne, type, res_op0, res_op1);
8953 65 : if (TREE_SIDE_EFFECTS (captures[1]))
8954 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
8955 65 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 966, __FILE__, __LINE__, true);
8956 65 : return _r;
8957 : }
8958 0 : next_after_fail1544:;
8959 : }
8960 : }
8961 : break;
8962 : }
8963 8203644 : CASE_CONVERT:
8964 8203644 : {
8965 8203644 : tree _q20 = TREE_OPERAND (_p0, 0);
8966 8203644 : switch (TREE_CODE (_p1))
8967 : {
8968 3107039 : CASE_CONVERT:
8969 3107039 : {
8970 3107039 : tree _q40 = TREE_OPERAND (_p1, 0);
8971 3107039 : {
8972 3107039 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8973 3107039 : tree res = generic_simplify_264 (loc, type, _p0, _p1, captures, NE_EXPR);
8974 3107039 : if (res) return res;
8975 : }
8976 2906339 : break;
8977 : }
8978 8002944 : default:;
8979 : }
8980 8002944 : {
8981 8002944 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
8982 8002944 : tree res = generic_simplify_265 (loc, type, _p0, _p1, captures, NE_EXPR);
8983 8002944 : if (res) return res;
8984 : }
8985 4608052 : switch (TREE_CODE (_q20))
8986 : {
8987 12 : case BIT_IOR_EXPR:
8988 12 : {
8989 12 : tree _q30 = TREE_OPERAND (_q20, 0);
8990 12 : tree _q31 = TREE_OPERAND (_q20, 1);
8991 12 : switch (TREE_CODE (_q31))
8992 : {
8993 0 : case INTEGER_CST:
8994 0 : {
8995 0 : switch (TREE_CODE (_p1))
8996 : {
8997 0 : case INTEGER_CST:
8998 0 : {
8999 0 : {
9000 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _p1 };
9001 0 : tree res = generic_simplify_266 (loc, type, _p0, _p1, captures, NE_EXPR);
9002 0 : if (res) return res;
9003 : }
9004 0 : break;
9005 : }
9006 : default:;
9007 : }
9008 : break;
9009 : }
9010 : default:;
9011 : }
9012 : break;
9013 : }
9014 : default:;
9015 : }
9016 : break;
9017 : }
9018 14978215 : case SSA_NAME:
9019 14978215 : {
9020 14978215 : switch (TREE_CODE (_p1))
9021 : {
9022 314945 : case ADDR_EXPR:
9023 314945 : {
9024 314945 : {
9025 314945 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9026 314945 : tree res = generic_simplify_267 (loc, type, _p0, _p1, captures, NE_EXPR);
9027 314945 : if (res) return res;
9028 : }
9029 314943 : break;
9030 : }
9031 : default:;
9032 : }
9033 : break;
9034 : }
9035 238074 : case BIT_IOR_EXPR:
9036 238074 : {
9037 238074 : tree _q20 = TREE_OPERAND (_p0, 0);
9038 238074 : tree _q21 = TREE_OPERAND (_p0, 1);
9039 238074 : switch (TREE_CODE (_q21))
9040 : {
9041 970 : case INTEGER_CST:
9042 970 : {
9043 970 : switch (TREE_CODE (_p1))
9044 : {
9045 233 : case INTEGER_CST:
9046 233 : {
9047 233 : {
9048 233 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
9049 233 : tree res = generic_simplify_266 (loc, type, _p0, _p1, captures, NE_EXPR);
9050 233 : if (res) return res;
9051 : }
9052 233 : break;
9053 : }
9054 : default:;
9055 : }
9056 : break;
9057 : }
9058 : default:;
9059 : }
9060 : break;
9061 : }
9062 29222 : case BIT_XOR_EXPR:
9063 29222 : {
9064 29222 : tree _q20 = TREE_OPERAND (_p0, 0);
9065 29222 : tree _q21 = TREE_OPERAND (_p0, 1);
9066 29222 : if (integer_zerop (_p1))
9067 : {
9068 24895 : {
9069 24895 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9070 24895 : tree res = generic_simplify_268 (loc, type, _p0, _p1, captures, NE_EXPR);
9071 24895 : if (res) return res;
9072 : }
9073 : }
9074 4327 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9075 : {
9076 1 : {
9077 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9078 1 : tree res = generic_simplify_269 (loc, type, _p0, _p1, captures, NE_EXPR);
9079 1 : if (res) return res;
9080 : }
9081 : }
9082 4326 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
9083 : {
9084 2 : {
9085 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9086 2 : tree res = generic_simplify_269 (loc, type, _p0, _p1, captures, NE_EXPR);
9087 2 : if (res) return res;
9088 : }
9089 : }
9090 : break;
9091 : }
9092 2741695 : case CALL_EXPR:
9093 2741695 : switch (get_call_combined_fn (_p0))
9094 : {
9095 42 : case CFN_BUILT_IN_SQRTF:
9096 42 : if (call_expr_nargs (_p0) == 1)
9097 : {
9098 42 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9099 42 : switch (TREE_CODE (_p1))
9100 : {
9101 0 : case REAL_CST:
9102 0 : {
9103 0 : {
9104 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9105 0 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, NE_EXPR);
9106 0 : if (res) return res;
9107 : }
9108 0 : break;
9109 : }
9110 42 : case CALL_EXPR:
9111 42 : switch (get_call_combined_fn (_p1))
9112 : {
9113 0 : case CFN_BUILT_IN_SQRTF:
9114 0 : if (call_expr_nargs (_p1) == 1)
9115 : {
9116 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9117 0 : {
9118 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9119 0 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, NE_EXPR);
9120 0 : if (res) return res;
9121 : }
9122 : }
9123 : break;
9124 : default:;
9125 : }
9126 : break;
9127 : default:;
9128 : }
9129 : }
9130 : break;
9131 42 : case CFN_BUILT_IN_SQRTL:
9132 42 : if (call_expr_nargs (_p0) == 1)
9133 : {
9134 42 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9135 42 : switch (TREE_CODE (_p1))
9136 : {
9137 0 : case REAL_CST:
9138 0 : {
9139 0 : {
9140 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9141 0 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, NE_EXPR);
9142 0 : if (res) return res;
9143 : }
9144 0 : break;
9145 : }
9146 42 : case CALL_EXPR:
9147 42 : switch (get_call_combined_fn (_p1))
9148 : {
9149 0 : case CFN_BUILT_IN_SQRTL:
9150 0 : if (call_expr_nargs (_p1) == 1)
9151 : {
9152 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9153 0 : {
9154 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9155 0 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, NE_EXPR);
9156 0 : if (res) return res;
9157 : }
9158 : }
9159 : break;
9160 : default:;
9161 : }
9162 : break;
9163 : default:;
9164 : }
9165 : }
9166 : break;
9167 46 : case CFN_BUILT_IN_SQRT:
9168 46 : if (call_expr_nargs (_p0) == 1)
9169 : {
9170 46 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9171 46 : switch (TREE_CODE (_p1))
9172 : {
9173 2 : case REAL_CST:
9174 2 : {
9175 2 : {
9176 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9177 2 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, NE_EXPR);
9178 2 : if (res) return res;
9179 : }
9180 2 : break;
9181 : }
9182 43 : case CALL_EXPR:
9183 43 : switch (get_call_combined_fn (_p1))
9184 : {
9185 0 : case CFN_BUILT_IN_SQRT:
9186 0 : if (call_expr_nargs (_p1) == 1)
9187 : {
9188 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9189 0 : {
9190 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9191 0 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, NE_EXPR);
9192 0 : if (res) return res;
9193 : }
9194 : }
9195 : break;
9196 : default:;
9197 : }
9198 : break;
9199 : default:;
9200 : }
9201 : }
9202 : break;
9203 0 : case CFN_SQRT:
9204 0 : if (call_expr_nargs (_p0) == 1)
9205 : {
9206 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9207 0 : switch (TREE_CODE (_p1))
9208 : {
9209 0 : case REAL_CST:
9210 0 : {
9211 0 : {
9212 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9213 0 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, CFN_SQRT, NE_EXPR);
9214 0 : if (res) return res;
9215 : }
9216 0 : break;
9217 : }
9218 0 : case CALL_EXPR:
9219 0 : switch (get_call_combined_fn (_p1))
9220 : {
9221 0 : case CFN_SQRT:
9222 0 : if (call_expr_nargs (_p1) == 1)
9223 : {
9224 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9225 0 : {
9226 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9227 0 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, CFN_SQRT, NE_EXPR);
9228 0 : if (res) return res;
9229 : }
9230 : }
9231 : break;
9232 : default:;
9233 : }
9234 : break;
9235 : default:;
9236 : }
9237 : }
9238 : break;
9239 : default:;
9240 : }
9241 : break;
9242 36585821 : default:;
9243 : }
9244 36585821 : switch (TREE_CODE (_p1))
9245 : {
9246 840 : case BIT_XOR_EXPR:
9247 840 : {
9248 840 : tree _q30 = TREE_OPERAND (_p1, 0);
9249 840 : tree _q31 = TREE_OPERAND (_p1, 1);
9250 840 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9251 : {
9252 0 : {
9253 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
9254 0 : tree res = generic_simplify_269 (loc, type, _p0, _p1, captures, NE_EXPR);
9255 0 : if (res) return res;
9256 : }
9257 : }
9258 840 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
9259 : {
9260 0 : {
9261 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
9262 0 : tree res = generic_simplify_269 (loc, type, _p0, _p1, captures, NE_EXPR);
9263 0 : if (res) return res;
9264 : }
9265 : }
9266 : break;
9267 : }
9268 36585821 : default:;
9269 : }
9270 36585821 : switch (TREE_CODE (_p0))
9271 : {
9272 1336426 : case BIT_AND_EXPR:
9273 1336426 : {
9274 1336426 : tree _q20 = TREE_OPERAND (_p0, 0);
9275 1336426 : tree _q21 = TREE_OPERAND (_p0, 1);
9276 1336426 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9277 : {
9278 179 : {
9279 179 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9280 179 : tree res = generic_simplify_270 (loc, type, _p0, _p1, captures, NE_EXPR);
9281 179 : if (res) return res;
9282 : }
9283 : }
9284 1336398 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
9285 : {
9286 3981 : {
9287 3981 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9288 3981 : tree res = generic_simplify_270 (loc, type, _p0, _p1, captures, NE_EXPR);
9289 3981 : if (res) return res;
9290 : }
9291 : }
9292 : break;
9293 : }
9294 36585793 : default:;
9295 : }
9296 36585793 : switch (TREE_CODE (_p1))
9297 : {
9298 15765 : case BIT_AND_EXPR:
9299 15765 : {
9300 15765 : tree _q30 = TREE_OPERAND (_p1, 0);
9301 15765 : tree _q31 = TREE_OPERAND (_p1, 1);
9302 15765 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9303 : {
9304 0 : {
9305 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
9306 0 : tree res = generic_simplify_270 (loc, type, _p0, _p1, captures, NE_EXPR);
9307 0 : if (res) return res;
9308 : }
9309 : }
9310 15765 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
9311 : {
9312 0 : {
9313 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
9314 0 : tree res = generic_simplify_270 (loc, type, _p0, _p1, captures, NE_EXPR);
9315 0 : if (res) return res;
9316 : }
9317 : }
9318 : break;
9319 : }
9320 36585793 : default:;
9321 : }
9322 36585793 : switch (TREE_CODE (_p0))
9323 : {
9324 4608052 : CASE_CONVERT:
9325 4608052 : {
9326 4608052 : tree _q20 = TREE_OPERAND (_p0, 0);
9327 4608052 : switch (TREE_CODE (_q20))
9328 : {
9329 0 : case BIT_AND_EXPR:
9330 0 : {
9331 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9332 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9333 0 : switch (TREE_CODE (_q30))
9334 : {
9335 0 : CASE_CONVERT:
9336 0 : {
9337 0 : tree _q40 = TREE_OPERAND (_q30, 0);
9338 0 : switch (TREE_CODE (_q31))
9339 : {
9340 0 : case INTEGER_CST:
9341 0 : {
9342 0 : switch (TREE_CODE (_p1))
9343 : {
9344 0 : CASE_CONVERT:
9345 0 : {
9346 0 : tree _q70 = TREE_OPERAND (_p1, 0);
9347 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
9348 : {
9349 0 : {
9350 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q40, _q31 };
9351 0 : tree res = generic_simplify_271 (loc, type, _p0, _p1, captures, NE_EXPR);
9352 0 : if (res) return res;
9353 : }
9354 : }
9355 : break;
9356 : }
9357 : default:;
9358 : }
9359 : break;
9360 : }
9361 : default:;
9362 : }
9363 : break;
9364 : }
9365 : default:;
9366 : }
9367 : break;
9368 : }
9369 4608052 : default:;
9370 : }
9371 4608052 : switch (TREE_CODE (_p1))
9372 : {
9373 2906339 : CASE_CONVERT:
9374 2906339 : {
9375 2906339 : tree _q40 = TREE_OPERAND (_p1, 0);
9376 2906339 : switch (TREE_CODE (_q40))
9377 : {
9378 0 : case BIT_AND_EXPR:
9379 0 : {
9380 0 : tree _q50 = TREE_OPERAND (_q40, 0);
9381 0 : tree _q51 = TREE_OPERAND (_q40, 1);
9382 0 : switch (TREE_CODE (_q50))
9383 : {
9384 0 : CASE_CONVERT:
9385 0 : {
9386 0 : tree _q60 = TREE_OPERAND (_q50, 0);
9387 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9388 : {
9389 0 : switch (TREE_CODE (_q51))
9390 : {
9391 0 : case INTEGER_CST:
9392 0 : {
9393 0 : {
9394 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q50, _q20, _q51 };
9395 0 : tree res = generic_simplify_271 (loc, type, _p0, _p1, captures, NE_EXPR);
9396 0 : if (res) return res;
9397 : }
9398 0 : break;
9399 : }
9400 : default:;
9401 : }
9402 : }
9403 : break;
9404 : }
9405 : default:;
9406 : }
9407 : break;
9408 : }
9409 : default:;
9410 : }
9411 : break;
9412 : }
9413 : default:;
9414 : }
9415 : break;
9416 : }
9417 238074 : case BIT_IOR_EXPR:
9418 238074 : {
9419 238074 : tree _q20 = TREE_OPERAND (_p0, 0);
9420 238074 : tree _q21 = TREE_OPERAND (_p0, 1);
9421 238074 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
9422 : {
9423 128 : {
9424 128 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9425 128 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, NE_EXPR);
9426 128 : if (res) return res;
9427 : }
9428 : }
9429 238066 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9430 : {
9431 253 : {
9432 253 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9433 253 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, NE_EXPR);
9434 253 : if (res) return res;
9435 : }
9436 : }
9437 : break;
9438 : }
9439 36585785 : default:;
9440 : }
9441 36585785 : switch (TREE_CODE (_p1))
9442 : {
9443 526 : case BIT_IOR_EXPR:
9444 526 : {
9445 526 : tree _q30 = TREE_OPERAND (_p1, 0);
9446 526 : tree _q31 = TREE_OPERAND (_p1, 1);
9447 526 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
9448 : {
9449 0 : {
9450 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
9451 0 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, NE_EXPR);
9452 0 : if (res) return res;
9453 : }
9454 : }
9455 526 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9456 : {
9457 0 : {
9458 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _p0 };
9459 0 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, NE_EXPR);
9460 0 : if (res) return res;
9461 : }
9462 : }
9463 : break;
9464 : }
9465 36585785 : default:;
9466 : }
9467 36585785 : switch (TREE_CODE (_p0))
9468 : {
9469 4608052 : CASE_CONVERT:
9470 4608052 : {
9471 4608052 : tree _q20 = TREE_OPERAND (_p0, 0);
9472 4608052 : switch (TREE_CODE (_q20))
9473 : {
9474 8 : case BIT_XOR_EXPR:
9475 8 : {
9476 8 : tree _q30 = TREE_OPERAND (_q20, 0);
9477 8 : tree _q31 = TREE_OPERAND (_q20, 1);
9478 8 : switch (TREE_CODE (_q31))
9479 : {
9480 0 : case INTEGER_CST:
9481 0 : {
9482 0 : switch (TREE_CODE (_p1))
9483 : {
9484 0 : case INTEGER_CST:
9485 0 : {
9486 0 : {
9487 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _p1 };
9488 0 : tree res = generic_simplify_273 (loc, type, _p0, _p1, captures, NE_EXPR);
9489 0 : if (res) return res;
9490 : }
9491 0 : break;
9492 : }
9493 : default:;
9494 : }
9495 : break;
9496 : }
9497 : default:;
9498 : }
9499 : break;
9500 : }
9501 : default:;
9502 : }
9503 : break;
9504 : }
9505 4324 : case BIT_XOR_EXPR:
9506 4324 : {
9507 4324 : tree _q20 = TREE_OPERAND (_p0, 0);
9508 4324 : tree _q21 = TREE_OPERAND (_p0, 1);
9509 4324 : switch (TREE_CODE (_q21))
9510 : {
9511 884 : case INTEGER_CST:
9512 884 : {
9513 884 : switch (TREE_CODE (_p1))
9514 : {
9515 10 : case INTEGER_CST:
9516 10 : {
9517 10 : {
9518 10 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
9519 10 : tree res = generic_simplify_273 (loc, type, _p0, _p1, captures, NE_EXPR);
9520 10 : if (res) return res;
9521 : }
9522 0 : break;
9523 : }
9524 : default:;
9525 : }
9526 : break;
9527 : }
9528 : default:;
9529 : }
9530 : break;
9531 : }
9532 36585775 : default:;
9533 : }
9534 36585775 : {
9535 36585775 : tree _p0_pops[1];
9536 36585775 : if (tree_nop_convert (_p0, _p0_pops))
9537 : {
9538 3895041 : tree _q20 = _p0_pops[0];
9539 3895041 : if (integer_zerop (_p1))
9540 : {
9541 899508 : {
9542 899508 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9543 899508 : tree res = generic_simplify_274 (loc, type, _p0, _p1, captures, NE_EXPR);
9544 899508 : if (res) return res;
9545 : }
9546 : }
9547 : }
9548 : }
9549 36067955 : if (integer_zerop (_p1))
9550 : {
9551 20538977 : {
9552 20538977 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
9553 20538977 : tree res = generic_simplify_274 (loc, type, _p0, _p1, captures, NE_EXPR);
9554 20538977 : if (res) return res;
9555 : }
9556 : }
9557 35884724 : switch (TREE_CODE (_p0))
9558 : {
9559 1336398 : case BIT_AND_EXPR:
9560 1336398 : {
9561 1336398 : tree _q20 = TREE_OPERAND (_p0, 0);
9562 1336398 : tree _q21 = TREE_OPERAND (_p0, 1);
9563 1336398 : switch (TREE_CODE (_p1))
9564 : {
9565 14326 : case BIT_AND_EXPR:
9566 14326 : {
9567 14326 : tree _q50 = TREE_OPERAND (_p1, 0);
9568 14326 : tree _q51 = TREE_OPERAND (_p1, 1);
9569 14326 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9570 : {
9571 14081 : {
9572 14081 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
9573 14081 : tree res = generic_simplify_275 (loc, type, _p0, _p1, captures, NE_EXPR);
9574 14081 : if (res) return res;
9575 : }
9576 : }
9577 245 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9578 : {
9579 2 : {
9580 2 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
9581 2 : tree res = generic_simplify_275 (loc, type, _p0, _p1, captures, NE_EXPR);
9582 2 : if (res) return res;
9583 : }
9584 : }
9585 243 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9586 : {
9587 1 : {
9588 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q50 };
9589 1 : tree res = generic_simplify_275 (loc, type, _p0, _p1, captures, NE_EXPR);
9590 1 : if (res) return res;
9591 : }
9592 : }
9593 242 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9594 : {
9595 7 : {
9596 7 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q51 };
9597 7 : tree res = generic_simplify_275 (loc, type, _p0, _p1, captures, NE_EXPR);
9598 7 : if (res) return res;
9599 : }
9600 : }
9601 : break;
9602 : }
9603 1322307 : default:;
9604 : }
9605 1322307 : if (integer_pow2p (_q21))
9606 : {
9607 649102 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
9608 : {
9609 579 : {
9610 579 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
9611 579 : tree res = generic_simplify_276 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
9612 579 : if (res) return res;
9613 : }
9614 : }
9615 : }
9616 1321732 : switch (TREE_CODE (_q20))
9617 : {
9618 192105 : CASE_CONVERT:
9619 192105 : {
9620 192105 : tree _q30 = TREE_OPERAND (_q20, 0);
9621 192105 : if (integer_pow2p (_q21))
9622 : {
9623 95006 : if (integer_zerop (_p1))
9624 : {
9625 94911 : {
9626 94911 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q21 };
9627 94911 : tree res = generic_simplify_277 (loc, type, _p0, _p1, captures, NE_EXPR, LT_EXPR);
9628 94911 : if (res) return res;
9629 : }
9630 : }
9631 : }
9632 : break;
9633 : }
9634 1318010 : default:;
9635 : }
9636 1318010 : if (integer_pow2p (_q21))
9637 : {
9638 644805 : if (integer_zerop (_p1))
9639 : {
9640 641397 : {
9641 641397 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q20, _q21 };
9642 641397 : tree res = generic_simplify_278 (loc, type, _p0, _p1, captures, NE_EXPR, LT_EXPR);
9643 641397 : if (res) return res;
9644 : }
9645 : }
9646 : }
9647 : break;
9648 : }
9649 5412 : case GE_EXPR:
9650 5412 : {
9651 5412 : tree _q20 = TREE_OPERAND (_p0, 0);
9652 5412 : tree _q21 = TREE_OPERAND (_p0, 1);
9653 5412 : if (integer_zerop (_q21))
9654 : {
9655 961 : switch (TREE_CODE (_p1))
9656 : {
9657 1 : case GE_EXPR:
9658 1 : {
9659 1 : tree _q50 = TREE_OPERAND (_p1, 0);
9660 1 : tree _q51 = TREE_OPERAND (_p1, 1);
9661 1 : if (integer_zerop (_q51))
9662 : {
9663 1 : {
9664 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
9665 1 : tree res = generic_simplify_279 (loc, type, _p0, _p1, captures, GE_EXPR, NE_EXPR, LT_EXPR);
9666 1 : if (res) return res;
9667 : }
9668 : }
9669 : break;
9670 : }
9671 3 : case LT_EXPR:
9672 3 : {
9673 3 : tree _q50 = TREE_OPERAND (_p1, 0);
9674 3 : tree _q51 = TREE_OPERAND (_p1, 1);
9675 3 : if (integer_zerop (_q51))
9676 : {
9677 3 : {
9678 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
9679 3 : tree res = generic_simplify_280 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR);
9680 3 : if (res) return res;
9681 : }
9682 : }
9683 : break;
9684 : }
9685 : default:;
9686 : }
9687 : }
9688 : break;
9689 : }
9690 15031 : case LT_EXPR:
9691 15031 : {
9692 15031 : tree _q20 = TREE_OPERAND (_p0, 0);
9693 15031 : tree _q21 = TREE_OPERAND (_p0, 1);
9694 15031 : if (integer_zerop (_q21))
9695 : {
9696 8426 : switch (TREE_CODE (_p1))
9697 : {
9698 66 : case LT_EXPR:
9699 66 : {
9700 66 : tree _q50 = TREE_OPERAND (_p1, 0);
9701 66 : tree _q51 = TREE_OPERAND (_p1, 1);
9702 66 : if (integer_zerop (_q51))
9703 : {
9704 66 : {
9705 66 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
9706 66 : tree res = generic_simplify_279 (loc, type, _p0, _p1, captures, LT_EXPR, NE_EXPR, LT_EXPR);
9707 66 : if (res) return res;
9708 : }
9709 : }
9710 : break;
9711 : }
9712 17 : case GE_EXPR:
9713 17 : {
9714 17 : tree _q50 = TREE_OPERAND (_p1, 0);
9715 17 : tree _q51 = TREE_OPERAND (_p1, 1);
9716 17 : if (integer_zerop (_q51))
9717 : {
9718 17 : {
9719 17 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
9720 17 : tree res = generic_simplify_281 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR);
9721 17 : if (res) return res;
9722 : }
9723 : }
9724 : break;
9725 : }
9726 : default:;
9727 : }
9728 : }
9729 : break;
9730 : }
9731 238066 : case BIT_IOR_EXPR:
9732 238066 : {
9733 238066 : tree _q20 = TREE_OPERAND (_p0, 0);
9734 238066 : tree _q21 = TREE_OPERAND (_p0, 1);
9735 238066 : switch (TREE_CODE (_q21))
9736 : {
9737 261 : CASE_CONVERT:
9738 261 : {
9739 261 : tree _q40 = TREE_OPERAND (_q21, 0);
9740 261 : switch (TREE_CODE (_q40))
9741 : {
9742 0 : case NE_EXPR:
9743 0 : {
9744 0 : tree _q50 = TREE_OPERAND (_q40, 0);
9745 0 : tree _q51 = TREE_OPERAND (_q40, 1);
9746 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9747 : {
9748 0 : if (integer_zerop (_q51))
9749 : {
9750 0 : if (integer_zerop (_p1))
9751 : {
9752 0 : {
9753 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9754 0 : tree res = generic_simplify_282 (loc, type, _p0, _p1, captures, NE_EXPR);
9755 0 : if (res) return res;
9756 : }
9757 : }
9758 : }
9759 : }
9760 : break;
9761 : }
9762 : default:;
9763 : }
9764 : break;
9765 : }
9766 238066 : default:;
9767 : }
9768 238066 : switch (TREE_CODE (_q20))
9769 : {
9770 800 : CASE_CONVERT:
9771 800 : {
9772 800 : tree _q30 = TREE_OPERAND (_q20, 0);
9773 800 : switch (TREE_CODE (_q30))
9774 : {
9775 0 : case NE_EXPR:
9776 0 : {
9777 0 : tree _q40 = TREE_OPERAND (_q30, 0);
9778 0 : tree _q41 = TREE_OPERAND (_q30, 1);
9779 0 : if (integer_zerop (_q41))
9780 : {
9781 0 : if ((_q21 == _q40 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q40, 0) && types_match (_q21, _q40)))
9782 : {
9783 0 : if (integer_zerop (_p1))
9784 : {
9785 0 : {
9786 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q40 };
9787 0 : tree res = generic_simplify_282 (loc, type, _p0, _p1, captures, NE_EXPR);
9788 0 : if (res) return res;
9789 : }
9790 : }
9791 : }
9792 : }
9793 : break;
9794 : }
9795 : default:;
9796 : }
9797 : break;
9798 : }
9799 238066 : default:;
9800 : }
9801 238066 : switch (TREE_CODE (_q21))
9802 : {
9803 24 : case NE_EXPR:
9804 24 : {
9805 24 : tree _q40 = TREE_OPERAND (_q21, 0);
9806 24 : tree _q41 = TREE_OPERAND (_q21, 1);
9807 24 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
9808 : {
9809 0 : if (integer_zerop (_q41))
9810 : {
9811 0 : if (integer_zerop (_p1))
9812 : {
9813 0 : {
9814 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9815 0 : tree res = generic_simplify_282 (loc, type, _p0, _p1, captures, NE_EXPR);
9816 0 : if (res) return res;
9817 : }
9818 : }
9819 : }
9820 : }
9821 : break;
9822 : }
9823 238066 : default:;
9824 : }
9825 238066 : switch (TREE_CODE (_q20))
9826 : {
9827 2 : case NE_EXPR:
9828 2 : {
9829 2 : tree _q30 = TREE_OPERAND (_q20, 0);
9830 2 : tree _q31 = TREE_OPERAND (_q20, 1);
9831 2 : if (integer_zerop (_q31))
9832 : {
9833 1 : if ((_q21 == _q30 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q30, 0) && types_match (_q21, _q30)))
9834 : {
9835 0 : if (integer_zerop (_p1))
9836 : {
9837 0 : {
9838 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
9839 0 : tree res = generic_simplify_282 (loc, type, _p0, _p1, captures, NE_EXPR);
9840 0 : if (res) return res;
9841 : }
9842 : }
9843 : }
9844 : }
9845 : break;
9846 : }
9847 : default:;
9848 : }
9849 : break;
9850 : }
9851 4090232 : CASE_CONVERT:
9852 4090232 : {
9853 4090232 : tree _q20 = TREE_OPERAND (_p0, 0);
9854 4090232 : switch (TREE_CODE (_q20))
9855 : {
9856 2761533 : case ADDR_EXPR:
9857 2761533 : {
9858 2761533 : switch (TREE_CODE (_p1))
9859 : {
9860 2732227 : CASE_CONVERT:
9861 2732227 : {
9862 2732227 : tree _q40 = TREE_OPERAND (_p1, 0);
9863 2732227 : switch (TREE_CODE (_q40))
9864 : {
9865 2732227 : case ADDR_EXPR:
9866 2732227 : {
9867 2732227 : {
9868 2732227 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
9869 2732227 : tree res = generic_simplify_283 (loc, type, _p0, _p1, captures, NE_EXPR);
9870 2732227 : if (res) return res;
9871 : }
9872 33 : break;
9873 : }
9874 : default:;
9875 : }
9876 : break;
9877 : }
9878 21269 : case ADDR_EXPR:
9879 21269 : {
9880 21269 : {
9881 21269 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9882 21269 : tree res = generic_simplify_283 (loc, type, _p0, _p1, captures, NE_EXPR);
9883 21269 : if (res) return res;
9884 : }
9885 7935 : break;
9886 : }
9887 : default:;
9888 : }
9889 : break;
9890 : }
9891 : default:;
9892 : }
9893 : break;
9894 : }
9895 61529 : case ADDR_EXPR:
9896 61529 : {
9897 61529 : switch (TREE_CODE (_p1))
9898 : {
9899 203 : CASE_CONVERT:
9900 203 : {
9901 203 : tree _q30 = TREE_OPERAND (_p1, 0);
9902 203 : switch (TREE_CODE (_q30))
9903 : {
9904 203 : case ADDR_EXPR:
9905 203 : {
9906 203 : {
9907 203 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q30 };
9908 203 : tree res = generic_simplify_284 (loc, type, _p0, _p1, captures, NE_EXPR);
9909 203 : if (res) return res;
9910 : }
9911 143 : break;
9912 : }
9913 : default:;
9914 : }
9915 : break;
9916 : }
9917 53151 : case ADDR_EXPR:
9918 53151 : {
9919 53151 : {
9920 53151 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
9921 53151 : tree res = generic_simplify_284 (loc, type, _p0, _p1, captures, NE_EXPR);
9922 53151 : if (res) return res;
9923 : }
9924 3693 : break;
9925 : }
9926 : default:;
9927 : }
9928 : break;
9929 : }
9930 33058865 : default:;
9931 : }
9932 33058865 : {
9933 33058865 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9934 33058865 : tree res = generic_simplify_285 (loc, type, _p0, _p1, captures, NE_EXPR);
9935 33058865 : if (res) return res;
9936 : }
9937 33049740 : switch (TREE_CODE (_p0))
9938 : {
9939 1344704 : CASE_CONVERT:
9940 1344704 : {
9941 1344704 : tree _q20 = TREE_OPERAND (_p0, 0);
9942 1344704 : switch (TREE_CODE (_p1))
9943 : {
9944 839561 : case INTEGER_CST:
9945 839561 : {
9946 839561 : {
9947 839561 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9948 839561 : tree res = generic_simplify_286 (loc, type, _p0, _p1, captures, NE_EXPR);
9949 839561 : if (res) return res;
9950 : }
9951 830926 : break;
9952 : }
9953 1336069 : default:;
9954 : }
9955 1336069 : switch (TREE_CODE (_q20))
9956 : {
9957 8 : case NE_EXPR:
9958 8 : {
9959 8 : tree _q30 = TREE_OPERAND (_q20, 0);
9960 8 : tree _q31 = TREE_OPERAND (_q20, 1);
9961 8 : switch (TREE_CODE (_q31))
9962 : {
9963 8 : case INTEGER_CST:
9964 8 : {
9965 8 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
9966 : {
9967 0 : {
9968 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
9969 0 : tree res = generic_simplify_287 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
9970 0 : if (res) return res;
9971 : }
9972 : }
9973 : break;
9974 : }
9975 : default:;
9976 : }
9977 : break;
9978 : }
9979 0 : case EQ_EXPR:
9980 0 : {
9981 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9982 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9983 0 : switch (TREE_CODE (_q31))
9984 : {
9985 0 : case INTEGER_CST:
9986 0 : {
9987 0 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
9988 : {
9989 0 : {
9990 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
9991 0 : tree res = generic_simplify_287 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR);
9992 0 : if (res) return res;
9993 : }
9994 : }
9995 : break;
9996 : }
9997 : default:;
9998 : }
9999 : break;
10000 : }
10001 : default:;
10002 : }
10003 : break;
10004 : }
10005 33041105 : default:;
10006 : }
10007 33041105 : switch (TREE_CODE (_p1))
10008 : {
10009 574380 : CASE_CONVERT:
10010 574380 : {
10011 574380 : tree _q30 = TREE_OPERAND (_p1, 0);
10012 574380 : switch (TREE_CODE (_q30))
10013 : {
10014 0 : case NE_EXPR:
10015 0 : {
10016 0 : tree _q40 = TREE_OPERAND (_q30, 0);
10017 0 : tree _q41 = TREE_OPERAND (_q30, 1);
10018 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
10019 : {
10020 0 : switch (TREE_CODE (_q41))
10021 : {
10022 0 : case INTEGER_CST:
10023 0 : {
10024 0 : {
10025 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
10026 0 : tree res = generic_simplify_287 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
10027 0 : if (res) return res;
10028 : }
10029 0 : break;
10030 : }
10031 : default:;
10032 : }
10033 : }
10034 : break;
10035 : }
10036 0 : case EQ_EXPR:
10037 0 : {
10038 0 : tree _q40 = TREE_OPERAND (_q30, 0);
10039 0 : tree _q41 = TREE_OPERAND (_q30, 1);
10040 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
10041 : {
10042 0 : switch (TREE_CODE (_q41))
10043 : {
10044 0 : case INTEGER_CST:
10045 0 : {
10046 0 : {
10047 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
10048 0 : tree res = generic_simplify_287 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR);
10049 0 : if (res) return res;
10050 : }
10051 0 : break;
10052 : }
10053 : default:;
10054 : }
10055 : }
10056 : break;
10057 : }
10058 : default:;
10059 : }
10060 : break;
10061 : }
10062 33041105 : default:;
10063 : }
10064 33041105 : if (integer_zerop (_p1))
10065 : {
10066 20330344 : {
10067 20330344 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10068 20330344 : if (TREE_CODE (TREE_TYPE (captures[0])) == BOOLEAN_TYPE
10069 20330344 : && types_match (type, TREE_TYPE (captures[0]))
10070 : )
10071 : {
10072 3355854 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1545;
10073 3355854 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1545;
10074 3355854 : {
10075 3355854 : tree res_op0;
10076 3355854 : res_op0 = captures[0];
10077 3355854 : tree _r;
10078 3355854 : _r = non_lvalue_loc (loc, res_op0);
10079 3355854 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 971, __FILE__, __LINE__, true);
10080 3355854 : return _r;
10081 : }
10082 : next_after_fail1545:;
10083 : }
10084 : }
10085 : }
10086 29685251 : switch (TREE_CODE (_p0))
10087 : {
10088 1037281 : case BIT_AND_EXPR:
10089 1037281 : {
10090 1037281 : tree _q20 = TREE_OPERAND (_p0, 0);
10091 1037281 : tree _q21 = TREE_OPERAND (_p0, 1);
10092 1037281 : switch (TREE_CODE (_q21))
10093 : {
10094 2034 : case VECTOR_CST:
10095 2034 : {
10096 2034 : if (integer_zerop (_p1))
10097 : {
10098 2034 : {
10099 2034 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
10100 2034 : const enum tree_code cmp = NE_EXPR;
10101 2034 : const enum tree_code icmp = GT_EXPR;
10102 2034 : {
10103 2034 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
10104 2034 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
10105 : )
10106 : {
10107 13 : {
10108 13 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
10109 13 : ? optab_vector : optab_default;
10110 13 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
10111 13 : if (target_supports_op_p (utype, icmp, optab)
10112 13 : || (optimize_vectors_before_lowering_p ()
10113 7 : && (!target_supports_op_p (type, cmp, optab)
10114 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
10115 : )
10116 : {
10117 7 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
10118 : )
10119 : {
10120 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1546;
10121 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1546;
10122 0 : {
10123 0 : tree res_op0;
10124 0 : res_op0 = captures[1];
10125 0 : tree res_op1;
10126 0 : res_op1 = csts;
10127 0 : tree _r;
10128 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10129 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10130 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10131 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 968, __FILE__, __LINE__, true);
10132 0 : return _r;
10133 : }
10134 2027 : next_after_fail1546:;
10135 : }
10136 : else
10137 : {
10138 7 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1547;
10139 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1547;
10140 7 : {
10141 7 : tree res_op0;
10142 7 : {
10143 7 : tree _o1[1], _r1;
10144 7 : _o1[0] = captures[1];
10145 7 : if (TREE_TYPE (_o1[0]) != utype)
10146 : {
10147 7 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, utype, _o1[0]);
10148 : }
10149 : else
10150 : _r1 = _o1[0];
10151 7 : res_op0 = _r1;
10152 : }
10153 7 : tree res_op1;
10154 7 : res_op1 = csts;
10155 7 : tree _r;
10156 7 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10157 7 : if (TREE_SIDE_EFFECTS (captures[2]))
10158 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10159 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 969, __FILE__, __LINE__, true);
10160 7 : return _r;
10161 : }
10162 2027 : next_after_fail1547:;
10163 : }
10164 : }
10165 : }
10166 : }
10167 : }
10168 : }
10169 : }
10170 : break;
10171 : }
10172 843000 : case INTEGER_CST:
10173 843000 : {
10174 843000 : if (integer_zerop (_p1))
10175 : {
10176 805361 : {
10177 805361 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
10178 805361 : const enum tree_code cmp = NE_EXPR;
10179 805361 : const enum tree_code icmp = GT_EXPR;
10180 805361 : {
10181 805361 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
10182 805361 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
10183 : )
10184 : {
10185 1261 : {
10186 1261 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
10187 1261 : ? optab_vector : optab_default;
10188 1261 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
10189 1261 : if (target_supports_op_p (utype, icmp, optab)
10190 1261 : || (optimize_vectors_before_lowering_p ()
10191 1092 : && (!target_supports_op_p (type, cmp, optab)
10192 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
10193 : )
10194 : {
10195 1092 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
10196 : )
10197 : {
10198 989 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1548;
10199 989 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1548;
10200 989 : {
10201 989 : tree res_op0;
10202 989 : res_op0 = captures[1];
10203 989 : tree res_op1;
10204 989 : res_op1 = csts;
10205 989 : tree _r;
10206 989 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10207 989 : if (TREE_SIDE_EFFECTS (captures[2]))
10208 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10209 989 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 968, __FILE__, __LINE__, true);
10210 989 : return _r;
10211 : }
10212 804269 : next_after_fail1548:;
10213 : }
10214 : else
10215 : {
10216 103 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1549;
10217 103 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1549;
10218 103 : {
10219 103 : tree res_op0;
10220 103 : {
10221 103 : tree _o1[1], _r1;
10222 103 : _o1[0] = captures[1];
10223 103 : if (TREE_TYPE (_o1[0]) != utype)
10224 : {
10225 103 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, utype, _o1[0]);
10226 : }
10227 : else
10228 : _r1 = _o1[0];
10229 103 : res_op0 = _r1;
10230 : }
10231 103 : tree res_op1;
10232 103 : res_op1 = csts;
10233 103 : tree _r;
10234 103 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10235 103 : if (TREE_SIDE_EFFECTS (captures[2]))
10236 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10237 103 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 969, __FILE__, __LINE__, true);
10238 103 : return _r;
10239 : }
10240 804269 : next_after_fail1549:;
10241 : }
10242 : }
10243 : }
10244 : }
10245 : }
10246 : }
10247 : }
10248 : break;
10249 : }
10250 1036182 : default:;
10251 : }
10252 1036182 : switch (TREE_CODE (_q20))
10253 : {
10254 0 : case VECTOR_CST:
10255 0 : {
10256 0 : if (integer_zerop (_p1))
10257 : {
10258 0 : {
10259 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
10260 0 : const enum tree_code cmp = NE_EXPR;
10261 0 : const enum tree_code icmp = GT_EXPR;
10262 0 : {
10263 0 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
10264 0 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
10265 : )
10266 : {
10267 0 : {
10268 0 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
10269 0 : ? optab_vector : optab_default;
10270 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
10271 0 : if (target_supports_op_p (utype, icmp, optab)
10272 0 : || (optimize_vectors_before_lowering_p ()
10273 0 : && (!target_supports_op_p (type, cmp, optab)
10274 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
10275 : )
10276 : {
10277 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
10278 : )
10279 : {
10280 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1550;
10281 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1550;
10282 0 : {
10283 0 : tree res_op0;
10284 0 : res_op0 = captures[1];
10285 0 : tree res_op1;
10286 0 : res_op1 = csts;
10287 0 : tree _r;
10288 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10289 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10290 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10291 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 968, __FILE__, __LINE__, true);
10292 0 : return _r;
10293 : }
10294 0 : next_after_fail1550:;
10295 : }
10296 : else
10297 : {
10298 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1551;
10299 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1551;
10300 0 : {
10301 0 : tree res_op0;
10302 0 : {
10303 0 : tree _o1[1], _r1;
10304 0 : _o1[0] = captures[1];
10305 0 : if (TREE_TYPE (_o1[0]) != utype)
10306 : {
10307 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, utype, _o1[0]);
10308 : }
10309 : else
10310 : _r1 = _o1[0];
10311 0 : res_op0 = _r1;
10312 : }
10313 0 : tree res_op1;
10314 0 : res_op1 = csts;
10315 0 : tree _r;
10316 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10317 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10318 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10319 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 969, __FILE__, __LINE__, true);
10320 0 : return _r;
10321 : }
10322 0 : next_after_fail1551:;
10323 : }
10324 : }
10325 : }
10326 : }
10327 : }
10328 : }
10329 : }
10330 : break;
10331 : }
10332 0 : case INTEGER_CST:
10333 0 : {
10334 0 : if (integer_zerop (_p1))
10335 : {
10336 0 : {
10337 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
10338 0 : const enum tree_code cmp = NE_EXPR;
10339 0 : const enum tree_code icmp = GT_EXPR;
10340 0 : {
10341 0 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
10342 0 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
10343 : )
10344 : {
10345 0 : {
10346 0 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
10347 0 : ? optab_vector : optab_default;
10348 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
10349 0 : if (target_supports_op_p (utype, icmp, optab)
10350 0 : || (optimize_vectors_before_lowering_p ()
10351 0 : && (!target_supports_op_p (type, cmp, optab)
10352 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
10353 : )
10354 : {
10355 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
10356 : )
10357 : {
10358 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1552;
10359 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1552;
10360 0 : {
10361 0 : tree res_op0;
10362 0 : res_op0 = captures[1];
10363 0 : tree res_op1;
10364 0 : res_op1 = csts;
10365 0 : tree _r;
10366 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10367 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10368 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10369 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 968, __FILE__, __LINE__, true);
10370 0 : return _r;
10371 : }
10372 0 : next_after_fail1552:;
10373 : }
10374 : else
10375 : {
10376 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1553;
10377 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1553;
10378 0 : {
10379 0 : tree res_op0;
10380 0 : {
10381 0 : tree _o1[1], _r1;
10382 0 : _o1[0] = captures[1];
10383 0 : if (TREE_TYPE (_o1[0]) != utype)
10384 : {
10385 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, utype, _o1[0]);
10386 : }
10387 : else
10388 : _r1 = _o1[0];
10389 0 : res_op0 = _r1;
10390 : }
10391 0 : tree res_op1;
10392 0 : res_op1 = csts;
10393 0 : tree _r;
10394 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10395 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10396 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10397 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 969, __FILE__, __LINE__, true);
10398 0 : return _r;
10399 : }
10400 0 : next_after_fail1553:;
10401 : }
10402 : }
10403 : }
10404 : }
10405 : }
10406 : }
10407 : }
10408 : break;
10409 : }
10410 : default:;
10411 : }
10412 : break;
10413 : }
10414 20774 : case RSHIFT_EXPR:
10415 20774 : {
10416 20774 : tree _q20 = TREE_OPERAND (_p0, 0);
10417 20774 : tree _q21 = TREE_OPERAND (_p0, 1);
10418 20774 : switch (TREE_CODE (_q20))
10419 : {
10420 1 : case MULT_EXPR:
10421 1 : {
10422 1 : tree _q30 = TREE_OPERAND (_q20, 0);
10423 1 : tree _q31 = TREE_OPERAND (_q20, 1);
10424 1 : switch (TREE_CODE (_q30))
10425 : {
10426 1 : CASE_CONVERT:
10427 1 : {
10428 1 : tree _q40 = TREE_OPERAND (_q30, 0);
10429 1 : switch (TREE_CODE (_q31))
10430 : {
10431 1 : CASE_CONVERT:
10432 1 : {
10433 1 : tree _q60 = TREE_OPERAND (_q31, 0);
10434 1 : switch (TREE_CODE (_q21))
10435 : {
10436 1 : case INTEGER_CST:
10437 1 : {
10438 1 : if (integer_zerop (_p1))
10439 : {
10440 1 : {
10441 1 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q30, _q40, _q60, _q21 };
10442 1 : tree res = generic_simplify_288 (loc, type, _p0, _p1, captures, NE_EXPR);
10443 1 : if (res) return res;
10444 : }
10445 : }
10446 : break;
10447 : }
10448 : default:;
10449 : }
10450 : break;
10451 : }
10452 : default:;
10453 : }
10454 : break;
10455 : }
10456 : default:;
10457 : }
10458 : break;
10459 : }
10460 : default:;
10461 : }
10462 : break;
10463 : }
10464 1325633 : case PLUS_EXPR:
10465 1325633 : {
10466 1325633 : tree _q20 = TREE_OPERAND (_p0, 0);
10467 1325633 : tree _q21 = TREE_OPERAND (_p0, 1);
10468 1325633 : switch (TREE_CODE (_q21))
10469 : {
10470 1216512 : case INTEGER_CST:
10471 1216512 : {
10472 1216512 : switch (TREE_CODE (_p1))
10473 : {
10474 720059 : case INTEGER_CST:
10475 720059 : {
10476 720059 : {
10477 720059 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
10478 720059 : tree res = generic_simplify_289 (loc, type, _p0, _p1, captures, PLUS_EXPR, MINUS_EXPR, NE_EXPR);
10479 720059 : if (res) return res;
10480 : }
10481 356 : break;
10482 : }
10483 : default:;
10484 : }
10485 : break;
10486 : }
10487 : default:;
10488 : }
10489 : break;
10490 : }
10491 69283 : case MINUS_EXPR:
10492 69283 : {
10493 69283 : tree _q20 = TREE_OPERAND (_p0, 0);
10494 69283 : tree _q21 = TREE_OPERAND (_p0, 1);
10495 69283 : switch (TREE_CODE (_q21))
10496 : {
10497 193 : case INTEGER_CST:
10498 193 : {
10499 193 : switch (TREE_CODE (_p1))
10500 : {
10501 72 : case INTEGER_CST:
10502 72 : {
10503 72 : {
10504 72 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
10505 72 : tree res = generic_simplify_289 (loc, type, _p0, _p1, captures, MINUS_EXPR, PLUS_EXPR, NE_EXPR);
10506 72 : if (res) return res;
10507 : }
10508 72 : break;
10509 : }
10510 : default:;
10511 : }
10512 : break;
10513 : }
10514 69283 : default:;
10515 : }
10516 69283 : switch (TREE_CODE (_q20))
10517 : {
10518 1719 : case INTEGER_CST:
10519 1719 : {
10520 1719 : switch (TREE_CODE (_p1))
10521 : {
10522 73 : case INTEGER_CST:
10523 73 : {
10524 73 : {
10525 73 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
10526 73 : tree res = generic_simplify_290 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
10527 73 : if (res) return res;
10528 : }
10529 0 : break;
10530 : }
10531 : default:;
10532 : }
10533 : break;
10534 : }
10535 : default:;
10536 : }
10537 : break;
10538 : }
10539 2739736 : case CALL_EXPR:
10540 2739736 : switch (get_call_combined_fn (_p0))
10541 : {
10542 224 : case CFN_BUILT_IN_CLZ:
10543 224 : if (call_expr_nargs (_p0) == 1)
10544 : {
10545 224 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10546 224 : switch (TREE_CODE (_p1))
10547 : {
10548 210 : case INTEGER_CST:
10549 210 : {
10550 210 : {
10551 210 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10552 210 : tree res = generic_simplify_291 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZ);
10553 210 : if (res) return res;
10554 : }
10555 135 : break;
10556 : }
10557 : default:;
10558 : }
10559 : }
10560 : break;
10561 246 : case CFN_BUILT_IN_CTZ:
10562 246 : if (call_expr_nargs (_p0) == 1)
10563 : {
10564 246 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10565 246 : switch (TREE_CODE (_p1))
10566 : {
10567 200 : case INTEGER_CST:
10568 200 : {
10569 200 : {
10570 200 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10571 200 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_CTZ);
10572 200 : if (res) return res;
10573 : }
10574 0 : break;
10575 : }
10576 : default:;
10577 : }
10578 : }
10579 : break;
10580 31 : case CFN_BUILT_IN_FFS:
10581 31 : if (call_expr_nargs (_p0) == 1)
10582 : {
10583 31 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10584 31 : switch (TREE_CODE (_p1))
10585 : {
10586 11 : case INTEGER_CST:
10587 11 : {
10588 11 : {
10589 11 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10590 11 : tree res = generic_simplify_296 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_FFS);
10591 11 : if (res) return res;
10592 : }
10593 0 : break;
10594 : }
10595 : default:;
10596 : }
10597 : }
10598 : break;
10599 0 : case CFN_REDUC_IOR:
10600 0 : if (call_expr_nargs (_p0) == 1)
10601 : {
10602 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10603 0 : if (integer_zerop (_p1))
10604 : {
10605 0 : {
10606 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10607 0 : tree res = generic_simplify_297 (loc, type, _p0, _p1, captures, NE_EXPR);
10608 0 : if (res) return res;
10609 : }
10610 : }
10611 : }
10612 : break;
10613 0 : case CFN_BUILT_IN_FFSIMAX:
10614 0 : if (call_expr_nargs (_p0) == 1)
10615 : {
10616 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10617 0 : switch (TREE_CODE (_p1))
10618 : {
10619 0 : case INTEGER_CST:
10620 0 : {
10621 0 : {
10622 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10623 0 : tree res = generic_simplify_296 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_FFSIMAX);
10624 0 : if (res) return res;
10625 : }
10626 0 : break;
10627 : }
10628 : default:;
10629 : }
10630 : }
10631 : break;
10632 13 : case CFN_BUILT_IN_POPCOUNT:
10633 13 : if (call_expr_nargs (_p0) == 1)
10634 : {
10635 13 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10636 13 : if (integer_zerop (_p1))
10637 : {
10638 1 : {
10639 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10640 1 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNT);
10641 1 : if (res) return res;
10642 : }
10643 : }
10644 : }
10645 : break;
10646 87 : case CFN_BUILT_IN_CLZL:
10647 87 : if (call_expr_nargs (_p0) == 1)
10648 : {
10649 87 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10650 87 : switch (TREE_CODE (_p1))
10651 : {
10652 79 : case INTEGER_CST:
10653 79 : {
10654 79 : {
10655 79 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10656 79 : tree res = generic_simplify_291 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZL);
10657 79 : if (res) return res;
10658 : }
10659 43 : break;
10660 : }
10661 : default:;
10662 : }
10663 : }
10664 : break;
10665 85 : case CFN_BUILT_IN_CTZL:
10666 85 : if (call_expr_nargs (_p0) == 1)
10667 : {
10668 85 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10669 85 : switch (TREE_CODE (_p1))
10670 : {
10671 77 : case INTEGER_CST:
10672 77 : {
10673 77 : {
10674 77 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10675 77 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_CTZL);
10676 77 : if (res) return res;
10677 : }
10678 16 : break;
10679 : }
10680 : default:;
10681 : }
10682 : }
10683 : break;
10684 8 : case CFN_BUILT_IN_FFSL:
10685 8 : if (call_expr_nargs (_p0) == 1)
10686 : {
10687 8 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10688 8 : switch (TREE_CODE (_p1))
10689 : {
10690 0 : case INTEGER_CST:
10691 0 : {
10692 0 : {
10693 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10694 0 : tree res = generic_simplify_296 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_FFSL);
10695 0 : if (res) return res;
10696 : }
10697 0 : break;
10698 : }
10699 : default:;
10700 : }
10701 : }
10702 : break;
10703 11 : case CFN_BUILT_IN_POPCOUNTLL:
10704 11 : if (call_expr_nargs (_p0) == 1)
10705 : {
10706 11 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10707 11 : if (integer_zerop (_p1))
10708 : {
10709 1 : {
10710 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10711 1 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNTLL);
10712 1 : if (res) return res;
10713 : }
10714 : }
10715 : }
10716 : break;
10717 0 : case CFN_BUILT_IN_CTZIMAX:
10718 0 : if (call_expr_nargs (_p0) == 1)
10719 : {
10720 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10721 0 : switch (TREE_CODE (_p1))
10722 : {
10723 0 : case INTEGER_CST:
10724 0 : {
10725 0 : {
10726 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10727 0 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_CTZIMAX);
10728 0 : if (res) return res;
10729 : }
10730 0 : break;
10731 : }
10732 : default:;
10733 : }
10734 : }
10735 : break;
10736 0 : case CFN_POPCOUNT:
10737 0 : if (call_expr_nargs (_p0) == 1)
10738 : {
10739 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10740 0 : if (integer_zerop (_p1))
10741 : {
10742 0 : {
10743 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10744 0 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_POPCOUNT);
10745 0 : if (res) return res;
10746 : }
10747 : }
10748 : }
10749 : break;
10750 0 : case CFN_CLZ:
10751 0 : if (call_expr_nargs (_p0) == 1)
10752 : {
10753 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10754 0 : switch (TREE_CODE (_p1))
10755 : {
10756 0 : case INTEGER_CST:
10757 0 : {
10758 0 : {
10759 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10760 0 : tree res = generic_simplify_291 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_CLZ);
10761 0 : if (res) return res;
10762 : }
10763 0 : break;
10764 : }
10765 : default:;
10766 : }
10767 : }
10768 0 : if (call_expr_nargs (_p0) == 2)
10769 : {
10770 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10771 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
10772 0 : switch (TREE_CODE (_p1))
10773 : {
10774 0 : case INTEGER_CST:
10775 0 : {
10776 0 : {
10777 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
10778 0 : tree res = generic_simplify_292 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR);
10779 0 : if (res) return res;
10780 : }
10781 0 : break;
10782 : }
10783 : default:;
10784 : }
10785 : }
10786 : break;
10787 0 : case CFN_CTZ:
10788 0 : if (call_expr_nargs (_p0) == 1)
10789 : {
10790 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10791 0 : switch (TREE_CODE (_p1))
10792 : {
10793 0 : case INTEGER_CST:
10794 0 : {
10795 0 : {
10796 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10797 0 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_CTZ);
10798 0 : if (res) return res;
10799 : }
10800 0 : break;
10801 : }
10802 : default:;
10803 : }
10804 : }
10805 0 : if (call_expr_nargs (_p0) == 2)
10806 : {
10807 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10808 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
10809 0 : switch (TREE_CODE (_p1))
10810 : {
10811 0 : case INTEGER_CST:
10812 0 : {
10813 0 : {
10814 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
10815 0 : tree res = generic_simplify_294 (loc, type, _p0, _p1, captures, NE_EXPR);
10816 0 : if (res) return res;
10817 : }
10818 0 : break;
10819 : }
10820 : default:;
10821 : }
10822 : }
10823 : break;
10824 0 : case CFN_FFS:
10825 0 : if (call_expr_nargs (_p0) == 1)
10826 : {
10827 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10828 0 : switch (TREE_CODE (_p1))
10829 : {
10830 0 : case INTEGER_CST:
10831 0 : {
10832 0 : {
10833 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10834 0 : tree res = generic_simplify_296 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_FFS);
10835 0 : if (res) return res;
10836 : }
10837 0 : break;
10838 : }
10839 : default:;
10840 : }
10841 : }
10842 : break;
10843 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
10844 0 : if (call_expr_nargs (_p0) == 1)
10845 : {
10846 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10847 0 : if (integer_zerop (_p1))
10848 : {
10849 0 : {
10850 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10851 0 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
10852 0 : if (res) return res;
10853 : }
10854 : }
10855 : }
10856 : break;
10857 0 : case CFN_BUILT_IN_CLZIMAX:
10858 0 : if (call_expr_nargs (_p0) == 1)
10859 : {
10860 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10861 0 : switch (TREE_CODE (_p1))
10862 : {
10863 0 : case INTEGER_CST:
10864 0 : {
10865 0 : {
10866 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10867 0 : tree res = generic_simplify_291 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZIMAX);
10868 0 : if (res) return res;
10869 : }
10870 0 : break;
10871 : }
10872 : default:;
10873 : }
10874 : }
10875 : break;
10876 12 : case CFN_BUILT_IN_POPCOUNTL:
10877 12 : if (call_expr_nargs (_p0) == 1)
10878 : {
10879 12 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10880 12 : if (integer_zerop (_p1))
10881 : {
10882 1 : {
10883 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10884 1 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNTL);
10885 1 : if (res) return res;
10886 : }
10887 : }
10888 : }
10889 : break;
10890 52 : case CFN_BUILT_IN_CLZLL:
10891 52 : if (call_expr_nargs (_p0) == 1)
10892 : {
10893 52 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10894 52 : switch (TREE_CODE (_p1))
10895 : {
10896 42 : case INTEGER_CST:
10897 42 : {
10898 42 : {
10899 42 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10900 42 : tree res = generic_simplify_291 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZLL);
10901 42 : if (res) return res;
10902 : }
10903 18 : break;
10904 : }
10905 : default:;
10906 : }
10907 : }
10908 : break;
10909 74 : case CFN_BUILT_IN_CTZLL:
10910 74 : if (call_expr_nargs (_p0) == 1)
10911 : {
10912 74 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10913 74 : switch (TREE_CODE (_p1))
10914 : {
10915 64 : case INTEGER_CST:
10916 64 : {
10917 64 : {
10918 64 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10919 64 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_CTZLL);
10920 64 : if (res) return res;
10921 : }
10922 16 : break;
10923 : }
10924 : default:;
10925 : }
10926 : }
10927 : break;
10928 11 : case CFN_BUILT_IN_FFSLL:
10929 11 : if (call_expr_nargs (_p0) == 1)
10930 : {
10931 11 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10932 11 : switch (TREE_CODE (_p1))
10933 : {
10934 1 : case INTEGER_CST:
10935 1 : {
10936 1 : {
10937 1 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10938 1 : tree res = generic_simplify_296 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_FFSLL);
10939 1 : if (res) return res;
10940 : }
10941 0 : break;
10942 : }
10943 : default:;
10944 : }
10945 : }
10946 : break;
10947 : default:;
10948 : }
10949 : break;
10950 : default:;
10951 : }
10952 : return NULL_TREE;
10953 : }
10954 :
10955 : tree
10956 649727 : generic_simplify_BIT_FIELD_REF (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1, tree _p2)
10957 : {
10958 649727 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10959 649727 : switch (TREE_CODE (_p0))
10960 : {
10961 0 : case BIT_FIELD_REF:
10962 0 : {
10963 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10964 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10965 0 : tree _q22 = TREE_OPERAND (_p0, 2);
10966 0 : {
10967 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _p1, _p2 };
10968 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1928;
10969 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1928;
10970 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1928;
10971 0 : {
10972 0 : tree res_op0;
10973 0 : res_op0 = captures[0];
10974 0 : tree res_op1;
10975 0 : res_op1 = captures[3];
10976 0 : tree res_op2;
10977 0 : res_op2 = const_binop (PLUS_EXPR, bitsizetype, captures[2], captures[4]);
10978 0 : tree _r;
10979 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
10980 0 : if (TREE_SIDE_EFFECTS (captures[1]))
10981 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
10982 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1060, __FILE__, __LINE__, true);
10983 0 : return _r;
10984 : }
10985 0 : next_after_fail1928:;
10986 : }
10987 0 : break;
10988 : }
10989 3 : case VIEW_CONVERT_EXPR:
10990 3 : {
10991 3 : tree _q20 = TREE_OPERAND (_p0, 0);
10992 3 : {
10993 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p1, _p2 };
10994 6 : if (! INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
10995 6 : || type_has_mode_precision_p (TREE_TYPE (captures[0]))
10996 : )
10997 : {
10998 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1929;
10999 0 : {
11000 0 : tree res_op0;
11001 0 : res_op0 = captures[0];
11002 0 : tree res_op1;
11003 0 : res_op1 = captures[1];
11004 0 : tree res_op2;
11005 0 : res_op2 = captures[2];
11006 0 : tree _r;
11007 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11008 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1061, __FILE__, __LINE__, true);
11009 0 : return _r;
11010 : }
11011 0 : next_after_fail1929:;
11012 : }
11013 : }
11014 3 : break;
11015 : }
11016 649727 : default:;
11017 : }
11018 649727 : if (integer_zerop (_p2))
11019 : {
11020 208272 : {
11021 208272 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
11022 208272 : if (tree_int_cst_equal (captures[1], TYPE_SIZE (TREE_TYPE (captures[0])))
11023 : )
11024 : {
11025 2533 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail1930;
11026 2533 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1930;
11027 2533 : {
11028 2533 : tree res_op0;
11029 2533 : res_op0 = captures[0];
11030 2533 : tree _r;
11031 2533 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11032 2533 : if (TREE_SIDE_EFFECTS (captures[1]))
11033 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11034 2533 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1062, __FILE__, __LINE__, true);
11035 2533 : return _r;
11036 : }
11037 205739 : next_after_fail1930:;
11038 : }
11039 : }
11040 : }
11041 647194 : {
11042 647194 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _p2 };
11043 647194 : if (TREE_CODE (TREE_TYPE (captures[0])) == COMPLEX_TYPE
11044 647194 : && tree_int_cst_equal (captures[1], TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0]))))
11045 : )
11046 : {
11047 2 : if (integer_zerop (captures[2])
11048 : )
11049 : {
11050 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1931;
11051 0 : {
11052 0 : tree res_op0;
11053 0 : {
11054 0 : tree _o1[1], _r1;
11055 0 : _o1[0] = captures[0];
11056 0 : _r1 = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
11057 0 : res_op0 = _r1;
11058 : }
11059 0 : tree _r;
11060 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11061 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11062 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11063 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11064 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11065 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1063, __FILE__, __LINE__, true);
11066 0 : return _r;
11067 : }
11068 0 : next_after_fail1931:;
11069 : }
11070 : else
11071 : {
11072 2 : if (tree_int_cst_equal (captures[2], TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0]))))
11073 : )
11074 : {
11075 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1932;
11076 0 : {
11077 0 : tree res_op0;
11078 0 : {
11079 0 : tree _o1[1], _r1;
11080 0 : _o1[0] = captures[0];
11081 0 : _r1 = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
11082 0 : res_op0 = _r1;
11083 : }
11084 0 : tree _r;
11085 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11086 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11087 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11088 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11089 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11090 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1064, __FILE__, __LINE__, true);
11091 0 : return _r;
11092 : }
11093 0 : next_after_fail1932:;
11094 : }
11095 : }
11096 : }
11097 : else
11098 : {
11099 1294322 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
11100 20390 : && INTEGRAL_TYPE_P (type)
11101 : && (!
11102 :
11103 : || is_gimple_reg (captures[0]))
11104 666604 : && ((compare_tree_int (captures[1], TYPE_PRECISION (TREE_TYPE (captures[0]))) == 0
11105 0 : && integer_zerop (captures[2]))
11106 : || (BYTES_BIG_ENDIAN == WORDS_BIG_ENDIAN
11107 : && canonicalize_math_after_vectorization_p ()
11108 : && TYPE_PRECISION (TREE_TYPE (captures[0])) % BITS_PER_UNIT == 0
11109 : && TYPE_PRECISION (type) % BITS_PER_UNIT == 0
11110 : && compare_tree_int (captures[2], (BYTES_BIG_ENDIAN
11111 : ? (TYPE_PRECISION (TREE_TYPE (captures[0]))
11112 : - TYPE_PRECISION (type))
11113 : : 0)) == 0))
11114 : )
11115 : {
11116 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1933;
11117 0 : {
11118 0 : tree res_op0;
11119 0 : res_op0 = captures[0];
11120 0 : tree _r;
11121 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
11122 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11123 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11124 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11125 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11126 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1065, __FILE__, __LINE__, true);
11127 0 : return _r;
11128 : }
11129 0 : next_after_fail1933:;
11130 : }
11131 : }
11132 : }
11133 647194 : switch (TREE_CODE (_p0))
11134 : {
11135 1031 : case CONSTRUCTOR:
11136 1031 : {
11137 1031 : {
11138 1031 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _p2 };
11139 1031 : if (VECTOR_TYPE_P (TREE_TYPE (captures[0]))
11140 1031 : && tree_fits_uhwi_p (TYPE_SIZE (type))
11141 2062 : && ((tree_to_uhwi (TYPE_SIZE (type))
11142 1031 : == tree_to_uhwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0])))))
11143 0 : || (VECTOR_TYPE_P (type)
11144 0 : && (tree_to_uhwi (TYPE_SIZE (TREE_TYPE (type)))
11145 0 : == tree_to_uhwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0])))))))
11146 : )
11147 : {
11148 1031 : {
11149 1031 : tree ctor = (TREE_CODE (captures[0]) == SSA_NAME
11150 : ? gimple_assign_rhs1 (SSA_NAME_DEF_STMT (captures[0])) : captures[0]);
11151 1031 : tree eltype = TREE_TYPE (TREE_TYPE (ctor));
11152 1031 : unsigned HOST_WIDE_INT width = tree_to_uhwi (TYPE_SIZE (eltype));
11153 1031 : unsigned HOST_WIDE_INT n = tree_to_uhwi (captures[1]);
11154 1031 : unsigned HOST_WIDE_INT idx = tree_to_uhwi (captures[2]);
11155 1031 : if (n != 0
11156 1031 : && (idx % width) == 0
11157 1031 : && (n % width) == 0
11158 2062 : && known_le ((idx + n) / width,
11159 : TYPE_VECTOR_SUBPARTS (TREE_TYPE (ctor)))
11160 : )
11161 : {
11162 1031 : {
11163 1031 : idx = idx / width;
11164 1031 : n = n / width;
11165 1031 : poly_uint64 k = 1;
11166 1031 : if (CONSTRUCTOR_NELTS (ctor) != 0)
11167 : {
11168 1031 : tree cons_elem = TREE_TYPE (CONSTRUCTOR_ELT (ctor, 0)->value);
11169 1031 : if (TREE_CODE (cons_elem) == VECTOR_TYPE)
11170 1031 : k = TYPE_VECTOR_SUBPARTS (cons_elem);
11171 : }
11172 1031 : unsigned HOST_WIDE_INT elt, count, const_k;
11173 1031 : if (multiple_p (idx, k, &elt) && multiple_p (n, k, &count)
11174 : )
11175 : {
11176 6 : if (CONSTRUCTOR_NELTS (ctor) == 0
11177 : )
11178 : {
11179 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1934;
11180 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1934;
11181 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1934;
11182 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1934;
11183 0 : {
11184 0 : tree _r;
11185 0 : _r = build_zero_cst (type);
11186 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1066, __FILE__, __LINE__, true);
11187 1031 : return _r;
11188 : }
11189 : next_after_fail1934:;
11190 : }
11191 : else
11192 : {
11193 6 : if (count == 1
11194 : )
11195 : {
11196 6 : if (elt < CONSTRUCTOR_NELTS (ctor)
11197 : )
11198 : {
11199 6 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1935;
11200 6 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1935;
11201 6 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1935;
11202 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1935;
11203 6 : {
11204 6 : tree res_op0;
11205 6 : res_op0 = CONSTRUCTOR_ELT (ctor, elt)->value;
11206 6 : tree _r;
11207 6 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11208 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1067, __FILE__, __LINE__, true);
11209 6 : return _r;
11210 : }
11211 : next_after_fail1935:;
11212 : }
11213 : else
11214 : {
11215 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1936;
11216 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1936;
11217 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1936;
11218 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1936;
11219 0 : {
11220 0 : tree _r;
11221 0 : _r = build_zero_cst (type);
11222 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1068, __FILE__, __LINE__, true);
11223 0 : return _r;
11224 : }
11225 : next_after_fail1936:;
11226 : }
11227 : }
11228 : else
11229 : {
11230 0 : if (single_use (captures[0])
11231 : )
11232 : {
11233 0 : {
11234 0 : vec<constructor_elt, va_gc> *vals;
11235 0 : vec_alloc (vals, count);
11236 0 : bool constant_p = true;
11237 0 : tree res;
11238 0 : for (unsigned i = 0;
11239 0 : i < count && elt + i < CONSTRUCTOR_NELTS (ctor); ++i)
11240 : {
11241 0 : tree e = CONSTRUCTOR_ELT (ctor, elt + i)->value;
11242 0 : CONSTRUCTOR_APPEND_ELT (vals, NULL_TREE, e);
11243 0 : if (!CONSTANT_CLASS_P (e))
11244 0 : constant_p = false;
11245 : }
11246 0 : tree evtype = (types_match (TREE_TYPE (type),
11247 0 : TREE_TYPE (TREE_TYPE (ctor)))
11248 0 : ? type
11249 0 : : build_vector_type (TREE_TYPE (TREE_TYPE (ctor)),
11250 0 : count * k));
11251 0 : res = (constant_p ? build_vector_from_ctor (evtype, vals)
11252 : : (
11253 :
11254 0 : ? NULL_TREE : build_constructor (evtype, vals)));
11255 0 : if (res
11256 : )
11257 : {
11258 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1937;
11259 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1937;
11260 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1937;
11261 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1937;
11262 0 : {
11263 0 : tree res_op0;
11264 0 : res_op0 = res;
11265 0 : tree _r;
11266 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11267 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1069, __FILE__, __LINE__, true);
11268 0 : return _r;
11269 : }
11270 0 : next_after_fail1937:;
11271 : }
11272 : }
11273 : }
11274 : }
11275 : }
11276 : }
11277 : else
11278 : {
11279 1025 : if (k.is_constant (&const_k)
11280 1025 : && idx + n <= (idx / const_k + 1) * const_k
11281 : )
11282 : {
11283 1025 : if (CONSTRUCTOR_NELTS (ctor) <= idx / const_k
11284 : )
11285 : {
11286 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1938;
11287 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1938;
11288 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1938;
11289 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1938;
11290 0 : {
11291 0 : tree _r;
11292 0 : _r = build_zero_cst (type);
11293 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1070, __FILE__, __LINE__, true);
11294 0 : return _r;
11295 : }
11296 : next_after_fail1938:;
11297 : }
11298 : else
11299 : {
11300 1025 : if (n == const_k
11301 : )
11302 : {
11303 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1939;
11304 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1939;
11305 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1939;
11306 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1939;
11307 0 : {
11308 0 : tree res_op0;
11309 0 : res_op0 = CONSTRUCTOR_ELT (ctor, idx / const_k)->value;
11310 0 : tree _r;
11311 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11312 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1071, __FILE__, __LINE__, true);
11313 0 : return _r;
11314 : }
11315 : next_after_fail1939:;
11316 : }
11317 : else
11318 : {
11319 1025 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1940;
11320 1025 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1940;
11321 1025 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1940;
11322 1025 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1940;
11323 1025 : {
11324 1025 : tree res_op0;
11325 1025 : res_op0 = CONSTRUCTOR_ELT (ctor, idx / const_k)->value;
11326 1025 : tree res_op1;
11327 1025 : res_op1 = captures[1];
11328 1025 : tree res_op2;
11329 1025 : res_op2 = bitsize_int ((idx % const_k) * width);
11330 1025 : tree _r;
11331 1025 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11332 1025 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1072, __FILE__, __LINE__, true);
11333 1025 : return _r;
11334 : }
11335 : next_after_fail1940:;
11336 : }
11337 : }
11338 : }
11339 : }
11340 : }
11341 : }
11342 : }
11343 : }
11344 : }
11345 0 : break;
11346 : }
11347 0 : case VEC_PERM_EXPR:
11348 0 : {
11349 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11350 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11351 0 : tree _q22 = TREE_OPERAND (_p0, 2);
11352 0 : switch (TREE_CODE (_q22))
11353 : {
11354 0 : case VECTOR_CST:
11355 0 : {
11356 0 : {
11357 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _p2 };
11358 0 : {
11359 0 : tree elem_type = TREE_TYPE (TREE_TYPE (captures[0]));
11360 0 : poly_uint64 elem_size = tree_to_poly_uint64 (TYPE_SIZE (elem_type));
11361 0 : poly_uint64 size = tree_to_poly_uint64 (TYPE_SIZE (type));
11362 0 : unsigned HOST_WIDE_INT nelts, idx;
11363 0 : unsigned HOST_WIDE_INT nelts_op = 0;
11364 0 : if (constant_multiple_p (tree_to_poly_uint64 (captures[5]), elem_size, &idx)
11365 0 : && VECTOR_CST_NELTS (captures[3]).is_constant (&nelts)
11366 0 : && (known_eq (size, elem_size)
11367 0 : || (constant_multiple_p (size, elem_size, &nelts_op)
11368 0 : && pow2p_hwi (nelts_op)))
11369 : )
11370 : {
11371 0 : {
11372 0 : bool ok = true;
11373 0 : if (known_eq (size, elem_size))
11374 0 : idx = TREE_INT_CST_LOW (VECTOR_CST_ELT (captures[3], idx)) % (2 * nelts);
11375 : else
11376 : {
11377 0 : unsigned start
11378 0 : = TREE_INT_CST_LOW (vector_cst_elt (captures[3], idx)) % (2 * nelts);
11379 0 : unsigned end
11380 0 : = (TREE_INT_CST_LOW (vector_cst_elt (captures[3], idx + nelts_op - 1))
11381 0 : % (2 * nelts));
11382 0 : if ((start < nelts) != (end < nelts))
11383 : ok = false;
11384 : else
11385 0 : for (unsigned HOST_WIDE_INT i = 1; i != nelts_op; i++)
11386 : {
11387 0 : if ((TREE_INT_CST_LOW (vector_cst_elt (captures[3], idx + i))
11388 0 : % (2 * nelts) - 1)
11389 0 : != (TREE_INT_CST_LOW (vector_cst_elt (captures[3], idx + i - 1))
11390 0 : % (2 * nelts)))
11391 : {
11392 : ok = false;
11393 : break;
11394 : }
11395 : }
11396 0 : if (start % nelts_op)
11397 : ok = false;
11398 0 : idx = start;
11399 : }
11400 0 : if (ok
11401 : )
11402 : {
11403 0 : if (idx < nelts
11404 : )
11405 : {
11406 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1941;
11407 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1941;
11408 0 : {
11409 0 : tree res_op0;
11410 0 : res_op0 = captures[1];
11411 0 : tree res_op1;
11412 0 : res_op1 = captures[4];
11413 0 : tree res_op2;
11414 0 : res_op2 = bitsize_int (idx * elem_size);
11415 0 : tree _r;
11416 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11417 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11418 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11419 0 : if (TREE_SIDE_EFFECTS (captures[5]))
11420 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
11421 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1073, __FILE__, __LINE__, true);
11422 0 : return _r;
11423 : }
11424 0 : next_after_fail1941:;
11425 : }
11426 : else
11427 : {
11428 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1942;
11429 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1942;
11430 0 : {
11431 0 : tree res_op0;
11432 0 : res_op0 = captures[2];
11433 0 : tree res_op1;
11434 0 : res_op1 = captures[4];
11435 0 : tree res_op2;
11436 0 : res_op2 = bitsize_int ((idx - nelts) * elem_size);
11437 0 : tree _r;
11438 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11439 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11440 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11441 0 : if (TREE_SIDE_EFFECTS (captures[5]))
11442 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
11443 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1074, __FILE__, __LINE__, true);
11444 0 : return _r;
11445 : }
11446 0 : next_after_fail1942:;
11447 : }
11448 : }
11449 : }
11450 : }
11451 : }
11452 : }
11453 0 : break;
11454 : }
11455 : default:;
11456 : }
11457 : break;
11458 : }
11459 0 : case BIT_INSERT_EXPR:
11460 0 : {
11461 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11462 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11463 0 : tree _q22 = TREE_OPERAND (_p0, 2);
11464 0 : {
11465 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _p1, _p2 };
11466 0 : {
11467 0 : unsigned HOST_WIDE_INT isize;
11468 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1])))
11469 0 : isize = TYPE_PRECISION (TREE_TYPE (captures[1]));
11470 : else
11471 0 : isize = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (captures[1])));
11472 0 : if ((!INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
11473 0 : || type_has_mode_precision_p (TREE_TYPE (captures[1])))
11474 0 : && wi::leu_p (wi::to_wide (captures[2]), wi::to_wide (captures[4]))
11475 0 : && wi::leu_p (wi::to_wide (captures[4]) + wi::to_wide (captures[3]),
11476 0 : wi::to_wide (captures[2]) + isize)
11477 : )
11478 : {
11479 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1943;
11480 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1943;
11481 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1943;
11482 0 : {
11483 0 : tree res_op0;
11484 0 : res_op0 = captures[1];
11485 0 : tree res_op1;
11486 0 : res_op1 = captures[3];
11487 0 : tree res_op2;
11488 0 : res_op2 = wide_int_to_tree (bitsizetype,
11489 0 : wi::to_wide (captures[4])
11490 0 : - wi::to_wide (captures[2]));
11491 0 : tree _r;
11492 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11493 0 : if (TREE_SIDE_EFFECTS (captures[0]))
11494 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
11495 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1075, __FILE__, __LINE__, true);
11496 0 : return _r;
11497 : }
11498 0 : next_after_fail1943:;
11499 : }
11500 : else
11501 : {
11502 0 : if (wi::eq_p (wi::to_wide (captures[2]), wi::to_wide (captures[4]))
11503 0 : && compare_tree_int (captures[3], isize) == 0
11504 : )
11505 : {
11506 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1944;
11507 0 : {
11508 0 : tree res_op0;
11509 0 : res_op0 = captures[1];
11510 0 : tree _r;
11511 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
11512 0 : if (TREE_SIDE_EFFECTS (captures[0]))
11513 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
11514 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11515 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11516 0 : if (TREE_SIDE_EFFECTS (captures[3]))
11517 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
11518 0 : if (TREE_SIDE_EFFECTS (captures[4]))
11519 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
11520 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1076, __FILE__, __LINE__, true);
11521 0 : return _r;
11522 : }
11523 0 : next_after_fail1944:;
11524 : }
11525 : else
11526 : {
11527 0 : if (wi::geu_p (wi::to_wide (captures[2]),
11528 0 : wi::to_wide (captures[4]) + wi::to_wide (captures[3]))
11529 0 : || wi::geu_p (wi::to_wide (captures[4]),
11530 0 : wi::to_wide (captures[2]) + isize)
11531 : )
11532 : {
11533 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1945;
11534 0 : {
11535 0 : tree res_op0;
11536 0 : res_op0 = captures[0];
11537 0 : tree res_op1;
11538 0 : res_op1 = captures[3];
11539 0 : tree res_op2;
11540 0 : res_op2 = captures[4];
11541 0 : tree _r;
11542 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11543 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11544 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11545 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11546 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11547 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1077, __FILE__, __LINE__, true);
11548 0 : return _r;
11549 : }
11550 0 : next_after_fail1945:;
11551 : }
11552 : }
11553 : }
11554 : }
11555 : }
11556 0 : break;
11557 : }
11558 : default:;
11559 : }
11560 : return NULL_TREE;
11561 : }
11562 : #pragma GCC diagnostic pop
|
