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 132545322 : tree_negate_expr_p (tree t)
11 : {
12 132545322 : const tree type = TREE_TYPE (t);
13 132545322 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 132545322 : if (TREE_SIDE_EFFECTS (t)) return false;
15 127224041 : switch (TREE_CODE (t))
16 : {
17 7666594 : case INTEGER_CST:
18 7666594 : {
19 7666594 : {
20 7666594 : if ((INTEGRAL_TYPE_P (type)
21 7666594 : && TYPE_UNSIGNED (type))
22 9854945 : || (!TYPE_OVERFLOW_SANITIZED (type)
23 2185616 : && may_negate_without_overflow_p (t))
24 : )
25 : {
26 7650750 : {
27 7650750 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 14, __FILE__, __LINE__, false);
28 7650750 : 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 399232 : break;
43 : }
44 399232 : case NEGATE_EXPR:
45 399232 : {
46 399232 : tree _p0 = TREE_OPERAND (t, 0);
47 399232 : {
48 399232 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
49 399232 : if (!TYPE_OVERFLOW_SANITIZED (type)
50 : )
51 : {
52 399212 : {
53 399212 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 16, __FILE__, __LINE__, false);
54 399212 : return true;
55 : }
56 : }
57 : }
58 : break;
59 : }
60 726207 : case REAL_CST:
61 726207 : {
62 726207 : {
63 726207 : 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 436 : case VECTOR_CST:
75 436 : {
76 436 : {
77 436 : 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 1218513 : case MINUS_EXPR:
89 1218513 : {
90 1218513 : tree _p0 = TREE_OPERAND (t, 0);
91 1218513 : tree _p1 = TREE_OPERAND (t, 1);
92 1218513 : {
93 1218513 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
94 1218513 : if ((ANY_INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_WRAPS (type))
95 2121223 : || (FLOAT_TYPE_P (type)
96 632729 : && !HONOR_SIGN_DEPENDENT_ROUNDING (type)
97 632729 : && !HONOR_SIGNED_ZEROS (type))
98 : )
99 : {
100 316376 : {
101 316376 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 19, __FILE__, __LINE__, false);
102 316376 : return true;
103 : }
104 : }
105 : }
106 902137 : 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 222249 : 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 222249 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
171 222249 : if (!TYPE_SATURATING (type)
172 : )
173 : {
174 222249 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[1]))
175 222249 : && !TYPE_OVERFLOW_SANITIZED (type)
176 : )
177 : {
178 220104 : {
179 220104 : tree t1 = type;
180 220104 : if (INTEGRAL_TYPE_P (type)
181 370729 : && TYPE_OVERFLOW_WRAPS (type) != TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1])))
182 4235 : t1 = TYPE_OVERFLOW_WRAPS (type) ? type : TREE_TYPE (captures[1]);
183 220104 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail86;
184 220104 : {
185 220104 : tree res_op0;
186 220104 : {
187 220104 : tree _o1[2], _r1;
188 220104 : {
189 220104 : tree _o2[1], _r2;
190 220104 : _o2[0] = captures[0];
191 220104 : if (TREE_TYPE (_o2[0]) != t1)
192 : {
193 3966 : _r2 = fold_build1_loc (loc, NOP_EXPR, t1, _o2[0]);
194 : }
195 : else
196 : _r2 = _o2[0];
197 220104 : _o1[0] = _r2;
198 : }
199 220104 : {
200 220104 : tree _o2[1], _r2;
201 220104 : _o2[0] = captures[1];
202 220104 : if (TREE_TYPE (_o2[0]) != t1)
203 : {
204 992 : _r2 = fold_build1_loc (loc, NOP_EXPR, t1, _o2[0]);
205 : }
206 : else
207 : _r2 = _o2[0];
208 220104 : _o1[1] = _r2;
209 : }
210 220104 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
211 220104 : res_op0 = _r1;
212 : }
213 220104 : tree _r;
214 220104 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
215 220104 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 63, __FILE__, __LINE__, true);
216 220104 : return _r;
217 : }
218 0 : next_after_fail86:;
219 : }
220 : }
221 : }
222 : return NULL_TREE;
223 : }
224 :
225 : tree
226 9046 : 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 9046 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
231 9046 : if (!TYPE_SATURATING (type)
232 9046 : && (!FLOAT_TYPE_P (type) || flag_associative_math)
233 : )
234 : {
235 8880 : if (!ALL_FRACT_MODE_P (TYPE_MODE (type))
236 : )
237 : {
238 4 : if ((!ANY_INTEGRAL_TYPE_P (type)
239 8876 : || TYPE_OVERFLOW_WRAPS (type)
240 3280 : || (INTEGRAL_TYPE_P (type)
241 3280 : && ((tree_expr_nonzero_p (captures[0])
242 136 : && expr_not_equal_to (captures[0],
243 9016 : wi::minus_one (TYPE_PRECISION (type)),
244 : gimple_match_ctx (captures[1])))
245 : || (plusminus == PLUS_EXPR
246 3144 : ? expr_not_equal_to (captures[2],
247 8898 : wi::max_value (TYPE_PRECISION (type), SIGNED),
248 : gimple_match_ctx (captures[1]))
249 3126 : : (expr_not_equal_to (captures[2],
250 12006 : 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 18186 : + 1, gimple_match_ctx (captures[1])))))))
255 12024 : && single_use (captures[1])
256 : )
257 : {
258 8856 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail107;
259 8856 : {
260 8856 : tree res_op0;
261 8856 : {
262 8856 : tree _o1[2], _r1;
263 8856 : _o1[0] = build_one_cst (type);
264 8856 : _o1[1] = captures[2];
265 8856 : _r1 = fold_build2_loc (loc, plusminus, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
266 8856 : res_op0 = _r1;
267 : }
268 8856 : tree res_op1;
269 8856 : res_op1 = captures[0];
270 8856 : tree _r;
271 8856 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
272 8856 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 84, __FILE__, __LINE__, true);
273 8856 : 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 2497 : 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 2497 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1072 4994 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1073 3200 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
1074 4126 : && 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 1368 : 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 1368 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1129 1368 : if (TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1130 374 : && TREE_CODE (TREE_TYPE (captures[0])) != COMPLEX_TYPE
1131 1720 : && (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 134364 : 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 134364 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1251 263906 : if (! FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1252 134630 : || ! tree_expr_maybe_nan_p (captures[0])
1253 : )
1254 : {
1255 129350 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail422;
1256 129350 : {
1257 129350 : tree _r;
1258 129350 : _r = constant_boolean_node (true, type);
1259 129350 : if (TREE_SIDE_EFFECTS (captures[0]))
1260 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1261 129350 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 334, __FILE__, __LINE__, true);
1262 129350 : return _r;
1263 : }
1264 0 : next_after_fail422:;
1265 : }
1266 : else
1267 : {
1268 5014 : if (cmp != EQ_EXPR
1269 5014 : && (! 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 18910 : 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 18910 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1296 18910 : 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 21564564 : 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 21564564 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1360 41907687 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1361 15317154 : && !(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 21564564 : && single_use (captures[0])
1367 : )
1368 : {
1369 15317154 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (TREE_TYPE (captures[0]))
1370 5723861 : && (TREE_CODE (captures[3]) == INTEGER_CST
1371 1972109 : || captures[2] != captures[3])
1372 3751752 : && (TYPE_UNSIGNED (TREE_TYPE (captures[1])) == TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1373 : || cmp == NE_EXPR
1374 1518746 : || cmp == EQ_EXPR)
1375 2699005 : && !POINTER_TYPE_P (TREE_TYPE (captures[1]))
1376 17984345 : && (TREE_CODE (TREE_TYPE (captures[1])) != BOOLEAN_TYPE
1377 1646 : || TREE_CODE (TREE_TYPE (captures[3])) == BOOLEAN_TYPE)
1378 : )
1379 : {
1380 2667163 : if (TREE_CODE (captures[2]) == INTEGER_CST
1381 : )
1382 : {
1383 2667163 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail486;
1384 2667163 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail486;
1385 2667163 : {
1386 2667163 : tree res_op0;
1387 2667163 : res_op0 = captures[1];
1388 2667163 : tree res_op1;
1389 2667163 : res_op1 = force_fit_type (TREE_TYPE (captures[1]),
1390 2667163 : wide_int::from (wi::to_wide (captures[2]),
1391 2667163 : MAX (TYPE_PRECISION (TREE_TYPE (captures[2])),
1392 : TYPE_PRECISION (TREE_TYPE (captures[1]))),
1393 2667163 : TYPE_SIGN (TREE_TYPE (captures[2]))),
1394 2667163 : 0, TREE_OVERFLOW (captures[2]));
1395 2667163 : tree _r;
1396 2667163 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1397 2667163 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 390, __FILE__, __LINE__, true);
1398 2667163 : 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 12649991 : if (TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (TREE_TYPE (captures[1]))
1431 : )
1432 : {
1433 8632283 : if ((cmp == EQ_EXPR || cmp == NE_EXPR
1434 3298001 : || TYPE_UNSIGNED (TREE_TYPE (captures[0])) == TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1435 569906 : || (!TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1436 484699 : && TYPE_UNSIGNED (TREE_TYPE (captures[1]))))
1437 11845077 : && (types_match (TREE_TYPE (captures[3]), TREE_TYPE (captures[1]))
1438 8547058 : || ((TYPE_PRECISION (TREE_TYPE (captures[1]))
1439 8547058 : >= TYPE_PRECISION (TREE_TYPE (captures[3])))
1440 0 : && (TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1441 0 : == TYPE_UNSIGNED (TREE_TYPE (captures[3]))))
1442 8547058 : || (TREE_CODE (captures[2]) == INTEGER_CST
1443 7420106 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1444 7420106 : && int_fits_type_p (captures[2], TREE_TYPE (captures[1]))))
1445 : )
1446 : {
1447 7379426 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail488;
1448 7379426 : {
1449 7379426 : tree res_op0;
1450 7379426 : res_op0 = captures[1];
1451 7379426 : tree res_op1;
1452 7379426 : {
1453 7379426 : tree _o1[1], _r1;
1454 7379426 : _o1[0] = captures[3];
1455 7379426 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
1456 : {
1457 7379408 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
1458 : }
1459 : else
1460 : _r1 = _o1[0];
1461 7379426 : res_op1 = _r1;
1462 : }
1463 7379426 : tree _r;
1464 7379426 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1465 7379426 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 392, __FILE__, __LINE__, true);
1466 7379426 : return _r;
1467 : }
1468 0 : next_after_fail488:;
1469 : }
1470 : else
1471 : {
1472 1252857 : if (TREE_CODE (captures[2]) == INTEGER_CST
1473 90489 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1474 1343346 : && !int_fits_type_p (captures[2], TREE_TYPE (captures[1]))
1475 : )
1476 : {
1477 44148 : {
1478 44148 : tree min = lower_bound_in_type (TREE_TYPE (captures[3]), TREE_TYPE (captures[1]));
1479 44148 : tree max = upper_bound_in_type (TREE_TYPE (captures[3]), TREE_TYPE (captures[1]));
1480 44148 : bool above = integer_nonzerop (const_binop (LT_EXPR, type, max, captures[2]));
1481 44148 : bool below = integer_nonzerop (const_binop (LT_EXPR, type, captures[2], min));
1482 44148 : if (above || below
1483 : )
1484 : {
1485 38034 : if (cmp == EQ_EXPR || cmp == NE_EXPR
1486 : )
1487 : {
1488 25136 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail489;
1489 25136 : {
1490 25136 : tree _r;
1491 25136 : _r = constant_boolean_node (cmp == EQ_EXPR ? false : true, type);
1492 25136 : if (TREE_SIDE_EFFECTS (captures[1]))
1493 10 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1494 25136 : if (TREE_SIDE_EFFECTS (captures[2]))
1495 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1496 25136 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 393, __FILE__, __LINE__, true);
1497 25136 : return _r;
1498 : }
1499 0 : next_after_fail489:;
1500 : }
1501 : else
1502 : {
1503 12898 : if (cmp == LT_EXPR || cmp == LE_EXPR
1504 : )
1505 : {
1506 12222 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail490;
1507 12222 : {
1508 12222 : tree _r;
1509 12222 : _r = constant_boolean_node (above ? true : false, type);
1510 12222 : if (TREE_SIDE_EFFECTS (captures[1]))
1511 10 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1512 12222 : if (TREE_SIDE_EFFECTS (captures[2]))
1513 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1514 12222 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 394, __FILE__, __LINE__, true);
1515 12222 : return _r;
1516 : }
1517 0 : next_after_fail490:;
1518 : }
1519 : else
1520 : {
1521 676 : if (cmp == GT_EXPR || cmp == GE_EXPR
1522 : )
1523 : {
1524 676 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail491;
1525 676 : {
1526 676 : tree _r;
1527 930 : _r = constant_boolean_node (above ? false : true, type);
1528 676 : if (TREE_SIDE_EFFECTS (captures[1]))
1529 4 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1530 676 : if (TREE_SIDE_EFFECTS (captures[2]))
1531 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1532 676 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 395, __FILE__, __LINE__, true);
1533 676 : return _r;
1534 : }
1535 0 : next_after_fail491:;
1536 : }
1537 : }
1538 : }
1539 : }
1540 : }
1541 : }
1542 : }
1543 : }
1544 : }
1545 : }
1546 : else
1547 : {
1548 11965894 : if (FLOAT_TYPE_P (TREE_TYPE (captures[1]))
1549 1084850 : && (DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1550 542425 : == DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[1])))
1551 7332022 : && (DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1552 542306 : == DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[3])))
1553 : )
1554 : {
1555 542306 : {
1556 542306 : tree type1 = TREE_TYPE (captures[3]);
1557 542306 : if (TREE_CODE (captures[3]) == REAL_CST && !DECIMAL_FLOAT_TYPE_P (type1))
1558 : {
1559 340378 : REAL_VALUE_TYPE orig = TREE_REAL_CST (captures[3]);
1560 340378 : if (TYPE_PRECISION (type1) > TYPE_PRECISION (float_type_node)
1561 340378 : && exact_real_truncate (TYPE_MODE (float_type_node), &orig))
1562 175795 : type1 = float_type_node;
1563 340378 : if (TYPE_PRECISION (type1) > TYPE_PRECISION (double_type_node)
1564 340378 : && exact_real_truncate (TYPE_MODE (double_type_node), &orig))
1565 292 : type1 = double_type_node;
1566 : }
1567 542306 : tree newtype
1568 542306 : = (element_precision (TREE_TYPE (captures[1])) > element_precision (type1)
1569 542306 : ? TREE_TYPE (captures[1]) : type1);
1570 542306 : if (element_precision (TREE_TYPE (captures[0])) > element_precision (newtype)
1571 542306 : && (!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 2366325 : 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 2366325 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1747 0 : if ((INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
1748 2366325 : && TYPE_UNSIGNED (type)
1749 : )
1750 : {
1751 2357164 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail587;
1752 2357164 : {
1753 2357164 : tree res_op0;
1754 2357164 : res_op0 = captures[0];
1755 2357164 : tree res_op1;
1756 2357164 : res_op1 = captures[1];
1757 2357164 : tree _r;
1758 2357164 : _r = fold_build2_loc (loc, trunc_divmod, type, res_op0, res_op1);
1759 2357164 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 479, __FILE__, __LINE__, true);
1760 2357164 : 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 157093 : 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 157093 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1818 157093 : {
1819 157093 : tree from_type = TREE_TYPE (captures[0]);
1820 157093 : tree c1_type = TREE_TYPE (captures[1]), c2_type = TREE_TYPE (captures[2]);
1821 157093 : enum tree_code code = ERROR_MARK;
1822 157093 : if (integer_zerop (captures[1])
1823 63317 : && INTEGRAL_TYPE_P (from_type)
1824 62827 : && (cmp == GE_EXPR || cmp == LT_EXPR)
1825 18149 : && TYPE_UNSIGNED (from_type)
1826 1733 : && !TYPE_UNSIGNED (c1_type)
1827 1733 : && TYPE_PRECISION (from_type) == TYPE_PRECISION (c1_type)
1828 587 : && int_fits_type_p (captures[2], from_type)
1829 157680 : && (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 157088 : && INTEGRAL_TYPE_P (from_type)
1840 156598 : && int_fits_type_p (captures[2], from_type)
1841 156597 : && (types_match (c1_type, from_type)
1842 7902 : || (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 149282 : && (types_match (c2_type, from_type)
1846 58002 : || (TYPE_PRECISION (c2_type) > TYPE_PRECISION (from_type)
1847 18727 : && (TYPE_UNSIGNED (from_type)
1848 698 : || TYPE_SIGN (c2_type) == TYPE_SIGN (from_type)))))
1849 : {
1850 108810 : if (cmp != EQ_EXPR)
1851 108798 : 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 157081 : if (code == MAX_EXPR
1856 : )
1857 : {
1858 19398 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail609;
1859 19398 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail609;
1860 19398 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail609;
1861 19398 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail609;
1862 19398 : {
1863 19398 : tree res_op0;
1864 19398 : {
1865 19398 : tree _o1[2], _r1;
1866 19398 : _o1[0] = captures[0];
1867 19398 : {
1868 19398 : tree _o2[1], _r2;
1869 19398 : _o2[0] = captures[2];
1870 19398 : 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 19398 : _o1[1] = _r2;
1877 : }
1878 19398 : _r1 = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1879 19398 : res_op0 = _r1;
1880 : }
1881 19398 : tree _r;
1882 19398 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1883 19398 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 501, __FILE__, __LINE__, true);
1884 19398 : return _r;
1885 : }
1886 : next_after_fail609:;
1887 : }
1888 : else
1889 : {
1890 137695 : 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 137440 : 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 10161718 : 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 10161718 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1999 10161718 : {
2000 10161718 : tree cst = uniform_integer_cst_p (captures[1]);
2001 10161718 : if (tree_int_cst_sgn (cst) == 1
2002 : )
2003 : {
2004 4108587 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail662;
2005 4108587 : {
2006 4108587 : tree res_op0;
2007 4108587 : res_op0 = captures[0];
2008 4108587 : tree res_op1;
2009 4108587 : res_op1 = build_uniform_cst (TREE_TYPE (captures[1]),
2010 4108587 : wide_int_to_tree (TREE_TYPE (cst),
2011 4108587 : wi::to_wide (cst) - 1));
2012 4108587 : tree _r;
2013 4108587 : _r = fold_build2_loc (loc, acmp, type, res_op0, res_op1);
2014 4108587 : if (TREE_SIDE_EFFECTS (captures[1]))
2015 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2016 4108587 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 552, __FILE__, __LINE__, true);
2017 4108587 : 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 2585064 : 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 2585064 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2061 5170114 : if (!TREE_OVERFLOW (captures[2]) && !TREE_OVERFLOW (captures[3])
2062 5170102 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
2063 : )
2064 : {
2065 878515 : {
2066 878515 : tree res = int_const_binop (rop, captures[3], captures[2]);
2067 878515 : 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 865902 : if (single_use (captures[0])
2090 : )
2091 : {
2092 865902 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail709;
2093 865902 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail709;
2094 865902 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail709;
2095 865902 : {
2096 865902 : tree res_op0;
2097 865902 : res_op0 = captures[1];
2098 865902 : tree res_op1;
2099 865902 : res_op1 = res;
2100 865902 : tree _r;
2101 865902 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2102 865902 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 582, __FILE__, __LINE__, true);
2103 865902 : return _r;
2104 : }
2105 : next_after_fail709:;
2106 : }
2107 : }
2108 : }
2109 : }
2110 : else
2111 : {
2112 1706549 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))
2113 : )
2114 : {
2115 1706426 : {
2116 1706426 : wide_int max = wi::max_value (TREE_TYPE (captures[1]));
2117 1706426 : wide_int min = wi::min_value (TREE_TYPE (captures[1]));
2118 1706426 : wide_int c2 = rop == PLUS_EXPR
2119 1706426 : ? wi::add (wi::to_wide (captures[3]), wi::to_wide (captures[2]))
2120 1706426 : : wi::sub (wi::to_wide (captures[3]), wi::to_wide (captures[2]));
2121 1634178 : if (((cmp == LE_EXPR || cmp == GT_EXPR) && wi::eq_p (c2, max))
2122 3321725 : || ((cmp == LT_EXPR || cmp == GE_EXPR) && wi::eq_p (c2, min))
2123 : )
2124 : {
2125 19037 : {
2126 19037 : wide_int c1 = rop == PLUS_EXPR
2127 19037 : ? wi::add (wi::bit_not (c2), wi::to_wide (captures[2]))
2128 38074 : : wi::sub (wi::bit_not (c2), wi::to_wide (captures[2]));
2129 19037 : tree c1_cst = wide_int_to_tree (TREE_TYPE (captures[1]), c1);
2130 19037 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail710;
2131 19037 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail710;
2132 19037 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail710;
2133 19037 : {
2134 19037 : tree res_op0;
2135 19037 : res_op0 = captures[1];
2136 19037 : tree res_op1;
2137 19037 : res_op1 = c1_cst;
2138 19037 : tree _r;
2139 19037 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
2140 19037 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 583, __FILE__, __LINE__, true);
2141 19037 : return _r;
2142 : }
2143 0 : next_after_fail710:;
2144 19037 : }
2145 : }
2146 1706428 : }
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 27431 : 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 27431 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2178 27431 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[2]))
2179 : )
2180 : {
2181 27431 : {
2182 27431 : tree mask = int_const_binop (shift, fold_convert (type, captures[3]), captures[4]);
2183 27431 : if (mask
2184 : )
2185 : {
2186 27424 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail744;
2187 27424 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail744;
2188 27424 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail744;
2189 27424 : {
2190 27424 : tree res_op0;
2191 27424 : {
2192 27424 : tree _o1[2], _r1;
2193 27424 : {
2194 27424 : tree _o2[1], _r2;
2195 27424 : _o2[0] = captures[2];
2196 27424 : 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 27424 : _o1[0] = _r2;
2203 : }
2204 27424 : _o1[1] = captures[4];
2205 27424 : _r1 = fold_build2_loc (loc, shift, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2206 27424 : res_op0 = _r1;
2207 : }
2208 27424 : tree res_op1;
2209 27424 : res_op1 = mask;
2210 27424 : tree _r;
2211 27424 : _r = fold_build2_loc (loc, bit_op, type, res_op0, res_op1);
2212 27424 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 611, __FILE__, __LINE__, true);
2213 27424 : 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 2511460 : 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 2511460 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2266 2511460 : if (INTEGRAL_TYPE_P (type)
2267 2055954 : && op != MULT_EXPR
2268 2055954 : && op != RDIV_EXPR
2269 1367017 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2270 1367017 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2271 1367017 : && type_has_mode_precision_p (TREE_TYPE (captures[2]))
2272 1366642 : && type_has_mode_precision_p (TREE_TYPE (captures[4]))
2273 1365888 : && type_has_mode_precision_p (type)
2274 1362035 : && TYPE_PRECISION (TREE_TYPE (captures[1])) > TYPE_PRECISION (TREE_TYPE (captures[2]))
2275 0 : && types_match (captures[2], type)
2276 2511460 : && (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 2499171 : if (FLOAT_TYPE_P (type)
2352 2523749 : && DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
2353 12289 : == DECIMAL_FLOAT_TYPE_P (type)
2354 : )
2355 : {
2356 12266 : {
2357 12266 : tree arg0 = strip_float_extensions (captures[2]);
2358 12266 : tree arg1 = strip_float_extensions (captures[4]);
2359 12266 : tree itype = TREE_TYPE (captures[0]);
2360 12266 : tree ty1 = TREE_TYPE (arg0);
2361 12266 : tree ty2 = TREE_TYPE (arg1);
2362 12266 : enum tree_code code = TREE_CODE (itype);
2363 0 : if (FLOAT_TYPE_P (ty1)
2364 12266 : && FLOAT_TYPE_P (ty2)
2365 : )
2366 : {
2367 12266 : {
2368 12266 : tree newtype = type;
2369 12266 : if (TYPE_MODE (ty1) == SDmode
2370 12257 : || TYPE_MODE (ty2) == SDmode
2371 24523 : || TYPE_MODE (type) == SDmode)
2372 9 : newtype = dfloat32_type_node;
2373 12266 : if (TYPE_MODE (ty1) == DDmode
2374 12260 : || TYPE_MODE (ty2) == DDmode
2375 24526 : || TYPE_MODE (type) == DDmode)
2376 6 : newtype = dfloat64_type_node;
2377 12266 : if (TYPE_MODE (ty1) == TDmode
2378 12266 : || TYPE_MODE (ty2) == TDmode
2379 24532 : || TYPE_MODE (type) == TDmode)
2380 15 : newtype = dfloat128_type_node;
2381 12266 : if ((newtype == dfloat32_type_node
2382 12266 : || newtype == dfloat64_type_node
2383 12266 : || newtype == dfloat128_type_node)
2384 15 : && newtype == type
2385 12272 : && 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 12260 : {
2426 12260 : if (element_precision (ty1) > element_precision (newtype))
2427 745 : newtype = ty1;
2428 12260 : if (element_precision (ty2) > element_precision (newtype))
2429 1 : newtype = ty2;
2430 12260 : if (element_precision (newtype) < element_precision (itype)
2431 10960 : && (!VECTOR_MODE_P (TYPE_MODE (newtype))
2432 0 : || target_supports_op_p (newtype, op, optab_default))
2433 10960 : && (flag_unsafe_math_optimizations
2434 10948 : || (element_precision (newtype) == element_precision (type)
2435 10944 : && real_can_shorten_arithmetic (element_mode (itype),
2436 : element_mode (type))
2437 3990 : && !excess_precision_type (newtype)))
2438 12933 : && !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 98206 : 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 98206 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2577 98206 : if (tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
2578 22368 : && TYPE_PRECISION (type) <= HOST_BITS_PER_WIDE_INT
2579 22368 : && tree_fits_uhwi_p (captures[4])
2580 22368 : && tree_to_uhwi (captures[4]) > 0
2581 120574 : && tree_to_uhwi (captures[4]) < TYPE_PRECISION (type)
2582 : )
2583 : {
2584 22368 : {
2585 22368 : unsigned int shiftc = tree_to_uhwi (captures[4]);
2586 22368 : unsigned HOST_WIDE_INT mask = TREE_INT_CST_LOW (captures[5]);
2587 22368 : unsigned HOST_WIDE_INT newmask, zerobits = 0;
2588 22368 : tree shift_type = TREE_TYPE (captures[2]);
2589 22368 : unsigned int prec;
2590 22368 : if (shift == LSHIFT_EXPR)
2591 0 : zerobits = ((HOST_WIDE_INT_1U << shiftc) - 1);
2592 22368 : else if (shift == RSHIFT_EXPR
2593 22368 : && type_has_mode_precision_p (shift_type))
2594 : {
2595 22368 : prec = TYPE_PRECISION (TREE_TYPE (captures[2]));
2596 22368 : tree arg00 = captures[3];
2597 22368 : if (captures[2] != captures[3]
2598 22368 : && TYPE_UNSIGNED (TREE_TYPE (captures[3])))
2599 : {
2600 21961 : tree inner_type = TREE_TYPE (captures[3]);
2601 21961 : if (type_has_mode_precision_p (inner_type)
2602 21961 : && 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 22368 : zerobits = HOST_WIDE_INT_M1U;
2610 22368 : if (shiftc < prec)
2611 : {
2612 22368 : zerobits >>= HOST_BITS_PER_WIDE_INT - shiftc;
2613 22368 : zerobits <<= prec - shiftc;
2614 : }
2615 22368 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[2]))
2616 22368 : && 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 22354 : 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 22368 : {
2643 22368 : newmask = mask | zerobits;
2644 22368 : 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 38982 : generic_simplify_503 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2794 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2795 : {
2796 38982 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2797 38982 : if (!HONOR_SIGN_DEPENDENT_ROUNDING (type)
2798 38982 : && !HONOR_SIGNED_ZEROS (type)
2799 : )
2800 : {
2801 38982 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail893;
2802 38982 : {
2803 38982 : tree res_op0;
2804 38982 : {
2805 38982 : tree _o1[1], _r1;
2806 38982 : _o1[0] = captures[1];
2807 38982 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2808 38982 : res_op0 = _r1;
2809 : }
2810 38982 : tree res_op1;
2811 38982 : res_op1 = captures[0];
2812 38982 : tree _r;
2813 38982 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
2814 38982 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 706, __FILE__, __LINE__, true);
2815 38982 : 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 59315439 : 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 59315439 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3497 59315439 : if (integer_zerop (_p1))
3498 : {
3499 3308739 : {
3500 3308739 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3501 3308739 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1160;
3502 3308739 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1160;
3503 3308739 : {
3504 3308739 : tree res_op0;
3505 3308739 : res_op0 = captures[0];
3506 3308739 : tree _r;
3507 3308739 : _r = non_lvalue_loc (loc, res_op0);
3508 3308739 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 869, __FILE__, __LINE__, true);
3509 3308739 : return _r;
3510 : }
3511 : next_after_fail1160:;
3512 : }
3513 : }
3514 56006700 : switch (TREE_CODE (_p0))
3515 : {
3516 4028327 : case POINTER_PLUS_EXPR:
3517 4028327 : {
3518 4028327 : tree _q20 = TREE_OPERAND (_p0, 0);
3519 4028327 : tree _q21 = TREE_OPERAND (_p0, 1);
3520 4028327 : {
3521 4028327 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
3522 4028327 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1161;
3523 4028327 : {
3524 4028327 : tree res_op0;
3525 4028327 : res_op0 = captures[1];
3526 4028327 : tree res_op1;
3527 4028327 : {
3528 4028327 : tree _o1[2], _r1;
3529 4028327 : _o1[0] = captures[2];
3530 4028327 : _o1[1] = captures[3];
3531 4028327 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3532 4028327 : res_op1 = _r1;
3533 : }
3534 4028327 : tree _r;
3535 4028327 : _r = fold_build2_loc (loc, POINTER_PLUS_EXPR, type, res_op0, res_op1);
3536 4028327 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 880, __FILE__, __LINE__, true);
3537 4028327 : return _r;
3538 : }
3539 0 : next_after_fail1161:;
3540 : }
3541 0 : break;
3542 : }
3543 24923940 : CASE_CONVERT:
3544 24923940 : {
3545 24923940 : tree _q20 = TREE_OPERAND (_p0, 0);
3546 24923940 : switch (TREE_CODE (_q20))
3547 : {
3548 27186 : case POINTER_PLUS_EXPR:
3549 27186 : {
3550 27186 : tree _q30 = TREE_OPERAND (_q20, 0);
3551 27186 : tree _q31 = TREE_OPERAND (_q20, 1);
3552 27186 : {
3553 27186 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
3554 27186 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1162;
3555 27186 : {
3556 27186 : tree res_op0;
3557 27186 : {
3558 27186 : tree _o1[1], _r1;
3559 27186 : _o1[0] = captures[2];
3560 27186 : if (TREE_TYPE (_o1[0]) != type)
3561 : {
3562 27080 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3563 : }
3564 : else
3565 : _r1 = _o1[0];
3566 27186 : res_op0 = _r1;
3567 : }
3568 27186 : tree res_op1;
3569 27186 : {
3570 27186 : tree _o1[2], _r1;
3571 27186 : _o1[0] = captures[3];
3572 27186 : _o1[1] = captures[4];
3573 27186 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3574 27186 : res_op1 = _r1;
3575 : }
3576 27186 : tree _r;
3577 27186 : _r = fold_build2_loc (loc, POINTER_PLUS_EXPR, type, res_op0, res_op1);
3578 27186 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 881, __FILE__, __LINE__, true);
3579 27186 : return _r;
3580 : }
3581 0 : next_after_fail1162:;
3582 : }
3583 0 : break;
3584 : }
3585 : default:;
3586 : }
3587 : break;
3588 : }
3589 51951187 : default:;
3590 : }
3591 51951187 : if (integer_zerop (_p0))
3592 : {
3593 646 : {
3594 646 : tree captures[1] ATTRIBUTE_UNUSED = { _p1 };
3595 646 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1163;
3596 646 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1163;
3597 646 : {
3598 646 : tree res_op0;
3599 646 : {
3600 646 : tree _o1[1], _r1;
3601 646 : _o1[0] = captures[0];
3602 646 : if (TREE_TYPE (_o1[0]) != type)
3603 : {
3604 646 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3605 : }
3606 : else
3607 : _r1 = _o1[0];
3608 646 : res_op0 = _r1;
3609 : }
3610 646 : tree _r;
3611 646 : _r = non_lvalue_loc (loc, res_op0);
3612 646 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 882, __FILE__, __LINE__, true);
3613 646 : return _r;
3614 : }
3615 : next_after_fail1163:;
3616 : }
3617 : }
3618 51950541 : switch (TREE_CODE (_p1))
3619 : {
3620 11603539 : CASE_CONVERT:
3621 11603539 : {
3622 11603539 : tree _q30 = TREE_OPERAND (_p1, 0);
3623 11603539 : switch (TREE_CODE (_q30))
3624 : {
3625 195205 : case MINUS_EXPR:
3626 195205 : {
3627 195205 : tree _q40 = TREE_OPERAND (_q30, 0);
3628 195205 : tree _q41 = TREE_OPERAND (_q30, 1);
3629 195205 : switch (TREE_CODE (_q40))
3630 : {
3631 90969 : CASE_CONVERT:
3632 90969 : {
3633 90969 : tree _q50 = TREE_OPERAND (_q40, 0);
3634 90969 : switch (TREE_CODE (_q41))
3635 : {
3636 7960 : CASE_CONVERT:
3637 7960 : {
3638 7960 : tree _q70 = TREE_OPERAND (_q41, 0);
3639 7960 : if ((_q70 == _p0 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _p0, 0) && types_match (_q70, _p0)))
3640 : {
3641 4730 : {
3642 4730 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q50 };
3643 4730 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (TREE_TYPE (captures[2]))
3644 4730 : && ((
3645 :
3646 : && useless_type_conversion_p (type, TREE_TYPE (captures[3])))
3647 : || (
3648 : 1
3649 4730 : && type == TREE_TYPE (captures[3])))
3650 : )
3651 : {
3652 3343 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1164;
3653 3343 : {
3654 3343 : tree _r;
3655 3343 : _r = captures[3];
3656 3343 : if (TREE_SIDE_EFFECTS (captures[0]))
3657 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3658 3343 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 883, __FILE__, __LINE__, true);
3659 3343 : return _r;
3660 : }
3661 0 : next_after_fail1164:;
3662 : }
3663 : }
3664 : }
3665 : break;
3666 : }
3667 : default:;
3668 : }
3669 : break;
3670 : }
3671 : default:;
3672 : }
3673 : break;
3674 : }
3675 568 : case POINTER_DIFF_EXPR:
3676 568 : {
3677 568 : tree _q40 = TREE_OPERAND (_q30, 0);
3678 568 : tree _q41 = TREE_OPERAND (_q30, 1);
3679 568 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _p0, 0))
3680 : {
3681 7 : {
3682 7 : tree captures[5] ATTRIBUTE_UNUSED = { _q41, _p1, _q30, _q40, _p0 };
3683 7 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) >= TYPE_PRECISION (TREE_TYPE (captures[2]))
3684 : )
3685 : {
3686 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1165;
3687 7 : {
3688 7 : tree res_op0;
3689 7 : res_op0 = captures[3];
3690 7 : tree _r;
3691 7 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3692 7 : if (TREE_SIDE_EFFECTS (captures[4]))
3693 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
3694 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 884, __FILE__, __LINE__, true);
3695 7 : return _r;
3696 : }
3697 0 : next_after_fail1165:;
3698 : }
3699 : }
3700 : }
3701 : break;
3702 : }
3703 : default:;
3704 : }
3705 : break;
3706 : }
3707 27415 : case MINUS_EXPR:
3708 27415 : {
3709 27415 : tree _q30 = TREE_OPERAND (_p1, 0);
3710 27415 : tree _q31 = TREE_OPERAND (_p1, 1);
3711 27415 : switch (TREE_CODE (_q30))
3712 : {
3713 23522 : CASE_CONVERT:
3714 23522 : {
3715 23522 : tree _q40 = TREE_OPERAND (_q30, 0);
3716 23522 : switch (TREE_CODE (_q31))
3717 : {
3718 7442 : CASE_CONVERT:
3719 7442 : {
3720 7442 : tree _q60 = TREE_OPERAND (_q31, 0);
3721 7442 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
3722 : {
3723 20 : {
3724 20 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p1, _p1, _q40 };
3725 20 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (TREE_TYPE (captures[2]))
3726 20 : && ((
3727 :
3728 : && useless_type_conversion_p (type, TREE_TYPE (captures[3])))
3729 : || (
3730 : 1
3731 20 : && type == TREE_TYPE (captures[3])))
3732 : )
3733 : {
3734 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1166;
3735 0 : {
3736 0 : tree _r;
3737 0 : _r = captures[3];
3738 0 : if (TREE_SIDE_EFFECTS (captures[0]))
3739 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3740 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 883, __FILE__, __LINE__, true);
3741 0 : return _r;
3742 : }
3743 0 : next_after_fail1166:;
3744 : }
3745 : }
3746 : }
3747 : break;
3748 : }
3749 : default:;
3750 : }
3751 : break;
3752 : }
3753 974 : case INTEGER_CST:
3754 974 : {
3755 974 : switch (TREE_CODE (_q31))
3756 : {
3757 16 : case BIT_AND_EXPR:
3758 16 : {
3759 16 : tree _q50 = TREE_OPERAND (_q31, 0);
3760 16 : tree _q51 = TREE_OPERAND (_q31, 1);
3761 16 : switch (TREE_CODE (_q50))
3762 : {
3763 16 : CASE_CONVERT:
3764 16 : {
3765 16 : tree _q60 = TREE_OPERAND (_q50, 0);
3766 16 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
3767 : {
3768 0 : switch (TREE_CODE (_q51))
3769 : {
3770 0 : case INTEGER_CST:
3771 0 : {
3772 0 : {
3773 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q51 };
3774 0 : if (tree_int_cst_min_precision (captures[3], UNSIGNED) <= tree_ctz (captures[2])
3775 : )
3776 : {
3777 0 : {
3778 0 : tree algn = wide_int_to_tree (TREE_TYPE (captures[0]), ~wi::to_wide (captures[3]));
3779 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1167;
3780 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1167;
3781 0 : {
3782 0 : tree res_op0;
3783 0 : {
3784 0 : tree _o1[2], _r1;
3785 0 : _o1[0] = captures[0];
3786 0 : _o1[1] = algn;
3787 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3788 0 : res_op0 = _r1;
3789 : }
3790 0 : tree res_op1;
3791 0 : res_op1 = captures[2];
3792 0 : tree _r;
3793 0 : _r = fold_build2_loc (loc, POINTER_PLUS_EXPR, type, res_op0, res_op1);
3794 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 885, __FILE__, __LINE__, true);
3795 0 : return _r;
3796 : }
3797 0 : next_after_fail1167:;
3798 : }
3799 : }
3800 : }
3801 0 : break;
3802 : }
3803 : default:;
3804 : }
3805 : }
3806 16 : switch (TREE_CODE (_q60))
3807 : {
3808 0 : case POINTER_PLUS_EXPR:
3809 0 : {
3810 0 : tree _q70 = TREE_OPERAND (_q60, 0);
3811 0 : tree _q71 = TREE_OPERAND (_q60, 1);
3812 0 : if ((_q70 == _p0 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _p0, 0) && types_match (_q70, _p0)))
3813 : {
3814 0 : switch (TREE_CODE (_q71))
3815 : {
3816 0 : case INTEGER_CST:
3817 0 : {
3818 0 : switch (TREE_CODE (_q51))
3819 : {
3820 0 : case INTEGER_CST:
3821 0 : {
3822 0 : {
3823 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q71, _q51 };
3824 0 : {
3825 0 : auto mask_width = tree_int_cst_min_precision (captures[4], UNSIGNED);
3826 0 : if (mask_width <= tree_ctz (captures[2]) && mask_width <= tree_ctz (captures[3])
3827 : )
3828 : {
3829 0 : {
3830 0 : tree algn = wide_int_to_tree (TREE_TYPE (captures[0]), ~wi::to_wide (captures[4]));
3831 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1168;
3832 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1168;
3833 0 : {
3834 0 : tree res_op0;
3835 0 : {
3836 0 : tree _o1[2], _r1;
3837 0 : _o1[0] = captures[0];
3838 0 : _o1[1] = algn;
3839 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3840 0 : res_op0 = _r1;
3841 : }
3842 0 : tree res_op1;
3843 0 : res_op1 = captures[2];
3844 0 : tree _r;
3845 0 : _r = fold_build2_loc (loc, POINTER_PLUS_EXPR, type, res_op0, res_op1);
3846 0 : if (TREE_SIDE_EFFECTS (captures[3]))
3847 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
3848 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 886, __FILE__, __LINE__, true);
3849 0 : return _r;
3850 : }
3851 0 : next_after_fail1168:;
3852 : }
3853 : }
3854 : }
3855 : }
3856 0 : break;
3857 : }
3858 : default:;
3859 : }
3860 : break;
3861 : }
3862 : default:;
3863 : }
3864 : }
3865 : break;
3866 : }
3867 : default:;
3868 : }
3869 : break;
3870 : }
3871 : default:;
3872 : }
3873 : break;
3874 : }
3875 : default:;
3876 : }
3877 : break;
3878 : }
3879 : default:;
3880 : }
3881 : break;
3882 : }
3883 0 : case POINTER_DIFF_EXPR:
3884 0 : {
3885 0 : tree _q30 = TREE_OPERAND (_p1, 0);
3886 0 : tree _q31 = TREE_OPERAND (_p1, 1);
3887 0 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || operand_equal_p (_q31, _p0, 0))
3888 : {
3889 0 : {
3890 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q31, _p1, _p1, _q30, _p0 };
3891 0 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) >= TYPE_PRECISION (TREE_TYPE (captures[2]))
3892 : )
3893 : {
3894 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1169;
3895 0 : {
3896 0 : tree res_op0;
3897 0 : res_op0 = captures[3];
3898 0 : tree _r;
3899 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3900 0 : if (TREE_SIDE_EFFECTS (captures[4]))
3901 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
3902 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 884, __FILE__, __LINE__, true);
3903 0 : return _r;
3904 : }
3905 0 : next_after_fail1169:;
3906 : }
3907 : }
3908 : }
3909 : break;
3910 : }
3911 638388 : case NEGATE_EXPR:
3912 638388 : {
3913 638388 : tree _q30 = TREE_OPERAND (_p1, 0);
3914 638388 : switch (TREE_CODE (_q30))
3915 : {
3916 22 : case BIT_AND_EXPR:
3917 22 : {
3918 22 : tree _q40 = TREE_OPERAND (_q30, 0);
3919 22 : tree _q41 = TREE_OPERAND (_q30, 1);
3920 22 : switch (TREE_CODE (_q40))
3921 : {
3922 22 : CASE_CONVERT:
3923 22 : {
3924 22 : tree _q50 = TREE_OPERAND (_q40, 0);
3925 22 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
3926 : {
3927 1 : switch (TREE_CODE (_q41))
3928 : {
3929 1 : case INTEGER_CST:
3930 1 : {
3931 1 : {
3932 1 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
3933 1 : {
3934 1 : tree algn = wide_int_to_tree (TREE_TYPE (captures[0]), ~wi::to_wide (captures[1]));
3935 1 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1170;
3936 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1170;
3937 1 : {
3938 1 : tree res_op0;
3939 1 : res_op0 = captures[0];
3940 1 : tree res_op1;
3941 1 : res_op1 = algn;
3942 1 : tree _r;
3943 1 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
3944 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 887, __FILE__, __LINE__, true);
3945 1 : return _r;
3946 : }
3947 0 : next_after_fail1170:;
3948 : }
3949 : }
3950 0 : break;
3951 : }
3952 : default:;
3953 : }
3954 : }
3955 21 : switch (TREE_CODE (_q50))
3956 : {
3957 0 : case POINTER_PLUS_EXPR:
3958 0 : {
3959 0 : tree _q60 = TREE_OPERAND (_q50, 0);
3960 0 : tree _q61 = TREE_OPERAND (_q50, 1);
3961 0 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
3962 : {
3963 0 : switch (TREE_CODE (_q61))
3964 : {
3965 0 : case INTEGER_CST:
3966 0 : {
3967 0 : switch (TREE_CODE (_q41))
3968 : {
3969 0 : case INTEGER_CST:
3970 0 : {
3971 0 : {
3972 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q61, _q41 };
3973 0 : if (tree_int_cst_min_precision (captures[2], UNSIGNED) <= tree_ctz (captures[1])
3974 : )
3975 : {
3976 0 : {
3977 0 : tree algn = wide_int_to_tree (TREE_TYPE (captures[0]), ~wi::to_wide (captures[2]));
3978 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1171;
3979 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1171;
3980 0 : {
3981 0 : tree res_op0;
3982 0 : res_op0 = captures[0];
3983 0 : tree res_op1;
3984 0 : res_op1 = algn;
3985 0 : tree _r;
3986 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
3987 0 : if (TREE_SIDE_EFFECTS (captures[1]))
3988 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3989 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 888, __FILE__, __LINE__, true);
3990 0 : return _r;
3991 : }
3992 0 : next_after_fail1171:;
3993 : }
3994 : }
3995 : }
3996 0 : break;
3997 : }
3998 : default:;
3999 : }
4000 : break;
4001 : }
4002 : default:;
4003 : }
4004 : }
4005 : break;
4006 : }
4007 : default:;
4008 : }
4009 : break;
4010 : }
4011 : default:;
4012 : }
4013 : break;
4014 : }
4015 : default:;
4016 : }
4017 : break;
4018 : }
4019 : default:;
4020 : }
4021 : return NULL_TREE;
4022 : }
4023 :
4024 : tree
4025 40880027 : generic_simplify_NE_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
4026 : {
4027 40880027 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4028 40880027 : switch (TREE_CODE (_p1))
4029 : {
4030 2251 : case NEGATE_EXPR:
4031 2251 : {
4032 2251 : tree _q30 = TREE_OPERAND (_p1, 0);
4033 2251 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
4034 : {
4035 0 : {
4036 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4037 0 : tree res = generic_simplify_202 (loc, type, _p0, _p1, captures, NE_EXPR);
4038 0 : if (res) return res;
4039 : }
4040 : }
4041 : break;
4042 : }
4043 40880027 : default:;
4044 : }
4045 40880027 : switch (TREE_CODE (_p0))
4046 : {
4047 6195 : case NEGATE_EXPR:
4048 6195 : {
4049 6195 : tree _q20 = TREE_OPERAND (_p0, 0);
4050 6195 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4051 : {
4052 88 : {
4053 88 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4054 88 : tree res = generic_simplify_202 (loc, type, _p0, _p1, captures, NE_EXPR);
4055 88 : if (res) return res;
4056 : }
4057 : }
4058 : break;
4059 : }
4060 0 : case CEIL_MOD_EXPR:
4061 0 : {
4062 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4063 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4064 0 : if (integer_pow2p (_q21))
4065 : {
4066 0 : if (integer_zerop (_p1))
4067 : {
4068 0 : {
4069 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4070 0 : tree res = generic_simplify_203 (loc, type, _p0, _p1, captures, NE_EXPR, CEIL_MOD_EXPR);
4071 0 : if (res) return res;
4072 : }
4073 : }
4074 : }
4075 : break;
4076 : }
4077 1623 : case FLOOR_MOD_EXPR:
4078 1623 : {
4079 1623 : tree _q20 = TREE_OPERAND (_p0, 0);
4080 1623 : tree _q21 = TREE_OPERAND (_p0, 1);
4081 1623 : if (integer_pow2p (_q21))
4082 : {
4083 20 : if (integer_zerop (_p1))
4084 : {
4085 20 : {
4086 20 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4087 20 : tree res = generic_simplify_203 (loc, type, _p0, _p1, captures, NE_EXPR, FLOOR_MOD_EXPR);
4088 20 : if (res) return res;
4089 : }
4090 : }
4091 : }
4092 : break;
4093 : }
4094 0 : case ROUND_MOD_EXPR:
4095 0 : {
4096 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4097 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4098 0 : if (integer_pow2p (_q21))
4099 : {
4100 0 : if (integer_zerop (_p1))
4101 : {
4102 0 : {
4103 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4104 0 : tree res = generic_simplify_203 (loc, type, _p0, _p1, captures, NE_EXPR, ROUND_MOD_EXPR);
4105 0 : if (res) return res;
4106 : }
4107 : }
4108 : }
4109 : break;
4110 : }
4111 80585 : case TRUNC_MOD_EXPR:
4112 80585 : {
4113 80585 : tree _q20 = TREE_OPERAND (_p0, 0);
4114 80585 : tree _q21 = TREE_OPERAND (_p0, 1);
4115 80585 : if (integer_pow2p (_q21))
4116 : {
4117 20774 : if (integer_zerop (_p1))
4118 : {
4119 19332 : {
4120 19332 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4121 19332 : tree res = generic_simplify_203 (loc, type, _p0, _p1, captures, NE_EXPR, TRUNC_MOD_EXPR);
4122 19332 : if (res) return res;
4123 : }
4124 : }
4125 : }
4126 : break;
4127 : }
4128 8297511 : CASE_CONVERT:
4129 8297511 : {
4130 8297511 : tree _q20 = TREE_OPERAND (_p0, 0);
4131 8297511 : switch (TREE_CODE (_p1))
4132 : {
4133 69 : case LSHIFT_EXPR:
4134 69 : {
4135 69 : tree _q40 = TREE_OPERAND (_p1, 0);
4136 69 : tree _q41 = TREE_OPERAND (_p1, 1);
4137 69 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
4138 : {
4139 0 : {
4140 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
4141 0 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR);
4142 0 : if (res) return res;
4143 : }
4144 : }
4145 : break;
4146 : }
4147 8297511 : default:;
4148 : }
4149 8297511 : {
4150 8297511 : tree _p1_pops[1];
4151 8297511 : if (tree_nop_convert (_p1, _p1_pops))
4152 : {
4153 3063005 : tree _q40 = _p1_pops[0];
4154 3063005 : switch (TREE_CODE (_q40))
4155 : {
4156 0 : case LSHIFT_EXPR:
4157 0 : {
4158 0 : tree _q50 = TREE_OPERAND (_q40, 0);
4159 0 : tree _q51 = TREE_OPERAND (_q40, 1);
4160 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4161 : {
4162 0 : {
4163 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q20 };
4164 0 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR);
4165 0 : if (res) return res;
4166 : }
4167 : }
4168 : break;
4169 : }
4170 : default:;
4171 : }
4172 : }
4173 : }
4174 8297511 : switch (TREE_CODE (_q20))
4175 : {
4176 0 : case EXACT_DIV_EXPR:
4177 0 : {
4178 0 : tree _q30 = TREE_OPERAND (_q20, 0);
4179 0 : tree _q31 = TREE_OPERAND (_q20, 1);
4180 0 : switch (TREE_CODE (_q31))
4181 : {
4182 0 : case INTEGER_CST:
4183 0 : {
4184 0 : switch (TREE_CODE (_p1))
4185 : {
4186 0 : CASE_CONVERT:
4187 0 : {
4188 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4189 0 : switch (TREE_CODE (_q60))
4190 : {
4191 0 : case EXACT_DIV_EXPR:
4192 0 : {
4193 0 : tree _q70 = TREE_OPERAND (_q60, 0);
4194 0 : tree _q71 = TREE_OPERAND (_q60, 1);
4195 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
4196 : {
4197 0 : {
4198 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q70 };
4199 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
4200 0 : if (res) return res;
4201 : }
4202 : }
4203 : break;
4204 : }
4205 : default:;
4206 : }
4207 : break;
4208 : }
4209 : default:;
4210 : }
4211 : break;
4212 : }
4213 : default:;
4214 : }
4215 : break;
4216 : }
4217 8297511 : default:;
4218 : }
4219 8297511 : switch (TREE_CODE (_p1))
4220 : {
4221 20430 : case PLUS_EXPR:
4222 20430 : {
4223 20430 : tree _q40 = TREE_OPERAND (_p1, 0);
4224 20430 : tree _q41 = TREE_OPERAND (_p1, 1);
4225 20430 : switch (TREE_CODE (_q41))
4226 : {
4227 203 : CASE_CONVERT:
4228 203 : {
4229 203 : tree _q60 = TREE_OPERAND (_q41, 0);
4230 203 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4231 : {
4232 0 : {
4233 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q40, _q20 };
4234 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4235 0 : if (res) return res;
4236 : }
4237 : }
4238 : break;
4239 : }
4240 20430 : default:;
4241 : }
4242 20430 : switch (TREE_CODE (_q40))
4243 : {
4244 796 : CASE_CONVERT:
4245 796 : {
4246 796 : tree _q50 = TREE_OPERAND (_q40, 0);
4247 796 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4248 : {
4249 13 : {
4250 13 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q41, _q20 };
4251 13 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4252 13 : if (res) return res;
4253 : }
4254 : }
4255 : break;
4256 : }
4257 20425 : default:;
4258 : }
4259 20425 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
4260 : {
4261 0 : {
4262 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q40, _q20 };
4263 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4264 0 : if (res) return res;
4265 : }
4266 : }
4267 20425 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
4268 : {
4269 0 : {
4270 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q41, _q20 };
4271 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4272 0 : if (res) return res;
4273 : }
4274 : }
4275 : break;
4276 : }
4277 8297506 : default:;
4278 : }
4279 8297506 : {
4280 8297506 : tree _p1_pops[1];
4281 8297506 : if (tree_nop_convert (_p1, _p1_pops))
4282 : {
4283 3063005 : tree _q40 = _p1_pops[0];
4284 3063005 : switch (TREE_CODE (_q40))
4285 : {
4286 140 : case PLUS_EXPR:
4287 140 : {
4288 140 : tree _q50 = TREE_OPERAND (_q40, 0);
4289 140 : tree _q51 = TREE_OPERAND (_q40, 1);
4290 140 : switch (TREE_CODE (_q51))
4291 : {
4292 0 : CASE_CONVERT:
4293 0 : {
4294 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4295 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4296 : {
4297 0 : {
4298 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q20 };
4299 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4300 0 : if (res) return res;
4301 : }
4302 : }
4303 : break;
4304 : }
4305 140 : default:;
4306 : }
4307 140 : switch (TREE_CODE (_q50))
4308 : {
4309 73 : CASE_CONVERT:
4310 73 : {
4311 73 : tree _q60 = TREE_OPERAND (_q50, 0);
4312 73 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4313 : {
4314 0 : {
4315 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q51, _q20 };
4316 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4317 0 : if (res) return res;
4318 : }
4319 : }
4320 : break;
4321 : }
4322 140 : default:;
4323 : }
4324 140 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4325 : {
4326 0 : {
4327 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q20 };
4328 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4329 0 : if (res) return res;
4330 : }
4331 : }
4332 140 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4333 : {
4334 0 : {
4335 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q51, _q20 };
4336 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4337 0 : if (res) return res;
4338 : }
4339 : }
4340 : break;
4341 : }
4342 : default:;
4343 : }
4344 : }
4345 : }
4346 8297506 : break;
4347 : }
4348 40860670 : default:;
4349 : }
4350 40860670 : {
4351 40860670 : tree _p0_pops[1];
4352 40860670 : if (tree_nop_convert (_p0, _p0_pops))
4353 : {
4354 4882508 : tree _q20 = _p0_pops[0];
4355 4882508 : switch (TREE_CODE (_q20))
4356 : {
4357 15 : case LSHIFT_EXPR:
4358 15 : {
4359 15 : tree _q30 = TREE_OPERAND (_q20, 0);
4360 15 : tree _q31 = TREE_OPERAND (_q20, 1);
4361 15 : switch (TREE_CODE (_p1))
4362 : {
4363 1 : CASE_CONVERT:
4364 1 : {
4365 1 : tree _q60 = TREE_OPERAND (_p1, 0);
4366 1 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
4367 : {
4368 0 : {
4369 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
4370 0 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR);
4371 0 : if (res) return res;
4372 : }
4373 : }
4374 : break;
4375 : }
4376 15 : default:;
4377 : }
4378 15 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
4379 : {
4380 1 : {
4381 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
4382 1 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR);
4383 1 : if (res) return res;
4384 : }
4385 : }
4386 : break;
4387 : }
4388 33360 : case PLUS_EXPR:
4389 33360 : {
4390 33360 : tree _q30 = TREE_OPERAND (_q20, 0);
4391 33360 : tree _q31 = TREE_OPERAND (_q20, 1);
4392 33360 : switch (TREE_CODE (_q31))
4393 : {
4394 37 : CASE_CONVERT:
4395 37 : {
4396 37 : tree _q50 = TREE_OPERAND (_q31, 0);
4397 37 : switch (TREE_CODE (_p1))
4398 : {
4399 0 : CASE_CONVERT:
4400 0 : {
4401 0 : tree _q70 = TREE_OPERAND (_p1, 0);
4402 0 : if ((_q70 == _q50 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q50, 0) && types_match (_q70, _q50)))
4403 : {
4404 0 : {
4405 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50 };
4406 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4407 0 : if (res) return res;
4408 : }
4409 : }
4410 : break;
4411 : }
4412 : default:;
4413 : }
4414 : break;
4415 : }
4416 33360 : default:;
4417 : }
4418 33360 : switch (TREE_CODE (_q30))
4419 : {
4420 28649 : CASE_CONVERT:
4421 28649 : {
4422 28649 : tree _q40 = TREE_OPERAND (_q30, 0);
4423 28649 : switch (TREE_CODE (_p1))
4424 : {
4425 415 : CASE_CONVERT:
4426 415 : {
4427 415 : tree _q70 = TREE_OPERAND (_p1, 0);
4428 415 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
4429 : {
4430 90 : {
4431 90 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q40 };
4432 90 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4433 90 : if (res) return res;
4434 : }
4435 : }
4436 : break;
4437 : }
4438 28559 : default:;
4439 : }
4440 28559 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
4441 : {
4442 11 : {
4443 11 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q40 };
4444 11 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4445 11 : if (res) return res;
4446 : }
4447 : }
4448 : break;
4449 : }
4450 33259 : default:;
4451 : }
4452 33259 : switch (TREE_CODE (_q31))
4453 : {
4454 37 : CASE_CONVERT:
4455 37 : {
4456 37 : tree _q50 = TREE_OPERAND (_q31, 0);
4457 37 : if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
4458 : {
4459 0 : {
4460 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50 };
4461 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4462 0 : if (res) return res;
4463 : }
4464 : }
4465 : break;
4466 : }
4467 33259 : default:;
4468 : }
4469 33259 : switch (TREE_CODE (_p1))
4470 : {
4471 400 : CASE_CONVERT:
4472 400 : {
4473 400 : tree _q60 = TREE_OPERAND (_p1, 0);
4474 400 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
4475 : {
4476 0 : {
4477 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
4478 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4479 0 : if (res) return res;
4480 : }
4481 : }
4482 400 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
4483 : {
4484 68 : {
4485 68 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q30 };
4486 68 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4487 68 : if (res) return res;
4488 : }
4489 : }
4490 : break;
4491 : }
4492 33191 : default:;
4493 : }
4494 33191 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
4495 : {
4496 0 : {
4497 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
4498 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4499 0 : if (res) return res;
4500 : }
4501 : }
4502 33191 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
4503 : {
4504 0 : {
4505 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q30 };
4506 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4507 0 : if (res) return res;
4508 : }
4509 : }
4510 : break;
4511 : }
4512 : default:;
4513 : }
4514 : }
4515 : }
4516 40860500 : {
4517 40860500 : tree _p1_pops[1];
4518 40860500 : if (tree_nop_convert (_p1, _p1_pops))
4519 : {
4520 3435659 : tree _q30 = _p1_pops[0];
4521 3435659 : switch (TREE_CODE (_q30))
4522 : {
4523 0 : case LSHIFT_EXPR:
4524 0 : {
4525 0 : tree _q40 = TREE_OPERAND (_q30, 0);
4526 0 : tree _q41 = TREE_OPERAND (_q30, 1);
4527 0 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
4528 : {
4529 0 : {
4530 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _p0 };
4531 0 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR);
4532 0 : if (res) return res;
4533 : }
4534 : }
4535 : break;
4536 : }
4537 : default:;
4538 : }
4539 : }
4540 : }
4541 40860500 : switch (TREE_CODE (_p0))
4542 : {
4543 5212 : case LSHIFT_EXPR:
4544 5212 : {
4545 5212 : tree _q20 = TREE_OPERAND (_p0, 0);
4546 5212 : tree _q21 = TREE_OPERAND (_p0, 1);
4547 5212 : switch (TREE_CODE (_p1))
4548 : {
4549 35 : CASE_CONVERT:
4550 35 : {
4551 35 : tree _q50 = TREE_OPERAND (_p1, 0);
4552 35 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4553 : {
4554 4 : {
4555 4 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4556 4 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR);
4557 4 : if (res) return res;
4558 : }
4559 : }
4560 : break;
4561 : }
4562 5211 : default:;
4563 : }
4564 5211 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
4565 : {
4566 27 : {
4567 27 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4568 27 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR);
4569 27 : if (res) return res;
4570 : }
4571 : }
4572 5207 : if (tree_zero_one_valued_p (_q20))
4573 : {
4574 484 : switch (TREE_CODE (_q21))
4575 : {
4576 120 : case INTEGER_CST:
4577 120 : {
4578 120 : if (integer_zerop (_p1))
4579 : {
4580 5 : {
4581 5 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4582 5 : if (tree_fits_shwi_p (captures[1])
4583 5 : && tree_to_shwi (captures[1]) > 0
4584 10 : && tree_to_shwi (captures[1]) < TYPE_PRECISION (TREE_TYPE (captures[0]))
4585 : )
4586 : {
4587 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1501;
4588 5 : {
4589 5 : tree res_op0;
4590 5 : res_op0 = captures[0];
4591 5 : tree _r;
4592 5 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4593 5 : if (TREE_SIDE_EFFECTS (captures[1]))
4594 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4595 5 : if (TREE_SIDE_EFFECTS (captures[2]))
4596 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4597 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 970, __FILE__, __LINE__, true);
4598 5 : return _r;
4599 : }
4600 0 : next_after_fail1501:;
4601 : }
4602 : }
4603 : }
4604 : break;
4605 : }
4606 : default:;
4607 : }
4608 : }
4609 : break;
4610 : }
4611 40860490 : default:;
4612 : }
4613 40860490 : switch (TREE_CODE (_p1))
4614 : {
4615 268 : case LSHIFT_EXPR:
4616 268 : {
4617 268 : tree _q30 = TREE_OPERAND (_p1, 0);
4618 268 : tree _q31 = TREE_OPERAND (_p1, 1);
4619 268 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
4620 : {
4621 0 : {
4622 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
4623 0 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR);
4624 0 : if (res) return res;
4625 : }
4626 : }
4627 : break;
4628 : }
4629 40860490 : default:;
4630 : }
4631 40860490 : switch (TREE_CODE (_p0))
4632 : {
4633 155 : case VIEW_CONVERT_EXPR:
4634 155 : {
4635 155 : tree _q20 = TREE_OPERAND (_p0, 0);
4636 155 : if (tree_zero_one_valued_p (_q20))
4637 : {
4638 0 : if (integer_zerop (_p1))
4639 : {
4640 0 : {
4641 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
4642 0 : tree res = generic_simplify_210 (loc, type, _p0, _p1, captures, NE_EXPR);
4643 0 : if (res) return res;
4644 : }
4645 : }
4646 : }
4647 : break;
4648 : }
4649 95088 : case MULT_EXPR:
4650 95088 : {
4651 95088 : tree _q20 = TREE_OPERAND (_p0, 0);
4652 95088 : tree _q21 = TREE_OPERAND (_p0, 1);
4653 95088 : switch (TREE_CODE (_p1))
4654 : {
4655 2890 : case MULT_EXPR:
4656 2890 : {
4657 2890 : tree _q50 = TREE_OPERAND (_p1, 0);
4658 2890 : tree _q51 = TREE_OPERAND (_p1, 1);
4659 2890 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4660 : {
4661 1635 : {
4662 1635 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4663 1635 : tree res = generic_simplify_211 (loc, type, _p0, _p1, captures, NE_EXPR);
4664 1635 : if (res) return res;
4665 : }
4666 : }
4667 2886 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4668 : {
4669 53 : {
4670 53 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
4671 53 : tree res = generic_simplify_211 (loc, type, _p0, _p1, captures, NE_EXPR);
4672 53 : if (res) return res;
4673 : }
4674 : }
4675 2886 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4676 : {
4677 22 : {
4678 22 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
4679 22 : tree res = generic_simplify_211 (loc, type, _p0, _p1, captures, NE_EXPR);
4680 22 : if (res) return res;
4681 : }
4682 : }
4683 2886 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4684 : {
4685 257 : {
4686 257 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
4687 257 : tree res = generic_simplify_211 (loc, type, _p0, _p1, captures, NE_EXPR);
4688 257 : if (res) return res;
4689 : }
4690 : }
4691 : break;
4692 : }
4693 95084 : default:;
4694 : }
4695 95084 : switch (TREE_CODE (_q21))
4696 : {
4697 77554 : case INTEGER_CST:
4698 77554 : {
4699 77554 : switch (TREE_CODE (_p1))
4700 : {
4701 2031 : case MULT_EXPR:
4702 2031 : {
4703 2031 : tree _q50 = TREE_OPERAND (_p1, 0);
4704 2031 : tree _q51 = TREE_OPERAND (_p1, 1);
4705 2031 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4706 : {
4707 1106 : {
4708 1106 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4709 1106 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR);
4710 1106 : if (res) return res;
4711 : }
4712 : }
4713 : break;
4714 : }
4715 : default:;
4716 : }
4717 : break;
4718 : }
4719 : default:;
4720 : }
4721 : break;
4722 : }
4723 2057 : case EXACT_DIV_EXPR:
4724 2057 : {
4725 2057 : tree _q20 = TREE_OPERAND (_p0, 0);
4726 2057 : tree _q21 = TREE_OPERAND (_p0, 1);
4727 2057 : switch (TREE_CODE (_q21))
4728 : {
4729 2057 : case INTEGER_CST:
4730 2057 : {
4731 2057 : switch (TREE_CODE (_p1))
4732 : {
4733 22 : case EXACT_DIV_EXPR:
4734 22 : {
4735 22 : tree _q50 = TREE_OPERAND (_p1, 0);
4736 22 : tree _q51 = TREE_OPERAND (_p1, 1);
4737 22 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4738 : {
4739 12 : {
4740 12 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
4741 12 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
4742 12 : if (res) return res;
4743 : }
4744 : }
4745 : break;
4746 : }
4747 : default:;
4748 : }
4749 : break;
4750 : }
4751 : default:;
4752 : }
4753 : break;
4754 : }
4755 11310 : case TRUNC_DIV_EXPR:
4756 11310 : {
4757 11310 : tree _q20 = TREE_OPERAND (_p0, 0);
4758 11310 : tree _q21 = TREE_OPERAND (_p0, 1);
4759 11310 : switch (TREE_CODE (_q21))
4760 : {
4761 8559 : case INTEGER_CST:
4762 8559 : {
4763 8559 : switch (TREE_CODE (_p1))
4764 : {
4765 2431 : case INTEGER_CST:
4766 2431 : {
4767 2431 : {
4768 2431 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
4769 2431 : tree res = generic_simplify_213 (loc, type, _p0, _p1, captures, NE_EXPR);
4770 2431 : if (res) return res;
4771 : }
4772 326 : break;
4773 : }
4774 : default:;
4775 : }
4776 : break;
4777 : }
4778 : default:;
4779 : }
4780 : break;
4781 : }
4782 21001 : case RSHIFT_EXPR:
4783 21001 : {
4784 21001 : tree _q20 = TREE_OPERAND (_p0, 0);
4785 21001 : tree _q21 = TREE_OPERAND (_p0, 1);
4786 21001 : switch (TREE_CODE (_q21))
4787 : {
4788 18658 : case INTEGER_CST:
4789 18658 : {
4790 18658 : if (integer_zerop (_p1))
4791 : {
4792 7721 : {
4793 7721 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
4794 7721 : tree res = generic_simplify_214 (loc, type, _p0, _p1, captures, NE_EXPR, LT_EXPR);
4795 7721 : if (res) return res;
4796 : }
4797 : }
4798 : break;
4799 : }
4800 : default:;
4801 : }
4802 : break;
4803 : }
4804 1565423 : case PLUS_EXPR:
4805 1565423 : {
4806 1565423 : tree _q20 = TREE_OPERAND (_p0, 0);
4807 1565423 : tree _q21 = TREE_OPERAND (_p0, 1);
4808 1565423 : switch (TREE_CODE (_p1))
4809 : {
4810 189505 : case PLUS_EXPR:
4811 189505 : {
4812 189505 : tree _q50 = TREE_OPERAND (_p1, 0);
4813 189505 : tree _q51 = TREE_OPERAND (_p1, 1);
4814 189505 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4815 : {
4816 869 : {
4817 869 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4818 1738 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4819 1709 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
4820 757 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
4821 : )
4822 : {
4823 840 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1502;
4824 840 : {
4825 840 : tree res_op0;
4826 840 : res_op0 = captures[0];
4827 840 : tree res_op1;
4828 840 : res_op1 = captures[2];
4829 840 : tree _r;
4830 840 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
4831 840 : if (TREE_SIDE_EFFECTS (captures[1]))
4832 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4833 840 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 903, __FILE__, __LINE__, true);
4834 840 : return _r;
4835 : }
4836 0 : next_after_fail1502:;
4837 : }
4838 : }
4839 : }
4840 188665 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4841 : {
4842 0 : {
4843 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
4844 0 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4845 0 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
4846 0 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
4847 : )
4848 : {
4849 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1503;
4850 0 : {
4851 0 : tree res_op0;
4852 0 : res_op0 = captures[0];
4853 0 : tree res_op1;
4854 0 : res_op1 = captures[2];
4855 0 : tree _r;
4856 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
4857 0 : if (TREE_SIDE_EFFECTS (captures[1]))
4858 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4859 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 903, __FILE__, __LINE__, true);
4860 0 : return _r;
4861 : }
4862 0 : next_after_fail1503:;
4863 : }
4864 : }
4865 : }
4866 188665 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4867 : {
4868 132 : {
4869 132 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
4870 264 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4871 264 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
4872 132 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
4873 : )
4874 : {
4875 132 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1504;
4876 132 : {
4877 132 : tree res_op0;
4878 132 : res_op0 = captures[0];
4879 132 : tree res_op1;
4880 132 : res_op1 = captures[2];
4881 132 : tree _r;
4882 132 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
4883 132 : if (TREE_SIDE_EFFECTS (captures[1]))
4884 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4885 132 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 903, __FILE__, __LINE__, true);
4886 132 : return _r;
4887 : }
4888 0 : next_after_fail1504:;
4889 : }
4890 : }
4891 : }
4892 188533 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4893 : {
4894 106899 : {
4895 106899 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
4896 213798 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4897 213777 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
4898 106878 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
4899 : )
4900 : {
4901 106878 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1505;
4902 106878 : {
4903 106878 : tree res_op0;
4904 106878 : res_op0 = captures[0];
4905 106878 : tree res_op1;
4906 106878 : res_op1 = captures[2];
4907 106878 : tree _r;
4908 106878 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
4909 106878 : if (TREE_SIDE_EFFECTS (captures[1]))
4910 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4911 106878 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 903, __FILE__, __LINE__, true);
4912 106878 : return _r;
4913 : }
4914 0 : next_after_fail1505:;
4915 : }
4916 : }
4917 : }
4918 : break;
4919 : }
4920 1457573 : default:;
4921 : }
4922 1457573 : switch (TREE_CODE (_q21))
4923 : {
4924 747 : CASE_CONVERT:
4925 747 : {
4926 747 : tree _q40 = TREE_OPERAND (_q21, 0);
4927 747 : switch (TREE_CODE (_p1))
4928 : {
4929 88 : CASE_CONVERT:
4930 88 : {
4931 88 : tree _q60 = TREE_OPERAND (_p1, 0);
4932 88 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
4933 : {
4934 0 : {
4935 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40 };
4936 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4937 0 : if (res) return res;
4938 : }
4939 : }
4940 : break;
4941 : }
4942 : default:;
4943 : }
4944 : break;
4945 : }
4946 1457573 : default:;
4947 : }
4948 1457573 : switch (TREE_CODE (_q20))
4949 : {
4950 147702 : CASE_CONVERT:
4951 147702 : {
4952 147702 : tree _q30 = TREE_OPERAND (_q20, 0);
4953 147702 : switch (TREE_CODE (_p1))
4954 : {
4955 3706 : CASE_CONVERT:
4956 3706 : {
4957 3706 : tree _q60 = TREE_OPERAND (_p1, 0);
4958 3706 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
4959 : {
4960 400 : {
4961 400 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q30 };
4962 400 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4963 400 : if (res) return res;
4964 : }
4965 : }
4966 : break;
4967 : }
4968 147302 : default:;
4969 : }
4970 147302 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
4971 : {
4972 0 : {
4973 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q30 };
4974 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4975 0 : if (res) return res;
4976 : }
4977 : }
4978 : break;
4979 : }
4980 1457173 : default:;
4981 : }
4982 1457173 : switch (TREE_CODE (_q21))
4983 : {
4984 747 : CASE_CONVERT:
4985 747 : {
4986 747 : tree _q40 = TREE_OPERAND (_q21, 0);
4987 747 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
4988 : {
4989 0 : {
4990 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40 };
4991 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4992 0 : if (res) return res;
4993 : }
4994 : }
4995 : break;
4996 : }
4997 1457173 : default:;
4998 : }
4999 1457173 : switch (TREE_CODE (_p1))
5000 : {
5001 43449 : CASE_CONVERT:
5002 43449 : {
5003 43449 : tree _q50 = TREE_OPERAND (_p1, 0);
5004 43449 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5005 : {
5006 0 : {
5007 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
5008 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
5009 0 : if (res) return res;
5010 : }
5011 : }
5012 43449 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5013 : {
5014 0 : {
5015 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q20 };
5016 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
5017 0 : if (res) return res;
5018 : }
5019 : }
5020 : break;
5021 : }
5022 1457173 : default:;
5023 : }
5024 1457173 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5025 : {
5026 108336 : {
5027 108336 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
5028 108336 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
5029 108336 : if (res) return res;
5030 : }
5031 : }
5032 1349541 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5033 : {
5034 19209 : {
5035 19209 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q20 };
5036 19209 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
5037 19209 : if (res) return res;
5038 : }
5039 : }
5040 : break;
5041 : }
5042 543636 : case POINTER_PLUS_EXPR:
5043 543636 : {
5044 543636 : tree _q20 = TREE_OPERAND (_p0, 0);
5045 543636 : tree _q21 = TREE_OPERAND (_p0, 1);
5046 543636 : switch (TREE_CODE (_p1))
5047 : {
5048 34748 : case POINTER_PLUS_EXPR:
5049 34748 : {
5050 34748 : tree _q50 = TREE_OPERAND (_p1, 0);
5051 34748 : tree _q51 = TREE_OPERAND (_p1, 1);
5052 34748 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5053 : {
5054 8502 : {
5055 8502 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5056 8502 : tree res = generic_simplify_215 (loc, type, _p0, _p1, captures, NE_EXPR);
5057 8502 : if (res) return res;
5058 : }
5059 : }
5060 : break;
5061 : }
5062 535134 : default:;
5063 : }
5064 535134 : switch (TREE_CODE (_q20))
5065 : {
5066 77621 : CASE_CONVERT:
5067 77621 : {
5068 77621 : tree _q30 = TREE_OPERAND (_q20, 0);
5069 77621 : switch (TREE_CODE (_p1))
5070 : {
5071 95 : CASE_CONVERT:
5072 95 : {
5073 95 : tree _q60 = TREE_OPERAND (_p1, 0);
5074 95 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
5075 : {
5076 0 : {
5077 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q30, _q21 };
5078 0 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, NE_EXPR);
5079 0 : if (res) return res;
5080 : }
5081 : }
5082 : break;
5083 : }
5084 77621 : default:;
5085 : }
5086 77621 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
5087 : {
5088 74 : {
5089 74 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q30, _q21 };
5090 74 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, NE_EXPR);
5091 74 : if (res) return res;
5092 : }
5093 : }
5094 : break;
5095 : }
5096 535060 : default:;
5097 : }
5098 535060 : switch (TREE_CODE (_p1))
5099 : {
5100 3566 : CASE_CONVERT:
5101 3566 : {
5102 3566 : tree _q50 = TREE_OPERAND (_p1, 0);
5103 3566 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5104 : {
5105 0 : {
5106 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
5107 0 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, NE_EXPR);
5108 0 : if (res) return res;
5109 : }
5110 : }
5111 : break;
5112 : }
5113 535060 : default:;
5114 : }
5115 535060 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5116 : {
5117 10770 : {
5118 10770 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
5119 10770 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, NE_EXPR);
5120 10770 : if (res) return res;
5121 : }
5122 : }
5123 : break;
5124 : }
5125 106028 : case MINUS_EXPR:
5126 106028 : {
5127 106028 : tree _q20 = TREE_OPERAND (_p0, 0);
5128 106028 : tree _q21 = TREE_OPERAND (_p0, 1);
5129 106028 : switch (TREE_CODE (_p1))
5130 : {
5131 5881 : case MINUS_EXPR:
5132 5881 : {
5133 5881 : tree _q50 = TREE_OPERAND (_p1, 0);
5134 5881 : tree _q51 = TREE_OPERAND (_p1, 1);
5135 5881 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5136 : {
5137 173 : {
5138 173 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5139 346 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
5140 176 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5141 0 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
5142 : )
5143 : {
5144 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1506;
5145 3 : {
5146 3 : tree res_op0;
5147 3 : res_op0 = captures[0];
5148 3 : tree res_op1;
5149 3 : res_op1 = captures[2];
5150 3 : tree _r;
5151 3 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
5152 3 : if (TREE_SIDE_EFFECTS (captures[1]))
5153 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5154 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 904, __FILE__, __LINE__, true);
5155 3 : return _r;
5156 : }
5157 0 : next_after_fail1506:;
5158 : }
5159 : }
5160 : }
5161 5878 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5162 : {
5163 169 : {
5164 169 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5165 338 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
5166 169 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
5167 0 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1])))
5168 : )
5169 : {
5170 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1507;
5171 0 : {
5172 0 : tree res_op0;
5173 0 : res_op0 = captures[2];
5174 0 : tree res_op1;
5175 0 : res_op1 = captures[1];
5176 0 : tree _r;
5177 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
5178 0 : if (TREE_SIDE_EFFECTS (captures[0]))
5179 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
5180 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 905, __FILE__, __LINE__, true);
5181 0 : return _r;
5182 : }
5183 0 : next_after_fail1507:;
5184 : }
5185 : }
5186 : }
5187 : break;
5188 : }
5189 106025 : default:;
5190 : }
5191 106025 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5192 : {
5193 1748 : {
5194 1748 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
5195 1748 : tree res = generic_simplify_217 (loc, type, _p0, _p1, captures, NE_EXPR);
5196 1748 : if (res) return res;
5197 : }
5198 : }
5199 : break;
5200 : }
5201 26760 : case POINTER_DIFF_EXPR:
5202 26760 : {
5203 26760 : tree _q20 = TREE_OPERAND (_p0, 0);
5204 26760 : tree _q21 = TREE_OPERAND (_p0, 1);
5205 26760 : switch (TREE_CODE (_p1))
5206 : {
5207 2269 : case POINTER_DIFF_EXPR:
5208 2269 : {
5209 2269 : tree _q50 = TREE_OPERAND (_p1, 0);
5210 2269 : tree _q51 = TREE_OPERAND (_p1, 1);
5211 2269 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5212 : {
5213 0 : {
5214 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
5215 0 : tree res = generic_simplify_218 (loc, type, _p0, _p1, captures, NE_EXPR);
5216 0 : if (res) return res;
5217 : }
5218 : }
5219 2269 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5220 : {
5221 0 : {
5222 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
5223 0 : tree res = generic_simplify_219 (loc, type, _p0, _p1, captures, NE_EXPR);
5224 0 : if (res) return res;
5225 : }
5226 : }
5227 : break;
5228 : }
5229 : default:;
5230 : }
5231 : break;
5232 : }
5233 40602053 : default:;
5234 : }
5235 40602053 : {
5236 40602053 : tree _p0_pops[1];
5237 40602053 : if (tree_logical_inverted_value (_p0, _p0_pops))
5238 : {
5239 728540 : tree _q20 = _p0_pops[0];
5240 728540 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5241 : {
5242 24 : if (tree_truth_valued_p (_p1))
5243 : {
5244 0 : {
5245 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
5246 0 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
5247 0 : if (res) return res;
5248 : }
5249 : }
5250 : }
5251 : }
5252 : }
5253 40602053 : if (tree_truth_valued_p (_p0))
5254 : {
5255 6394731 : {
5256 6394731 : tree _p1_pops[1];
5257 6394731 : if (tree_logical_inverted_value (_p1, _p1_pops))
5258 : {
5259 1139 : tree _q30 = _p1_pops[0];
5260 1139 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5261 : {
5262 0 : {
5263 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
5264 0 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
5265 0 : if (res) return res;
5266 : }
5267 : }
5268 : }
5269 : }
5270 : }
5271 40602053 : switch (TREE_CODE (_p1))
5272 : {
5273 122930 : case PLUS_EXPR:
5274 122930 : {
5275 122930 : tree _q30 = TREE_OPERAND (_p1, 0);
5276 122930 : tree _q31 = TREE_OPERAND (_p1, 1);
5277 122930 : switch (TREE_CODE (_q31))
5278 : {
5279 342 : CASE_CONVERT:
5280 342 : {
5281 342 : tree _q50 = TREE_OPERAND (_q31, 0);
5282 342 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
5283 : {
5284 0 : {
5285 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0 };
5286 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
5287 0 : if (res) return res;
5288 : }
5289 : }
5290 : break;
5291 : }
5292 122930 : default:;
5293 : }
5294 122930 : switch (TREE_CODE (_q30))
5295 : {
5296 6038 : CASE_CONVERT:
5297 6038 : {
5298 6038 : tree _q40 = TREE_OPERAND (_q30, 0);
5299 6038 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
5300 : {
5301 0 : {
5302 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q31, _p0 };
5303 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
5304 0 : if (res) return res;
5305 : }
5306 : }
5307 : break;
5308 : }
5309 122930 : default:;
5310 : }
5311 122930 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5312 : {
5313 0 : {
5314 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0 };
5315 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
5316 0 : if (res) return res;
5317 : }
5318 : }
5319 122930 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5320 : {
5321 8 : {
5322 8 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q31, _p0 };
5323 8 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
5324 8 : if (res) return res;
5325 : }
5326 : }
5327 : break;
5328 : }
5329 40602045 : default:;
5330 : }
5331 40602045 : {
5332 40602045 : tree _p1_pops[1];
5333 40602045 : if (tree_nop_convert (_p1, _p1_pops))
5334 : {
5335 3435257 : tree _q30 = _p1_pops[0];
5336 3435257 : switch (TREE_CODE (_q30))
5337 : {
5338 1103 : case PLUS_EXPR:
5339 1103 : {
5340 1103 : tree _q40 = TREE_OPERAND (_q30, 0);
5341 1103 : tree _q41 = TREE_OPERAND (_q30, 1);
5342 1103 : switch (TREE_CODE (_q41))
5343 : {
5344 3 : CASE_CONVERT:
5345 3 : {
5346 3 : tree _q60 = TREE_OPERAND (_q41, 0);
5347 3 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
5348 : {
5349 0 : {
5350 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0 };
5351 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
5352 0 : if (res) return res;
5353 : }
5354 : }
5355 : break;
5356 : }
5357 1103 : default:;
5358 : }
5359 1103 : switch (TREE_CODE (_q40))
5360 : {
5361 547 : CASE_CONVERT:
5362 547 : {
5363 547 : tree _q50 = TREE_OPERAND (_q40, 0);
5364 547 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
5365 : {
5366 0 : {
5367 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q41, _p0 };
5368 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
5369 0 : if (res) return res;
5370 : }
5371 : }
5372 : break;
5373 : }
5374 1103 : default:;
5375 : }
5376 1103 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
5377 : {
5378 0 : {
5379 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0 };
5380 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
5381 0 : if (res) return res;
5382 : }
5383 : }
5384 1103 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
5385 : {
5386 0 : {
5387 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q41, _p0 };
5388 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
5389 0 : if (res) return res;
5390 : }
5391 : }
5392 : break;
5393 : }
5394 : default:;
5395 : }
5396 : }
5397 : }
5398 40602045 : switch (TREE_CODE (_p0))
5399 : {
5400 8297328 : CASE_CONVERT:
5401 8297328 : {
5402 8297328 : tree _q20 = TREE_OPERAND (_p0, 0);
5403 8297328 : switch (TREE_CODE (_p1))
5404 : {
5405 179 : case POINTER_PLUS_EXPR:
5406 179 : {
5407 179 : tree _q40 = TREE_OPERAND (_p1, 0);
5408 179 : tree _q41 = TREE_OPERAND (_p1, 1);
5409 179 : switch (TREE_CODE (_q40))
5410 : {
5411 48 : CASE_CONVERT:
5412 48 : {
5413 48 : tree _q50 = TREE_OPERAND (_q40, 0);
5414 48 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5415 : {
5416 0 : {
5417 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q20, _q41 };
5418 0 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, NE_EXPR);
5419 0 : if (res) return res;
5420 : }
5421 : }
5422 : break;
5423 : }
5424 179 : default:;
5425 : }
5426 179 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
5427 : {
5428 0 : {
5429 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q20, _q41 };
5430 0 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, NE_EXPR);
5431 0 : if (res) return res;
5432 : }
5433 : }
5434 : break;
5435 : }
5436 8297328 : default:;
5437 : }
5438 8297328 : {
5439 8297328 : tree _p1_pops[1];
5440 8297328 : if (tree_nop_convert (_p1, _p1_pops))
5441 : {
5442 3062847 : tree _q40 = _p1_pops[0];
5443 3062847 : switch (TREE_CODE (_q40))
5444 : {
5445 50 : case POINTER_PLUS_EXPR:
5446 50 : {
5447 50 : tree _q50 = TREE_OPERAND (_q40, 0);
5448 50 : tree _q51 = TREE_OPERAND (_q40, 1);
5449 50 : switch (TREE_CODE (_q50))
5450 : {
5451 8 : CASE_CONVERT:
5452 8 : {
5453 8 : tree _q60 = TREE_OPERAND (_q50, 0);
5454 8 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
5455 : {
5456 0 : {
5457 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q20, _q51 };
5458 0 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, NE_EXPR);
5459 0 : if (res) return res;
5460 : }
5461 : }
5462 : break;
5463 : }
5464 50 : default:;
5465 : }
5466 50 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5467 : {
5468 0 : {
5469 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q20, _q51 };
5470 0 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, NE_EXPR);
5471 0 : if (res) return res;
5472 : }
5473 : }
5474 : break;
5475 : }
5476 : default:;
5477 : }
5478 : }
5479 : }
5480 8297328 : break;
5481 : }
5482 40602045 : default:;
5483 : }
5484 40602045 : {
5485 40602045 : tree _p0_pops[1];
5486 40602045 : if (tree_nop_convert (_p0, _p0_pops))
5487 : {
5488 4882338 : tree _q20 = _p0_pops[0];
5489 4882338 : switch (TREE_CODE (_q20))
5490 : {
5491 187 : case POINTER_PLUS_EXPR:
5492 187 : {
5493 187 : tree _q30 = TREE_OPERAND (_q20, 0);
5494 187 : tree _q31 = TREE_OPERAND (_q20, 1);
5495 187 : switch (TREE_CODE (_q30))
5496 : {
5497 52 : CASE_CONVERT:
5498 52 : {
5499 52 : tree _q40 = TREE_OPERAND (_q30, 0);
5500 52 : switch (TREE_CODE (_p1))
5501 : {
5502 36 : CASE_CONVERT:
5503 36 : {
5504 36 : tree _q70 = TREE_OPERAND (_p1, 0);
5505 36 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
5506 : {
5507 0 : {
5508 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31 };
5509 0 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, NE_EXPR);
5510 0 : if (res) return res;
5511 : }
5512 : }
5513 : break;
5514 : }
5515 52 : default:;
5516 : }
5517 52 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
5518 : {
5519 0 : {
5520 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31 };
5521 0 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, NE_EXPR);
5522 0 : if (res) return res;
5523 : }
5524 : }
5525 : break;
5526 : }
5527 187 : default:;
5528 : }
5529 187 : switch (TREE_CODE (_p1))
5530 : {
5531 52 : CASE_CONVERT:
5532 52 : {
5533 52 : tree _q60 = TREE_OPERAND (_p1, 0);
5534 52 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
5535 : {
5536 0 : {
5537 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
5538 0 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, NE_EXPR);
5539 0 : if (res) return res;
5540 : }
5541 : }
5542 : break;
5543 : }
5544 187 : default:;
5545 : }
5546 187 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
5547 : {
5548 0 : {
5549 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
5550 0 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, NE_EXPR);
5551 0 : if (res) return res;
5552 : }
5553 : }
5554 : break;
5555 : }
5556 : default:;
5557 : }
5558 : }
5559 : }
5560 40602045 : switch (TREE_CODE (_p1))
5561 : {
5562 30211 : case POINTER_PLUS_EXPR:
5563 30211 : {
5564 30211 : tree _q30 = TREE_OPERAND (_p1, 0);
5565 30211 : tree _q31 = TREE_OPERAND (_p1, 1);
5566 30211 : switch (TREE_CODE (_q30))
5567 : {
5568 2724 : CASE_CONVERT:
5569 2724 : {
5570 2724 : tree _q40 = TREE_OPERAND (_q30, 0);
5571 2724 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
5572 : {
5573 0 : {
5574 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _p0, _q31 };
5575 0 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, NE_EXPR);
5576 0 : if (res) return res;
5577 : }
5578 : }
5579 : break;
5580 : }
5581 30211 : default:;
5582 : }
5583 30211 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5584 : {
5585 0 : {
5586 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _p0, _q31 };
5587 0 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, NE_EXPR);
5588 0 : if (res) return res;
5589 : }
5590 : }
5591 : break;
5592 : }
5593 40602045 : default:;
5594 : }
5595 40602045 : {
5596 40602045 : tree _p1_pops[1];
5597 40602045 : if (tree_nop_convert (_p1, _p1_pops))
5598 : {
5599 3435257 : tree _q30 = _p1_pops[0];
5600 3435257 : switch (TREE_CODE (_q30))
5601 : {
5602 389 : case POINTER_PLUS_EXPR:
5603 389 : {
5604 389 : tree _q40 = TREE_OPERAND (_q30, 0);
5605 389 : tree _q41 = TREE_OPERAND (_q30, 1);
5606 389 : switch (TREE_CODE (_q40))
5607 : {
5608 8 : CASE_CONVERT:
5609 8 : {
5610 8 : tree _q50 = TREE_OPERAND (_q40, 0);
5611 8 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
5612 : {
5613 0 : {
5614 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _p0, _q41 };
5615 0 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, NE_EXPR);
5616 0 : if (res) return res;
5617 : }
5618 : }
5619 : break;
5620 : }
5621 389 : default:;
5622 : }
5623 389 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
5624 : {
5625 0 : {
5626 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _p0, _q41 };
5627 0 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, NE_EXPR);
5628 0 : if (res) return res;
5629 : }
5630 : }
5631 : break;
5632 : }
5633 : default:;
5634 : }
5635 : }
5636 : }
5637 40602045 : switch (TREE_CODE (_p0))
5638 : {
5639 524290 : case POINTER_PLUS_EXPR:
5640 524290 : {
5641 524290 : tree _q20 = TREE_OPERAND (_p0, 0);
5642 524290 : tree _q21 = TREE_OPERAND (_p0, 1);
5643 524290 : switch (TREE_CODE (_p1))
5644 : {
5645 45280 : case ADDR_EXPR:
5646 45280 : {
5647 45280 : {
5648 45280 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5649 45280 : tree res = generic_simplify_221 (loc, type, _p0, _p1, captures, NE_EXPR);
5650 45280 : if (res) return res;
5651 : }
5652 33835 : break;
5653 : }
5654 512845 : default:;
5655 : }
5656 512845 : switch (TREE_CODE (_q20))
5657 : {
5658 4895 : case ADDR_EXPR:
5659 4895 : {
5660 4895 : switch (TREE_CODE (_p1))
5661 : {
5662 265 : case POINTER_PLUS_EXPR:
5663 265 : {
5664 265 : tree _q50 = TREE_OPERAND (_p1, 0);
5665 265 : tree _q51 = TREE_OPERAND (_p1, 1);
5666 265 : switch (TREE_CODE (_q50))
5667 : {
5668 0 : case ADDR_EXPR:
5669 0 : {
5670 0 : {
5671 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51 };
5672 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, NE_EXPR);
5673 0 : if (res) return res;
5674 : }
5675 0 : break;
5676 : }
5677 : default:;
5678 : }
5679 : break;
5680 : }
5681 : default:;
5682 : }
5683 : break;
5684 : }
5685 : default:;
5686 : }
5687 : break;
5688 : }
5689 198534 : case ADDR_EXPR:
5690 198534 : {
5691 198534 : switch (TREE_CODE (_p1))
5692 : {
5693 0 : case POINTER_PLUS_EXPR:
5694 0 : {
5695 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5696 0 : tree _q31 = TREE_OPERAND (_p1, 1);
5697 0 : {
5698 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
5699 0 : tree res = generic_simplify_221 (loc, type, _p0, _p1, captures, NE_EXPR);
5700 0 : if (res) return res;
5701 : }
5702 0 : break;
5703 : }
5704 : default:;
5705 : }
5706 : break;
5707 : }
5708 40590600 : default:;
5709 : }
5710 40590600 : switch (TREE_CODE (_p1))
5711 : {
5712 30836 : case MINUS_EXPR:
5713 30836 : {
5714 30836 : tree _q30 = TREE_OPERAND (_p1, 0);
5715 30836 : tree _q31 = TREE_OPERAND (_p1, 1);
5716 30836 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5717 : {
5718 0 : {
5719 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
5720 0 : tree res = generic_simplify_217 (loc, type, _p0, _p1, captures, NE_EXPR);
5721 0 : if (res) return res;
5722 : }
5723 : }
5724 : break;
5725 : }
5726 40590600 : default:;
5727 : }
5728 40590600 : switch (TREE_CODE (_p0))
5729 : {
5730 9205 : case TRUNC_DIV_EXPR:
5731 9205 : {
5732 9205 : tree _q20 = TREE_OPERAND (_p0, 0);
5733 9205 : tree _q21 = TREE_OPERAND (_p0, 1);
5734 9205 : if (integer_zerop (_p1))
5735 : {
5736 1037 : {
5737 1037 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5738 1037 : tree res = generic_simplify_223 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR);
5739 1037 : if (res) return res;
5740 : }
5741 : }
5742 : break;
5743 : }
5744 8297328 : CASE_CONVERT:
5745 8297328 : {
5746 8297328 : tree _q20 = TREE_OPERAND (_p0, 0);
5747 8297328 : switch (TREE_CODE (_p1))
5748 : {
5749 3203984 : CASE_CONVERT:
5750 3203984 : {
5751 3203984 : tree _q40 = TREE_OPERAND (_p1, 0);
5752 3203984 : switch (TREE_CODE (_q40))
5753 : {
5754 0 : case MINUS_EXPR:
5755 0 : {
5756 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5757 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5758 0 : switch (TREE_CODE (_q50))
5759 : {
5760 0 : case INTEGER_CST:
5761 0 : {
5762 0 : switch (TREE_CODE (_q51))
5763 : {
5764 0 : CASE_CONVERT:
5765 0 : {
5766 0 : tree _q70 = TREE_OPERAND (_q51, 0);
5767 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
5768 : {
5769 0 : {
5770 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
5771 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5772 0 : if (res) return res;
5773 : }
5774 : }
5775 : break;
5776 : }
5777 : default:;
5778 : }
5779 : break;
5780 : }
5781 : default:;
5782 : }
5783 : break;
5784 : }
5785 : default:;
5786 : }
5787 : break;
5788 : }
5789 8297328 : default:;
5790 : }
5791 8297328 : switch (TREE_CODE (_q20))
5792 : {
5793 99 : case MINUS_EXPR:
5794 99 : {
5795 99 : tree _q30 = TREE_OPERAND (_q20, 0);
5796 99 : tree _q31 = TREE_OPERAND (_q20, 1);
5797 99 : switch (TREE_CODE (_q30))
5798 : {
5799 49 : case INTEGER_CST:
5800 49 : {
5801 49 : switch (TREE_CODE (_q31))
5802 : {
5803 0 : CASE_CONVERT:
5804 0 : {
5805 0 : tree _q50 = TREE_OPERAND (_q31, 0);
5806 0 : switch (TREE_CODE (_p1))
5807 : {
5808 0 : CASE_CONVERT:
5809 0 : {
5810 0 : tree _q70 = TREE_OPERAND (_p1, 0);
5811 0 : if ((_q70 == _q50 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q50, 0) && types_match (_q70, _q50)))
5812 : {
5813 0 : {
5814 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
5815 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5816 0 : if (res) return res;
5817 : }
5818 : }
5819 : break;
5820 : }
5821 0 : default:;
5822 : }
5823 0 : if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
5824 : {
5825 0 : {
5826 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
5827 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5828 0 : if (res) return res;
5829 : }
5830 : }
5831 : break;
5832 : }
5833 49 : default:;
5834 : }
5835 49 : switch (TREE_CODE (_p1))
5836 : {
5837 0 : CASE_CONVERT:
5838 0 : {
5839 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5840 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
5841 : {
5842 0 : {
5843 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q30 };
5844 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5845 0 : if (res) return res;
5846 : }
5847 : }
5848 : break;
5849 : }
5850 49 : default:;
5851 : }
5852 49 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
5853 : {
5854 0 : {
5855 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q30 };
5856 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5857 0 : if (res) return res;
5858 : }
5859 : }
5860 : break;
5861 : }
5862 : default:;
5863 : }
5864 : break;
5865 : }
5866 8297328 : default:;
5867 : }
5868 8297328 : switch (TREE_CODE (_p1))
5869 : {
5870 3203984 : CASE_CONVERT:
5871 3203984 : {
5872 3203984 : tree _q40 = TREE_OPERAND (_p1, 0);
5873 3203984 : switch (TREE_CODE (_q40))
5874 : {
5875 0 : case MINUS_EXPR:
5876 0 : {
5877 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5878 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5879 0 : switch (TREE_CODE (_q50))
5880 : {
5881 0 : case INTEGER_CST:
5882 0 : {
5883 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5884 : {
5885 0 : {
5886 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
5887 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5888 0 : if (res) return res;
5889 : }
5890 : }
5891 : break;
5892 : }
5893 : default:;
5894 : }
5895 : break;
5896 : }
5897 : default:;
5898 : }
5899 : break;
5900 : }
5901 21676 : case MINUS_EXPR:
5902 21676 : {
5903 21676 : tree _q40 = TREE_OPERAND (_p1, 0);
5904 21676 : tree _q41 = TREE_OPERAND (_p1, 1);
5905 21676 : switch (TREE_CODE (_q40))
5906 : {
5907 401 : case INTEGER_CST:
5908 401 : {
5909 401 : switch (TREE_CODE (_q41))
5910 : {
5911 20 : CASE_CONVERT:
5912 20 : {
5913 20 : tree _q60 = TREE_OPERAND (_q41, 0);
5914 20 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
5915 : {
5916 0 : {
5917 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
5918 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5919 0 : if (res) return res;
5920 : }
5921 : }
5922 : break;
5923 : }
5924 401 : default:;
5925 : }
5926 401 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
5927 : {
5928 0 : {
5929 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
5930 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5931 0 : if (res) return res;
5932 : }
5933 : }
5934 : break;
5935 : }
5936 : default:;
5937 : }
5938 : break;
5939 : }
5940 : default:;
5941 : }
5942 : break;
5943 : }
5944 104317 : case MINUS_EXPR:
5945 104317 : {
5946 104317 : tree _q20 = TREE_OPERAND (_p0, 0);
5947 104317 : tree _q21 = TREE_OPERAND (_p0, 1);
5948 104317 : switch (TREE_CODE (_q20))
5949 : {
5950 2122 : case INTEGER_CST:
5951 2122 : {
5952 2122 : switch (TREE_CODE (_q21))
5953 : {
5954 182 : CASE_CONVERT:
5955 182 : {
5956 182 : tree _q40 = TREE_OPERAND (_q21, 0);
5957 182 : switch (TREE_CODE (_p1))
5958 : {
5959 0 : CASE_CONVERT:
5960 0 : {
5961 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5962 0 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
5963 : {
5964 0 : {
5965 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
5966 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5967 0 : if (res) return res;
5968 : }
5969 : }
5970 : break;
5971 : }
5972 182 : default:;
5973 : }
5974 182 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
5975 : {
5976 0 : {
5977 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
5978 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5979 0 : if (res) return res;
5980 : }
5981 : }
5982 : break;
5983 : }
5984 2122 : default:;
5985 : }
5986 2122 : switch (TREE_CODE (_p1))
5987 : {
5988 306 : CASE_CONVERT:
5989 306 : {
5990 306 : tree _q50 = TREE_OPERAND (_p1, 0);
5991 306 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5992 : {
5993 0 : {
5994 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
5995 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5996 0 : if (res) return res;
5997 : }
5998 : }
5999 : break;
6000 : }
6001 2122 : default:;
6002 : }
6003 2122 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
6004 : {
6005 1 : {
6006 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6007 1 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
6008 1 : if (res) return res;
6009 : }
6010 : }
6011 : break;
6012 : }
6013 : default:;
6014 : }
6015 : break;
6016 : }
6017 40590484 : default:;
6018 : }
6019 40590484 : switch (TREE_CODE (_p1))
6020 : {
6021 3603235 : CASE_CONVERT:
6022 3603235 : {
6023 3603235 : tree _q30 = TREE_OPERAND (_p1, 0);
6024 3603235 : switch (TREE_CODE (_q30))
6025 : {
6026 556 : case MINUS_EXPR:
6027 556 : {
6028 556 : tree _q40 = TREE_OPERAND (_q30, 0);
6029 556 : tree _q41 = TREE_OPERAND (_q30, 1);
6030 556 : switch (TREE_CODE (_q40))
6031 : {
6032 17 : case INTEGER_CST:
6033 17 : {
6034 17 : switch (TREE_CODE (_q41))
6035 : {
6036 0 : CASE_CONVERT:
6037 0 : {
6038 0 : tree _q60 = TREE_OPERAND (_q41, 0);
6039 0 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
6040 : {
6041 0 : {
6042 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
6043 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
6044 0 : if (res) return res;
6045 : }
6046 : }
6047 : break;
6048 : }
6049 17 : default:;
6050 : }
6051 17 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
6052 : {
6053 0 : {
6054 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
6055 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
6056 0 : if (res) return res;
6057 : }
6058 : }
6059 : break;
6060 : }
6061 : default:;
6062 : }
6063 : break;
6064 : }
6065 : default:;
6066 : }
6067 : break;
6068 : }
6069 30836 : case MINUS_EXPR:
6070 30836 : {
6071 30836 : tree _q30 = TREE_OPERAND (_p1, 0);
6072 30836 : tree _q31 = TREE_OPERAND (_p1, 1);
6073 30836 : switch (TREE_CODE (_q30))
6074 : {
6075 608 : case INTEGER_CST:
6076 608 : {
6077 608 : switch (TREE_CODE (_q31))
6078 : {
6079 32 : CASE_CONVERT:
6080 32 : {
6081 32 : tree _q50 = TREE_OPERAND (_q31, 0);
6082 32 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
6083 : {
6084 0 : {
6085 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
6086 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
6087 0 : if (res) return res;
6088 : }
6089 : }
6090 : break;
6091 : }
6092 608 : default:;
6093 : }
6094 608 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6095 : {
6096 0 : {
6097 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
6098 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
6099 0 : if (res) return res;
6100 : }
6101 : }
6102 : break;
6103 : }
6104 : default:;
6105 : }
6106 : break;
6107 : }
6108 40590484 : default:;
6109 : }
6110 40590484 : switch (TREE_CODE (_p0))
6111 : {
6112 18071 : case LT_EXPR:
6113 18071 : {
6114 18071 : tree _q20 = TREE_OPERAND (_p0, 0);
6115 18071 : tree _q21 = TREE_OPERAND (_p0, 1);
6116 18071 : switch (TREE_CODE (_p1))
6117 : {
6118 18 : case GT_EXPR:
6119 18 : {
6120 18 : tree _q50 = TREE_OPERAND (_p1, 0);
6121 18 : tree _q51 = TREE_OPERAND (_p1, 1);
6122 18 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6123 : {
6124 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6125 : {
6126 0 : {
6127 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6128 0 : const enum tree_code cmp1 = LT_EXPR;
6129 0 : const enum tree_code cmp2 = GT_EXPR;
6130 0 : const enum tree_code rcmp = NE_EXPR;
6131 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6132 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6133 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6134 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6135 : )
6136 : {
6137 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1508;
6138 0 : {
6139 0 : tree res_op0;
6140 0 : res_op0 = captures[0];
6141 0 : tree res_op1;
6142 0 : res_op1 = captures[1];
6143 0 : tree _r;
6144 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6145 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6146 0 : return _r;
6147 : }
6148 0 : next_after_fail1508:;
6149 : }
6150 : }
6151 : }
6152 : }
6153 : break;
6154 : }
6155 23 : case EQ_EXPR:
6156 23 : {
6157 23 : tree _q50 = TREE_OPERAND (_p1, 0);
6158 23 : tree _q51 = TREE_OPERAND (_p1, 1);
6159 23 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6160 : {
6161 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6162 : {
6163 0 : {
6164 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6165 0 : const enum tree_code cmp1 = LT_EXPR;
6166 0 : const enum tree_code cmp2 = EQ_EXPR;
6167 0 : const enum tree_code rcmp = LE_EXPR;
6168 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6169 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6170 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6171 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6172 : )
6173 : {
6174 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1509;
6175 0 : {
6176 0 : tree res_op0;
6177 0 : res_op0 = captures[0];
6178 0 : tree res_op1;
6179 0 : res_op1 = captures[1];
6180 0 : tree _r;
6181 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6182 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6183 0 : return _r;
6184 : }
6185 0 : next_after_fail1509:;
6186 : }
6187 : }
6188 : }
6189 : }
6190 : break;
6191 : }
6192 23 : case NE_EXPR:
6193 23 : {
6194 23 : tree _q50 = TREE_OPERAND (_p1, 0);
6195 23 : tree _q51 = TREE_OPERAND (_p1, 1);
6196 23 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6197 : {
6198 9 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6199 : {
6200 0 : {
6201 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6202 0 : const enum tree_code cmp1 = LT_EXPR;
6203 0 : const enum tree_code cmp2 = NE_EXPR;
6204 0 : const enum tree_code rcmp = GT_EXPR;
6205 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6206 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6207 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6208 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6209 : )
6210 : {
6211 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1510;
6212 0 : {
6213 0 : tree res_op0;
6214 0 : res_op0 = captures[0];
6215 0 : tree res_op1;
6216 0 : res_op1 = captures[1];
6217 0 : tree _r;
6218 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6219 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6220 0 : return _r;
6221 : }
6222 0 : next_after_fail1510:;
6223 : }
6224 : }
6225 : }
6226 : }
6227 : break;
6228 : }
6229 : default:;
6230 : }
6231 : break;
6232 : }
6233 11872 : case LE_EXPR:
6234 11872 : {
6235 11872 : tree _q20 = TREE_OPERAND (_p0, 0);
6236 11872 : tree _q21 = TREE_OPERAND (_p0, 1);
6237 11872 : switch (TREE_CODE (_p1))
6238 : {
6239 25 : case GE_EXPR:
6240 25 : {
6241 25 : tree _q50 = TREE_OPERAND (_p1, 0);
6242 25 : tree _q51 = TREE_OPERAND (_p1, 1);
6243 25 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6244 : {
6245 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6246 : {
6247 0 : {
6248 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6249 0 : const enum tree_code cmp1 = LE_EXPR;
6250 0 : const enum tree_code cmp2 = GE_EXPR;
6251 0 : const enum tree_code rcmp = NE_EXPR;
6252 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6253 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6254 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6255 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6256 : )
6257 : {
6258 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1511;
6259 0 : {
6260 0 : tree res_op0;
6261 0 : res_op0 = captures[0];
6262 0 : tree res_op1;
6263 0 : res_op1 = captures[1];
6264 0 : tree _r;
6265 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6266 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6267 0 : return _r;
6268 : }
6269 0 : next_after_fail1511:;
6270 : }
6271 : }
6272 : }
6273 : }
6274 : break;
6275 : }
6276 41 : case EQ_EXPR:
6277 41 : {
6278 41 : tree _q50 = TREE_OPERAND (_p1, 0);
6279 41 : tree _q51 = TREE_OPERAND (_p1, 1);
6280 41 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6281 : {
6282 9 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6283 : {
6284 0 : {
6285 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6286 0 : const enum tree_code cmp1 = LE_EXPR;
6287 0 : const enum tree_code cmp2 = EQ_EXPR;
6288 0 : const enum tree_code rcmp = LT_EXPR;
6289 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6290 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6291 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6292 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6293 : )
6294 : {
6295 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1512;
6296 0 : {
6297 0 : tree res_op0;
6298 0 : res_op0 = captures[0];
6299 0 : tree res_op1;
6300 0 : res_op1 = captures[1];
6301 0 : tree _r;
6302 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6303 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6304 0 : return _r;
6305 : }
6306 0 : next_after_fail1512:;
6307 : }
6308 : }
6309 : }
6310 : }
6311 : break;
6312 : }
6313 13 : case NE_EXPR:
6314 13 : {
6315 13 : tree _q50 = TREE_OPERAND (_p1, 0);
6316 13 : tree _q51 = TREE_OPERAND (_p1, 1);
6317 13 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6318 : {
6319 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6320 : {
6321 0 : {
6322 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6323 0 : const enum tree_code cmp1 = LE_EXPR;
6324 0 : const enum tree_code cmp2 = NE_EXPR;
6325 0 : const enum tree_code rcmp = GE_EXPR;
6326 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6327 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6328 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6329 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6330 : )
6331 : {
6332 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1513;
6333 0 : {
6334 0 : tree res_op0;
6335 0 : res_op0 = captures[0];
6336 0 : tree res_op1;
6337 0 : res_op1 = captures[1];
6338 0 : tree _r;
6339 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6340 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6341 0 : return _r;
6342 : }
6343 0 : next_after_fail1513:;
6344 : }
6345 : }
6346 : }
6347 : }
6348 : break;
6349 : }
6350 : default:;
6351 : }
6352 : break;
6353 : }
6354 35380 : case GT_EXPR:
6355 35380 : {
6356 35380 : tree _q20 = TREE_OPERAND (_p0, 0);
6357 35380 : tree _q21 = TREE_OPERAND (_p0, 1);
6358 35380 : switch (TREE_CODE (_p1))
6359 : {
6360 77 : case GT_EXPR:
6361 77 : {
6362 77 : tree _q50 = TREE_OPERAND (_p1, 0);
6363 77 : tree _q51 = TREE_OPERAND (_p1, 1);
6364 77 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6365 : {
6366 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6367 : {
6368 0 : {
6369 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6370 0 : const enum tree_code cmp1 = LT_EXPR;
6371 0 : const enum tree_code cmp2 = GT_EXPR;
6372 0 : const enum tree_code rcmp = NE_EXPR;
6373 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6374 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6375 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6376 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6377 : )
6378 : {
6379 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1514;
6380 0 : {
6381 0 : tree res_op0;
6382 0 : res_op0 = captures[0];
6383 0 : tree res_op1;
6384 0 : res_op1 = captures[1];
6385 0 : tree _r;
6386 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6387 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6388 0 : return _r;
6389 : }
6390 0 : next_after_fail1514:;
6391 : }
6392 : }
6393 0 : {
6394 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6395 0 : const enum tree_code cmp1 = LT_EXPR;
6396 0 : const enum tree_code cmp2 = GT_EXPR;
6397 0 : const enum tree_code rcmp = NE_EXPR;
6398 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6399 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6400 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6401 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6402 : )
6403 : {
6404 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1515;
6405 0 : {
6406 0 : tree res_op0;
6407 0 : res_op0 = captures[0];
6408 0 : tree res_op1;
6409 0 : res_op1 = captures[1];
6410 0 : tree _r;
6411 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6412 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6413 0 : return _r;
6414 : }
6415 0 : next_after_fail1515:;
6416 : }
6417 : }
6418 : }
6419 : }
6420 : break;
6421 : }
6422 29 : case EQ_EXPR:
6423 29 : {
6424 29 : tree _q50 = TREE_OPERAND (_p1, 0);
6425 29 : tree _q51 = TREE_OPERAND (_p1, 1);
6426 29 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6427 : {
6428 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6429 : {
6430 0 : {
6431 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6432 0 : const enum tree_code cmp1 = LT_EXPR;
6433 0 : const enum tree_code cmp2 = EQ_EXPR;
6434 0 : const enum tree_code rcmp = LE_EXPR;
6435 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6436 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6437 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6438 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6439 : )
6440 : {
6441 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1516;
6442 0 : {
6443 0 : tree res_op0;
6444 0 : res_op0 = captures[0];
6445 0 : tree res_op1;
6446 0 : res_op1 = captures[1];
6447 0 : tree _r;
6448 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6449 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6450 0 : return _r;
6451 : }
6452 0 : next_after_fail1516:;
6453 : }
6454 : }
6455 : }
6456 : }
6457 : break;
6458 : }
6459 53 : case NE_EXPR:
6460 53 : {
6461 53 : tree _q50 = TREE_OPERAND (_p1, 0);
6462 53 : tree _q51 = TREE_OPERAND (_p1, 1);
6463 53 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6464 : {
6465 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6466 : {
6467 0 : {
6468 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6469 0 : const enum tree_code cmp1 = LT_EXPR;
6470 0 : const enum tree_code cmp2 = NE_EXPR;
6471 0 : const enum tree_code rcmp = GT_EXPR;
6472 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6473 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6474 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6475 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6476 : )
6477 : {
6478 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1517;
6479 0 : {
6480 0 : tree res_op0;
6481 0 : res_op0 = captures[0];
6482 0 : tree res_op1;
6483 0 : res_op1 = captures[1];
6484 0 : tree _r;
6485 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6486 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6487 0 : return _r;
6488 : }
6489 0 : next_after_fail1517:;
6490 : }
6491 : }
6492 : }
6493 : }
6494 : break;
6495 : }
6496 32 : case LT_EXPR:
6497 32 : {
6498 32 : tree _q50 = TREE_OPERAND (_p1, 0);
6499 32 : tree _q51 = TREE_OPERAND (_p1, 1);
6500 32 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6501 : {
6502 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6503 : {
6504 0 : {
6505 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6506 0 : const enum tree_code cmp1 = LT_EXPR;
6507 0 : const enum tree_code cmp2 = GT_EXPR;
6508 0 : const enum tree_code rcmp = NE_EXPR;
6509 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6510 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6511 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6512 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6513 : )
6514 : {
6515 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1518;
6516 0 : {
6517 0 : tree res_op0;
6518 0 : res_op0 = captures[0];
6519 0 : tree res_op1;
6520 0 : res_op1 = captures[1];
6521 0 : tree _r;
6522 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6523 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6524 0 : return _r;
6525 : }
6526 0 : next_after_fail1518:;
6527 : }
6528 : }
6529 : }
6530 : }
6531 : break;
6532 : }
6533 : default:;
6534 : }
6535 : break;
6536 : }
6537 6123 : case GE_EXPR:
6538 6123 : {
6539 6123 : tree _q20 = TREE_OPERAND (_p0, 0);
6540 6123 : tree _q21 = TREE_OPERAND (_p0, 1);
6541 6123 : switch (TREE_CODE (_p1))
6542 : {
6543 76 : case GE_EXPR:
6544 76 : {
6545 76 : tree _q50 = TREE_OPERAND (_p1, 0);
6546 76 : tree _q51 = TREE_OPERAND (_p1, 1);
6547 76 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6548 : {
6549 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6550 : {
6551 0 : {
6552 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6553 0 : const enum tree_code cmp1 = LE_EXPR;
6554 0 : const enum tree_code cmp2 = GE_EXPR;
6555 0 : const enum tree_code rcmp = NE_EXPR;
6556 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6557 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6558 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6559 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6560 : )
6561 : {
6562 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1519;
6563 0 : {
6564 0 : tree res_op0;
6565 0 : res_op0 = captures[0];
6566 0 : tree res_op1;
6567 0 : res_op1 = captures[1];
6568 0 : tree _r;
6569 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6570 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6571 0 : return _r;
6572 : }
6573 0 : next_after_fail1519:;
6574 : }
6575 : }
6576 0 : {
6577 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6578 0 : const enum tree_code cmp1 = LE_EXPR;
6579 0 : const enum tree_code cmp2 = GE_EXPR;
6580 0 : const enum tree_code rcmp = NE_EXPR;
6581 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6582 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6583 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6584 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6585 : )
6586 : {
6587 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1520;
6588 0 : {
6589 0 : tree res_op0;
6590 0 : res_op0 = captures[0];
6591 0 : tree res_op1;
6592 0 : res_op1 = captures[1];
6593 0 : tree _r;
6594 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6595 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6596 0 : return _r;
6597 : }
6598 0 : next_after_fail1520:;
6599 : }
6600 : }
6601 : }
6602 : }
6603 : break;
6604 : }
6605 52 : case EQ_EXPR:
6606 52 : {
6607 52 : tree _q50 = TREE_OPERAND (_p1, 0);
6608 52 : tree _q51 = TREE_OPERAND (_p1, 1);
6609 52 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6610 : {
6611 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6612 : {
6613 0 : {
6614 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6615 0 : const enum tree_code cmp1 = LE_EXPR;
6616 0 : const enum tree_code cmp2 = EQ_EXPR;
6617 0 : const enum tree_code rcmp = LT_EXPR;
6618 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6619 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6620 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6621 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6622 : )
6623 : {
6624 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1521;
6625 0 : {
6626 0 : tree res_op0;
6627 0 : res_op0 = captures[0];
6628 0 : tree res_op1;
6629 0 : res_op1 = captures[1];
6630 0 : tree _r;
6631 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6632 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6633 0 : return _r;
6634 : }
6635 0 : next_after_fail1521:;
6636 : }
6637 : }
6638 : }
6639 : }
6640 : break;
6641 : }
6642 11 : case NE_EXPR:
6643 11 : {
6644 11 : tree _q50 = TREE_OPERAND (_p1, 0);
6645 11 : tree _q51 = TREE_OPERAND (_p1, 1);
6646 11 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6647 : {
6648 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6649 : {
6650 0 : {
6651 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6652 0 : const enum tree_code cmp1 = LE_EXPR;
6653 0 : const enum tree_code cmp2 = NE_EXPR;
6654 0 : const enum tree_code rcmp = GE_EXPR;
6655 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6656 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6657 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6658 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6659 : )
6660 : {
6661 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1522;
6662 0 : {
6663 0 : tree res_op0;
6664 0 : res_op0 = captures[0];
6665 0 : tree res_op1;
6666 0 : res_op1 = captures[1];
6667 0 : tree _r;
6668 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6669 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6670 0 : return _r;
6671 : }
6672 0 : next_after_fail1522:;
6673 : }
6674 : }
6675 : }
6676 : }
6677 : break;
6678 : }
6679 16 : case LE_EXPR:
6680 16 : {
6681 16 : tree _q50 = TREE_OPERAND (_p1, 0);
6682 16 : tree _q51 = TREE_OPERAND (_p1, 1);
6683 16 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6684 : {
6685 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6686 : {
6687 0 : {
6688 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6689 0 : const enum tree_code cmp1 = LE_EXPR;
6690 0 : const enum tree_code cmp2 = GE_EXPR;
6691 0 : const enum tree_code rcmp = NE_EXPR;
6692 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6693 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6694 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6695 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6696 : )
6697 : {
6698 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1523;
6699 0 : {
6700 0 : tree res_op0;
6701 0 : res_op0 = captures[0];
6702 0 : tree res_op1;
6703 0 : res_op1 = captures[1];
6704 0 : tree _r;
6705 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6706 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6707 0 : return _r;
6708 : }
6709 0 : next_after_fail1523:;
6710 : }
6711 : }
6712 : }
6713 : }
6714 : break;
6715 : }
6716 : default:;
6717 : }
6718 : break;
6719 : }
6720 63220 : case EQ_EXPR:
6721 63220 : {
6722 63220 : tree _q20 = TREE_OPERAND (_p0, 0);
6723 63220 : tree _q21 = TREE_OPERAND (_p0, 1);
6724 63220 : switch (TREE_CODE (_p1))
6725 : {
6726 5 : case LT_EXPR:
6727 5 : {
6728 5 : tree _q50 = TREE_OPERAND (_p1, 0);
6729 5 : tree _q51 = TREE_OPERAND (_p1, 1);
6730 5 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6731 : {
6732 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6733 : {
6734 0 : {
6735 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6736 0 : const enum tree_code cmp1 = LT_EXPR;
6737 0 : const enum tree_code cmp2 = EQ_EXPR;
6738 0 : const enum tree_code rcmp = LE_EXPR;
6739 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6740 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6741 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6742 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6743 : )
6744 : {
6745 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1524;
6746 0 : {
6747 0 : tree res_op0;
6748 0 : res_op0 = captures[0];
6749 0 : tree res_op1;
6750 0 : res_op1 = captures[1];
6751 0 : tree _r;
6752 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6753 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6754 0 : return _r;
6755 : }
6756 0 : next_after_fail1524:;
6757 : }
6758 : }
6759 : }
6760 : }
6761 : break;
6762 : }
6763 42 : case LE_EXPR:
6764 42 : {
6765 42 : tree _q50 = TREE_OPERAND (_p1, 0);
6766 42 : tree _q51 = TREE_OPERAND (_p1, 1);
6767 42 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6768 : {
6769 7 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6770 : {
6771 0 : {
6772 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6773 0 : const enum tree_code cmp1 = LE_EXPR;
6774 0 : const enum tree_code cmp2 = EQ_EXPR;
6775 0 : const enum tree_code rcmp = LT_EXPR;
6776 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6777 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6778 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6779 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6780 : )
6781 : {
6782 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1525;
6783 0 : {
6784 0 : tree res_op0;
6785 0 : res_op0 = captures[0];
6786 0 : tree res_op1;
6787 0 : res_op1 = captures[1];
6788 0 : tree _r;
6789 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6790 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6791 0 : return _r;
6792 : }
6793 0 : next_after_fail1525:;
6794 : }
6795 : }
6796 : }
6797 : }
6798 : break;
6799 : }
6800 7 : case GT_EXPR:
6801 7 : {
6802 7 : tree _q50 = TREE_OPERAND (_p1, 0);
6803 7 : tree _q51 = TREE_OPERAND (_p1, 1);
6804 7 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6805 : {
6806 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6807 : {
6808 0 : {
6809 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6810 0 : const enum tree_code cmp1 = LT_EXPR;
6811 0 : const enum tree_code cmp2 = EQ_EXPR;
6812 0 : const enum tree_code rcmp = LE_EXPR;
6813 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6814 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6815 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6816 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6817 : )
6818 : {
6819 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1526;
6820 0 : {
6821 0 : tree res_op0;
6822 0 : res_op0 = captures[0];
6823 0 : tree res_op1;
6824 0 : res_op1 = captures[1];
6825 0 : tree _r;
6826 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6827 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6828 0 : return _r;
6829 : }
6830 0 : next_after_fail1526:;
6831 : }
6832 : }
6833 : }
6834 : }
6835 : break;
6836 : }
6837 14 : case GE_EXPR:
6838 14 : {
6839 14 : tree _q50 = TREE_OPERAND (_p1, 0);
6840 14 : tree _q51 = TREE_OPERAND (_p1, 1);
6841 14 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6842 : {
6843 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6844 : {
6845 0 : {
6846 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6847 0 : const enum tree_code cmp1 = LE_EXPR;
6848 0 : const enum tree_code cmp2 = EQ_EXPR;
6849 0 : const enum tree_code rcmp = LT_EXPR;
6850 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6851 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6852 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6853 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6854 : )
6855 : {
6856 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1527;
6857 0 : {
6858 0 : tree res_op0;
6859 0 : res_op0 = captures[0];
6860 0 : tree res_op1;
6861 0 : res_op1 = captures[1];
6862 0 : tree _r;
6863 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6864 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6865 0 : return _r;
6866 : }
6867 0 : next_after_fail1527:;
6868 : }
6869 : }
6870 : }
6871 : }
6872 : break;
6873 : }
6874 : default:;
6875 : }
6876 : break;
6877 : }
6878 68520 : case NE_EXPR:
6879 68520 : {
6880 68520 : tree _q20 = TREE_OPERAND (_p0, 0);
6881 68520 : tree _q21 = TREE_OPERAND (_p0, 1);
6882 68520 : switch (TREE_CODE (_p1))
6883 : {
6884 7 : case LT_EXPR:
6885 7 : {
6886 7 : tree _q50 = TREE_OPERAND (_p1, 0);
6887 7 : tree _q51 = TREE_OPERAND (_p1, 1);
6888 7 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6889 : {
6890 7 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6891 : {
6892 0 : {
6893 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6894 0 : const enum tree_code cmp1 = LT_EXPR;
6895 0 : const enum tree_code cmp2 = NE_EXPR;
6896 0 : const enum tree_code rcmp = GT_EXPR;
6897 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6898 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6899 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6900 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6901 : )
6902 : {
6903 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1528;
6904 0 : {
6905 0 : tree res_op0;
6906 0 : res_op0 = captures[0];
6907 0 : tree res_op1;
6908 0 : res_op1 = captures[1];
6909 0 : tree _r;
6910 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6911 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6912 0 : return _r;
6913 : }
6914 0 : next_after_fail1528:;
6915 : }
6916 : }
6917 : }
6918 : }
6919 : break;
6920 : }
6921 302 : case LE_EXPR:
6922 302 : {
6923 302 : tree _q50 = TREE_OPERAND (_p1, 0);
6924 302 : tree _q51 = TREE_OPERAND (_p1, 1);
6925 302 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6926 : {
6927 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6928 : {
6929 0 : {
6930 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6931 0 : const enum tree_code cmp1 = LE_EXPR;
6932 0 : const enum tree_code cmp2 = NE_EXPR;
6933 0 : const enum tree_code rcmp = GE_EXPR;
6934 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6935 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6936 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6937 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6938 : )
6939 : {
6940 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1529;
6941 0 : {
6942 0 : tree res_op0;
6943 0 : res_op0 = captures[0];
6944 0 : tree res_op1;
6945 0 : res_op1 = captures[1];
6946 0 : tree _r;
6947 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6948 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6949 0 : return _r;
6950 : }
6951 0 : next_after_fail1529:;
6952 : }
6953 : }
6954 : }
6955 : }
6956 : break;
6957 : }
6958 323 : case GT_EXPR:
6959 323 : {
6960 323 : tree _q50 = TREE_OPERAND (_p1, 0);
6961 323 : tree _q51 = TREE_OPERAND (_p1, 1);
6962 323 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6963 : {
6964 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6965 : {
6966 0 : {
6967 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6968 0 : const enum tree_code cmp1 = LT_EXPR;
6969 0 : const enum tree_code cmp2 = NE_EXPR;
6970 0 : const enum tree_code rcmp = GT_EXPR;
6971 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6972 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6973 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6974 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6975 : )
6976 : {
6977 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1530;
6978 0 : {
6979 0 : tree res_op0;
6980 0 : res_op0 = captures[0];
6981 0 : tree res_op1;
6982 0 : res_op1 = captures[1];
6983 0 : tree _r;
6984 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6985 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
6986 0 : return _r;
6987 : }
6988 0 : next_after_fail1530:;
6989 : }
6990 : }
6991 : }
6992 : }
6993 : break;
6994 : }
6995 2 : case GE_EXPR:
6996 2 : {
6997 2 : tree _q50 = TREE_OPERAND (_p1, 0);
6998 2 : tree _q51 = TREE_OPERAND (_p1, 1);
6999 2 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7000 : {
7001 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7002 : {
7003 0 : {
7004 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7005 0 : const enum tree_code cmp1 = LE_EXPR;
7006 0 : const enum tree_code cmp2 = NE_EXPR;
7007 0 : const enum tree_code rcmp = GE_EXPR;
7008 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
7009 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
7010 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
7011 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
7012 : )
7013 : {
7014 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1531;
7015 0 : {
7016 0 : tree res_op0;
7017 0 : res_op0 = captures[0];
7018 0 : tree res_op1;
7019 0 : res_op1 = captures[1];
7020 0 : tree _r;
7021 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
7022 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
7023 0 : return _r;
7024 : }
7025 0 : next_after_fail1531:;
7026 : }
7027 : }
7028 : }
7029 : }
7030 : break;
7031 : }
7032 : default:;
7033 : }
7034 : break;
7035 : }
7036 8678 : case MIN_EXPR:
7037 8678 : {
7038 8678 : tree _q20 = TREE_OPERAND (_p0, 0);
7039 8678 : tree _q21 = TREE_OPERAND (_p0, 1);
7040 8678 : switch (TREE_CODE (_p1))
7041 : {
7042 0 : case MAX_EXPR:
7043 0 : {
7044 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7045 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7046 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7047 : {
7048 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7049 : {
7050 0 : {
7051 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7052 0 : if (!HONOR_NANS (captures[0])
7053 : )
7054 : {
7055 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1532;
7056 0 : {
7057 0 : tree res_op0;
7058 0 : res_op0 = captures[0];
7059 0 : tree res_op1;
7060 0 : res_op1 = captures[1];
7061 0 : tree _r;
7062 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
7063 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
7064 0 : return _r;
7065 : }
7066 0 : next_after_fail1532:;
7067 : }
7068 : }
7069 : }
7070 : }
7071 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7072 : {
7073 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7074 : {
7075 0 : {
7076 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
7077 0 : if (!HONOR_NANS (captures[0])
7078 : )
7079 : {
7080 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1533;
7081 0 : {
7082 0 : tree res_op0;
7083 0 : res_op0 = captures[0];
7084 0 : tree res_op1;
7085 0 : res_op1 = captures[1];
7086 0 : tree _r;
7087 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
7088 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
7089 0 : return _r;
7090 : }
7091 0 : next_after_fail1533:;
7092 : }
7093 : }
7094 : }
7095 : }
7096 : break;
7097 : }
7098 8678 : default:;
7099 : }
7100 8678 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
7101 : {
7102 0 : {
7103 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7104 0 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MIN_EXPR, NE_EXPR, GT_EXPR);
7105 0 : if (res) return res;
7106 : }
7107 : }
7108 8678 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
7109 : {
7110 616 : {
7111 616 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
7112 616 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MIN_EXPR, NE_EXPR, GT_EXPR);
7113 616 : if (res) return res;
7114 : }
7115 : }
7116 : break;
7117 : }
7118 8146 : case MAX_EXPR:
7119 8146 : {
7120 8146 : tree _q20 = TREE_OPERAND (_p0, 0);
7121 8146 : tree _q21 = TREE_OPERAND (_p0, 1);
7122 8146 : switch (TREE_CODE (_p1))
7123 : {
7124 0 : case MIN_EXPR:
7125 0 : {
7126 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7127 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7128 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7129 : {
7130 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7131 : {
7132 0 : {
7133 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7134 0 : if (!HONOR_NANS (captures[0])
7135 : )
7136 : {
7137 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1534;
7138 0 : {
7139 0 : tree res_op0;
7140 0 : res_op0 = captures[0];
7141 0 : tree res_op1;
7142 0 : res_op1 = captures[1];
7143 0 : tree _r;
7144 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
7145 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
7146 0 : return _r;
7147 : }
7148 0 : next_after_fail1534:;
7149 : }
7150 : }
7151 : }
7152 : }
7153 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7154 : {
7155 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7156 : {
7157 0 : {
7158 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7159 0 : if (!HONOR_NANS (captures[0])
7160 : )
7161 : {
7162 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1535;
7163 0 : {
7164 0 : tree res_op0;
7165 0 : res_op0 = captures[0];
7166 0 : tree res_op1;
7167 0 : res_op1 = captures[1];
7168 0 : tree _r;
7169 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
7170 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
7171 0 : return _r;
7172 : }
7173 0 : next_after_fail1535:;
7174 : }
7175 : }
7176 : }
7177 : }
7178 : break;
7179 : }
7180 8146 : default:;
7181 : }
7182 8146 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
7183 : {
7184 0 : {
7185 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7186 0 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MAX_EXPR, NE_EXPR, LT_EXPR);
7187 0 : if (res) return res;
7188 : }
7189 : }
7190 8146 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
7191 : {
7192 425 : {
7193 425 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
7194 425 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MAX_EXPR, NE_EXPR, LT_EXPR);
7195 425 : if (res) return res;
7196 : }
7197 : }
7198 : break;
7199 : }
7200 40590355 : default:;
7201 : }
7202 40590355 : if (tree_with_possible_nonzero_bits (_p0))
7203 : {
7204 15693717 : if (tree_with_known_nonzero_bits (_p1))
7205 : {
7206 14199508 : {
7207 14199508 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
7208 14199508 : tree res = generic_simplify_225 (loc, type, _p0, _p1, captures, NE_EXPR);
7209 14199508 : if (res) return res;
7210 : }
7211 : }
7212 : }
7213 40527557 : if (tree_with_known_nonzero_bits (_p0))
7214 : {
7215 11474377 : if (tree_with_possible_nonzero_bits (_p1))
7216 : {
7217 11424629 : {
7218 11424629 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _p0 };
7219 11424629 : tree res = generic_simplify_225 (loc, type, _p0, _p1, captures, NE_EXPR);
7220 11424629 : if (res) return res;
7221 : }
7222 : }
7223 : }
7224 40526155 : switch (TREE_CODE (_p1))
7225 : {
7226 164 : case MIN_EXPR:
7227 164 : {
7228 164 : tree _q30 = TREE_OPERAND (_p1, 0);
7229 164 : tree _q31 = TREE_OPERAND (_p1, 1);
7230 164 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
7231 : {
7232 0 : {
7233 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
7234 0 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MIN_EXPR, NE_EXPR, GT_EXPR);
7235 0 : if (res) return res;
7236 : }
7237 : }
7238 164 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
7239 : {
7240 0 : {
7241 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
7242 0 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MIN_EXPR, NE_EXPR, GT_EXPR);
7243 0 : if (res) return res;
7244 : }
7245 : }
7246 : break;
7247 : }
7248 1673 : case MAX_EXPR:
7249 1673 : {
7250 1673 : tree _q30 = TREE_OPERAND (_p1, 0);
7251 1673 : tree _q31 = TREE_OPERAND (_p1, 1);
7252 1673 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
7253 : {
7254 0 : {
7255 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
7256 0 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MAX_EXPR, NE_EXPR, LT_EXPR);
7257 0 : if (res) return res;
7258 : }
7259 : }
7260 1673 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
7261 : {
7262 0 : {
7263 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
7264 0 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, MAX_EXPR, NE_EXPR, LT_EXPR);
7265 0 : if (res) return res;
7266 : }
7267 : }
7268 : break;
7269 : }
7270 40526155 : default:;
7271 : }
7272 40526155 : switch (TREE_CODE (_p0))
7273 : {
7274 8678 : case MIN_EXPR:
7275 8678 : {
7276 8678 : tree _q20 = TREE_OPERAND (_p0, 0);
7277 8678 : tree _q21 = TREE_OPERAND (_p0, 1);
7278 8678 : switch (TREE_CODE (_q21))
7279 : {
7280 683 : case INTEGER_CST:
7281 683 : {
7282 683 : switch (TREE_CODE (_p1))
7283 : {
7284 0 : case INTEGER_CST:
7285 0 : {
7286 0 : {
7287 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7288 0 : tree res = generic_simplify_228 (loc, type, _p0, _p1, captures, NE_EXPR);
7289 0 : if (res) return res;
7290 : }
7291 0 : break;
7292 : }
7293 : default:;
7294 : }
7295 : break;
7296 : }
7297 : default:;
7298 : }
7299 : break;
7300 : }
7301 8017 : case MAX_EXPR:
7302 8017 : {
7303 8017 : tree _q20 = TREE_OPERAND (_p0, 0);
7304 8017 : tree _q21 = TREE_OPERAND (_p0, 1);
7305 8017 : switch (TREE_CODE (_q21))
7306 : {
7307 6959 : case INTEGER_CST:
7308 6959 : {
7309 6959 : switch (TREE_CODE (_p1))
7310 : {
7311 683 : case INTEGER_CST:
7312 683 : {
7313 683 : {
7314 683 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7315 683 : tree res = generic_simplify_229 (loc, type, _p0, _p1, captures, NE_EXPR);
7316 683 : if (res) return res;
7317 : }
7318 0 : break;
7319 : }
7320 : default:;
7321 : }
7322 : break;
7323 : }
7324 7334 : default:;
7325 : }
7326 7334 : if (integer_zerop (_p1))
7327 : {
7328 34 : {
7329 34 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7330 34 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
7331 34 : if (res) return res;
7332 : }
7333 : }
7334 : break;
7335 : }
7336 1335278 : case BIT_AND_EXPR:
7337 1335278 : {
7338 1335278 : tree _q20 = TREE_OPERAND (_p0, 0);
7339 1335278 : tree _q21 = TREE_OPERAND (_p0, 1);
7340 1335278 : switch (TREE_CODE (_q20))
7341 : {
7342 3686 : case LSHIFT_EXPR:
7343 3686 : {
7344 3686 : tree _q30 = TREE_OPERAND (_q20, 0);
7345 3686 : tree _q31 = TREE_OPERAND (_q20, 1);
7346 3686 : if (integer_pow2p (_q30))
7347 : {
7348 3666 : if (integer_pow2p (_q21))
7349 : {
7350 5 : if (integer_zerop (_p1))
7351 : {
7352 5 : {
7353 5 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q21 };
7354 5 : tree res = generic_simplify_231 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
7355 5 : if (res) return res;
7356 : }
7357 : }
7358 : }
7359 : }
7360 3681 : switch (TREE_CODE (_q31))
7361 : {
7362 13 : case INTEGER_CST:
7363 13 : {
7364 13 : switch (TREE_CODE (_q21))
7365 : {
7366 13 : case INTEGER_CST:
7367 13 : {
7368 13 : switch (TREE_CODE (_p1))
7369 : {
7370 13 : case INTEGER_CST:
7371 13 : {
7372 13 : {
7373 13 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1 };
7374 13 : tree res = generic_simplify_232 (loc, type, _p0, _p1, captures, NE_EXPR);
7375 13 : if (res) return res;
7376 : }
7377 0 : break;
7378 : }
7379 : default:;
7380 : }
7381 : break;
7382 : }
7383 : default:;
7384 : }
7385 : break;
7386 : }
7387 3668 : default:;
7388 : }
7389 3668 : if (integer_onep (_q30))
7390 : {
7391 3660 : if (integer_pow2p (_q21))
7392 : {
7393 0 : if (integer_zerop (_p1))
7394 : {
7395 0 : {
7396 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q21 };
7397 0 : tree res = generic_simplify_233 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
7398 0 : if (res) return res;
7399 : }
7400 : }
7401 : }
7402 : }
7403 : break;
7404 : }
7405 4887 : case RSHIFT_EXPR:
7406 4887 : {
7407 4887 : tree _q30 = TREE_OPERAND (_q20, 0);
7408 4887 : tree _q31 = TREE_OPERAND (_q20, 1);
7409 4887 : if (integer_pow2p (_q30))
7410 : {
7411 33 : if (integer_pow2p (_q21))
7412 : {
7413 1 : if (integer_zerop (_p1))
7414 : {
7415 1 : {
7416 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q21 };
7417 1 : tree res = generic_simplify_234 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
7418 1 : if (res) return res;
7419 : }
7420 : }
7421 : }
7422 : }
7423 4886 : switch (TREE_CODE (_q31))
7424 : {
7425 329 : case INTEGER_CST:
7426 329 : {
7427 329 : switch (TREE_CODE (_q21))
7428 : {
7429 305 : case INTEGER_CST:
7430 305 : {
7431 305 : switch (TREE_CODE (_p1))
7432 : {
7433 280 : case INTEGER_CST:
7434 280 : {
7435 280 : {
7436 280 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1 };
7437 280 : tree res = generic_simplify_235 (loc, type, _p0, _p1, captures, NE_EXPR);
7438 280 : if (res) return res;
7439 : }
7440 14 : break;
7441 : }
7442 : default:;
7443 : }
7444 : break;
7445 : }
7446 : default:;
7447 : }
7448 : break;
7449 : }
7450 : default:;
7451 : }
7452 : break;
7453 : }
7454 1334993 : default:;
7455 : }
7456 1334993 : {
7457 1334993 : tree _q20_pops[1];
7458 1334993 : if (tree_nop_convert (_q20, _q20_pops))
7459 : {
7460 136883 : tree _q30 = _q20_pops[0];
7461 136883 : switch (TREE_CODE (_q30))
7462 : {
7463 37188 : case LSHIFT_EXPR:
7464 37188 : {
7465 37188 : tree _q40 = TREE_OPERAND (_q30, 0);
7466 37188 : tree _q41 = TREE_OPERAND (_q30, 1);
7467 37188 : if (integer_onep (_q40))
7468 : {
7469 37188 : if (integer_pow2p (_q21))
7470 : {
7471 0 : if (integer_zerop (_p1))
7472 : {
7473 0 : {
7474 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q41, _q21 };
7475 0 : tree res = generic_simplify_233 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
7476 0 : if (res) return res;
7477 : }
7478 : }
7479 : }
7480 : }
7481 : break;
7482 : }
7483 : default:;
7484 : }
7485 : }
7486 : }
7487 1334993 : break;
7488 : }
7489 5202 : case LSHIFT_EXPR:
7490 5202 : {
7491 5202 : tree _q20 = TREE_OPERAND (_p0, 0);
7492 5202 : tree _q21 = TREE_OPERAND (_p0, 1);
7493 5202 : switch (TREE_CODE (_q20))
7494 : {
7495 538 : case INTEGER_CST:
7496 538 : {
7497 538 : switch (TREE_CODE (_p1))
7498 : {
7499 159 : case INTEGER_CST:
7500 159 : {
7501 159 : {
7502 159 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7503 159 : tree res = generic_simplify_236 (loc, type, _p0, _p1, captures, NE_EXPR);
7504 159 : if (res) return res;
7505 : }
7506 88 : break;
7507 : }
7508 : default:;
7509 : }
7510 : break;
7511 : }
7512 : default:;
7513 : }
7514 : break;
7515 : }
7516 414 : case LROTATE_EXPR:
7517 414 : {
7518 414 : tree _q20 = TREE_OPERAND (_p0, 0);
7519 414 : tree _q21 = TREE_OPERAND (_p0, 1);
7520 414 : switch (TREE_CODE (_p1))
7521 : {
7522 0 : case LROTATE_EXPR:
7523 0 : {
7524 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7525 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7526 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7527 : {
7528 0 : {
7529 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
7530 0 : tree res = generic_simplify_237 (loc, type, _p0, _p1, captures, LROTATE_EXPR, RROTATE_EXPR, NE_EXPR);
7531 0 : if (res) return res;
7532 : }
7533 : }
7534 : break;
7535 : }
7536 414 : default:;
7537 : }
7538 414 : switch (TREE_CODE (_q21))
7539 : {
7540 112 : case INTEGER_CST:
7541 112 : {
7542 112 : switch (TREE_CODE (_p1))
7543 : {
7544 112 : case INTEGER_CST:
7545 112 : {
7546 112 : {
7547 112 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7548 112 : tree res = generic_simplify_238 (loc, type, _p0, _p1, captures, LROTATE_EXPR, RROTATE_EXPR, NE_EXPR);
7549 112 : if (res) return res;
7550 : }
7551 0 : break;
7552 : }
7553 : default:;
7554 : }
7555 : break;
7556 : }
7557 302 : default:;
7558 : }
7559 302 : switch (TREE_CODE (_p1))
7560 : {
7561 197 : case INTEGER_CST:
7562 197 : {
7563 197 : {
7564 197 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7565 197 : tree res = generic_simplify_239 (loc, type, _p0, _p1, captures, LROTATE_EXPR, RROTATE_EXPR, NE_EXPR);
7566 197 : if (res) return res;
7567 : }
7568 197 : break;
7569 : }
7570 : default:;
7571 : }
7572 : break;
7573 : }
7574 491 : case RROTATE_EXPR:
7575 491 : {
7576 491 : tree _q20 = TREE_OPERAND (_p0, 0);
7577 491 : tree _q21 = TREE_OPERAND (_p0, 1);
7578 491 : switch (TREE_CODE (_p1))
7579 : {
7580 0 : case RROTATE_EXPR:
7581 0 : {
7582 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7583 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7584 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7585 : {
7586 0 : {
7587 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
7588 0 : tree res = generic_simplify_237 (loc, type, _p0, _p1, captures, RROTATE_EXPR, LROTATE_EXPR, NE_EXPR);
7589 0 : if (res) return res;
7590 : }
7591 : }
7592 : break;
7593 : }
7594 491 : default:;
7595 : }
7596 491 : switch (TREE_CODE (_q21))
7597 : {
7598 281 : case INTEGER_CST:
7599 281 : {
7600 281 : switch (TREE_CODE (_p1))
7601 : {
7602 12 : case INTEGER_CST:
7603 12 : {
7604 12 : {
7605 12 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7606 12 : tree res = generic_simplify_238 (loc, type, _p0, _p1, captures, RROTATE_EXPR, LROTATE_EXPR, NE_EXPR);
7607 12 : if (res) return res;
7608 : }
7609 0 : break;
7610 : }
7611 : default:;
7612 : }
7613 : break;
7614 : }
7615 479 : default:;
7616 : }
7617 479 : switch (TREE_CODE (_p1))
7618 : {
7619 194 : case INTEGER_CST:
7620 194 : {
7621 194 : {
7622 194 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7623 194 : tree res = generic_simplify_239 (loc, type, _p0, _p1, captures, RROTATE_EXPR, LROTATE_EXPR, NE_EXPR);
7624 194 : if (res) return res;
7625 : }
7626 194 : break;
7627 : }
7628 : default:;
7629 : }
7630 : break;
7631 : }
7632 260 : case VEC_COND_EXPR:
7633 260 : {
7634 260 : tree _q20 = TREE_OPERAND (_p0, 0);
7635 260 : tree _q21 = TREE_OPERAND (_p0, 1);
7636 260 : tree _q22 = TREE_OPERAND (_p0, 2);
7637 260 : switch (TREE_CODE (_p1))
7638 : {
7639 8 : case VEC_COND_EXPR:
7640 8 : {
7641 8 : tree _q60 = TREE_OPERAND (_p1, 0);
7642 8 : tree _q61 = TREE_OPERAND (_p1, 1);
7643 8 : tree _q62 = TREE_OPERAND (_p1, 2);
7644 8 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7645 : {
7646 0 : {
7647 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
7648 0 : if (VECTOR_TYPE_P (type)
7649 0 : && (TREE_CODE_CLASS (NE_EXPR) != tcc_comparison
7650 0 : || types_match (type, TREE_TYPE (captures[2]))
7651 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
7652 : || (optimize_vectors_before_lowering_p ()
7653 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
7654 : )
7655 : {
7656 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1536;
7657 0 : {
7658 0 : tree res_op0;
7659 0 : res_op0 = captures[1];
7660 0 : tree res_op1;
7661 0 : {
7662 0 : tree _o1[2], _r1;
7663 0 : _o1[0] = captures[2];
7664 0 : _o1[1] = captures[5];
7665 0 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7666 0 : if (EXPR_P (_r1))
7667 0 : goto next_after_fail1536;
7668 0 : res_op1 = _r1;
7669 : }
7670 0 : tree res_op2;
7671 0 : {
7672 0 : tree _o1[2], _r1;
7673 0 : _o1[0] = captures[3];
7674 0 : _o1[1] = captures[6];
7675 0 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7676 0 : if (EXPR_P (_r1))
7677 0 : goto next_after_fail1536;
7678 0 : res_op2 = _r1;
7679 : }
7680 0 : tree _r;
7681 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7682 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
7683 0 : return _r;
7684 : }
7685 0 : next_after_fail1536:;
7686 : }
7687 : }
7688 : }
7689 : break;
7690 : }
7691 260 : default:;
7692 : }
7693 260 : {
7694 260 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
7695 260 : if (VECTOR_TYPE_P (type)
7696 260 : && (TREE_CODE_CLASS (NE_EXPR) != tcc_comparison
7697 258 : || types_match (type, TREE_TYPE (captures[2]))
7698 258 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
7699 : || (optimize_vectors_before_lowering_p ()
7700 27 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
7701 : )
7702 : {
7703 258 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1537;
7704 258 : {
7705 258 : if (! tree_invariant_p (captures[4])) goto next_after_fail1537;
7706 80 : tree res_op0;
7707 80 : res_op0 = captures[1];
7708 80 : tree res_op1;
7709 80 : {
7710 80 : tree _o1[2], _r1;
7711 80 : _o1[0] = captures[2];
7712 80 : _o1[1] = unshare_expr (captures[4]);
7713 80 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7714 80 : if (EXPR_P (_r1))
7715 8 : goto next_after_fail1537;
7716 72 : res_op1 = _r1;
7717 : }
7718 72 : tree res_op2;
7719 72 : {
7720 72 : tree _o1[2], _r1;
7721 72 : _o1[0] = captures[3];
7722 72 : _o1[1] = captures[4];
7723 72 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7724 72 : if (EXPR_P (_r1))
7725 0 : goto next_after_fail1537;
7726 72 : res_op2 = _r1;
7727 : }
7728 72 : tree _r;
7729 72 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7730 72 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
7731 72 : return _r;
7732 : }
7733 188 : next_after_fail1537:;
7734 : }
7735 : }
7736 188 : break;
7737 : }
7738 2758856 : case CALL_EXPR:
7739 2758856 : switch (get_call_combined_fn (_p0))
7740 : {
7741 2 : case CFN_BUILT_IN_BSWAP128:
7742 2 : if (call_expr_nargs (_p0) == 1)
7743 : {
7744 2 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7745 2 : switch (TREE_CODE (_p1))
7746 : {
7747 0 : case INTEGER_CST:
7748 0 : {
7749 0 : {
7750 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7751 0 : tree res = generic_simplify_242 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP128);
7752 0 : if (res) return res;
7753 : }
7754 0 : break;
7755 : }
7756 1 : case CALL_EXPR:
7757 1 : switch (get_call_combined_fn (_p1))
7758 : {
7759 0 : case CFN_BUILT_IN_BSWAP128:
7760 0 : if (call_expr_nargs (_p1) == 1)
7761 : {
7762 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7763 0 : {
7764 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7765 0 : tree res = generic_simplify_241 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP128);
7766 0 : if (res) return res;
7767 : }
7768 : }
7769 : break;
7770 : default:;
7771 : }
7772 : break;
7773 : default:;
7774 : }
7775 : }
7776 : break;
7777 11 : case CFN_BUILT_IN_BSWAP16:
7778 11 : if (call_expr_nargs (_p0) == 1)
7779 : {
7780 11 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7781 11 : switch (TREE_CODE (_p1))
7782 : {
7783 9 : case INTEGER_CST:
7784 9 : {
7785 9 : {
7786 9 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7787 9 : tree res = generic_simplify_242 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP16);
7788 9 : if (res) return res;
7789 : }
7790 9 : break;
7791 : }
7792 1 : case CALL_EXPR:
7793 1 : switch (get_call_combined_fn (_p1))
7794 : {
7795 1 : case CFN_BUILT_IN_BSWAP16:
7796 1 : if (call_expr_nargs (_p1) == 1)
7797 : {
7798 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7799 1 : {
7800 1 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7801 1 : tree res = generic_simplify_241 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP16);
7802 1 : if (res) return res;
7803 : }
7804 : }
7805 : break;
7806 : default:;
7807 : }
7808 : break;
7809 : default:;
7810 : }
7811 : }
7812 : break;
7813 7 : case CFN_BUILT_IN_BSWAP32:
7814 7 : if (call_expr_nargs (_p0) == 1)
7815 : {
7816 7 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7817 7 : switch (TREE_CODE (_p1))
7818 : {
7819 3 : case INTEGER_CST:
7820 3 : {
7821 3 : {
7822 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7823 3 : tree res = generic_simplify_242 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP32);
7824 3 : if (res) return res;
7825 : }
7826 3 : break;
7827 : }
7828 3 : case CALL_EXPR:
7829 3 : switch (get_call_combined_fn (_p1))
7830 : {
7831 3 : case CFN_BUILT_IN_BSWAP32:
7832 3 : if (call_expr_nargs (_p1) == 1)
7833 : {
7834 3 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7835 3 : {
7836 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7837 3 : tree res = generic_simplify_241 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP32);
7838 3 : if (res) return res;
7839 : }
7840 : }
7841 : break;
7842 : default:;
7843 : }
7844 : break;
7845 : default:;
7846 : }
7847 : }
7848 : break;
7849 7 : case CFN_BUILT_IN_BSWAP64:
7850 7 : if (call_expr_nargs (_p0) == 1)
7851 : {
7852 7 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7853 7 : switch (TREE_CODE (_p1))
7854 : {
7855 3 : case INTEGER_CST:
7856 3 : {
7857 3 : {
7858 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7859 3 : tree res = generic_simplify_242 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP64);
7860 3 : if (res) return res;
7861 : }
7862 3 : break;
7863 : }
7864 3 : case CALL_EXPR:
7865 3 : switch (get_call_combined_fn (_p1))
7866 : {
7867 3 : case CFN_BUILT_IN_BSWAP64:
7868 3 : if (call_expr_nargs (_p1) == 1)
7869 : {
7870 3 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7871 3 : {
7872 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7873 3 : tree res = generic_simplify_241 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP64);
7874 3 : if (res) return res;
7875 : }
7876 : }
7877 : break;
7878 : default:;
7879 : }
7880 : break;
7881 : default:;
7882 : }
7883 : }
7884 : break;
7885 : default:;
7886 : }
7887 : break;
7888 40524913 : default:;
7889 : }
7890 40524913 : switch (TREE_CODE (_p1))
7891 : {
7892 16 : case VEC_COND_EXPR:
7893 16 : {
7894 16 : tree _q30 = TREE_OPERAND (_p1, 0);
7895 16 : tree _q31 = TREE_OPERAND (_p1, 1);
7896 16 : tree _q32 = TREE_OPERAND (_p1, 2);
7897 16 : {
7898 16 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
7899 16 : if (VECTOR_TYPE_P (type)
7900 16 : && (TREE_CODE_CLASS (NE_EXPR) != tcc_comparison
7901 16 : || types_match (type, TREE_TYPE (captures[3]))
7902 16 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
7903 : || (optimize_vectors_before_lowering_p ()
7904 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
7905 : )
7906 : {
7907 16 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1538;
7908 16 : {
7909 16 : if (! tree_invariant_p (captures[0])) goto next_after_fail1538;
7910 0 : tree res_op0;
7911 0 : res_op0 = captures[2];
7912 0 : tree res_op1;
7913 0 : {
7914 0 : tree _o1[2], _r1;
7915 0 : _o1[0] = unshare_expr (captures[0]);
7916 0 : _o1[1] = captures[3];
7917 0 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7918 0 : if (EXPR_P (_r1))
7919 0 : goto next_after_fail1538;
7920 0 : res_op1 = _r1;
7921 : }
7922 0 : tree res_op2;
7923 0 : {
7924 0 : tree _o1[2], _r1;
7925 0 : _o1[0] = captures[0];
7926 0 : _o1[1] = captures[4];
7927 0 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7928 0 : if (EXPR_P (_r1))
7929 0 : goto next_after_fail1538;
7930 0 : res_op2 = _r1;
7931 : }
7932 0 : tree _r;
7933 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7934 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
7935 0 : return _r;
7936 : }
7937 16 : next_after_fail1538:;
7938 : }
7939 : }
7940 16 : break;
7941 : }
7942 40524913 : default:;
7943 : }
7944 40524913 : switch (TREE_CODE (_p0))
7945 : {
7946 96593 : case COND_EXPR:
7947 96593 : {
7948 96593 : tree _q20 = TREE_OPERAND (_p0, 0);
7949 96593 : tree _q21 = TREE_OPERAND (_p0, 1);
7950 96593 : tree _q22 = TREE_OPERAND (_p0, 2);
7951 96593 : switch (TREE_CODE (_p1))
7952 : {
7953 276 : case COND_EXPR:
7954 276 : {
7955 276 : tree _q60 = TREE_OPERAND (_p1, 0);
7956 276 : tree _q61 = TREE_OPERAND (_p1, 1);
7957 276 : tree _q62 = TREE_OPERAND (_p1, 2);
7958 276 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
7959 : {
7960 72 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
7961 : {
7962 72 : {
7963 72 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
7964 72 : const enum tree_code eqne = NE_EXPR;
7965 72 : if (!HONOR_NANS (captures[1])
7966 56 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
7967 49 : && types_match (type, TREE_TYPE (captures[0]))
7968 49 : && expr_no_side_effects_p (captures[1])
7969 114 : && expr_no_side_effects_p (captures[2])
7970 : )
7971 : {
7972 42 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1539;
7973 42 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1539;
7974 42 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1539;
7975 42 : {
7976 42 : tree res_op0;
7977 42 : {
7978 42 : tree _o1[2], _r1;
7979 42 : {
7980 42 : tree _o2[2], _r2;
7981 42 : _o2[0] = captures[0];
7982 42 : _o2[1] = captures[3];
7983 42 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
7984 42 : _o1[0] = _r2;
7985 : }
7986 42 : {
7987 42 : tree _o2[2], _r2;
7988 42 : _o2[0] = captures[1];
7989 42 : _o2[1] = captures[2];
7990 42 : _r2 = fold_build2_loc (loc, NE_EXPR, type, _o2[0], _o2[1]);
7991 42 : _o1[1] = _r2;
7992 : }
7993 42 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
7994 42 : res_op0 = _r1;
7995 : }
7996 42 : tree res_op1;
7997 42 : res_op1 = constant_boolean_node (eqne == NE_EXPR, type);
7998 42 : tree res_op2;
7999 42 : res_op2 = constant_boolean_node (eqne != NE_EXPR, type);
8000 42 : tree _r;
8001 42 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
8002 42 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 964, __FILE__, __LINE__, true);
8003 42 : return _r;
8004 : }
8005 30 : next_after_fail1539:;
8006 : }
8007 : }
8008 : }
8009 : }
8010 234 : if ((_q61 == _q22 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q22, 0) && types_match (_q61, _q22)))
8011 : {
8012 0 : if ((_q62 == _q21 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q21, 0) && types_match (_q62, _q21)))
8013 : {
8014 0 : {
8015 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
8016 0 : const enum tree_code eqne = NE_EXPR;
8017 0 : if (!HONOR_NANS (captures[1])
8018 0 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
8019 0 : && types_match (type, TREE_TYPE (captures[0]))
8020 0 : && expr_no_side_effects_p (captures[1])
8021 0 : && expr_no_side_effects_p (captures[2])
8022 : )
8023 : {
8024 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1540;
8025 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1540;
8026 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1540;
8027 0 : {
8028 0 : tree res_op0;
8029 0 : {
8030 0 : tree _o1[2], _r1;
8031 0 : {
8032 0 : tree _o2[2], _r2;
8033 0 : _o2[0] = captures[0];
8034 0 : _o2[1] = captures[3];
8035 0 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8036 0 : _o1[0] = _r2;
8037 : }
8038 0 : {
8039 0 : tree _o2[2], _r2;
8040 0 : _o2[0] = captures[1];
8041 0 : _o2[1] = captures[2];
8042 0 : _r2 = fold_build2_loc (loc, EQ_EXPR, type, _o2[0], _o2[1]);
8043 0 : _o1[1] = _r2;
8044 : }
8045 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8046 0 : res_op0 = _r1;
8047 : }
8048 0 : tree res_op1;
8049 0 : res_op1 = constant_boolean_node (eqne != NE_EXPR, type);
8050 0 : tree res_op2;
8051 0 : res_op2 = constant_boolean_node (eqne == NE_EXPR, type);
8052 0 : tree _r;
8053 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
8054 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 965, __FILE__, __LINE__, true);
8055 0 : return _r;
8056 : }
8057 0 : next_after_fail1540:;
8058 : }
8059 : }
8060 : }
8061 : }
8062 : break;
8063 : }
8064 : default:;
8065 : }
8066 : break;
8067 : }
8068 188 : case VEC_COND_EXPR:
8069 188 : {
8070 188 : tree _q20 = TREE_OPERAND (_p0, 0);
8071 188 : tree _q21 = TREE_OPERAND (_p0, 1);
8072 188 : tree _q22 = TREE_OPERAND (_p0, 2);
8073 188 : switch (TREE_CODE (_p1))
8074 : {
8075 8 : case VEC_COND_EXPR:
8076 8 : {
8077 8 : tree _q60 = TREE_OPERAND (_p1, 0);
8078 8 : tree _q61 = TREE_OPERAND (_p1, 1);
8079 8 : tree _q62 = TREE_OPERAND (_p1, 2);
8080 8 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
8081 : {
8082 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
8083 : {
8084 0 : {
8085 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
8086 0 : const enum tree_code eqne = NE_EXPR;
8087 0 : if (!HONOR_NANS (captures[1])
8088 0 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
8089 0 : && types_match (type, TREE_TYPE (captures[0]))
8090 0 : && expr_no_side_effects_p (captures[1])
8091 0 : && expr_no_side_effects_p (captures[2])
8092 : )
8093 : {
8094 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1541;
8095 0 : {
8096 0 : tree res_op0;
8097 0 : {
8098 0 : tree _o1[2], _r1;
8099 0 : {
8100 0 : tree _o2[2], _r2;
8101 0 : _o2[0] = captures[0];
8102 0 : _o2[1] = captures[3];
8103 0 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8104 0 : _o1[0] = _r2;
8105 : }
8106 0 : {
8107 0 : tree _o2[2], _r2;
8108 0 : _o2[0] = captures[1];
8109 0 : _o2[1] = captures[2];
8110 0 : _r2 = fold_build2_loc (loc, NE_EXPR, type, _o2[0], _o2[1]);
8111 0 : _o1[1] = _r2;
8112 : }
8113 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8114 0 : res_op0 = _r1;
8115 : }
8116 0 : tree res_op1;
8117 0 : res_op1 = constant_boolean_node (eqne == NE_EXPR, type);
8118 0 : tree res_op2;
8119 0 : res_op2 = constant_boolean_node (eqne != NE_EXPR, type);
8120 0 : tree _r;
8121 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8122 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 964, __FILE__, __LINE__, true);
8123 0 : return _r;
8124 : }
8125 0 : next_after_fail1541:;
8126 : }
8127 : }
8128 : }
8129 : }
8130 8 : if ((_q61 == _q22 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q22, 0) && types_match (_q61, _q22)))
8131 : {
8132 8 : if ((_q62 == _q21 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q21, 0) && types_match (_q62, _q21)))
8133 : {
8134 8 : {
8135 8 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
8136 8 : const enum tree_code eqne = NE_EXPR;
8137 8 : if (!HONOR_NANS (captures[1])
8138 0 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
8139 0 : && types_match (type, TREE_TYPE (captures[0]))
8140 0 : && expr_no_side_effects_p (captures[1])
8141 8 : && expr_no_side_effects_p (captures[2])
8142 : )
8143 : {
8144 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1542;
8145 0 : {
8146 0 : tree res_op0;
8147 0 : {
8148 0 : tree _o1[2], _r1;
8149 0 : {
8150 0 : tree _o2[2], _r2;
8151 0 : _o2[0] = captures[0];
8152 0 : _o2[1] = captures[3];
8153 0 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8154 0 : _o1[0] = _r2;
8155 : }
8156 0 : {
8157 0 : tree _o2[2], _r2;
8158 0 : _o2[0] = captures[1];
8159 0 : _o2[1] = captures[2];
8160 0 : _r2 = fold_build2_loc (loc, EQ_EXPR, type, _o2[0], _o2[1]);
8161 0 : _o1[1] = _r2;
8162 : }
8163 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8164 0 : res_op0 = _r1;
8165 : }
8166 0 : tree res_op1;
8167 0 : res_op1 = constant_boolean_node (eqne != NE_EXPR, type);
8168 0 : tree res_op2;
8169 0 : res_op2 = constant_boolean_node (eqne == NE_EXPR, type);
8170 0 : tree _r;
8171 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8172 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 965, __FILE__, __LINE__, true);
8173 0 : return _r;
8174 : }
8175 0 : next_after_fail1542:;
8176 : }
8177 : }
8178 : }
8179 : }
8180 : break;
8181 : }
8182 : default:;
8183 : }
8184 : break;
8185 : }
8186 18071 : case LT_EXPR:
8187 18071 : {
8188 18071 : tree _q20 = TREE_OPERAND (_p0, 0);
8189 18071 : tree _q21 = TREE_OPERAND (_p0, 1);
8190 18071 : if (integer_zerop (_p1))
8191 : {
8192 16571 : {
8193 16571 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8194 16571 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, LT_EXPR, GE_EXPR, UNGE_EXPR);
8195 16571 : if (res) return res;
8196 : }
8197 : }
8198 15137 : if (integer_truep (_p1))
8199 : {
8200 547 : {
8201 547 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8202 547 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, LT_EXPR, GE_EXPR, UNGE_EXPR);
8203 547 : if (res) return res;
8204 : }
8205 : }
8206 : break;
8207 : }
8208 11872 : case LE_EXPR:
8209 11872 : {
8210 11872 : tree _q20 = TREE_OPERAND (_p0, 0);
8211 11872 : tree _q21 = TREE_OPERAND (_p0, 1);
8212 11872 : if (integer_zerop (_p1))
8213 : {
8214 9311 : {
8215 9311 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8216 9311 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR, UNGT_EXPR);
8217 9311 : if (res) return res;
8218 : }
8219 : }
8220 11080 : if (integer_truep (_p1))
8221 : {
8222 461 : {
8223 461 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8224 461 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR, UNGT_EXPR);
8225 461 : if (res) return res;
8226 : }
8227 : }
8228 : break;
8229 : }
8230 63220 : case EQ_EXPR:
8231 63220 : {
8232 63220 : tree _q20 = TREE_OPERAND (_p0, 0);
8233 63220 : tree _q21 = TREE_OPERAND (_p0, 1);
8234 63220 : if (integer_zerop (_p1))
8235 : {
8236 35581 : {
8237 35581 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8238 35581 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR, NE_EXPR);
8239 35581 : if (res) return res;
8240 : }
8241 : }
8242 62099 : if (integer_truep (_p1))
8243 : {
8244 21941 : {
8245 21941 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8246 21941 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR, NE_EXPR);
8247 21941 : if (res) return res;
8248 : }
8249 : }
8250 : break;
8251 : }
8252 68520 : case NE_EXPR:
8253 68520 : {
8254 68520 : tree _q20 = TREE_OPERAND (_p0, 0);
8255 68520 : tree _q21 = TREE_OPERAND (_p0, 1);
8256 68520 : if (integer_zerop (_p1))
8257 : {
8258 56702 : {
8259 56702 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8260 56702 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR, EQ_EXPR);
8261 56702 : if (res) return res;
8262 : }
8263 : }
8264 34349 : if (integer_truep (_p1))
8265 : {
8266 141 : {
8267 141 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8268 141 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR, EQ_EXPR);
8269 141 : if (res) return res;
8270 : }
8271 : }
8272 : break;
8273 : }
8274 6123 : case GE_EXPR:
8275 6123 : {
8276 6123 : tree _q20 = TREE_OPERAND (_p0, 0);
8277 6123 : tree _q21 = TREE_OPERAND (_p0, 1);
8278 6123 : if (integer_zerop (_p1))
8279 : {
8280 4174 : {
8281 4174 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8282 4174 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, GE_EXPR, LT_EXPR, UNLT_EXPR);
8283 4174 : if (res) return res;
8284 : }
8285 : }
8286 5465 : if (integer_truep (_p1))
8287 : {
8288 478 : {
8289 478 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8290 478 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, GE_EXPR, LT_EXPR, UNLT_EXPR);
8291 478 : if (res) return res;
8292 : }
8293 : }
8294 : break;
8295 : }
8296 35380 : case GT_EXPR:
8297 35380 : {
8298 35380 : tree _q20 = TREE_OPERAND (_p0, 0);
8299 35380 : tree _q21 = TREE_OPERAND (_p0, 1);
8300 35380 : if (integer_zerop (_p1))
8301 : {
8302 33314 : {
8303 33314 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8304 33314 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, GT_EXPR, LE_EXPR, UNLE_EXPR);
8305 33314 : if (res) return res;
8306 : }
8307 : }
8308 29394 : if (integer_truep (_p1))
8309 : {
8310 320 : {
8311 320 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8312 320 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, GT_EXPR, LE_EXPR, UNLE_EXPR);
8313 320 : if (res) return res;
8314 : }
8315 : }
8316 : break;
8317 : }
8318 128161 : case UNORDERED_EXPR:
8319 128161 : {
8320 128161 : tree _q20 = TREE_OPERAND (_p0, 0);
8321 128161 : tree _q21 = TREE_OPERAND (_p0, 1);
8322 128161 : if (integer_zerop (_p1))
8323 : {
8324 125953 : {
8325 125953 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8326 125953 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR);
8327 125953 : if (res) return res;
8328 : }
8329 : }
8330 127771 : if (integer_truep (_p1))
8331 : {
8332 42 : {
8333 42 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8334 42 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR);
8335 42 : if (res) return res;
8336 : }
8337 : }
8338 : break;
8339 : }
8340 125 : case ORDERED_EXPR:
8341 125 : {
8342 125 : tree _q20 = TREE_OPERAND (_p0, 0);
8343 125 : tree _q21 = TREE_OPERAND (_p0, 1);
8344 125 : if (integer_zerop (_p1))
8345 : {
8346 42 : {
8347 42 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8348 42 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR);
8349 42 : if (res) return res;
8350 : }
8351 : }
8352 83 : if (integer_truep (_p1))
8353 : {
8354 0 : {
8355 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8356 0 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR);
8357 0 : if (res) return res;
8358 : }
8359 : }
8360 : break;
8361 : }
8362 225 : case UNLT_EXPR:
8363 225 : {
8364 225 : tree _q20 = TREE_OPERAND (_p0, 0);
8365 225 : tree _q21 = TREE_OPERAND (_p0, 1);
8366 225 : if (integer_zerop (_p1))
8367 : {
8368 28 : {
8369 28 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8370 28 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, UNLT_EXPR, GE_EXPR, GE_EXPR);
8371 28 : if (res) return res;
8372 : }
8373 : }
8374 197 : if (integer_truep (_p1))
8375 : {
8376 169 : {
8377 169 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8378 169 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, UNLT_EXPR, GE_EXPR, GE_EXPR);
8379 169 : if (res) return res;
8380 : }
8381 : }
8382 : break;
8383 : }
8384 1442 : case UNLE_EXPR:
8385 1442 : {
8386 1442 : tree _q20 = TREE_OPERAND (_p0, 0);
8387 1442 : tree _q21 = TREE_OPERAND (_p0, 1);
8388 1442 : if (integer_zerop (_p1))
8389 : {
8390 104 : {
8391 104 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8392 104 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, UNLE_EXPR, GT_EXPR, GT_EXPR);
8393 104 : if (res) return res;
8394 : }
8395 : }
8396 1338 : if (integer_truep (_p1))
8397 : {
8398 1310 : {
8399 1310 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8400 1310 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, UNLE_EXPR, GT_EXPR, GT_EXPR);
8401 1310 : if (res) return res;
8402 : }
8403 : }
8404 : break;
8405 : }
8406 2800 : case UNGT_EXPR:
8407 2800 : {
8408 2800 : tree _q20 = TREE_OPERAND (_p0, 0);
8409 2800 : tree _q21 = TREE_OPERAND (_p0, 1);
8410 2800 : if (integer_zerop (_p1))
8411 : {
8412 96 : {
8413 96 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8414 96 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, UNGT_EXPR, LE_EXPR, LE_EXPR);
8415 96 : if (res) return res;
8416 : }
8417 : }
8418 2704 : if (integer_truep (_p1))
8419 : {
8420 2556 : {
8421 2556 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8422 2556 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, UNGT_EXPR, LE_EXPR, LE_EXPR);
8423 2556 : if (res) return res;
8424 : }
8425 : }
8426 : break;
8427 : }
8428 403 : case UNGE_EXPR:
8429 403 : {
8430 403 : tree _q20 = TREE_OPERAND (_p0, 0);
8431 403 : tree _q21 = TREE_OPERAND (_p0, 1);
8432 403 : if (integer_zerop (_p1))
8433 : {
8434 16 : {
8435 16 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8436 16 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, UNGE_EXPR, LT_EXPR, LT_EXPR);
8437 16 : if (res) return res;
8438 : }
8439 : }
8440 387 : if (integer_truep (_p1))
8441 : {
8442 219 : {
8443 219 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8444 219 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, UNGE_EXPR, LT_EXPR, LT_EXPR);
8445 219 : if (res) return res;
8446 : }
8447 : }
8448 : break;
8449 : }
8450 175 : case UNEQ_EXPR:
8451 175 : {
8452 175 : tree _q20 = TREE_OPERAND (_p0, 0);
8453 175 : tree _q21 = TREE_OPERAND (_p0, 1);
8454 175 : if (integer_zerop (_p1))
8455 : {
8456 0 : {
8457 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8458 0 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR);
8459 0 : if (res) return res;
8460 : }
8461 : }
8462 175 : if (integer_truep (_p1))
8463 : {
8464 132 : {
8465 132 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8466 132 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR);
8467 132 : if (res) return res;
8468 : }
8469 : }
8470 : break;
8471 : }
8472 27 : case LTGT_EXPR:
8473 27 : {
8474 27 : tree _q20 = TREE_OPERAND (_p0, 0);
8475 27 : tree _q21 = TREE_OPERAND (_p0, 1);
8476 27 : if (integer_zerop (_p1))
8477 : {
8478 6 : {
8479 6 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8480 6 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR);
8481 6 : if (res) return res;
8482 : }
8483 : }
8484 27 : if (integer_truep (_p1))
8485 : {
8486 0 : {
8487 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8488 0 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR);
8489 0 : if (res) return res;
8490 : }
8491 : }
8492 : break;
8493 : }
8494 104316 : case MINUS_EXPR:
8495 104316 : {
8496 104316 : tree _q20 = TREE_OPERAND (_p0, 0);
8497 104316 : tree _q21 = TREE_OPERAND (_p0, 1);
8498 104316 : if (integer_zerop (_p1))
8499 : {
8500 34699 : {
8501 34699 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8502 34699 : tree res = generic_simplify_245 (loc, type, _p0, _p1, captures, NE_EXPR);
8503 34699 : if (res) return res;
8504 : }
8505 : }
8506 : break;
8507 : }
8508 26760 : case POINTER_DIFF_EXPR:
8509 26760 : {
8510 26760 : tree _q20 = TREE_OPERAND (_p0, 0);
8511 26760 : tree _q21 = TREE_OPERAND (_p0, 1);
8512 26760 : if (integer_zerop (_p1))
8513 : {
8514 14795 : {
8515 14795 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8516 14795 : tree res = generic_simplify_246 (loc, type, _p0, _p1, captures, NE_EXPR);
8517 14795 : if (res) return res;
8518 : }
8519 : }
8520 : break;
8521 : }
8522 95074 : case MULT_EXPR:
8523 95074 : {
8524 95074 : tree _q20 = TREE_OPERAND (_p0, 0);
8525 95074 : tree _q21 = TREE_OPERAND (_p0, 1);
8526 95074 : switch (TREE_CODE (_q21))
8527 : {
8528 77544 : case INTEGER_CST:
8529 77544 : {
8530 77544 : switch (TREE_CODE (_p1))
8531 : {
8532 51770 : case INTEGER_CST:
8533 51770 : {
8534 51770 : {
8535 51770 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8536 51770 : tree res = generic_simplify_248 (loc, type, _p0, _p1, captures, NE_EXPR);
8537 51770 : if (res) return res;
8538 : }
8539 35241 : break;
8540 : }
8541 61015 : default:;
8542 : }
8543 61015 : if (integer_zerop (_p1))
8544 : {
8545 12614 : {
8546 12614 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
8547 12614 : tree res = generic_simplify_247 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
8548 12614 : if (res) return res;
8549 : }
8550 : }
8551 : break;
8552 : }
8553 : default:;
8554 : }
8555 : break;
8556 : }
8557 40390474 : default:;
8558 : }
8559 40390474 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
8560 : {
8561 123843 : {
8562 123843 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8563 123843 : tree res = generic_simplify_300 (loc, type, _p0, _p1, captures, NE_EXPR);
8564 123843 : if (res) return res;
8565 : }
8566 : }
8567 40273316 : switch (TREE_CODE (_p0))
8568 : {
8569 8199781 : CASE_CONVERT:
8570 8199781 : {
8571 8199781 : tree _q20 = TREE_OPERAND (_p0, 0);
8572 8199781 : switch (TREE_CODE (_p1))
8573 : {
8574 3106498 : CASE_CONVERT:
8575 3106498 : {
8576 3106498 : tree _q40 = TREE_OPERAND (_p1, 0);
8577 3106498 : {
8578 3106498 : tree _q40_pops[1];
8579 3106498 : if (tree_maybe_bit_not (_q40, _q40_pops))
8580 : {
8581 0 : tree _q50 = _q40_pops[0];
8582 0 : {
8583 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
8584 0 : tree res = generic_simplify_250 (loc, type, _p0, _p1, captures, NE_EXPR);
8585 0 : if (res) return res;
8586 : }
8587 : }
8588 : }
8589 3106498 : break;
8590 : }
8591 8199781 : default:;
8592 : }
8593 8199781 : {
8594 8199781 : tree _q20_pops[1];
8595 8199781 : if (tree_maybe_bit_not (_q20, _q20_pops))
8596 : {
8597 12515 : tree _q30 = _q20_pops[0];
8598 12515 : switch (TREE_CODE (_p1))
8599 : {
8600 0 : CASE_CONVERT:
8601 0 : {
8602 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8603 0 : {
8604 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
8605 0 : tree res = generic_simplify_250 (loc, type, _p0, _p1, captures, NE_EXPR);
8606 0 : if (res) return res;
8607 : }
8608 0 : break;
8609 : }
8610 : default:;
8611 : }
8612 : }
8613 : }
8614 8199781 : break;
8615 : }
8616 40273316 : default:;
8617 : }
8618 40273316 : {
8619 40273316 : tree _p1_pops[1];
8620 40273316 : if (tree_maybe_bit_not (_p1, _p1_pops))
8621 : {
8622 30097569 : tree _q30 = _p1_pops[0];
8623 30097569 : {
8624 30097569 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
8625 30097569 : tree res = generic_simplify_250 (loc, type, _p0, _p1, captures, NE_EXPR);
8626 30097569 : if (res) return res;
8627 : }
8628 : }
8629 : }
8630 40273316 : switch (TREE_CODE (_p0))
8631 : {
8632 13363 : case BIT_NOT_EXPR:
8633 13363 : {
8634 13363 : tree _q20 = TREE_OPERAND (_p0, 0);
8635 13363 : switch (TREE_CODE (_p1))
8636 : {
8637 11 : case BIT_NOT_EXPR:
8638 11 : {
8639 11 : tree _q40 = TREE_OPERAND (_p1, 0);
8640 11 : {
8641 11 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _p1, _q40 };
8642 11 : tree res = generic_simplify_253 (loc, type, _p0, _p1, captures, NE_EXPR);
8643 11 : if (res) return res;
8644 : }
8645 0 : break;
8646 : }
8647 13352 : default:;
8648 : }
8649 13352 : {
8650 13352 : tree _p1_pops[1];
8651 13352 : if (tree_nop_convert (_p1, _p1_pops))
8652 : {
8653 80 : tree _q40 = _p1_pops[0];
8654 80 : switch (TREE_CODE (_q40))
8655 : {
8656 0 : case BIT_NOT_EXPR:
8657 0 : {
8658 0 : tree _q50 = TREE_OPERAND (_q40, 0);
8659 0 : {
8660 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40, _q50 };
8661 0 : tree res = generic_simplify_253 (loc, type, _p0, _p1, captures, NE_EXPR);
8662 0 : if (res) return res;
8663 : }
8664 0 : break;
8665 : }
8666 : default:;
8667 : }
8668 : }
8669 : }
8670 13352 : if (CONSTANT_CLASS_P (_p1))
8671 : {
8672 12166 : {
8673 12166 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8674 12166 : tree res = generic_simplify_252 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
8675 12166 : if (res) return res;
8676 : }
8677 : }
8678 : break;
8679 : }
8680 40261139 : default:;
8681 : }
8682 40261139 : {
8683 40261139 : tree _p0_pops[1];
8684 40261139 : if (tree_maybe_bit_not (_p0, _p0_pops))
8685 : {
8686 283163 : tree _q20 = _p0_pops[0];
8687 283163 : {
8688 283163 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _q20 };
8689 283163 : tree res = generic_simplify_250 (loc, type, _p0, _p1, captures, NE_EXPR);
8690 283163 : if (res) return res;
8691 : }
8692 : }
8693 : }
8694 40261137 : {
8695 40261137 : tree _p0_pops[1];
8696 40261137 : if (tree_nop_convert (_p0, _p0_pops))
8697 : {
8698 4784882 : tree _q20 = _p0_pops[0];
8699 4784882 : switch (TREE_CODE (_q20))
8700 : {
8701 1 : case BIT_NOT_EXPR:
8702 1 : {
8703 1 : tree _q30 = TREE_OPERAND (_q20, 0);
8704 1 : switch (TREE_CODE (_p1))
8705 : {
8706 0 : case BIT_NOT_EXPR:
8707 0 : {
8708 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8709 0 : {
8710 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _p1, _q50 };
8711 0 : tree res = generic_simplify_251 (loc, type, _p0, _p1, captures, NE_EXPR);
8712 0 : if (res) return res;
8713 : }
8714 0 : break;
8715 : }
8716 1 : default:;
8717 : }
8718 1 : {
8719 1 : tree _p1_pops[1];
8720 1 : if (tree_nop_convert (_p1, _p1_pops))
8721 : {
8722 0 : tree _q50 = _p1_pops[0];
8723 0 : switch (TREE_CODE (_q50))
8724 : {
8725 0 : case BIT_NOT_EXPR:
8726 0 : {
8727 0 : tree _q60 = TREE_OPERAND (_q50, 0);
8728 0 : {
8729 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50, _q60 };
8730 0 : tree res = generic_simplify_251 (loc, type, _p0, _p1, captures, NE_EXPR);
8731 0 : if (res) return res;
8732 : }
8733 0 : break;
8734 : }
8735 : default:;
8736 : }
8737 : }
8738 : }
8739 1 : if (CONSTANT_CLASS_P (_p1))
8740 : {
8741 1 : {
8742 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
8743 1 : tree res = generic_simplify_252 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
8744 1 : if (res) return res;
8745 : }
8746 : }
8747 : break;
8748 : }
8749 : default:;
8750 : }
8751 : }
8752 : }
8753 40261136 : switch (TREE_CODE (_p1))
8754 : {
8755 693480 : case REAL_CST:
8756 693480 : {
8757 693480 : {
8758 693480 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8759 693480 : tree res = generic_simplify_254 (loc, type, _p0, _p1, captures, NE_EXPR);
8760 693480 : if (res) return res;
8761 : }
8762 626216 : break;
8763 : }
8764 40193872 : default:;
8765 : }
8766 40193872 : switch (TREE_CODE (_p0))
8767 : {
8768 1330335 : case PLUS_EXPR:
8769 1330335 : {
8770 1330335 : tree _q20 = TREE_OPERAND (_p0, 0);
8771 1330335 : tree _q21 = TREE_OPERAND (_p0, 1);
8772 1330335 : switch (TREE_CODE (_q21))
8773 : {
8774 3850 : case REAL_CST:
8775 3850 : {
8776 3850 : switch (TREE_CODE (_p1))
8777 : {
8778 3069 : case REAL_CST:
8779 3069 : {
8780 3069 : {
8781 3069 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8782 3069 : tree res = generic_simplify_255 (loc, type, _p0, _p1, captures, PLUS_EXPR, NE_EXPR);
8783 3069 : if (res) return res;
8784 : }
8785 3069 : break;
8786 : }
8787 : default:;
8788 : }
8789 : break;
8790 : }
8791 : default:;
8792 : }
8793 : break;
8794 : }
8795 69613 : case MINUS_EXPR:
8796 69613 : {
8797 69613 : tree _q20 = TREE_OPERAND (_p0, 0);
8798 69613 : tree _q21 = TREE_OPERAND (_p0, 1);
8799 69613 : switch (TREE_CODE (_q21))
8800 : {
8801 3215 : case REAL_CST:
8802 3215 : {
8803 3215 : switch (TREE_CODE (_p1))
8804 : {
8805 2849 : case REAL_CST:
8806 2849 : {
8807 2849 : {
8808 2849 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8809 2849 : tree res = generic_simplify_255 (loc, type, _p0, _p1, captures, MINUS_EXPR, NE_EXPR);
8810 2849 : if (res) return res;
8811 : }
8812 2849 : break;
8813 : }
8814 : default:;
8815 : }
8816 : break;
8817 : }
8818 69613 : default:;
8819 : }
8820 69613 : switch (TREE_CODE (_q20))
8821 : {
8822 87 : case REAL_CST:
8823 87 : {
8824 87 : switch (TREE_CODE (_p1))
8825 : {
8826 44 : case REAL_CST:
8827 44 : {
8828 44 : {
8829 44 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8830 44 : tree res = generic_simplify_256 (loc, type, _p0, _p1, captures, NE_EXPR);
8831 44 : if (res) return res;
8832 : }
8833 44 : break;
8834 : }
8835 : default:;
8836 : }
8837 : break;
8838 : }
8839 : default:;
8840 : }
8841 : break;
8842 : }
8843 9956 : case FLOAT_EXPR:
8844 9956 : {
8845 9956 : tree _q20 = TREE_OPERAND (_p0, 0);
8846 9956 : switch (TREE_CODE (_p1))
8847 : {
8848 1115 : case FLOAT_EXPR:
8849 1115 : {
8850 1115 : tree _q40 = TREE_OPERAND (_p1, 0);
8851 1115 : {
8852 1115 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
8853 1115 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
8854 1115 : if (res) return res;
8855 : }
8856 971 : break;
8857 : }
8858 1808 : case REAL_CST:
8859 1808 : {
8860 1808 : {
8861 1808 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
8862 1808 : tree res = generic_simplify_260 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
8863 1808 : if (res) return res;
8864 : }
8865 1687 : break;
8866 : }
8867 : default:;
8868 : }
8869 : break;
8870 : }
8871 2045 : case EXACT_DIV_EXPR:
8872 2045 : {
8873 2045 : tree _q20 = TREE_OPERAND (_p0, 0);
8874 2045 : tree _q21 = TREE_OPERAND (_p0, 1);
8875 2045 : switch (TREE_CODE (_p1))
8876 : {
8877 36 : case INTEGER_CST:
8878 36 : {
8879 36 : {
8880 36 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8881 36 : tree res = generic_simplify_261 (loc, type, _p0, _p1, captures, NE_EXPR);
8882 36 : if (res) return res;
8883 : }
8884 0 : break;
8885 : }
8886 : default:;
8887 : }
8888 : break;
8889 : }
8890 6195 : case NEGATE_EXPR:
8891 6195 : {
8892 6195 : tree _q20 = TREE_OPERAND (_p0, 0);
8893 6195 : switch (TREE_CODE (_p1))
8894 : {
8895 4 : case NEGATE_EXPR:
8896 4 : {
8897 4 : tree _q40 = TREE_OPERAND (_p1, 0);
8898 4 : {
8899 4 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
8900 4 : tree res = generic_simplify_262 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
8901 4 : if (res) return res;
8902 : }
8903 0 : break;
8904 : }
8905 6191 : default:;
8906 : }
8907 6191 : if (CONSTANT_CLASS_P (_p1))
8908 : {
8909 580 : {
8910 580 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
8911 580 : tree res = generic_simplify_263 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
8912 580 : if (res) return res;
8913 : }
8914 : }
8915 : break;
8916 : }
8917 1940 : case ABS_EXPR:
8918 1940 : {
8919 1940 : tree _q20 = TREE_OPERAND (_p0, 0);
8920 1940 : if (zerop (_p1))
8921 : {
8922 72 : {
8923 72 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
8924 72 : const enum tree_code eqne = NE_EXPR;
8925 72 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1543;
8926 72 : {
8927 72 : tree res_op0;
8928 72 : res_op0 = captures[0];
8929 72 : tree res_op1;
8930 72 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
8931 72 : tree _r;
8932 72 : _r = fold_build2_loc (loc, eqne, type, res_op0, res_op1);
8933 72 : if (TREE_SIDE_EFFECTS (captures[1]))
8934 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
8935 72 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 966, __FILE__, __LINE__, true);
8936 72 : return _r;
8937 : }
8938 0 : next_after_fail1543:;
8939 : }
8940 : }
8941 : break;
8942 : }
8943 1698 : case ABSU_EXPR:
8944 1698 : {
8945 1698 : tree _q20 = TREE_OPERAND (_p0, 0);
8946 1698 : if (zerop (_p1))
8947 : {
8948 65 : {
8949 65 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
8950 65 : const enum tree_code eqne = NE_EXPR;
8951 65 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1544;
8952 65 : {
8953 65 : tree res_op0;
8954 65 : res_op0 = captures[0];
8955 65 : tree res_op1;
8956 65 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
8957 65 : tree _r;
8958 65 : _r = fold_build2_loc (loc, eqne, type, res_op0, res_op1);
8959 65 : if (TREE_SIDE_EFFECTS (captures[1]))
8960 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
8961 65 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 966, __FILE__, __LINE__, true);
8962 65 : return _r;
8963 : }
8964 0 : next_after_fail1544:;
8965 : }
8966 : }
8967 : break;
8968 : }
8969 8199697 : CASE_CONVERT:
8970 8199697 : {
8971 8199697 : tree _q20 = TREE_OPERAND (_p0, 0);
8972 8199697 : switch (TREE_CODE (_p1))
8973 : {
8974 3106498 : CASE_CONVERT:
8975 3106498 : {
8976 3106498 : tree _q40 = TREE_OPERAND (_p1, 0);
8977 3106498 : {
8978 3106498 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8979 3106498 : tree res = generic_simplify_264 (loc, type, _p0, _p1, captures, NE_EXPR);
8980 3106498 : if (res) return res;
8981 : }
8982 2905813 : break;
8983 : }
8984 7999012 : default:;
8985 : }
8986 7999012 : {
8987 7999012 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
8988 7999012 : tree res = generic_simplify_265 (loc, type, _p0, _p1, captures, NE_EXPR);
8989 7999012 : if (res) return res;
8990 : }
8991 4593370 : switch (TREE_CODE (_q20))
8992 : {
8993 12 : case BIT_IOR_EXPR:
8994 12 : {
8995 12 : tree _q30 = TREE_OPERAND (_q20, 0);
8996 12 : tree _q31 = TREE_OPERAND (_q20, 1);
8997 12 : switch (TREE_CODE (_q31))
8998 : {
8999 0 : case INTEGER_CST:
9000 0 : {
9001 0 : switch (TREE_CODE (_p1))
9002 : {
9003 0 : case INTEGER_CST:
9004 0 : {
9005 0 : {
9006 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _p1 };
9007 0 : tree res = generic_simplify_266 (loc, type, _p0, _p1, captures, NE_EXPR);
9008 0 : if (res) return res;
9009 : }
9010 0 : break;
9011 : }
9012 : default:;
9013 : }
9014 : break;
9015 : }
9016 : default:;
9017 : }
9018 : break;
9019 : }
9020 : default:;
9021 : }
9022 : break;
9023 : }
9024 14942292 : case SSA_NAME:
9025 14942292 : {
9026 14942292 : switch (TREE_CODE (_p1))
9027 : {
9028 313601 : case ADDR_EXPR:
9029 313601 : {
9030 313601 : {
9031 313601 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9032 313601 : tree res = generic_simplify_267 (loc, type, _p0, _p1, captures, NE_EXPR);
9033 313601 : if (res) return res;
9034 : }
9035 313599 : break;
9036 : }
9037 : default:;
9038 : }
9039 : break;
9040 : }
9041 238060 : case BIT_IOR_EXPR:
9042 238060 : {
9043 238060 : tree _q20 = TREE_OPERAND (_p0, 0);
9044 238060 : tree _q21 = TREE_OPERAND (_p0, 1);
9045 238060 : switch (TREE_CODE (_q21))
9046 : {
9047 970 : case INTEGER_CST:
9048 970 : {
9049 970 : switch (TREE_CODE (_p1))
9050 : {
9051 233 : case INTEGER_CST:
9052 233 : {
9053 233 : {
9054 233 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
9055 233 : tree res = generic_simplify_266 (loc, type, _p0, _p1, captures, NE_EXPR);
9056 233 : if (res) return res;
9057 : }
9058 233 : break;
9059 : }
9060 : default:;
9061 : }
9062 : break;
9063 : }
9064 : default:;
9065 : }
9066 : break;
9067 : }
9068 28972 : case BIT_XOR_EXPR:
9069 28972 : {
9070 28972 : tree _q20 = TREE_OPERAND (_p0, 0);
9071 28972 : tree _q21 = TREE_OPERAND (_p0, 1);
9072 28972 : if (integer_zerop (_p1))
9073 : {
9074 24647 : {
9075 24647 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9076 24647 : tree res = generic_simplify_268 (loc, type, _p0, _p1, captures, NE_EXPR);
9077 24647 : if (res) return res;
9078 : }
9079 : }
9080 4325 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9081 : {
9082 1 : {
9083 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9084 1 : tree res = generic_simplify_269 (loc, type, _p0, _p1, captures, NE_EXPR);
9085 1 : if (res) return res;
9086 : }
9087 : }
9088 4324 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
9089 : {
9090 2 : {
9091 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9092 2 : tree res = generic_simplify_269 (loc, type, _p0, _p1, captures, NE_EXPR);
9093 2 : if (res) return res;
9094 : }
9095 : }
9096 : break;
9097 : }
9098 2752764 : case CALL_EXPR:
9099 2752764 : switch (get_call_combined_fn (_p0))
9100 : {
9101 42 : case CFN_BUILT_IN_SQRTF:
9102 42 : if (call_expr_nargs (_p0) == 1)
9103 : {
9104 42 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9105 42 : switch (TREE_CODE (_p1))
9106 : {
9107 0 : case REAL_CST:
9108 0 : {
9109 0 : {
9110 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9111 0 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, NE_EXPR);
9112 0 : if (res) return res;
9113 : }
9114 0 : break;
9115 : }
9116 42 : case CALL_EXPR:
9117 42 : switch (get_call_combined_fn (_p1))
9118 : {
9119 0 : case CFN_BUILT_IN_SQRTF:
9120 0 : if (call_expr_nargs (_p1) == 1)
9121 : {
9122 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9123 0 : {
9124 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9125 0 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, NE_EXPR);
9126 0 : if (res) return res;
9127 : }
9128 : }
9129 : break;
9130 : default:;
9131 : }
9132 : break;
9133 : default:;
9134 : }
9135 : }
9136 : break;
9137 42 : case CFN_BUILT_IN_SQRTL:
9138 42 : if (call_expr_nargs (_p0) == 1)
9139 : {
9140 42 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9141 42 : switch (TREE_CODE (_p1))
9142 : {
9143 0 : case REAL_CST:
9144 0 : {
9145 0 : {
9146 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9147 0 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, NE_EXPR);
9148 0 : if (res) return res;
9149 : }
9150 0 : break;
9151 : }
9152 42 : case CALL_EXPR:
9153 42 : switch (get_call_combined_fn (_p1))
9154 : {
9155 0 : case CFN_BUILT_IN_SQRTL:
9156 0 : if (call_expr_nargs (_p1) == 1)
9157 : {
9158 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9159 0 : {
9160 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9161 0 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, NE_EXPR);
9162 0 : if (res) return res;
9163 : }
9164 : }
9165 : break;
9166 : default:;
9167 : }
9168 : break;
9169 : default:;
9170 : }
9171 : }
9172 : break;
9173 46 : case CFN_BUILT_IN_SQRT:
9174 46 : if (call_expr_nargs (_p0) == 1)
9175 : {
9176 46 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9177 46 : switch (TREE_CODE (_p1))
9178 : {
9179 2 : case REAL_CST:
9180 2 : {
9181 2 : {
9182 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9183 2 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, NE_EXPR);
9184 2 : if (res) return res;
9185 : }
9186 2 : break;
9187 : }
9188 43 : case CALL_EXPR:
9189 43 : switch (get_call_combined_fn (_p1))
9190 : {
9191 0 : case CFN_BUILT_IN_SQRT:
9192 0 : if (call_expr_nargs (_p1) == 1)
9193 : {
9194 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9195 0 : {
9196 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9197 0 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, NE_EXPR);
9198 0 : if (res) return res;
9199 : }
9200 : }
9201 : break;
9202 : default:;
9203 : }
9204 : break;
9205 : default:;
9206 : }
9207 : }
9208 : break;
9209 0 : case CFN_SQRT:
9210 0 : if (call_expr_nargs (_p0) == 1)
9211 : {
9212 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9213 0 : switch (TREE_CODE (_p1))
9214 : {
9215 0 : case REAL_CST:
9216 0 : {
9217 0 : {
9218 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9219 0 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, CFN_SQRT, NE_EXPR);
9220 0 : if (res) return res;
9221 : }
9222 0 : break;
9223 : }
9224 0 : case CALL_EXPR:
9225 0 : switch (get_call_combined_fn (_p1))
9226 : {
9227 0 : case CFN_SQRT:
9228 0 : if (call_expr_nargs (_p1) == 1)
9229 : {
9230 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9231 0 : {
9232 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9233 0 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, CFN_SQRT, NE_EXPR);
9234 0 : if (res) return res;
9235 : }
9236 : }
9237 : break;
9238 : default:;
9239 : }
9240 : break;
9241 : default:;
9242 : }
9243 : }
9244 : break;
9245 : default:;
9246 : }
9247 : break;
9248 36561889 : default:;
9249 : }
9250 36561889 : switch (TREE_CODE (_p1))
9251 : {
9252 840 : case BIT_XOR_EXPR:
9253 840 : {
9254 840 : tree _q30 = TREE_OPERAND (_p1, 0);
9255 840 : tree _q31 = TREE_OPERAND (_p1, 1);
9256 840 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9257 : {
9258 0 : {
9259 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
9260 0 : tree res = generic_simplify_269 (loc, type, _p0, _p1, captures, NE_EXPR);
9261 0 : if (res) return res;
9262 : }
9263 : }
9264 840 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
9265 : {
9266 0 : {
9267 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
9268 0 : tree res = generic_simplify_269 (loc, type, _p0, _p1, captures, NE_EXPR);
9269 0 : if (res) return res;
9270 : }
9271 : }
9272 : break;
9273 : }
9274 36561889 : default:;
9275 : }
9276 36561889 : switch (TREE_CODE (_p0))
9277 : {
9278 1334981 : case BIT_AND_EXPR:
9279 1334981 : {
9280 1334981 : tree _q20 = TREE_OPERAND (_p0, 0);
9281 1334981 : tree _q21 = TREE_OPERAND (_p0, 1);
9282 1334981 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9283 : {
9284 179 : {
9285 179 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9286 179 : tree res = generic_simplify_270 (loc, type, _p0, _p1, captures, NE_EXPR);
9287 179 : if (res) return res;
9288 : }
9289 : }
9290 1334953 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
9291 : {
9292 4425 : {
9293 4425 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9294 4425 : tree res = generic_simplify_270 (loc, type, _p0, _p1, captures, NE_EXPR);
9295 4425 : if (res) return res;
9296 : }
9297 : }
9298 : break;
9299 : }
9300 36561861 : default:;
9301 : }
9302 36561861 : switch (TREE_CODE (_p1))
9303 : {
9304 15638 : case BIT_AND_EXPR:
9305 15638 : {
9306 15638 : tree _q30 = TREE_OPERAND (_p1, 0);
9307 15638 : tree _q31 = TREE_OPERAND (_p1, 1);
9308 15638 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9309 : {
9310 0 : {
9311 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
9312 0 : tree res = generic_simplify_270 (loc, type, _p0, _p1, captures, NE_EXPR);
9313 0 : if (res) return res;
9314 : }
9315 : }
9316 15638 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
9317 : {
9318 0 : {
9319 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
9320 0 : tree res = generic_simplify_270 (loc, type, _p0, _p1, captures, NE_EXPR);
9321 0 : if (res) return res;
9322 : }
9323 : }
9324 : break;
9325 : }
9326 36561861 : default:;
9327 : }
9328 36561861 : switch (TREE_CODE (_p0))
9329 : {
9330 4593370 : CASE_CONVERT:
9331 4593370 : {
9332 4593370 : tree _q20 = TREE_OPERAND (_p0, 0);
9333 4593370 : switch (TREE_CODE (_q20))
9334 : {
9335 0 : case BIT_AND_EXPR:
9336 0 : {
9337 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9338 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9339 0 : switch (TREE_CODE (_q30))
9340 : {
9341 0 : CASE_CONVERT:
9342 0 : {
9343 0 : tree _q40 = TREE_OPERAND (_q30, 0);
9344 0 : switch (TREE_CODE (_q31))
9345 : {
9346 0 : case INTEGER_CST:
9347 0 : {
9348 0 : switch (TREE_CODE (_p1))
9349 : {
9350 0 : CASE_CONVERT:
9351 0 : {
9352 0 : tree _q70 = TREE_OPERAND (_p1, 0);
9353 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
9354 : {
9355 0 : {
9356 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q40, _q31 };
9357 0 : tree res = generic_simplify_271 (loc, type, _p0, _p1, captures, NE_EXPR);
9358 0 : if (res) return res;
9359 : }
9360 : }
9361 : break;
9362 : }
9363 : default:;
9364 : }
9365 : break;
9366 : }
9367 : default:;
9368 : }
9369 : break;
9370 : }
9371 : default:;
9372 : }
9373 : break;
9374 : }
9375 4593370 : default:;
9376 : }
9377 4593370 : switch (TREE_CODE (_p1))
9378 : {
9379 2905813 : CASE_CONVERT:
9380 2905813 : {
9381 2905813 : tree _q40 = TREE_OPERAND (_p1, 0);
9382 2905813 : switch (TREE_CODE (_q40))
9383 : {
9384 0 : case BIT_AND_EXPR:
9385 0 : {
9386 0 : tree _q50 = TREE_OPERAND (_q40, 0);
9387 0 : tree _q51 = TREE_OPERAND (_q40, 1);
9388 0 : switch (TREE_CODE (_q50))
9389 : {
9390 0 : CASE_CONVERT:
9391 0 : {
9392 0 : tree _q60 = TREE_OPERAND (_q50, 0);
9393 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9394 : {
9395 0 : switch (TREE_CODE (_q51))
9396 : {
9397 0 : case INTEGER_CST:
9398 0 : {
9399 0 : {
9400 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q50, _q20, _q51 };
9401 0 : tree res = generic_simplify_271 (loc, type, _p0, _p1, captures, NE_EXPR);
9402 0 : if (res) return res;
9403 : }
9404 0 : break;
9405 : }
9406 : default:;
9407 : }
9408 : }
9409 : break;
9410 : }
9411 : default:;
9412 : }
9413 : break;
9414 : }
9415 : default:;
9416 : }
9417 : break;
9418 : }
9419 : default:;
9420 : }
9421 : break;
9422 : }
9423 238060 : case BIT_IOR_EXPR:
9424 238060 : {
9425 238060 : tree _q20 = TREE_OPERAND (_p0, 0);
9426 238060 : tree _q21 = TREE_OPERAND (_p0, 1);
9427 238060 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
9428 : {
9429 128 : {
9430 128 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9431 128 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, NE_EXPR);
9432 128 : if (res) return res;
9433 : }
9434 : }
9435 238052 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9436 : {
9437 253 : {
9438 253 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9439 253 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, NE_EXPR);
9440 253 : if (res) return res;
9441 : }
9442 : }
9443 : break;
9444 : }
9445 36561853 : default:;
9446 : }
9447 36561853 : switch (TREE_CODE (_p1))
9448 : {
9449 550 : case BIT_IOR_EXPR:
9450 550 : {
9451 550 : tree _q30 = TREE_OPERAND (_p1, 0);
9452 550 : tree _q31 = TREE_OPERAND (_p1, 1);
9453 550 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
9454 : {
9455 0 : {
9456 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
9457 0 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, NE_EXPR);
9458 0 : if (res) return res;
9459 : }
9460 : }
9461 550 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9462 : {
9463 0 : {
9464 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _p0 };
9465 0 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, NE_EXPR);
9466 0 : if (res) return res;
9467 : }
9468 : }
9469 : break;
9470 : }
9471 36561853 : default:;
9472 : }
9473 36561853 : switch (TREE_CODE (_p0))
9474 : {
9475 4593370 : CASE_CONVERT:
9476 4593370 : {
9477 4593370 : tree _q20 = TREE_OPERAND (_p0, 0);
9478 4593370 : switch (TREE_CODE (_q20))
9479 : {
9480 8 : case BIT_XOR_EXPR:
9481 8 : {
9482 8 : tree _q30 = TREE_OPERAND (_q20, 0);
9483 8 : tree _q31 = TREE_OPERAND (_q20, 1);
9484 8 : switch (TREE_CODE (_q31))
9485 : {
9486 0 : case INTEGER_CST:
9487 0 : {
9488 0 : switch (TREE_CODE (_p1))
9489 : {
9490 0 : case INTEGER_CST:
9491 0 : {
9492 0 : {
9493 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _p1 };
9494 0 : tree res = generic_simplify_273 (loc, type, _p0, _p1, captures, NE_EXPR);
9495 0 : if (res) return res;
9496 : }
9497 0 : break;
9498 : }
9499 : default:;
9500 : }
9501 : break;
9502 : }
9503 : default:;
9504 : }
9505 : break;
9506 : }
9507 : default:;
9508 : }
9509 : break;
9510 : }
9511 4322 : case BIT_XOR_EXPR:
9512 4322 : {
9513 4322 : tree _q20 = TREE_OPERAND (_p0, 0);
9514 4322 : tree _q21 = TREE_OPERAND (_p0, 1);
9515 4322 : switch (TREE_CODE (_q21))
9516 : {
9517 884 : case INTEGER_CST:
9518 884 : {
9519 884 : switch (TREE_CODE (_p1))
9520 : {
9521 10 : case INTEGER_CST:
9522 10 : {
9523 10 : {
9524 10 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
9525 10 : tree res = generic_simplify_273 (loc, type, _p0, _p1, captures, NE_EXPR);
9526 10 : if (res) return res;
9527 : }
9528 0 : break;
9529 : }
9530 : default:;
9531 : }
9532 : break;
9533 : }
9534 : default:;
9535 : }
9536 : break;
9537 : }
9538 36561843 : default:;
9539 : }
9540 36561843 : {
9541 36561843 : tree _p0_pops[1];
9542 36561843 : if (tree_nop_convert (_p0, _p0_pops))
9543 : {
9544 3880322 : tree _q20 = _p0_pops[0];
9545 3880322 : if (integer_zerop (_p1))
9546 : {
9547 886916 : {
9548 886916 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9549 886916 : tree res = generic_simplify_274 (loc, type, _p0, _p1, captures, NE_EXPR);
9550 886916 : if (res) return res;
9551 : }
9552 : }
9553 : }
9554 : }
9555 36056310 : if (integer_zerop (_p1))
9556 : {
9557 20562204 : {
9558 20562204 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
9559 20562204 : tree res = generic_simplify_274 (loc, type, _p0, _p1, captures, NE_EXPR);
9560 20562204 : if (res) return res;
9561 : }
9562 : }
9563 35871168 : switch (TREE_CODE (_p0))
9564 : {
9565 1334953 : case BIT_AND_EXPR:
9566 1334953 : {
9567 1334953 : tree _q20 = TREE_OPERAND (_p0, 0);
9568 1334953 : tree _q21 = TREE_OPERAND (_p0, 1);
9569 1334953 : switch (TREE_CODE (_p1))
9570 : {
9571 14171 : case BIT_AND_EXPR:
9572 14171 : {
9573 14171 : tree _q50 = TREE_OPERAND (_p1, 0);
9574 14171 : tree _q51 = TREE_OPERAND (_p1, 1);
9575 14171 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9576 : {
9577 13926 : {
9578 13926 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
9579 13926 : tree res = generic_simplify_275 (loc, type, _p0, _p1, captures, NE_EXPR);
9580 13926 : if (res) return res;
9581 : }
9582 : }
9583 245 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9584 : {
9585 2 : {
9586 2 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
9587 2 : tree res = generic_simplify_275 (loc, type, _p0, _p1, captures, NE_EXPR);
9588 2 : if (res) return res;
9589 : }
9590 : }
9591 243 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9592 : {
9593 1 : {
9594 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q50 };
9595 1 : tree res = generic_simplify_275 (loc, type, _p0, _p1, captures, NE_EXPR);
9596 1 : if (res) return res;
9597 : }
9598 : }
9599 242 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9600 : {
9601 7 : {
9602 7 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q51 };
9603 7 : tree res = generic_simplify_275 (loc, type, _p0, _p1, captures, NE_EXPR);
9604 7 : if (res) return res;
9605 : }
9606 : }
9607 : break;
9608 : }
9609 1321017 : default:;
9610 : }
9611 1321017 : if (integer_pow2p (_q21))
9612 : {
9613 648560 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
9614 : {
9615 579 : {
9616 579 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
9617 579 : tree res = generic_simplify_276 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
9618 579 : if (res) return res;
9619 : }
9620 : }
9621 : }
9622 1320442 : switch (TREE_CODE (_q20))
9623 : {
9624 191426 : CASE_CONVERT:
9625 191426 : {
9626 191426 : tree _q30 = TREE_OPERAND (_q20, 0);
9627 191426 : if (integer_pow2p (_q21))
9628 : {
9629 94886 : if (integer_zerop (_p1))
9630 : {
9631 94791 : {
9632 94791 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q21 };
9633 94791 : tree res = generic_simplify_277 (loc, type, _p0, _p1, captures, NE_EXPR, LT_EXPR);
9634 94791 : if (res) return res;
9635 : }
9636 : }
9637 : }
9638 : break;
9639 : }
9640 1316570 : default:;
9641 : }
9642 1316570 : if (integer_pow2p (_q21))
9643 : {
9644 644113 : if (integer_zerop (_p1))
9645 : {
9646 640689 : {
9647 640689 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q20, _q21 };
9648 640689 : tree res = generic_simplify_278 (loc, type, _p0, _p1, captures, NE_EXPR, LT_EXPR);
9649 640689 : if (res) return res;
9650 : }
9651 : }
9652 : }
9653 : break;
9654 : }
9655 5412 : case GE_EXPR:
9656 5412 : {
9657 5412 : tree _q20 = TREE_OPERAND (_p0, 0);
9658 5412 : tree _q21 = TREE_OPERAND (_p0, 1);
9659 5412 : if (integer_zerop (_q21))
9660 : {
9661 961 : switch (TREE_CODE (_p1))
9662 : {
9663 1 : case GE_EXPR:
9664 1 : {
9665 1 : tree _q50 = TREE_OPERAND (_p1, 0);
9666 1 : tree _q51 = TREE_OPERAND (_p1, 1);
9667 1 : if (integer_zerop (_q51))
9668 : {
9669 1 : {
9670 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
9671 1 : tree res = generic_simplify_279 (loc, type, _p0, _p1, captures, GE_EXPR, NE_EXPR, LT_EXPR);
9672 1 : if (res) return res;
9673 : }
9674 : }
9675 : break;
9676 : }
9677 3 : case LT_EXPR:
9678 3 : {
9679 3 : tree _q50 = TREE_OPERAND (_p1, 0);
9680 3 : tree _q51 = TREE_OPERAND (_p1, 1);
9681 3 : if (integer_zerop (_q51))
9682 : {
9683 3 : {
9684 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
9685 3 : tree res = generic_simplify_280 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR);
9686 3 : if (res) return res;
9687 : }
9688 : }
9689 : break;
9690 : }
9691 : default:;
9692 : }
9693 : }
9694 : break;
9695 : }
9696 15081 : case LT_EXPR:
9697 15081 : {
9698 15081 : tree _q20 = TREE_OPERAND (_p0, 0);
9699 15081 : tree _q21 = TREE_OPERAND (_p0, 1);
9700 15081 : if (integer_zerop (_q21))
9701 : {
9702 8476 : switch (TREE_CODE (_p1))
9703 : {
9704 66 : case LT_EXPR:
9705 66 : {
9706 66 : tree _q50 = TREE_OPERAND (_p1, 0);
9707 66 : tree _q51 = TREE_OPERAND (_p1, 1);
9708 66 : if (integer_zerop (_q51))
9709 : {
9710 66 : {
9711 66 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
9712 66 : tree res = generic_simplify_279 (loc, type, _p0, _p1, captures, LT_EXPR, NE_EXPR, LT_EXPR);
9713 66 : if (res) return res;
9714 : }
9715 : }
9716 : break;
9717 : }
9718 17 : case GE_EXPR:
9719 17 : {
9720 17 : tree _q50 = TREE_OPERAND (_p1, 0);
9721 17 : tree _q51 = TREE_OPERAND (_p1, 1);
9722 17 : if (integer_zerop (_q51))
9723 : {
9724 17 : {
9725 17 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
9726 17 : tree res = generic_simplify_281 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR);
9727 17 : if (res) return res;
9728 : }
9729 : }
9730 : break;
9731 : }
9732 : default:;
9733 : }
9734 : }
9735 : break;
9736 : }
9737 238052 : case BIT_IOR_EXPR:
9738 238052 : {
9739 238052 : tree _q20 = TREE_OPERAND (_p0, 0);
9740 238052 : tree _q21 = TREE_OPERAND (_p0, 1);
9741 238052 : switch (TREE_CODE (_q21))
9742 : {
9743 261 : CASE_CONVERT:
9744 261 : {
9745 261 : tree _q40 = TREE_OPERAND (_q21, 0);
9746 261 : switch (TREE_CODE (_q40))
9747 : {
9748 0 : case NE_EXPR:
9749 0 : {
9750 0 : tree _q50 = TREE_OPERAND (_q40, 0);
9751 0 : tree _q51 = TREE_OPERAND (_q40, 1);
9752 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9753 : {
9754 0 : if (integer_zerop (_q51))
9755 : {
9756 0 : if (integer_zerop (_p1))
9757 : {
9758 0 : {
9759 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9760 0 : tree res = generic_simplify_282 (loc, type, _p0, _p1, captures, NE_EXPR);
9761 0 : if (res) return res;
9762 : }
9763 : }
9764 : }
9765 : }
9766 : break;
9767 : }
9768 : default:;
9769 : }
9770 : break;
9771 : }
9772 238052 : default:;
9773 : }
9774 238052 : switch (TREE_CODE (_q20))
9775 : {
9776 800 : CASE_CONVERT:
9777 800 : {
9778 800 : tree _q30 = TREE_OPERAND (_q20, 0);
9779 800 : switch (TREE_CODE (_q30))
9780 : {
9781 0 : case NE_EXPR:
9782 0 : {
9783 0 : tree _q40 = TREE_OPERAND (_q30, 0);
9784 0 : tree _q41 = TREE_OPERAND (_q30, 1);
9785 0 : if (integer_zerop (_q41))
9786 : {
9787 0 : if ((_q21 == _q40 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q40, 0) && types_match (_q21, _q40)))
9788 : {
9789 0 : if (integer_zerop (_p1))
9790 : {
9791 0 : {
9792 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q40 };
9793 0 : tree res = generic_simplify_282 (loc, type, _p0, _p1, captures, NE_EXPR);
9794 0 : if (res) return res;
9795 : }
9796 : }
9797 : }
9798 : }
9799 : break;
9800 : }
9801 : default:;
9802 : }
9803 : break;
9804 : }
9805 238052 : default:;
9806 : }
9807 238052 : switch (TREE_CODE (_q21))
9808 : {
9809 24 : case NE_EXPR:
9810 24 : {
9811 24 : tree _q40 = TREE_OPERAND (_q21, 0);
9812 24 : tree _q41 = TREE_OPERAND (_q21, 1);
9813 24 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
9814 : {
9815 0 : if (integer_zerop (_q41))
9816 : {
9817 0 : if (integer_zerop (_p1))
9818 : {
9819 0 : {
9820 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9821 0 : tree res = generic_simplify_282 (loc, type, _p0, _p1, captures, NE_EXPR);
9822 0 : if (res) return res;
9823 : }
9824 : }
9825 : }
9826 : }
9827 : break;
9828 : }
9829 238052 : default:;
9830 : }
9831 238052 : switch (TREE_CODE (_q20))
9832 : {
9833 2 : case NE_EXPR:
9834 2 : {
9835 2 : tree _q30 = TREE_OPERAND (_q20, 0);
9836 2 : tree _q31 = TREE_OPERAND (_q20, 1);
9837 2 : if (integer_zerop (_q31))
9838 : {
9839 1 : if ((_q21 == _q30 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q30, 0) && types_match (_q21, _q30)))
9840 : {
9841 0 : if (integer_zerop (_p1))
9842 : {
9843 0 : {
9844 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
9845 0 : tree res = generic_simplify_282 (loc, type, _p0, _p1, captures, NE_EXPR);
9846 0 : if (res) return res;
9847 : }
9848 : }
9849 : }
9850 : }
9851 : break;
9852 : }
9853 : default:;
9854 : }
9855 : break;
9856 : }
9857 4087837 : CASE_CONVERT:
9858 4087837 : {
9859 4087837 : tree _q20 = TREE_OPERAND (_p0, 0);
9860 4087837 : switch (TREE_CODE (_q20))
9861 : {
9862 2761645 : case ADDR_EXPR:
9863 2761645 : {
9864 2761645 : switch (TREE_CODE (_p1))
9865 : {
9866 2732354 : CASE_CONVERT:
9867 2732354 : {
9868 2732354 : tree _q40 = TREE_OPERAND (_p1, 0);
9869 2732354 : switch (TREE_CODE (_q40))
9870 : {
9871 2732354 : case ADDR_EXPR:
9872 2732354 : {
9873 2732354 : {
9874 2732354 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
9875 2732354 : tree res = generic_simplify_283 (loc, type, _p0, _p1, captures, NE_EXPR);
9876 2732354 : if (res) return res;
9877 : }
9878 33 : break;
9879 : }
9880 : default:;
9881 : }
9882 : break;
9883 : }
9884 21243 : case ADDR_EXPR:
9885 21243 : {
9886 21243 : {
9887 21243 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9888 21243 : tree res = generic_simplify_283 (loc, type, _p0, _p1, captures, NE_EXPR);
9889 21243 : if (res) return res;
9890 : }
9891 7935 : break;
9892 : }
9893 : default:;
9894 : }
9895 : break;
9896 : }
9897 : default:;
9898 : }
9899 : break;
9900 : }
9901 61897 : case ADDR_EXPR:
9902 61897 : {
9903 61897 : switch (TREE_CODE (_p1))
9904 : {
9905 203 : CASE_CONVERT:
9906 203 : {
9907 203 : tree _q30 = TREE_OPERAND (_p1, 0);
9908 203 : switch (TREE_CODE (_q30))
9909 : {
9910 203 : case ADDR_EXPR:
9911 203 : {
9912 203 : {
9913 203 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q30 };
9914 203 : tree res = generic_simplify_284 (loc, type, _p0, _p1, captures, NE_EXPR);
9915 203 : if (res) return res;
9916 : }
9917 143 : break;
9918 : }
9919 : default:;
9920 : }
9921 : break;
9922 : }
9923 53507 : case ADDR_EXPR:
9924 53507 : {
9925 53507 : {
9926 53507 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
9927 53507 : tree res = generic_simplify_284 (loc, type, _p0, _p1, captures, NE_EXPR);
9928 53507 : if (res) return res;
9929 : }
9930 3446 : break;
9931 : }
9932 : default:;
9933 : }
9934 : break;
9935 : }
9936 33044476 : default:;
9937 : }
9938 33044476 : {
9939 33044476 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9940 33044476 : tree res = generic_simplify_285 (loc, type, _p0, _p1, captures, NE_EXPR);
9941 33044476 : if (res) return res;
9942 : }
9943 33035381 : switch (TREE_CODE (_p0))
9944 : {
9945 1342208 : CASE_CONVERT:
9946 1342208 : {
9947 1342208 : tree _q20 = TREE_OPERAND (_p0, 0);
9948 1342208 : switch (TREE_CODE (_p1))
9949 : {
9950 839074 : case INTEGER_CST:
9951 839074 : {
9952 839074 : {
9953 839074 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9954 839074 : tree res = generic_simplify_286 (loc, type, _p0, _p1, captures, NE_EXPR);
9955 839074 : if (res) return res;
9956 : }
9957 830366 : break;
9958 : }
9959 1333500 : default:;
9960 : }
9961 1333500 : switch (TREE_CODE (_q20))
9962 : {
9963 8 : case NE_EXPR:
9964 8 : {
9965 8 : tree _q30 = TREE_OPERAND (_q20, 0);
9966 8 : tree _q31 = TREE_OPERAND (_q20, 1);
9967 8 : switch (TREE_CODE (_q31))
9968 : {
9969 8 : case INTEGER_CST:
9970 8 : {
9971 8 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
9972 : {
9973 0 : {
9974 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
9975 0 : tree res = generic_simplify_287 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
9976 0 : if (res) return res;
9977 : }
9978 : }
9979 : break;
9980 : }
9981 : default:;
9982 : }
9983 : break;
9984 : }
9985 0 : case EQ_EXPR:
9986 0 : {
9987 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9988 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9989 0 : switch (TREE_CODE (_q31))
9990 : {
9991 0 : case INTEGER_CST:
9992 0 : {
9993 0 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
9994 : {
9995 0 : {
9996 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
9997 0 : tree res = generic_simplify_287 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR);
9998 0 : if (res) return res;
9999 : }
10000 : }
10001 : break;
10002 : }
10003 : default:;
10004 : }
10005 : break;
10006 : }
10007 : default:;
10008 : }
10009 : break;
10010 : }
10011 33026673 : default:;
10012 : }
10013 33026673 : switch (TREE_CODE (_p1))
10014 : {
10015 572683 : CASE_CONVERT:
10016 572683 : {
10017 572683 : tree _q30 = TREE_OPERAND (_p1, 0);
10018 572683 : switch (TREE_CODE (_q30))
10019 : {
10020 0 : case NE_EXPR:
10021 0 : {
10022 0 : tree _q40 = TREE_OPERAND (_q30, 0);
10023 0 : tree _q41 = TREE_OPERAND (_q30, 1);
10024 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
10025 : {
10026 0 : switch (TREE_CODE (_q41))
10027 : {
10028 0 : case INTEGER_CST:
10029 0 : {
10030 0 : {
10031 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
10032 0 : tree res = generic_simplify_287 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
10033 0 : if (res) return res;
10034 : }
10035 0 : break;
10036 : }
10037 : default:;
10038 : }
10039 : }
10040 : break;
10041 : }
10042 0 : case EQ_EXPR:
10043 0 : {
10044 0 : tree _q40 = TREE_OPERAND (_q30, 0);
10045 0 : tree _q41 = TREE_OPERAND (_q30, 1);
10046 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
10047 : {
10048 0 : switch (TREE_CODE (_q41))
10049 : {
10050 0 : case INTEGER_CST:
10051 0 : {
10052 0 : {
10053 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
10054 0 : tree res = generic_simplify_287 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR);
10055 0 : if (res) return res;
10056 : }
10057 0 : break;
10058 : }
10059 : default:;
10060 : }
10061 : }
10062 : break;
10063 : }
10064 : default:;
10065 : }
10066 : break;
10067 : }
10068 33026673 : default:;
10069 : }
10070 33026673 : if (integer_zerop (_p1))
10071 : {
10072 20351387 : {
10073 20351387 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10074 20351387 : if (TREE_CODE (TREE_TYPE (captures[0])) == BOOLEAN_TYPE
10075 20351387 : && types_match (type, TREE_TYPE (captures[0]))
10076 : )
10077 : {
10078 3356726 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1545;
10079 3356726 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1545;
10080 3356726 : {
10081 3356726 : tree res_op0;
10082 3356726 : res_op0 = captures[0];
10083 3356726 : tree _r;
10084 3356726 : _r = non_lvalue_loc (loc, res_op0);
10085 3356726 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 971, __FILE__, __LINE__, true);
10086 3356726 : return _r;
10087 : }
10088 : next_after_fail1545:;
10089 : }
10090 : }
10091 : }
10092 29669947 : switch (TREE_CODE (_p0))
10093 : {
10094 1036235 : case BIT_AND_EXPR:
10095 1036235 : {
10096 1036235 : tree _q20 = TREE_OPERAND (_p0, 0);
10097 1036235 : tree _q21 = TREE_OPERAND (_p0, 1);
10098 1036235 : switch (TREE_CODE (_q21))
10099 : {
10100 2052 : case VECTOR_CST:
10101 2052 : {
10102 2052 : if (integer_zerop (_p1))
10103 : {
10104 2052 : {
10105 2052 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
10106 2052 : const enum tree_code cmp = NE_EXPR;
10107 2052 : const enum tree_code icmp = GT_EXPR;
10108 2052 : {
10109 2052 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
10110 2052 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
10111 : )
10112 : {
10113 13 : {
10114 13 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
10115 13 : ? optab_vector : optab_default;
10116 13 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
10117 13 : if (target_supports_op_p (utype, icmp, optab)
10118 13 : || (optimize_vectors_before_lowering_p ()
10119 7 : && (!target_supports_op_p (type, cmp, optab)
10120 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
10121 : )
10122 : {
10123 7 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
10124 : )
10125 : {
10126 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1546;
10127 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1546;
10128 0 : {
10129 0 : tree res_op0;
10130 0 : res_op0 = captures[1];
10131 0 : tree res_op1;
10132 0 : res_op1 = csts;
10133 0 : tree _r;
10134 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10135 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10136 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10137 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 968, __FILE__, __LINE__, true);
10138 0 : return _r;
10139 : }
10140 2045 : next_after_fail1546:;
10141 : }
10142 : else
10143 : {
10144 7 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1547;
10145 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1547;
10146 7 : {
10147 7 : tree res_op0;
10148 7 : {
10149 7 : tree _o1[1], _r1;
10150 7 : _o1[0] = captures[1];
10151 7 : if (TREE_TYPE (_o1[0]) != utype)
10152 : {
10153 7 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, utype, _o1[0]);
10154 : }
10155 : else
10156 : _r1 = _o1[0];
10157 7 : res_op0 = _r1;
10158 : }
10159 7 : tree res_op1;
10160 7 : res_op1 = csts;
10161 7 : tree _r;
10162 7 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10163 7 : if (TREE_SIDE_EFFECTS (captures[2]))
10164 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10165 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 969, __FILE__, __LINE__, true);
10166 7 : return _r;
10167 : }
10168 2045 : next_after_fail1547:;
10169 : }
10170 : }
10171 : }
10172 : }
10173 : }
10174 : }
10175 : }
10176 : break;
10177 : }
10178 842351 : case INTEGER_CST:
10179 842351 : {
10180 842351 : if (integer_zerop (_p1))
10181 : {
10182 804236 : {
10183 804236 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
10184 804236 : const enum tree_code cmp = NE_EXPR;
10185 804236 : const enum tree_code icmp = GT_EXPR;
10186 804236 : {
10187 804236 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
10188 804236 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
10189 : )
10190 : {
10191 1261 : {
10192 1261 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
10193 1261 : ? optab_vector : optab_default;
10194 1261 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
10195 1261 : if (target_supports_op_p (utype, icmp, optab)
10196 1261 : || (optimize_vectors_before_lowering_p ()
10197 1092 : && (!target_supports_op_p (type, cmp, optab)
10198 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
10199 : )
10200 : {
10201 1092 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
10202 : )
10203 : {
10204 989 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1548;
10205 989 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1548;
10206 989 : {
10207 989 : tree res_op0;
10208 989 : res_op0 = captures[1];
10209 989 : tree res_op1;
10210 989 : res_op1 = csts;
10211 989 : tree _r;
10212 989 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10213 989 : if (TREE_SIDE_EFFECTS (captures[2]))
10214 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10215 989 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 968, __FILE__, __LINE__, true);
10216 989 : return _r;
10217 : }
10218 803144 : next_after_fail1548:;
10219 : }
10220 : else
10221 : {
10222 103 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1549;
10223 103 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1549;
10224 103 : {
10225 103 : tree res_op0;
10226 103 : {
10227 103 : tree _o1[1], _r1;
10228 103 : _o1[0] = captures[1];
10229 103 : if (TREE_TYPE (_o1[0]) != utype)
10230 : {
10231 103 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, utype, _o1[0]);
10232 : }
10233 : else
10234 : _r1 = _o1[0];
10235 103 : res_op0 = _r1;
10236 : }
10237 103 : tree res_op1;
10238 103 : res_op1 = csts;
10239 103 : tree _r;
10240 103 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10241 103 : if (TREE_SIDE_EFFECTS (captures[2]))
10242 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10243 103 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 969, __FILE__, __LINE__, true);
10244 103 : return _r;
10245 : }
10246 803144 : next_after_fail1549:;
10247 : }
10248 : }
10249 : }
10250 : }
10251 : }
10252 : }
10253 : }
10254 : break;
10255 : }
10256 1035136 : default:;
10257 : }
10258 1035136 : switch (TREE_CODE (_q20))
10259 : {
10260 0 : case VECTOR_CST:
10261 0 : {
10262 0 : if (integer_zerop (_p1))
10263 : {
10264 0 : {
10265 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
10266 0 : const enum tree_code cmp = NE_EXPR;
10267 0 : const enum tree_code icmp = GT_EXPR;
10268 0 : {
10269 0 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
10270 0 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
10271 : )
10272 : {
10273 0 : {
10274 0 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
10275 0 : ? optab_vector : optab_default;
10276 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
10277 0 : if (target_supports_op_p (utype, icmp, optab)
10278 0 : || (optimize_vectors_before_lowering_p ()
10279 0 : && (!target_supports_op_p (type, cmp, optab)
10280 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
10281 : )
10282 : {
10283 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
10284 : )
10285 : {
10286 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1550;
10287 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1550;
10288 0 : {
10289 0 : tree res_op0;
10290 0 : res_op0 = captures[1];
10291 0 : tree res_op1;
10292 0 : res_op1 = csts;
10293 0 : tree _r;
10294 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10295 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10296 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10297 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 968, __FILE__, __LINE__, true);
10298 0 : return _r;
10299 : }
10300 0 : next_after_fail1550:;
10301 : }
10302 : else
10303 : {
10304 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1551;
10305 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1551;
10306 0 : {
10307 0 : tree res_op0;
10308 0 : {
10309 0 : tree _o1[1], _r1;
10310 0 : _o1[0] = captures[1];
10311 0 : if (TREE_TYPE (_o1[0]) != utype)
10312 : {
10313 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, utype, _o1[0]);
10314 : }
10315 : else
10316 : _r1 = _o1[0];
10317 0 : res_op0 = _r1;
10318 : }
10319 0 : tree res_op1;
10320 0 : res_op1 = csts;
10321 0 : tree _r;
10322 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10323 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10324 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10325 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 969, __FILE__, __LINE__, true);
10326 0 : return _r;
10327 : }
10328 0 : next_after_fail1551:;
10329 : }
10330 : }
10331 : }
10332 : }
10333 : }
10334 : }
10335 : }
10336 : break;
10337 : }
10338 0 : case INTEGER_CST:
10339 0 : {
10340 0 : if (integer_zerop (_p1))
10341 : {
10342 0 : {
10343 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
10344 0 : const enum tree_code cmp = NE_EXPR;
10345 0 : const enum tree_code icmp = GT_EXPR;
10346 0 : {
10347 0 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
10348 0 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
10349 : )
10350 : {
10351 0 : {
10352 0 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
10353 0 : ? optab_vector : optab_default;
10354 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
10355 0 : if (target_supports_op_p (utype, icmp, optab)
10356 0 : || (optimize_vectors_before_lowering_p ()
10357 0 : && (!target_supports_op_p (type, cmp, optab)
10358 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
10359 : )
10360 : {
10361 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
10362 : )
10363 : {
10364 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1552;
10365 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1552;
10366 0 : {
10367 0 : tree res_op0;
10368 0 : res_op0 = captures[1];
10369 0 : tree res_op1;
10370 0 : res_op1 = csts;
10371 0 : tree _r;
10372 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10373 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10374 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10375 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 968, __FILE__, __LINE__, true);
10376 0 : return _r;
10377 : }
10378 0 : next_after_fail1552:;
10379 : }
10380 : else
10381 : {
10382 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1553;
10383 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1553;
10384 0 : {
10385 0 : tree res_op0;
10386 0 : {
10387 0 : tree _o1[1], _r1;
10388 0 : _o1[0] = captures[1];
10389 0 : if (TREE_TYPE (_o1[0]) != utype)
10390 : {
10391 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, utype, _o1[0]);
10392 : }
10393 : else
10394 : _r1 = _o1[0];
10395 0 : res_op0 = _r1;
10396 : }
10397 0 : tree res_op1;
10398 0 : res_op1 = csts;
10399 0 : tree _r;
10400 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10401 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10402 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10403 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 969, __FILE__, __LINE__, true);
10404 0 : return _r;
10405 : }
10406 0 : next_after_fail1553:;
10407 : }
10408 : }
10409 : }
10410 : }
10411 : }
10412 : }
10413 : }
10414 : break;
10415 : }
10416 : default:;
10417 : }
10418 : break;
10419 : }
10420 20822 : case RSHIFT_EXPR:
10421 20822 : {
10422 20822 : tree _q20 = TREE_OPERAND (_p0, 0);
10423 20822 : tree _q21 = TREE_OPERAND (_p0, 1);
10424 20822 : switch (TREE_CODE (_q20))
10425 : {
10426 1 : case MULT_EXPR:
10427 1 : {
10428 1 : tree _q30 = TREE_OPERAND (_q20, 0);
10429 1 : tree _q31 = TREE_OPERAND (_q20, 1);
10430 1 : switch (TREE_CODE (_q30))
10431 : {
10432 1 : CASE_CONVERT:
10433 1 : {
10434 1 : tree _q40 = TREE_OPERAND (_q30, 0);
10435 1 : switch (TREE_CODE (_q31))
10436 : {
10437 1 : CASE_CONVERT:
10438 1 : {
10439 1 : tree _q60 = TREE_OPERAND (_q31, 0);
10440 1 : switch (TREE_CODE (_q21))
10441 : {
10442 1 : case INTEGER_CST:
10443 1 : {
10444 1 : if (integer_zerop (_p1))
10445 : {
10446 1 : {
10447 1 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q30, _q40, _q60, _q21 };
10448 1 : tree res = generic_simplify_288 (loc, type, _p0, _p1, captures, NE_EXPR);
10449 1 : if (res) return res;
10450 : }
10451 : }
10452 : break;
10453 : }
10454 : default:;
10455 : }
10456 : break;
10457 : }
10458 : default:;
10459 : }
10460 : break;
10461 : }
10462 : default:;
10463 : }
10464 : break;
10465 : }
10466 : default:;
10467 : }
10468 : break;
10469 : }
10470 1330282 : case PLUS_EXPR:
10471 1330282 : {
10472 1330282 : tree _q20 = TREE_OPERAND (_p0, 0);
10473 1330282 : tree _q21 = TREE_OPERAND (_p0, 1);
10474 1330282 : switch (TREE_CODE (_q21))
10475 : {
10476 1220325 : case INTEGER_CST:
10477 1220325 : {
10478 1220325 : switch (TREE_CODE (_p1))
10479 : {
10480 722204 : case INTEGER_CST:
10481 722204 : {
10482 722204 : {
10483 722204 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
10484 722204 : tree res = generic_simplify_289 (loc, type, _p0, _p1, captures, PLUS_EXPR, MINUS_EXPR, NE_EXPR);
10485 722204 : if (res) return res;
10486 : }
10487 355 : break;
10488 : }
10489 : default:;
10490 : }
10491 : break;
10492 : }
10493 : default:;
10494 : }
10495 : break;
10496 : }
10497 69613 : case MINUS_EXPR:
10498 69613 : {
10499 69613 : tree _q20 = TREE_OPERAND (_p0, 0);
10500 69613 : tree _q21 = TREE_OPERAND (_p0, 1);
10501 69613 : switch (TREE_CODE (_q21))
10502 : {
10503 193 : case INTEGER_CST:
10504 193 : {
10505 193 : switch (TREE_CODE (_p1))
10506 : {
10507 72 : case INTEGER_CST:
10508 72 : {
10509 72 : {
10510 72 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
10511 72 : tree res = generic_simplify_289 (loc, type, _p0, _p1, captures, MINUS_EXPR, PLUS_EXPR, NE_EXPR);
10512 72 : if (res) return res;
10513 : }
10514 72 : break;
10515 : }
10516 : default:;
10517 : }
10518 : break;
10519 : }
10520 69613 : default:;
10521 : }
10522 69613 : switch (TREE_CODE (_q20))
10523 : {
10524 1719 : case INTEGER_CST:
10525 1719 : {
10526 1719 : switch (TREE_CODE (_p1))
10527 : {
10528 73 : case INTEGER_CST:
10529 73 : {
10530 73 : {
10531 73 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
10532 73 : tree res = generic_simplify_290 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
10533 73 : if (res) return res;
10534 : }
10535 0 : break;
10536 : }
10537 : default:;
10538 : }
10539 : break;
10540 : }
10541 : default:;
10542 : }
10543 : break;
10544 : }
10545 2750560 : case CALL_EXPR:
10546 2750560 : switch (get_call_combined_fn (_p0))
10547 : {
10548 224 : case CFN_BUILT_IN_CLZ:
10549 224 : if (call_expr_nargs (_p0) == 1)
10550 : {
10551 224 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10552 224 : switch (TREE_CODE (_p1))
10553 : {
10554 210 : case INTEGER_CST:
10555 210 : {
10556 210 : {
10557 210 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10558 210 : tree res = generic_simplify_291 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZ);
10559 210 : if (res) return res;
10560 : }
10561 135 : break;
10562 : }
10563 : default:;
10564 : }
10565 : }
10566 : break;
10567 246 : case CFN_BUILT_IN_CTZ:
10568 246 : if (call_expr_nargs (_p0) == 1)
10569 : {
10570 246 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10571 246 : switch (TREE_CODE (_p1))
10572 : {
10573 200 : case INTEGER_CST:
10574 200 : {
10575 200 : {
10576 200 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10577 200 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_CTZ);
10578 200 : if (res) return res;
10579 : }
10580 0 : break;
10581 : }
10582 : default:;
10583 : }
10584 : }
10585 : break;
10586 31 : case CFN_BUILT_IN_FFS:
10587 31 : if (call_expr_nargs (_p0) == 1)
10588 : {
10589 31 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10590 31 : switch (TREE_CODE (_p1))
10591 : {
10592 11 : case INTEGER_CST:
10593 11 : {
10594 11 : {
10595 11 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10596 11 : tree res = generic_simplify_296 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_FFS);
10597 11 : if (res) return res;
10598 : }
10599 0 : break;
10600 : }
10601 : default:;
10602 : }
10603 : }
10604 : break;
10605 0 : case CFN_REDUC_IOR:
10606 0 : if (call_expr_nargs (_p0) == 1)
10607 : {
10608 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10609 0 : if (integer_zerop (_p1))
10610 : {
10611 0 : {
10612 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10613 0 : tree res = generic_simplify_297 (loc, type, _p0, _p1, captures, NE_EXPR);
10614 0 : if (res) return res;
10615 : }
10616 : }
10617 : }
10618 : break;
10619 0 : case CFN_BUILT_IN_FFSIMAX:
10620 0 : if (call_expr_nargs (_p0) == 1)
10621 : {
10622 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10623 0 : switch (TREE_CODE (_p1))
10624 : {
10625 0 : case INTEGER_CST:
10626 0 : {
10627 0 : {
10628 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10629 0 : tree res = generic_simplify_296 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_FFSIMAX);
10630 0 : if (res) return res;
10631 : }
10632 0 : break;
10633 : }
10634 : default:;
10635 : }
10636 : }
10637 : break;
10638 13 : case CFN_BUILT_IN_POPCOUNT:
10639 13 : if (call_expr_nargs (_p0) == 1)
10640 : {
10641 13 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10642 13 : if (integer_zerop (_p1))
10643 : {
10644 1 : {
10645 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10646 1 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNT);
10647 1 : if (res) return res;
10648 : }
10649 : }
10650 : }
10651 : break;
10652 87 : case CFN_BUILT_IN_CLZL:
10653 87 : if (call_expr_nargs (_p0) == 1)
10654 : {
10655 87 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10656 87 : switch (TREE_CODE (_p1))
10657 : {
10658 79 : case INTEGER_CST:
10659 79 : {
10660 79 : {
10661 79 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10662 79 : tree res = generic_simplify_291 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZL);
10663 79 : if (res) return res;
10664 : }
10665 43 : break;
10666 : }
10667 : default:;
10668 : }
10669 : }
10670 : break;
10671 85 : case CFN_BUILT_IN_CTZL:
10672 85 : if (call_expr_nargs (_p0) == 1)
10673 : {
10674 85 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10675 85 : switch (TREE_CODE (_p1))
10676 : {
10677 77 : case INTEGER_CST:
10678 77 : {
10679 77 : {
10680 77 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10681 77 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_CTZL);
10682 77 : if (res) return res;
10683 : }
10684 16 : break;
10685 : }
10686 : default:;
10687 : }
10688 : }
10689 : break;
10690 8 : case CFN_BUILT_IN_FFSL:
10691 8 : if (call_expr_nargs (_p0) == 1)
10692 : {
10693 8 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10694 8 : switch (TREE_CODE (_p1))
10695 : {
10696 0 : case INTEGER_CST:
10697 0 : {
10698 0 : {
10699 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10700 0 : tree res = generic_simplify_296 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_FFSL);
10701 0 : if (res) return res;
10702 : }
10703 0 : break;
10704 : }
10705 : default:;
10706 : }
10707 : }
10708 : break;
10709 11 : case CFN_BUILT_IN_POPCOUNTLL:
10710 11 : if (call_expr_nargs (_p0) == 1)
10711 : {
10712 11 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10713 11 : if (integer_zerop (_p1))
10714 : {
10715 1 : {
10716 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10717 1 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNTLL);
10718 1 : if (res) return res;
10719 : }
10720 : }
10721 : }
10722 : break;
10723 0 : case CFN_BUILT_IN_CTZIMAX:
10724 0 : if (call_expr_nargs (_p0) == 1)
10725 : {
10726 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10727 0 : switch (TREE_CODE (_p1))
10728 : {
10729 0 : case INTEGER_CST:
10730 0 : {
10731 0 : {
10732 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10733 0 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_CTZIMAX);
10734 0 : if (res) return res;
10735 : }
10736 0 : break;
10737 : }
10738 : default:;
10739 : }
10740 : }
10741 : break;
10742 0 : case CFN_POPCOUNT:
10743 0 : if (call_expr_nargs (_p0) == 1)
10744 : {
10745 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10746 0 : if (integer_zerop (_p1))
10747 : {
10748 0 : {
10749 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10750 0 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_POPCOUNT);
10751 0 : if (res) return res;
10752 : }
10753 : }
10754 : }
10755 : break;
10756 0 : case CFN_CLZ:
10757 0 : if (call_expr_nargs (_p0) == 1)
10758 : {
10759 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10760 0 : switch (TREE_CODE (_p1))
10761 : {
10762 0 : case INTEGER_CST:
10763 0 : {
10764 0 : {
10765 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10766 0 : tree res = generic_simplify_291 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_CLZ);
10767 0 : if (res) return res;
10768 : }
10769 0 : break;
10770 : }
10771 : default:;
10772 : }
10773 : }
10774 0 : if (call_expr_nargs (_p0) == 2)
10775 : {
10776 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10777 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
10778 0 : switch (TREE_CODE (_p1))
10779 : {
10780 0 : case INTEGER_CST:
10781 0 : {
10782 0 : {
10783 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
10784 0 : tree res = generic_simplify_292 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR);
10785 0 : if (res) return res;
10786 : }
10787 0 : break;
10788 : }
10789 : default:;
10790 : }
10791 : }
10792 : break;
10793 0 : case CFN_CTZ:
10794 0 : if (call_expr_nargs (_p0) == 1)
10795 : {
10796 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10797 0 : switch (TREE_CODE (_p1))
10798 : {
10799 0 : case INTEGER_CST:
10800 0 : {
10801 0 : {
10802 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10803 0 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_CTZ);
10804 0 : if (res) return res;
10805 : }
10806 0 : break;
10807 : }
10808 : default:;
10809 : }
10810 : }
10811 0 : if (call_expr_nargs (_p0) == 2)
10812 : {
10813 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10814 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
10815 0 : switch (TREE_CODE (_p1))
10816 : {
10817 0 : case INTEGER_CST:
10818 0 : {
10819 0 : {
10820 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
10821 0 : tree res = generic_simplify_294 (loc, type, _p0, _p1, captures, NE_EXPR);
10822 0 : if (res) return res;
10823 : }
10824 0 : break;
10825 : }
10826 : default:;
10827 : }
10828 : }
10829 : break;
10830 0 : case CFN_FFS:
10831 0 : if (call_expr_nargs (_p0) == 1)
10832 : {
10833 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10834 0 : switch (TREE_CODE (_p1))
10835 : {
10836 0 : case INTEGER_CST:
10837 0 : {
10838 0 : {
10839 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10840 0 : tree res = generic_simplify_296 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_FFS);
10841 0 : if (res) return res;
10842 : }
10843 0 : break;
10844 : }
10845 : default:;
10846 : }
10847 : }
10848 : break;
10849 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
10850 0 : if (call_expr_nargs (_p0) == 1)
10851 : {
10852 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10853 0 : if (integer_zerop (_p1))
10854 : {
10855 0 : {
10856 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10857 0 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
10858 0 : if (res) return res;
10859 : }
10860 : }
10861 : }
10862 : break;
10863 0 : case CFN_BUILT_IN_CLZIMAX:
10864 0 : if (call_expr_nargs (_p0) == 1)
10865 : {
10866 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10867 0 : switch (TREE_CODE (_p1))
10868 : {
10869 0 : case INTEGER_CST:
10870 0 : {
10871 0 : {
10872 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10873 0 : tree res = generic_simplify_291 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZIMAX);
10874 0 : if (res) return res;
10875 : }
10876 0 : break;
10877 : }
10878 : default:;
10879 : }
10880 : }
10881 : break;
10882 12 : case CFN_BUILT_IN_POPCOUNTL:
10883 12 : if (call_expr_nargs (_p0) == 1)
10884 : {
10885 12 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10886 12 : if (integer_zerop (_p1))
10887 : {
10888 1 : {
10889 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10890 1 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNTL);
10891 1 : if (res) return res;
10892 : }
10893 : }
10894 : }
10895 : break;
10896 52 : case CFN_BUILT_IN_CLZLL:
10897 52 : if (call_expr_nargs (_p0) == 1)
10898 : {
10899 52 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10900 52 : switch (TREE_CODE (_p1))
10901 : {
10902 42 : case INTEGER_CST:
10903 42 : {
10904 42 : {
10905 42 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10906 42 : tree res = generic_simplify_291 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZLL);
10907 42 : if (res) return res;
10908 : }
10909 18 : break;
10910 : }
10911 : default:;
10912 : }
10913 : }
10914 : break;
10915 74 : case CFN_BUILT_IN_CTZLL:
10916 74 : if (call_expr_nargs (_p0) == 1)
10917 : {
10918 74 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10919 74 : switch (TREE_CODE (_p1))
10920 : {
10921 64 : case INTEGER_CST:
10922 64 : {
10923 64 : {
10924 64 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10925 64 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_CTZLL);
10926 64 : if (res) return res;
10927 : }
10928 16 : break;
10929 : }
10930 : default:;
10931 : }
10932 : }
10933 : break;
10934 11 : case CFN_BUILT_IN_FFSLL:
10935 11 : if (call_expr_nargs (_p0) == 1)
10936 : {
10937 11 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10938 11 : switch (TREE_CODE (_p1))
10939 : {
10940 1 : case INTEGER_CST:
10941 1 : {
10942 1 : {
10943 1 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10944 1 : tree res = generic_simplify_296 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_FFSLL);
10945 1 : if (res) return res;
10946 : }
10947 0 : break;
10948 : }
10949 : default:;
10950 : }
10951 : }
10952 : break;
10953 : default:;
10954 : }
10955 : break;
10956 : default:;
10957 : }
10958 : return NULL_TREE;
10959 : }
10960 :
10961 : tree
10962 774857 : 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)
10963 : {
10964 774857 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10965 774857 : switch (TREE_CODE (_p0))
10966 : {
10967 8 : case BIT_FIELD_REF:
10968 8 : {
10969 8 : tree _q20 = TREE_OPERAND (_p0, 0);
10970 8 : tree _q21 = TREE_OPERAND (_p0, 1);
10971 8 : tree _q22 = TREE_OPERAND (_p0, 2);
10972 8 : {
10973 8 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _p1, _p2 };
10974 8 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1928;
10975 8 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1928;
10976 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1928;
10977 8 : {
10978 8 : tree res_op0;
10979 8 : res_op0 = captures[0];
10980 8 : tree res_op1;
10981 8 : res_op1 = captures[3];
10982 8 : tree res_op2;
10983 8 : res_op2 = const_binop (PLUS_EXPR, bitsizetype, captures[2], captures[4]);
10984 8 : tree _r;
10985 8 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
10986 8 : if (TREE_SIDE_EFFECTS (captures[1]))
10987 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
10988 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1060, __FILE__, __LINE__, true);
10989 8 : return _r;
10990 : }
10991 0 : next_after_fail1928:;
10992 : }
10993 0 : break;
10994 : }
10995 3 : case VIEW_CONVERT_EXPR:
10996 3 : {
10997 3 : tree _q20 = TREE_OPERAND (_p0, 0);
10998 3 : {
10999 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p1, _p2 };
11000 6 : if (! INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
11001 6 : || type_has_mode_precision_p (TREE_TYPE (captures[0]))
11002 : )
11003 : {
11004 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1929;
11005 0 : {
11006 0 : tree res_op0;
11007 0 : res_op0 = captures[0];
11008 0 : tree res_op1;
11009 0 : res_op1 = captures[1];
11010 0 : tree res_op2;
11011 0 : res_op2 = captures[2];
11012 0 : tree _r;
11013 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11014 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1061, __FILE__, __LINE__, true);
11015 0 : return _r;
11016 : }
11017 0 : next_after_fail1929:;
11018 : }
11019 : }
11020 3 : break;
11021 : }
11022 774849 : default:;
11023 : }
11024 774849 : if (integer_zerop (_p2))
11025 : {
11026 247823 : {
11027 247823 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
11028 247823 : if (tree_int_cst_equal (captures[1], TYPE_SIZE (TREE_TYPE (captures[0])))
11029 : )
11030 : {
11031 2534 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail1930;
11032 2534 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1930;
11033 2534 : {
11034 2534 : tree res_op0;
11035 2534 : res_op0 = captures[0];
11036 2534 : tree _r;
11037 2534 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11038 2534 : if (TREE_SIDE_EFFECTS (captures[1]))
11039 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11040 2534 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1062, __FILE__, __LINE__, true);
11041 2534 : return _r;
11042 : }
11043 245289 : next_after_fail1930:;
11044 : }
11045 : }
11046 : }
11047 772315 : {
11048 772315 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _p2 };
11049 772315 : if (TREE_CODE (TREE_TYPE (captures[0])) == COMPLEX_TYPE
11050 772315 : && tree_int_cst_equal (captures[1], TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0]))))
11051 : )
11052 : {
11053 2 : if (integer_zerop (captures[2])
11054 : )
11055 : {
11056 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1931;
11057 0 : {
11058 0 : tree res_op0;
11059 0 : {
11060 0 : tree _o1[1], _r1;
11061 0 : _o1[0] = captures[0];
11062 0 : _r1 = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
11063 0 : res_op0 = _r1;
11064 : }
11065 0 : tree _r;
11066 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11067 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11068 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11069 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11070 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11071 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1063, __FILE__, __LINE__, true);
11072 0 : return _r;
11073 : }
11074 0 : next_after_fail1931:;
11075 : }
11076 : else
11077 : {
11078 2 : if (tree_int_cst_equal (captures[2], TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0]))))
11079 : )
11080 : {
11081 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1932;
11082 0 : {
11083 0 : tree res_op0;
11084 0 : {
11085 0 : tree _o1[1], _r1;
11086 0 : _o1[0] = captures[0];
11087 0 : _r1 = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
11088 0 : res_op0 = _r1;
11089 : }
11090 0 : tree _r;
11091 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11092 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11093 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11094 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11095 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11096 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1064, __FILE__, __LINE__, true);
11097 0 : return _r;
11098 : }
11099 0 : next_after_fail1932:;
11100 : }
11101 : }
11102 : }
11103 : else
11104 : {
11105 1544564 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
11106 20557 : && INTEGRAL_TYPE_P (type)
11107 : && (!
11108 :
11109 : || is_gimple_reg (captures[0]))
11110 791892 : && ((compare_tree_int (captures[1], TYPE_PRECISION (TREE_TYPE (captures[0]))) == 0
11111 0 : && integer_zerop (captures[2]))
11112 : || (BYTES_BIG_ENDIAN == WORDS_BIG_ENDIAN
11113 : && canonicalize_math_after_vectorization_p ()
11114 : && TYPE_PRECISION (TREE_TYPE (captures[0])) % BITS_PER_UNIT == 0
11115 : && TYPE_PRECISION (type) % BITS_PER_UNIT == 0
11116 : && compare_tree_int (captures[2], (BYTES_BIG_ENDIAN
11117 : ? (TYPE_PRECISION (TREE_TYPE (captures[0]))
11118 : - TYPE_PRECISION (type))
11119 : : 0)) == 0))
11120 : )
11121 : {
11122 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1933;
11123 0 : {
11124 0 : tree res_op0;
11125 0 : res_op0 = captures[0];
11126 0 : tree _r;
11127 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
11128 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11129 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11130 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11131 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11132 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1065, __FILE__, __LINE__, true);
11133 0 : return _r;
11134 : }
11135 0 : next_after_fail1933:;
11136 : }
11137 : }
11138 : }
11139 772315 : switch (TREE_CODE (_p0))
11140 : {
11141 1383 : case CONSTRUCTOR:
11142 1383 : {
11143 1383 : {
11144 1383 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _p2 };
11145 1383 : if (VECTOR_TYPE_P (TREE_TYPE (captures[0]))
11146 1383 : && tree_fits_uhwi_p (TYPE_SIZE (type))
11147 2766 : && ((tree_to_uhwi (TYPE_SIZE (type))
11148 1383 : == tree_to_uhwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0])))))
11149 0 : || (VECTOR_TYPE_P (type)
11150 0 : && (tree_to_uhwi (TYPE_SIZE (TREE_TYPE (type)))
11151 0 : == tree_to_uhwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0])))))))
11152 : )
11153 : {
11154 1383 : {
11155 1383 : tree ctor = (TREE_CODE (captures[0]) == SSA_NAME
11156 : ? gimple_assign_rhs1 (SSA_NAME_DEF_STMT (captures[0])) : captures[0]);
11157 1383 : tree eltype = TREE_TYPE (TREE_TYPE (ctor));
11158 1383 : unsigned HOST_WIDE_INT width = tree_to_uhwi (TYPE_SIZE (eltype));
11159 1383 : unsigned HOST_WIDE_INT n = tree_to_uhwi (captures[1]);
11160 1383 : unsigned HOST_WIDE_INT idx = tree_to_uhwi (captures[2]);
11161 1383 : if (n != 0
11162 1383 : && (idx % width) == 0
11163 1383 : && (n % width) == 0
11164 2766 : && known_le ((idx + n) / width,
11165 : TYPE_VECTOR_SUBPARTS (TREE_TYPE (ctor)))
11166 : )
11167 : {
11168 1383 : {
11169 1383 : idx = idx / width;
11170 1383 : n = n / width;
11171 1383 : poly_uint64 k = 1;
11172 1383 : if (CONSTRUCTOR_NELTS (ctor) != 0)
11173 : {
11174 1383 : tree cons_elem = TREE_TYPE (CONSTRUCTOR_ELT (ctor, 0)->value);
11175 1383 : if (TREE_CODE (cons_elem) == VECTOR_TYPE)
11176 1383 : k = TYPE_VECTOR_SUBPARTS (cons_elem);
11177 : }
11178 1383 : unsigned HOST_WIDE_INT elt, count, const_k;
11179 1383 : if (multiple_p (idx, k, &elt) && multiple_p (n, k, &count)
11180 : )
11181 : {
11182 6 : if (CONSTRUCTOR_NELTS (ctor) == 0
11183 : )
11184 : {
11185 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1934;
11186 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1934;
11187 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1934;
11188 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1934;
11189 0 : {
11190 0 : tree _r;
11191 0 : _r = build_zero_cst (type);
11192 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1066, __FILE__, __LINE__, true);
11193 1383 : return _r;
11194 : }
11195 : next_after_fail1934:;
11196 : }
11197 : else
11198 : {
11199 6 : if (count == 1
11200 : )
11201 : {
11202 6 : if (elt < CONSTRUCTOR_NELTS (ctor)
11203 : )
11204 : {
11205 6 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1935;
11206 6 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1935;
11207 6 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1935;
11208 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1935;
11209 6 : {
11210 6 : tree res_op0;
11211 6 : res_op0 = CONSTRUCTOR_ELT (ctor, elt)->value;
11212 6 : tree _r;
11213 6 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11214 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1067, __FILE__, __LINE__, true);
11215 6 : return _r;
11216 : }
11217 : next_after_fail1935:;
11218 : }
11219 : else
11220 : {
11221 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1936;
11222 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1936;
11223 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1936;
11224 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1936;
11225 0 : {
11226 0 : tree _r;
11227 0 : _r = build_zero_cst (type);
11228 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1068, __FILE__, __LINE__, true);
11229 0 : return _r;
11230 : }
11231 : next_after_fail1936:;
11232 : }
11233 : }
11234 : else
11235 : {
11236 0 : if (single_use (captures[0])
11237 : )
11238 : {
11239 0 : {
11240 0 : vec<constructor_elt, va_gc> *vals;
11241 0 : vec_alloc (vals, count);
11242 0 : bool constant_p = true;
11243 0 : tree res;
11244 0 : for (unsigned i = 0;
11245 0 : i < count && elt + i < CONSTRUCTOR_NELTS (ctor); ++i)
11246 : {
11247 0 : tree e = CONSTRUCTOR_ELT (ctor, elt + i)->value;
11248 0 : CONSTRUCTOR_APPEND_ELT (vals, NULL_TREE, e);
11249 0 : if (!CONSTANT_CLASS_P (e))
11250 0 : constant_p = false;
11251 : }
11252 0 : tree evtype = (types_match (TREE_TYPE (type),
11253 0 : TREE_TYPE (TREE_TYPE (ctor)))
11254 0 : ? type
11255 0 : : build_vector_type (TREE_TYPE (TREE_TYPE (ctor)),
11256 0 : count * k));
11257 0 : res = (constant_p ? build_vector_from_ctor (evtype, vals)
11258 : : (
11259 :
11260 0 : ? NULL_TREE : build_constructor (evtype, vals)));
11261 0 : if (res
11262 : )
11263 : {
11264 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1937;
11265 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1937;
11266 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1937;
11267 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1937;
11268 0 : {
11269 0 : tree res_op0;
11270 0 : res_op0 = res;
11271 0 : tree _r;
11272 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11273 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1069, __FILE__, __LINE__, true);
11274 0 : return _r;
11275 : }
11276 0 : next_after_fail1937:;
11277 : }
11278 : }
11279 : }
11280 : }
11281 : }
11282 : }
11283 : else
11284 : {
11285 1377 : if (k.is_constant (&const_k)
11286 1377 : && idx + n <= (idx / const_k + 1) * const_k
11287 : )
11288 : {
11289 1377 : if (CONSTRUCTOR_NELTS (ctor) <= idx / const_k
11290 : )
11291 : {
11292 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1938;
11293 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1938;
11294 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1938;
11295 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1938;
11296 0 : {
11297 0 : tree _r;
11298 0 : _r = build_zero_cst (type);
11299 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1070, __FILE__, __LINE__, true);
11300 0 : return _r;
11301 : }
11302 : next_after_fail1938:;
11303 : }
11304 : else
11305 : {
11306 1377 : if (n == const_k
11307 : )
11308 : {
11309 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1939;
11310 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1939;
11311 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1939;
11312 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1939;
11313 0 : {
11314 0 : tree res_op0;
11315 0 : res_op0 = CONSTRUCTOR_ELT (ctor, idx / const_k)->value;
11316 0 : tree _r;
11317 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11318 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1071, __FILE__, __LINE__, true);
11319 0 : return _r;
11320 : }
11321 : next_after_fail1939:;
11322 : }
11323 : else
11324 : {
11325 1377 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1940;
11326 1377 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1940;
11327 1377 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1940;
11328 1377 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1940;
11329 1377 : {
11330 1377 : tree res_op0;
11331 1377 : res_op0 = CONSTRUCTOR_ELT (ctor, idx / const_k)->value;
11332 1377 : tree res_op1;
11333 1377 : res_op1 = captures[1];
11334 1377 : tree res_op2;
11335 1377 : res_op2 = bitsize_int ((idx % const_k) * width);
11336 1377 : tree _r;
11337 1377 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11338 1377 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1072, __FILE__, __LINE__, true);
11339 1377 : return _r;
11340 : }
11341 : next_after_fail1940:;
11342 : }
11343 : }
11344 : }
11345 : }
11346 : }
11347 : }
11348 : }
11349 : }
11350 : }
11351 0 : break;
11352 : }
11353 0 : case VEC_PERM_EXPR:
11354 0 : {
11355 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11356 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11357 0 : tree _q22 = TREE_OPERAND (_p0, 2);
11358 0 : switch (TREE_CODE (_q22))
11359 : {
11360 0 : case VECTOR_CST:
11361 0 : {
11362 0 : {
11363 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _p2 };
11364 0 : {
11365 0 : tree elem_type = TREE_TYPE (TREE_TYPE (captures[0]));
11366 0 : poly_uint64 elem_size = tree_to_poly_uint64 (TYPE_SIZE (elem_type));
11367 0 : poly_uint64 size = tree_to_poly_uint64 (TYPE_SIZE (type));
11368 0 : unsigned HOST_WIDE_INT nelts, idx;
11369 0 : unsigned HOST_WIDE_INT nelts_op = 0;
11370 0 : if (constant_multiple_p (tree_to_poly_uint64 (captures[5]), elem_size, &idx)
11371 0 : && VECTOR_CST_NELTS (captures[3]).is_constant (&nelts)
11372 0 : && (known_eq (size, elem_size)
11373 0 : || (constant_multiple_p (size, elem_size, &nelts_op)
11374 0 : && pow2p_hwi (nelts_op)))
11375 : )
11376 : {
11377 0 : {
11378 0 : bool ok = true;
11379 0 : if (known_eq (size, elem_size))
11380 0 : idx = TREE_INT_CST_LOW (VECTOR_CST_ELT (captures[3], idx)) % (2 * nelts);
11381 : else
11382 : {
11383 0 : unsigned start
11384 0 : = TREE_INT_CST_LOW (vector_cst_elt (captures[3], idx)) % (2 * nelts);
11385 0 : unsigned end
11386 0 : = (TREE_INT_CST_LOW (vector_cst_elt (captures[3], idx + nelts_op - 1))
11387 0 : % (2 * nelts));
11388 0 : if ((start < nelts) != (end < nelts))
11389 : ok = false;
11390 : else
11391 0 : for (unsigned HOST_WIDE_INT i = 1; i != nelts_op; i++)
11392 : {
11393 0 : if ((TREE_INT_CST_LOW (vector_cst_elt (captures[3], idx + i))
11394 0 : % (2 * nelts) - 1)
11395 0 : != (TREE_INT_CST_LOW (vector_cst_elt (captures[3], idx + i - 1))
11396 0 : % (2 * nelts)))
11397 : {
11398 : ok = false;
11399 : break;
11400 : }
11401 : }
11402 0 : if (start % nelts_op)
11403 : ok = false;
11404 0 : idx = start;
11405 : }
11406 0 : if (ok
11407 : )
11408 : {
11409 0 : if (idx < nelts
11410 : )
11411 : {
11412 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1941;
11413 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1941;
11414 0 : {
11415 0 : tree res_op0;
11416 0 : res_op0 = captures[1];
11417 0 : tree res_op1;
11418 0 : res_op1 = captures[4];
11419 0 : tree res_op2;
11420 0 : res_op2 = bitsize_int (idx * elem_size);
11421 0 : tree _r;
11422 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11423 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11424 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11425 0 : if (TREE_SIDE_EFFECTS (captures[5]))
11426 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
11427 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1073, __FILE__, __LINE__, true);
11428 0 : return _r;
11429 : }
11430 0 : next_after_fail1941:;
11431 : }
11432 : else
11433 : {
11434 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1942;
11435 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1942;
11436 0 : {
11437 0 : tree res_op0;
11438 0 : res_op0 = captures[2];
11439 0 : tree res_op1;
11440 0 : res_op1 = captures[4];
11441 0 : tree res_op2;
11442 0 : res_op2 = bitsize_int ((idx - nelts) * elem_size);
11443 0 : tree _r;
11444 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11445 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11446 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11447 0 : if (TREE_SIDE_EFFECTS (captures[5]))
11448 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
11449 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1074, __FILE__, __LINE__, true);
11450 0 : return _r;
11451 : }
11452 0 : next_after_fail1942:;
11453 : }
11454 : }
11455 : }
11456 : }
11457 : }
11458 : }
11459 0 : break;
11460 : }
11461 : default:;
11462 : }
11463 : break;
11464 : }
11465 0 : case BIT_INSERT_EXPR:
11466 0 : {
11467 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11468 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11469 0 : tree _q22 = TREE_OPERAND (_p0, 2);
11470 0 : {
11471 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _p1, _p2 };
11472 0 : {
11473 0 : unsigned HOST_WIDE_INT isize;
11474 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1])))
11475 0 : isize = TYPE_PRECISION (TREE_TYPE (captures[1]));
11476 : else
11477 0 : isize = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (captures[1])));
11478 0 : if ((!INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
11479 0 : || type_has_mode_precision_p (TREE_TYPE (captures[1])))
11480 0 : && wi::leu_p (wi::to_wide (captures[2]), wi::to_wide (captures[4]))
11481 0 : && wi::leu_p (wi::to_wide (captures[4]) + wi::to_wide (captures[3]),
11482 0 : wi::to_wide (captures[2]) + isize)
11483 : )
11484 : {
11485 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1943;
11486 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1943;
11487 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1943;
11488 0 : {
11489 0 : tree res_op0;
11490 0 : res_op0 = captures[1];
11491 0 : tree res_op1;
11492 0 : res_op1 = captures[3];
11493 0 : tree res_op2;
11494 0 : res_op2 = wide_int_to_tree (bitsizetype,
11495 0 : wi::to_wide (captures[4])
11496 0 : - wi::to_wide (captures[2]));
11497 0 : tree _r;
11498 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11499 0 : if (TREE_SIDE_EFFECTS (captures[0]))
11500 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
11501 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1075, __FILE__, __LINE__, true);
11502 0 : return _r;
11503 : }
11504 0 : next_after_fail1943:;
11505 : }
11506 : else
11507 : {
11508 0 : if (wi::eq_p (wi::to_wide (captures[2]), wi::to_wide (captures[4]))
11509 0 : && compare_tree_int (captures[3], isize) == 0
11510 : )
11511 : {
11512 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1944;
11513 0 : {
11514 0 : tree res_op0;
11515 0 : res_op0 = captures[1];
11516 0 : tree _r;
11517 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
11518 0 : if (TREE_SIDE_EFFECTS (captures[0]))
11519 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
11520 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11521 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11522 0 : if (TREE_SIDE_EFFECTS (captures[3]))
11523 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
11524 0 : if (TREE_SIDE_EFFECTS (captures[4]))
11525 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
11526 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1076, __FILE__, __LINE__, true);
11527 0 : return _r;
11528 : }
11529 0 : next_after_fail1944:;
11530 : }
11531 : else
11532 : {
11533 0 : if (wi::geu_p (wi::to_wide (captures[2]),
11534 0 : wi::to_wide (captures[4]) + wi::to_wide (captures[3]))
11535 0 : || wi::geu_p (wi::to_wide (captures[4]),
11536 0 : wi::to_wide (captures[2]) + isize)
11537 : )
11538 : {
11539 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1945;
11540 0 : {
11541 0 : tree res_op0;
11542 0 : res_op0 = captures[0];
11543 0 : tree res_op1;
11544 0 : res_op1 = captures[3];
11545 0 : tree res_op2;
11546 0 : res_op2 = captures[4];
11547 0 : tree _r;
11548 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
11549 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11550 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11551 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11552 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11553 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1077, __FILE__, __LINE__, true);
11554 0 : return _r;
11555 : }
11556 0 : next_after_fail1945:;
11557 : }
11558 : }
11559 : }
11560 : }
11561 : }
11562 0 : break;
11563 : }
11564 : default:;
11565 : }
11566 : return NULL_TREE;
11567 : }
11568 : #pragma GCC diagnostic pop
|
