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 177131878 : tree_maybe_bit_not (tree t, tree *res_ops)
11 : {
12 177131878 : const tree type = TREE_TYPE (t);
13 177131878 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 177131878 : if (TREE_SIDE_EFFECTS (t)) return false;
15 169366460 : switch (TREE_CODE (t))
16 : {
17 51366072 : case INTEGER_CST:
18 51366072 : {
19 51366072 : {
20 51366072 : tree captures[1] ATTRIBUTE_UNUSED = { t };
21 51366072 : {
22 51366072 : res_ops[0] = captures[0];
23 51366072 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 8, __FILE__, __LINE__, false);
24 : return true;
25 : }
26 : }
27 118000388 : break;
28 : }
29 118000388 : default:;
30 : }
31 118000388 : {
32 118000388 : tree t_pops[1];
33 118000388 : if (tree_bit_not_with_nop (t, t_pops))
34 : {
35 150291 : tree _p0 = t_pops[0];
36 150291 : {
37 150291 : tree captures[2] ATTRIBUTE_UNUSED = { t, _p0 };
38 150291 : {
39 150291 : res_ops[0] = captures[0];
40 150291 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 9, __FILE__, __LINE__, false);
41 150291 : return true;
42 : }
43 : }
44 : }
45 : }
46 117850097 : {
47 117850097 : tree t_pops[1];
48 117850097 : if (tree_maybe_cmp (t, t_pops))
49 : {
50 565064 : tree _p0 = t_pops[0];
51 565064 : {
52 565064 : tree captures[2] ATTRIBUTE_UNUSED = { t, _p0 };
53 565064 : {
54 565064 : res_ops[0] = captures[0];
55 565064 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 10, __FILE__, __LINE__, false);
56 565064 : return true;
57 : }
58 : }
59 : }
60 : }
61 117285033 : {
62 117285033 : tree t_pops[2];
63 117285033 : if (tree_bit_xor_cst (t, t_pops))
64 : {
65 1598 : tree _p0 = t_pops[0];
66 1598 : tree _p1 = t_pops[1];
67 1598 : {
68 1598 : tree captures[3] ATTRIBUTE_UNUSED = { t, _p0, _p1 };
69 1598 : {
70 1598 : res_ops[0] = captures[0];
71 1598 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 11, __FILE__, __LINE__, false);
72 1598 : return true;
73 : }
74 : }
75 : }
76 : }
77 117283435 : return false;
78 : }
79 :
80 : bool
81 2455 : tree_min_value (tree t)
82 : {
83 2455 : const tree type = TREE_TYPE (t);
84 2455 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
85 2455 : if (TREE_SIDE_EFFECTS (t)) return false;
86 2447 : if (uniform_integer_cst_p (t))
87 : {
88 2175 : {
89 2175 : {
90 2175 : tree int_cst = uniform_integer_cst_p (t);
91 2175 : tree inner_type = TREE_TYPE (int_cst);
92 4350 : if ((INTEGRAL_TYPE_P (inner_type)
93 17 : || POINTER_TYPE_P (inner_type))
94 4367 : && wi::eq_p (wi::to_wide (int_cst), wi::min_value (inner_type))
95 : )
96 : {
97 134 : {
98 134 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 41, __FILE__, __LINE__, false);
99 134 : return true;
100 : }
101 : }
102 : }
103 : }
104 : }
105 : return false;
106 : }
107 :
108 : tree
109 3 : generic_simplify_1 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
110 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
111 : const enum tree_code ARG_UNUSED (op))
112 : {
113 3 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
114 3 : if (!flag_trapping_math
115 : )
116 : {
117 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail72;
118 2 : {
119 2 : tree res_op0;
120 2 : res_op0 = captures[0];
121 2 : tree _r;
122 2 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
123 2 : if (TREE_SIDE_EFFECTS (captures[1]))
124 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
125 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 49, __FILE__, __LINE__, true);
126 2 : return _r;
127 : }
128 0 : next_after_fail72:;
129 : }
130 : return NULL_TREE;
131 : }
132 :
133 : tree
134 29 : generic_simplify_8 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
135 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
136 : const enum tree_code ARG_UNUSED (bit_op))
137 : {
138 29 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
139 29 : if (bit_op == BIT_AND_EXPR
140 : )
141 : {
142 9 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail79;
143 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail79;
144 9 : {
145 9 : tree _r;
146 9 : _r = build_zero_cst (type);
147 9 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 56, __FILE__, __LINE__, true);
148 9 : return _r;
149 : }
150 : next_after_fail79:;
151 : }
152 : else
153 : {
154 20 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail80;
155 20 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail80;
156 20 : {
157 20 : tree _r;
158 20 : _r = build_minus_one_cst (type);
159 20 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 57, __FILE__, __LINE__, true);
160 20 : return _r;
161 : }
162 : next_after_fail80:;
163 : }
164 : return NULL_TREE;
165 : }
166 :
167 : tree
168 1 : generic_simplify_17 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
169 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
170 : {
171 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
172 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail92;
173 1 : {
174 1 : tree res_op0;
175 1 : res_op0 = captures[0];
176 1 : tree res_op1;
177 1 : res_op1 = captures[1];
178 1 : tree _r;
179 1 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
180 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 65, __FILE__, __LINE__, true);
181 : return _r;
182 : }
183 0 : next_after_fail92:;
184 0 : return NULL_TREE;
185 : }
186 :
187 : tree
188 510 : generic_simplify_25 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
189 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
190 : const enum tree_code ARG_UNUSED (op))
191 : {
192 510 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
193 510 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[1]))
194 510 : && tree_nop_conversion_p (type, TREE_TYPE (captures[4]))
195 1020 : && (wi::to_wide (captures[2]) & wi::to_wide (captures[5])) == 0
196 : )
197 : {
198 101 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail100;
199 101 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail100;
200 101 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail100;
201 101 : {
202 101 : tree res_op0;
203 101 : {
204 101 : tree _o1[1], _r1;
205 101 : _o1[0] = captures[0];
206 101 : if (TREE_TYPE (_o1[0]) != type)
207 : {
208 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
209 : }
210 : else
211 : _r1 = _o1[0];
212 101 : res_op0 = _r1;
213 : }
214 101 : tree res_op1;
215 101 : {
216 101 : tree _o1[1], _r1;
217 101 : _o1[0] = captures[3];
218 101 : if (TREE_TYPE (_o1[0]) != type)
219 : {
220 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
221 : }
222 : else
223 : _r1 = _o1[0];
224 101 : res_op1 = _r1;
225 : }
226 101 : tree _r;
227 101 : _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
228 101 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 73, __FILE__, __LINE__, true);
229 101 : return _r;
230 : }
231 : next_after_fail100:;
232 : }
233 : return NULL_TREE;
234 : }
235 :
236 : tree
237 24 : generic_simplify_38 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
238 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
239 : const enum tree_code ARG_UNUSED (op),
240 : const enum tree_code ARG_UNUSED (cmp),
241 : const enum tree_code ARG_UNUSED (icmp))
242 : {
243 24 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
244 24 : if (invert_tree_comparison (cmp, HONOR_NANS (captures[2])) == icmp
245 : )
246 : {
247 24 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail115;
248 24 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail115;
249 24 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail115;
250 24 : {
251 24 : tree res_op0;
252 24 : res_op0 = captures[1];
253 24 : tree res_op1;
254 24 : res_op1 = captures[4];
255 24 : tree res_op2;
256 24 : res_op2 = captures[7];
257 24 : tree _r;
258 24 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
259 24 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 87, __FILE__, __LINE__, true);
260 24 : return _r;
261 : }
262 : next_after_fail115:;
263 : }
264 : return NULL_TREE;
265 : }
266 :
267 : tree
268 0 : generic_simplify_45 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
269 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
270 : const enum tree_code ARG_UNUSED (op))
271 : {
272 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
273 0 : if (INTEGRAL_TYPE_P (type)
274 0 : && tree_int_cst_sgn (captures[5]) > 0
275 0 : && (tree_nonzero_bits (captures[0]) & tree_nonzero_bits (captures[4])) == 0
276 : )
277 : {
278 0 : {
279 0 : tree t = type;
280 0 : if (!TYPE_OVERFLOW_WRAPS (t))
281 0 : t = unsigned_type_for (t);
282 0 : wide_int wone = wi::one (TYPE_PRECISION (type));
283 0 : wide_int c = wi::add (wi::to_wide (captures[3]),
284 0 : wi::lshift (wone, wi::to_wide (captures[5])));
285 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail123;
286 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail123;
287 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail123;
288 0 : {
289 0 : tree res_op0;
290 0 : {
291 0 : tree _o1[2], _r1;
292 0 : {
293 0 : tree _o2[1], _r2;
294 0 : _o2[0] = captures[2];
295 0 : if (TREE_TYPE (_o2[0]) != t)
296 : {
297 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, t, _o2[0]);
298 : }
299 : else
300 : _r2 = _o2[0];
301 0 : _o1[0] = _r2;
302 : }
303 0 : _o1[1] = wide_int_to_tree (t, c);
304 0 : _r1 = fold_build2_loc (loc, MULT_EXPR, t, _o1[0], _o1[1]);
305 0 : res_op0 = _r1;
306 : }
307 0 : tree _r;
308 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
309 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 89, __FILE__, __LINE__, true);
310 0 : return _r;
311 : }
312 0 : next_after_fail123:;
313 0 : }
314 : }
315 : return NULL_TREE;
316 : }
317 :
318 : tree
319 311 : generic_simplify_55 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
320 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
321 : const enum tree_code ARG_UNUSED (outer_op),
322 : const enum tree_code ARG_UNUSED (inner_op))
323 : {
324 311 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
325 311 : if (real_zerop (captures[2])
326 34 : && real_zerop (captures[3])
327 345 : && !HONOR_SIGN_DEPENDENT_ROUNDING (type)
328 : )
329 : {
330 10 : {
331 10 : bool inner_plus = ((inner_op == PLUS_EXPR)
332 10 : ^ REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (captures[2])));
333 10 : bool outer_plus
334 10 : = ((outer_op == PLUS_EXPR)
335 10 : ^ REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (captures[3])));
336 10 : if (outer_plus && !inner_plus
337 : )
338 : {
339 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail135;
340 2 : {
341 2 : tree res_op0;
342 2 : res_op0 = captures[1];
343 2 : tree res_op1;
344 2 : res_op1 = captures[3];
345 2 : tree _r;
346 2 : _r = fold_build2_loc (loc, outer_op, type, res_op0, res_op1);
347 2 : if (TREE_SIDE_EFFECTS (captures[2]))
348 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
349 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 103, __FILE__, __LINE__, true);
350 2 : return _r;
351 : }
352 0 : next_after_fail135:;
353 : }
354 : else
355 : {
356 8 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail136;
357 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail136;
358 8 : {
359 8 : tree _r;
360 8 : _r = captures[0];
361 8 : if (TREE_SIDE_EFFECTS (captures[3]))
362 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
363 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 104, __FILE__, __LINE__, true);
364 8 : return _r;
365 : }
366 : next_after_fail136:;
367 : }
368 : }
369 : }
370 : return NULL_TREE;
371 : }
372 :
373 : tree
374 540 : generic_simplify_69 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
375 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
376 : {
377 540 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
378 540 : if (!TYPE_SATURATING (type)
379 : )
380 : {
381 540 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
382 1080 : && !FIXED_POINT_TYPE_P (type)
383 : )
384 : {
385 540 : if (!TYPE_OVERFLOW_TRAPS (type)
386 : )
387 : {
388 540 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail158;
389 540 : {
390 540 : tree res_op0;
391 540 : res_op0 = build_all_ones_cst (TREE_TYPE (captures[0]));
392 540 : tree _r;
393 540 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
394 540 : if (TREE_SIDE_EFFECTS (captures[0]))
395 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
396 540 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 126, __FILE__, __LINE__, true);
397 540 : return _r;
398 : }
399 0 : next_after_fail158:;
400 : }
401 : }
402 : }
403 : return NULL_TREE;
404 : }
405 :
406 : tree
407 2 : generic_simplify_76 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
408 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
409 : const enum tree_code ARG_UNUSED (div),
410 : const enum tree_code ARG_UNUSED (mod))
411 : {
412 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
413 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail166;
414 2 : {
415 2 : tree _r;
416 2 : _r = captures[0];
417 2 : if (TREE_SIDE_EFFECTS (captures[1]))
418 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
419 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 134, __FILE__, __LINE__, true);
420 : return _r;
421 : }
422 0 : next_after_fail166:;
423 0 : return NULL_TREE;
424 : }
425 :
426 : tree
427 19475 : generic_simplify_79 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
428 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
429 : const enum tree_code ARG_UNUSED (op))
430 : {
431 19475 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
432 19475 : if (flag_unsafe_math_optimizations
433 : )
434 : {
435 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail170;
436 12 : {
437 12 : tree res_op0;
438 12 : {
439 12 : tree _o1[2], _r1;
440 12 : _o1[0] = captures[0];
441 12 : _o1[1] = captures[2];
442 12 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
443 12 : res_op0 = _r1;
444 : }
445 12 : tree res_op1;
446 12 : res_op1 = captures[1];
447 12 : tree _r;
448 12 : _r = fold_build2_loc (loc, RDIV_EXPR, type, res_op0, res_op1);
449 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 138, __FILE__, __LINE__, true);
450 12 : return _r;
451 : }
452 0 : next_after_fail170:;
453 : }
454 : return NULL_TREE;
455 : }
456 :
457 : tree
458 0 : generic_simplify_85 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
459 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
460 : const enum tree_code ARG_UNUSED (op))
461 : {
462 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
463 0 : if (VECTOR_FLOAT_TYPE_P (type)
464 0 : && TYPE_VECTOR_SUBPARTS (type).is_constant ()
465 : )
466 : {
467 0 : {
468 0 : tree perm_cst = captures[1];
469 0 : vec_perm_builder builder;
470 0 : bool full_perm_p = false;
471 0 : if (tree_to_vec_perm_builder (&builder, perm_cst))
472 : {
473 0 : unsigned HOST_WIDE_INT nelts;
474 0 : nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
475 0 : vec_perm_indices sel (builder, 1, nelts);
476 0 : if (sel.encoding ().encoded_full_vector_p ())
477 : {
478 0 : auto_sbitmap seen (nelts);
479 0 : bitmap_clear (seen);
480 0 : unsigned HOST_WIDE_INT count = 0, i;
481 0 : for (i = 0; i < nelts; i++)
482 : {
483 0 : if (!bitmap_set_bit (seen, sel[i].to_constant ()))
484 : break;
485 0 : count++;
486 : }
487 0 : full_perm_p = count == nelts;
488 0 : }
489 0 : }
490 0 : if (full_perm_p
491 : )
492 : {
493 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail176;
494 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail176;
495 0 : {
496 0 : tree res_op0;
497 0 : {
498 0 : tree _o1[2], _r1;
499 0 : _o1[0] = captures[0];
500 0 : _o1[1] = captures[2];
501 0 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
502 0 : captures[3] = _r1;
503 : }
504 0 : res_op0 = unshare_expr (captures[3]);
505 0 : tree res_op1;
506 0 : res_op1 = captures[3];
507 0 : tree res_op2;
508 0 : res_op2 = captures[1];
509 0 : tree _r;
510 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
511 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 144, __FILE__, __LINE__, true);
512 0 : return _r;
513 : }
514 0 : next_after_fail176:;
515 : }
516 0 : }
517 : }
518 : return NULL_TREE;
519 : }
520 :
521 : tree
522 43522 : generic_simplify_98 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
523 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
524 : {
525 43522 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
526 43522 : if (!TYPE_SATURATING (type)
527 : )
528 : {
529 43522 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
530 87044 : && !FIXED_POINT_TYPE_P (type)
531 : )
532 : {
533 0 : if (!ANY_INTEGRAL_TYPE_P (type)
534 43522 : || TYPE_OVERFLOW_WRAPS (type)
535 : )
536 : {
537 39768 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail190;
538 39768 : {
539 39768 : tree res_op0;
540 39768 : {
541 39768 : tree _o1[1], _r1;
542 39768 : _o1[0] = captures[1];
543 39768 : if (TREE_TYPE (_o1[0]) != type)
544 : {
545 202 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
546 : }
547 : else
548 : _r1 = _o1[0];
549 39768 : res_op0 = _r1;
550 : }
551 39768 : tree _r;
552 39768 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
553 39768 : if (TREE_SIDE_EFFECTS (captures[0]))
554 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
555 39768 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 157, __FILE__, __LINE__, true);
556 39768 : return _r;
557 : }
558 0 : next_after_fail190:;
559 : }
560 : else
561 : {
562 3754 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail191;
563 3754 : {
564 3754 : tree res_op0;
565 3754 : {
566 3754 : tree _o1[1], _r1;
567 3754 : _o1[0] = captures[1];
568 3754 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
569 3754 : res_op0 = _r1;
570 : }
571 3754 : tree _r;
572 3754 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
573 3754 : if (TREE_SIDE_EFFECTS (captures[0]))
574 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
575 3754 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 158, __FILE__, __LINE__, true);
576 3754 : return _r;
577 : }
578 0 : next_after_fail191:;
579 : }
580 : }
581 : }
582 : return NULL_TREE;
583 : }
584 :
585 : tree
586 36 : generic_simplify_111 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
587 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
588 : const enum tree_code ARG_UNUSED (bitop),
589 : const enum tree_code ARG_UNUSED (cmp))
590 : {
591 36 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
592 72 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
593 36 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
594 72 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == TYPE_PRECISION (TREE_TYPE (captures[2]))
595 : )
596 : {
597 36 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail208;
598 36 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail208;
599 36 : {
600 36 : tree res_op0;
601 36 : {
602 36 : tree _o1[2], _r1;
603 36 : _o1[0] = captures[0];
604 36 : {
605 36 : tree _o2[1], _r2;
606 36 : _o2[0] = captures[2];
607 36 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
608 : {
609 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
610 : }
611 : else
612 : _r2 = _o2[0];
613 36 : _o1[1] = _r2;
614 : }
615 36 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
616 36 : res_op0 = _r1;
617 : }
618 36 : tree res_op1;
619 36 : res_op1 = captures[1];
620 36 : tree _r;
621 36 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
622 36 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 175, __FILE__, __LINE__, true);
623 36 : return _r;
624 : }
625 : next_after_fail208:;
626 : }
627 : return NULL_TREE;
628 : }
629 :
630 : tree
631 16 : generic_simplify_118 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
632 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
633 : {
634 16 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
635 32 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
636 32 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
637 : )
638 : {
639 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail215;
640 0 : {
641 0 : tree res_op0;
642 0 : res_op0 = captures[0];
643 0 : tree res_op1;
644 0 : {
645 0 : tree _o1[2], _r1;
646 0 : _o1[0] = captures[1];
647 0 : _o1[1] = build_one_cst (type);
648 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
649 0 : res_op1 = _r1;
650 : }
651 0 : tree _r;
652 0 : _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
653 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 181, __FILE__, __LINE__, true);
654 0 : return _r;
655 : }
656 0 : next_after_fail215:;
657 : }
658 : return NULL_TREE;
659 : }
660 :
661 : tree
662 1 : generic_simplify_131 (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 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
666 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail228;
667 1 : {
668 1 : tree res_op0;
669 1 : {
670 1 : tree _o1[2], _r1;
671 1 : _o1[0] = captures[1];
672 1 : _o1[1] = captures[2];
673 1 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
674 1 : res_op0 = _r1;
675 : }
676 1 : tree _r;
677 1 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
678 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 190, __FILE__, __LINE__, true);
679 : return _r;
680 : }
681 0 : next_after_fail228:;
682 0 : return NULL_TREE;
683 : }
684 :
685 : tree
686 21 : generic_simplify_141 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
687 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
688 : const enum tree_code ARG_UNUSED (bitop),
689 : const enum tree_code ARG_UNUSED (rbitop))
690 : {
691 21 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
692 21 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail242;
693 21 : {
694 21 : tree _r;
695 21 : _r = captures[0];
696 21 : if (TREE_SIDE_EFFECTS (captures[1]))
697 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
698 21 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 196, __FILE__, __LINE__, true);
699 : return _r;
700 : }
701 0 : next_after_fail242:;
702 0 : return NULL_TREE;
703 : }
704 :
705 : tree
706 0 : generic_simplify_145 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
707 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
708 : const enum tree_code ARG_UNUSED (bitop),
709 : const enum tree_code ARG_UNUSED (rbitop))
710 : {
711 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
712 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail246;
713 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail246;
714 0 : {
715 0 : tree res_op0;
716 0 : res_op0 = captures[0];
717 0 : tree res_op1;
718 0 : res_op1 = captures[2];
719 0 : tree _r;
720 0 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
721 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 198, __FILE__, __LINE__, true);
722 : return _r;
723 : }
724 : next_after_fail246:;
725 : return NULL_TREE;
726 : }
727 :
728 : tree
729 0 : generic_simplify_152 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
730 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
731 : const enum tree_code ARG_UNUSED (cmp),
732 : const enum tree_code ARG_UNUSED (icmp))
733 : {
734 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
735 0 : if (integer_zerop (captures[5])
736 0 : && invert_tree_comparison (cmp, HONOR_NANS (captures[2])) == icmp
737 : )
738 : {
739 0 : if (integer_onep (captures[4])
740 : )
741 : {
742 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail254;
743 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail254;
744 0 : {
745 0 : tree res_op0;
746 0 : {
747 0 : tree _o1[3], _r1;
748 0 : _o1[0] = captures[1];
749 0 : _o1[1] = captures[6];
750 0 : _o1[2] = captures[9];
751 0 : _r1 = fold_build3_loc (loc, VEC_COND_EXPR, TREE_TYPE (_o1[1]), _o1[0], _o1[1], _o1[2]);
752 0 : res_op0 = _r1;
753 : }
754 0 : tree res_op1;
755 0 : res_op1 = captures[4];
756 0 : tree _r;
757 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
758 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 203, __FILE__, __LINE__, true);
759 0 : return _r;
760 : }
761 : next_after_fail254:;
762 : }
763 : else
764 : {
765 0 : if (integer_minus_onep (captures[4])
766 : )
767 : {
768 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail255;
769 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail255;
770 0 : {
771 0 : tree res_op0;
772 0 : res_op0 = captures[1];
773 0 : tree res_op1;
774 0 : res_op1 = captures[6];
775 0 : tree res_op2;
776 0 : res_op2 = captures[9];
777 0 : tree _r;
778 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
779 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 204, __FILE__, __LINE__, true);
780 0 : return _r;
781 : }
782 : next_after_fail255:;
783 : }
784 : }
785 : }
786 : else
787 : {
788 0 : if (integer_zerop (captures[4])
789 0 : && invert_tree_comparison (cmp, HONOR_NANS (captures[2])) == icmp
790 : )
791 : {
792 0 : if (integer_onep (captures[5])
793 : )
794 : {
795 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail256;
796 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail256;
797 0 : {
798 0 : tree res_op0;
799 0 : {
800 0 : tree _o1[3], _r1;
801 0 : _o1[0] = captures[1];
802 0 : _o1[1] = captures[9];
803 0 : _o1[2] = captures[6];
804 0 : _r1 = fold_build3_loc (loc, VEC_COND_EXPR, TREE_TYPE (_o1[1]), _o1[0], _o1[1], _o1[2]);
805 0 : res_op0 = _r1;
806 : }
807 0 : tree res_op1;
808 0 : res_op1 = captures[5];
809 0 : tree _r;
810 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
811 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 205, __FILE__, __LINE__, true);
812 0 : return _r;
813 : }
814 : next_after_fail256:;
815 : }
816 : else
817 : {
818 0 : if (integer_minus_onep (captures[5])
819 : )
820 : {
821 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail257;
822 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail257;
823 0 : {
824 0 : tree res_op0;
825 0 : res_op0 = captures[1];
826 0 : tree res_op1;
827 0 : res_op1 = captures[9];
828 0 : tree res_op2;
829 0 : res_op2 = captures[6];
830 0 : tree _r;
831 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
832 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 206, __FILE__, __LINE__, true);
833 0 : return _r;
834 : }
835 : next_after_fail257:;
836 : }
837 : }
838 : }
839 : }
840 : return NULL_TREE;
841 : }
842 :
843 : tree
844 4 : generic_simplify_173 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
845 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
846 : {
847 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
848 4 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail311;
849 4 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail311;
850 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail311;
851 4 : {
852 4 : tree _r;
853 4 : _r = captures[0];
854 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 232, __FILE__, __LINE__, true);
855 : return _r;
856 : }
857 : next_after_fail311:;
858 : return NULL_TREE;
859 : }
860 :
861 : tree
862 0 : generic_simplify_178 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
863 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
864 : {
865 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
866 0 : if (type_has_mode_precision_p (type)
867 0 : && tree_fits_uhwi_p (captures[1])
868 0 : && tree_fits_uhwi_p (captures[3])
869 0 : && tree_fits_uhwi_p (captures[4])
870 0 : && ((~((HOST_WIDE_INT_1U << tree_to_uhwi (captures[1])) - 1)) & tree_to_uhwi (captures[4])) == 0
871 0 : && (tree_to_uhwi (captures[1]) + tree_to_uhwi (captures[3])) == TYPE_PRECISION (type)
872 0 : && TYPE_UNSIGNED (type)
873 0 : && captures[0] == captures[2]
874 : )
875 : {
876 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail316;
877 0 : {
878 0 : tree res_op0;
879 0 : {
880 0 : tree _o1[2], _r1;
881 0 : _o1[0] = captures[0];
882 0 : _o1[1] = captures[3];
883 0 : _r1 = fold_build2_loc (loc, RROTATE_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
884 0 : res_op0 = _r1;
885 : }
886 0 : tree res_op1;
887 0 : res_op1 = captures[4];
888 0 : tree _r;
889 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
890 0 : if (TREE_SIDE_EFFECTS (captures[1]))
891 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
892 0 : if (TREE_SIDE_EFFECTS (captures[2]))
893 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
894 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 235, __FILE__, __LINE__, true);
895 0 : return _r;
896 : }
897 0 : next_after_fail316:;
898 : }
899 : return NULL_TREE;
900 : }
901 :
902 : tree
903 0 : generic_simplify_185 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
904 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
905 : const combined_fn ARG_UNUSED (copysigns))
906 : {
907 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
908 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail323;
909 0 : {
910 0 : if (! tree_invariant_p (captures[1])) goto next_after_fail323;
911 0 : tree res_op0;
912 0 : res_op0 = unshare_expr (captures[1]);
913 0 : tree res_op1;
914 0 : res_op1 = captures[1];
915 0 : tree _r;
916 0 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
917 0 : if (TREE_SIDE_EFFECTS (captures[2]))
918 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
919 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 240, __FILE__, __LINE__, true);
920 : return _r;
921 : }
922 : next_after_fail323:;
923 : return NULL_TREE;
924 : }
925 :
926 : tree
927 37502 : generic_simplify_191 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
928 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
929 : {
930 37502 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
931 37502 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
932 37502 : && tree_nop_conversion_p (type, TREE_TYPE (captures[1]))
933 : )
934 : {
935 34863 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail331;
936 34863 : {
937 34863 : tree res_op0;
938 34863 : {
939 34863 : tree _o1[1], _r1;
940 34863 : _o1[0] = captures[0];
941 34863 : if (TREE_TYPE (_o1[0]) != type)
942 : {
943 890 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
944 : }
945 : else
946 : _r1 = _o1[0];
947 34863 : res_op0 = _r1;
948 : }
949 34863 : tree res_op1;
950 34863 : {
951 34863 : tree _o1[1], _r1;
952 34863 : {
953 34863 : tree _o2[1], _r2;
954 34863 : _o2[0] = captures[1];
955 34863 : _r2 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
956 34863 : _o1[0] = _r2;
957 : }
958 34863 : if (TREE_TYPE (_o1[0]) != type)
959 : {
960 7 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
961 : }
962 : else
963 : _r1 = _o1[0];
964 34863 : res_op1 = _r1;
965 : }
966 34863 : tree _r;
967 34863 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
968 34863 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 245, __FILE__, __LINE__, true);
969 34863 : return _r;
970 : }
971 0 : next_after_fail331:;
972 : }
973 : return NULL_TREE;
974 : }
975 :
976 : tree
977 2 : generic_simplify_200 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
978 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
979 : const combined_fn ARG_UNUSED (SQRT_ALL))
980 : {
981 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
982 2 : if (flag_unsafe_math_optimizations
983 : )
984 : {
985 2 : if (!tree_expr_maybe_signaling_nan_p (captures[1])
986 : )
987 : {
988 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail341;
989 2 : {
990 2 : tree _r;
991 2 : _r = captures[1];
992 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 254, __FILE__, __LINE__, true);
993 2 : return _r;
994 : }
995 0 : next_after_fail341:;
996 : }
997 : }
998 : return NULL_TREE;
999 : }
1000 :
1001 : tree
1002 12 : generic_simplify_204 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1003 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1004 : const combined_fn ARG_UNUSED (TAN),
1005 : const combined_fn ARG_UNUSED (COS),
1006 : const combined_fn ARG_UNUSED (SIN))
1007 : {
1008 12 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1009 12 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1010 : )
1011 : {
1012 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail345;
1013 12 : {
1014 12 : tree res_op0;
1015 12 : res_op0 = captures[1];
1016 12 : tree _r;
1017 12 : _r = maybe_build_call_expr_loc (loc, SIN, type, 1, res_op0);
1018 12 : if (!_r)
1019 0 : goto next_after_fail345;
1020 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 258, __FILE__, __LINE__, true);
1021 12 : return _r;
1022 : }
1023 : next_after_fail345:;
1024 : }
1025 : return NULL_TREE;
1026 : }
1027 :
1028 : tree
1029 182 : generic_simplify_210 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1030 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1031 : const enum tree_code ARG_UNUSED (op))
1032 : {
1033 182 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1034 364 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
1035 364 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
1036 182 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2])))
1037 : && (CONSTANT_CLASS_P (captures[2]) || (single_use (captures[1]) && single_use (captures[0])))
1038 182 : && tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
1039 546 : && tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
1040 : )
1041 : {
1042 182 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail351;
1043 182 : {
1044 182 : tree res_op0;
1045 182 : res_op0 = captures[2];
1046 182 : tree res_op1;
1047 182 : res_op1 = build_zero_cst (TREE_TYPE (captures[2]));
1048 182 : tree _r;
1049 182 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1050 182 : if (TREE_SIDE_EFFECTS (captures[3]))
1051 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
1052 182 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 264, __FILE__, __LINE__, true);
1053 182 : return _r;
1054 : }
1055 0 : next_after_fail351:;
1056 : }
1057 : return NULL_TREE;
1058 : }
1059 :
1060 : tree
1061 1654327 : generic_simplify_220 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1062 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1063 : const enum tree_code ARG_UNUSED (cmp))
1064 : {
1065 1654327 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1066 3308654 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1067 1654327 : && integer_nonzerop (captures[2])
1068 1652737 : && !TREE_OVERFLOW (captures[2])
1069 3307064 : && !TREE_OVERFLOW (captures[3])
1070 : )
1071 : {
1072 1652737 : {
1073 1652737 : tree lo, hi; bool neg_overflow;
1074 1652737 : enum tree_code code = fold_div_compare (cmp, captures[2], captures[3], &lo, &hi,
1075 : &neg_overflow);
1076 1652737 : if (code == LT_EXPR || code == GE_EXPR
1077 : )
1078 : {
1079 40070 : if (TREE_OVERFLOW (lo)
1080 : )
1081 : {
1082 4742 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail364;
1083 4742 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail364;
1084 4742 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail364;
1085 4742 : {
1086 4742 : tree _r;
1087 4742 : _r = build_int_cst (type, (code == LT_EXPR) ^ neg_overflow);
1088 4742 : if (TREE_SIDE_EFFECTS (captures[1]))
1089 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1090 4742 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 276, __FILE__, __LINE__, true);
1091 1652734 : return _r;
1092 : }
1093 3 : next_after_fail364:;
1094 : }
1095 : else
1096 : {
1097 35328 : if (code == LT_EXPR
1098 : )
1099 : {
1100 720 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail365;
1101 720 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail365;
1102 720 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail365;
1103 720 : {
1104 720 : tree res_op0;
1105 720 : res_op0 = captures[1];
1106 720 : tree res_op1;
1107 720 : res_op1 = lo;
1108 720 : tree _r;
1109 720 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
1110 720 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 277, __FILE__, __LINE__, true);
1111 720 : return _r;
1112 : }
1113 3 : next_after_fail365:;
1114 : }
1115 : else
1116 : {
1117 34608 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail366;
1118 34608 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail366;
1119 34608 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail366;
1120 34608 : {
1121 34608 : tree res_op0;
1122 34608 : res_op0 = captures[1];
1123 34608 : tree res_op1;
1124 34608 : res_op1 = lo;
1125 34608 : tree _r;
1126 34608 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
1127 34608 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 278, __FILE__, __LINE__, true);
1128 34608 : return _r;
1129 : }
1130 3 : next_after_fail366:;
1131 : }
1132 : }
1133 : }
1134 : else
1135 : {
1136 1612667 : if (code == LE_EXPR || code == GT_EXPR
1137 : )
1138 : {
1139 1609571 : if (TREE_OVERFLOW (hi)
1140 : )
1141 : {
1142 531295 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail367;
1143 531295 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail367;
1144 531295 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail367;
1145 531295 : {
1146 531295 : tree _r;
1147 531295 : _r = build_int_cst (type, (code == LE_EXPR) ^ neg_overflow);
1148 531295 : if (TREE_SIDE_EFFECTS (captures[1]))
1149 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1150 531295 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 279, __FILE__, __LINE__, true);
1151 531295 : return _r;
1152 : }
1153 3 : next_after_fail367:;
1154 : }
1155 : else
1156 : {
1157 1078276 : if (code == LE_EXPR
1158 : )
1159 : {
1160 640 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail368;
1161 640 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail368;
1162 640 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail368;
1163 640 : {
1164 640 : tree res_op0;
1165 640 : res_op0 = captures[1];
1166 640 : tree res_op1;
1167 640 : res_op1 = hi;
1168 640 : tree _r;
1169 640 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1170 640 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 280, __FILE__, __LINE__, true);
1171 640 : return _r;
1172 : }
1173 3 : next_after_fail368:;
1174 : }
1175 : else
1176 : {
1177 1077636 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail369;
1178 1077636 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail369;
1179 1077636 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail369;
1180 1077636 : {
1181 1077636 : tree res_op0;
1182 1077636 : res_op0 = captures[1];
1183 1077636 : tree res_op1;
1184 1077636 : res_op1 = hi;
1185 1077636 : tree _r;
1186 1077636 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
1187 1077636 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 281, __FILE__, __LINE__, true);
1188 1077636 : return _r;
1189 : }
1190 3 : next_after_fail369:;
1191 : }
1192 : }
1193 : }
1194 : else
1195 : {
1196 3096 : if (!lo && !hi
1197 : )
1198 : {
1199 40 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail370;
1200 40 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail370;
1201 40 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail370;
1202 40 : {
1203 40 : tree _r;
1204 40 : _r = build_int_cst (type, code == NE_EXPR);
1205 40 : if (TREE_SIDE_EFFECTS (captures[1]))
1206 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1207 40 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 282, __FILE__, __LINE__, true);
1208 40 : return _r;
1209 : }
1210 3 : next_after_fail370:;
1211 : }
1212 : else
1213 : {
1214 3056 : if (code == EQ_EXPR && !hi
1215 : )
1216 : {
1217 15 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail371;
1218 15 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail371;
1219 15 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail371;
1220 15 : {
1221 15 : tree res_op0;
1222 15 : res_op0 = captures[1];
1223 15 : tree res_op1;
1224 15 : res_op1 = lo;
1225 15 : tree _r;
1226 15 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
1227 15 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 283, __FILE__, __LINE__, true);
1228 15 : return _r;
1229 : }
1230 3 : next_after_fail371:;
1231 : }
1232 : else
1233 : {
1234 943 : if (code == EQ_EXPR && !lo
1235 : )
1236 : {
1237 11 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail372;
1238 11 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail372;
1239 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail372;
1240 11 : {
1241 11 : tree res_op0;
1242 11 : res_op0 = captures[1];
1243 11 : tree res_op1;
1244 11 : res_op1 = hi;
1245 11 : tree _r;
1246 11 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1247 11 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 284, __FILE__, __LINE__, true);
1248 11 : return _r;
1249 : }
1250 3 : next_after_fail372:;
1251 : }
1252 : else
1253 : {
1254 3030 : if (code == NE_EXPR && !hi
1255 : )
1256 : {
1257 4 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail373;
1258 4 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail373;
1259 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail373;
1260 4 : {
1261 4 : tree res_op0;
1262 4 : res_op0 = captures[1];
1263 4 : tree res_op1;
1264 4 : res_op1 = lo;
1265 4 : tree _r;
1266 4 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
1267 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 285, __FILE__, __LINE__, true);
1268 4 : return _r;
1269 : }
1270 3 : next_after_fail373:;
1271 : }
1272 : else
1273 : {
1274 2094 : if (code == NE_EXPR && !lo
1275 : )
1276 : {
1277 20 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail374;
1278 20 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail374;
1279 20 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail374;
1280 20 : {
1281 20 : tree res_op0;
1282 20 : res_op0 = captures[1];
1283 20 : tree res_op1;
1284 20 : res_op1 = hi;
1285 20 : tree _r;
1286 20 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
1287 20 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 286, __FILE__, __LINE__, true);
1288 20 : return _r;
1289 : }
1290 3 : next_after_fail374:;
1291 : }
1292 : else
1293 : {
1294 3006 : if (1
1295 : )
1296 : {
1297 3006 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail375;
1298 3003 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail375;
1299 3003 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail375;
1300 3003 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail375;
1301 3003 : {
1302 3003 : tree _r;
1303 3003 : _r = build_range_check (UNKNOWN_LOCATION, type, captures[1], code == EQ_EXPR,
1304 : lo, hi);
1305 3003 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 287, __FILE__, __LINE__, true);
1306 3003 : return _r;
1307 : }
1308 3 : next_after_fail375:;
1309 : }
1310 : else
1311 : {
1312 : {
1313 : tree etype = range_check_type (TREE_TYPE (captures[1]));
1314 : if (etype)
1315 : {
1316 : hi = fold_convert (etype, hi);
1317 : lo = fold_convert (etype, lo);
1318 : hi = const_binop (MINUS_EXPR, etype, hi, lo);
1319 : }
1320 : if (etype && hi && !TREE_OVERFLOW (hi)
1321 : )
1322 : {
1323 : if (code == EQ_EXPR
1324 : )
1325 : {
1326 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail376;
1327 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail376;
1328 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail376;
1329 : {
1330 : tree res_op0;
1331 : {
1332 : tree _o1[2], _r1;
1333 : {
1334 : tree _o2[1], _r2;
1335 : _o2[0] = captures[1];
1336 : if (TREE_TYPE (_o2[0]) != etype)
1337 : {
1338 : _r2 = fold_build1_loc (loc, NOP_EXPR, etype, _o2[0]);
1339 : }
1340 : else
1341 : _r2 = _o2[0];
1342 : _o1[0] = _r2;
1343 : }
1344 : _o1[1] = lo;
1345 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1346 : res_op0 = _r1;
1347 : }
1348 : tree res_op1;
1349 : res_op1 = hi;
1350 : tree _r;
1351 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1352 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 288, __FILE__, __LINE__, true);
1353 : return _r;
1354 : }
1355 : next_after_fail376:;
1356 : }
1357 : else
1358 : {
1359 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail377;
1360 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail377;
1361 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail377;
1362 : {
1363 : tree res_op0;
1364 : {
1365 : tree _o1[2], _r1;
1366 : {
1367 : tree _o2[1], _r2;
1368 : _o2[0] = captures[1];
1369 : if (TREE_TYPE (_o2[0]) != etype)
1370 : {
1371 : _r2 = fold_build1_loc (loc, NOP_EXPR, etype, _o2[0]);
1372 : }
1373 : else
1374 : _r2 = _o2[0];
1375 : _o1[0] = _r2;
1376 : }
1377 : _o1[1] = lo;
1378 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1379 : res_op0 = _r1;
1380 : }
1381 : tree res_op1;
1382 : res_op1 = hi;
1383 : tree _r;
1384 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
1385 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 289, __FILE__, __LINE__, true);
1386 : return _r;
1387 : }
1388 : next_after_fail377:;
1389 : }
1390 : }
1391 : }
1392 : }
1393 : }
1394 : }
1395 : }
1396 : }
1397 : }
1398 : }
1399 : }
1400 : }
1401 : }
1402 : return NULL_TREE;
1403 : }
1404 :
1405 : tree
1406 0 : generic_simplify_277 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1407 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1408 : const enum tree_code ARG_UNUSED (cmp))
1409 : {
1410 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1411 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
1412 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1413 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1414 0 : && TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (TREE_TYPE (captures[2]))
1415 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (TREE_TYPE (captures[1]))
1416 0 : && !wi::neg_p (wi::to_wide (captures[3]))
1417 : )
1418 : {
1419 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail510;
1420 0 : {
1421 0 : tree res_op0;
1422 0 : {
1423 0 : tree _o1[2], _r1;
1424 0 : _o1[0] = captures[2];
1425 0 : {
1426 0 : tree _o2[1], _r2;
1427 0 : {
1428 0 : tree _o3[1], _r3;
1429 0 : _o3[0] = captures[3];
1430 0 : _r3 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o3[0]), _o3[0]);
1431 0 : _o2[0] = _r3;
1432 : }
1433 0 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
1434 : {
1435 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
1436 : }
1437 : else
1438 : _r2 = _o2[0];
1439 0 : _o1[1] = _r2;
1440 : }
1441 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1442 0 : res_op0 = _r1;
1443 : }
1444 0 : tree res_op1;
1445 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[2]));
1446 0 : tree _r;
1447 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1448 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 411, __FILE__, __LINE__, true);
1449 0 : return _r;
1450 : }
1451 0 : next_after_fail510:;
1452 : }
1453 : return NULL_TREE;
1454 : }
1455 :
1456 : tree
1457 828200 : generic_simplify_284 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1458 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1459 : const enum tree_code ARG_UNUSED (cmp),
1460 : const enum tree_code ARG_UNUSED (ncmp))
1461 : {
1462 828200 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1463 1592105 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1464 828200 : && type_has_mode_precision_p (TREE_TYPE (captures[1]))
1465 826904 : && element_precision (captures[0]) >= element_precision (captures[1])
1466 1656400 : && wi::only_sign_bit_p (wi::to_wide (captures[2]), element_precision (captures[1]))
1467 : )
1468 : {
1469 14697 : {
1470 14697 : tree stype = signed_type_for (TREE_TYPE (captures[1]));
1471 14697 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail517;
1472 14697 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail517;
1473 14697 : {
1474 14697 : tree res_op0;
1475 14697 : {
1476 14697 : tree _o1[1], _r1;
1477 14697 : _o1[0] = captures[1];
1478 14697 : if (TREE_TYPE (_o1[0]) != stype)
1479 : {
1480 14476 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
1481 : }
1482 : else
1483 : _r1 = _o1[0];
1484 14697 : res_op0 = _r1;
1485 : }
1486 14697 : tree res_op1;
1487 14697 : res_op1 = build_zero_cst (stype);
1488 14697 : tree _r;
1489 14697 : _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
1490 14697 : if (TREE_SIDE_EFFECTS (captures[2]))
1491 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1492 14697 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 417, __FILE__, __LINE__, true);
1493 14697 : return _r;
1494 : }
1495 : next_after_fail517:;
1496 : }
1497 : }
1498 : return NULL_TREE;
1499 : }
1500 :
1501 : tree
1502 8 : generic_simplify_294 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1503 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1504 : const enum tree_code ARG_UNUSED (cmp),
1505 : const enum tree_code ARG_UNUSED (out))
1506 : {
1507 8 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1508 16 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
1509 8 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1510 8 : && TYPE_UNSIGNED (TREE_TYPE (captures[2]))
1511 8 : && (TYPE_PRECISION (TREE_TYPE (captures[1]))
1512 8 : >= 2 * TYPE_PRECISION (TREE_TYPE (captures[2])))
1513 8 : && tree_fits_uhwi_p (captures[4])
1514 8 : && tree_to_uhwi (captures[4]) == TYPE_PRECISION (TREE_TYPE (captures[2]))
1515 8 : && types_match (captures[2], captures[3])
1516 16 : && TYPE_MAX_VALUE (TREE_TYPE (captures[2]))
1517 : )
1518 : {
1519 8 : {
1520 8 : tree utype = unsigned_type_for (TREE_TYPE (captures[1]));
1521 8 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail545;
1522 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail545;
1523 8 : {
1524 8 : tree res_op0;
1525 8 : {
1526 8 : tree _o1[2], _r1;
1527 8 : {
1528 8 : tree _o2[1], _r2;
1529 8 : _o2[0] = captures[2];
1530 8 : if (TREE_TYPE (_o2[0]) != utype)
1531 : {
1532 8 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
1533 : }
1534 : else
1535 : _r2 = _o2[0];
1536 8 : _o1[0] = _r2;
1537 : }
1538 8 : {
1539 8 : tree _o2[1], _r2;
1540 8 : _o2[0] = captures[3];
1541 8 : if (TREE_TYPE (_o2[0]) != utype)
1542 : {
1543 8 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
1544 : }
1545 : else
1546 : _r2 = _o2[0];
1547 8 : _o1[1] = _r2;
1548 : }
1549 8 : _r1 = fold_build2_loc (loc, MULT_EXPR, utype, _o1[0], _o1[1]);
1550 8 : res_op0 = _r1;
1551 : }
1552 8 : tree res_op1;
1553 8 : res_op1 = fold_convert (utype, TYPE_MAX_VALUE (TREE_TYPE (captures[2])));
1554 8 : tree _r;
1555 8 : _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
1556 8 : if (TREE_SIDE_EFFECTS (captures[4]))
1557 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
1558 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 436, __FILE__, __LINE__, true);
1559 8 : return _r;
1560 : }
1561 : next_after_fail545:;
1562 : }
1563 : }
1564 : return NULL_TREE;
1565 : }
1566 :
1567 : tree
1568 366 : generic_simplify_297 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1569 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1570 : const enum tree_code ARG_UNUSED (op),
1571 : const enum tree_code ARG_UNUSED (cmp),
1572 : const combined_fn ARG_UNUSED (clz))
1573 : {
1574 366 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1575 366 : if (!sanitize_flags_p (SANITIZE_BUILTIN)
1576 366 : || (cfun && (cfun->curr_properties & PROP_ssa) != 0)
1577 : )
1578 : {
1579 302 : if (integer_zerop (captures[2]) && single_use (captures[0])
1580 : )
1581 : {
1582 59 : {
1583 59 : tree stype = signed_type_for (TREE_TYPE (captures[1]));
1584 59 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail557;
1585 59 : {
1586 59 : tree res_op0;
1587 59 : {
1588 59 : tree _o1[1], _r1;
1589 59 : _o1[0] = captures[1];
1590 59 : if (TREE_TYPE (_o1[0]) != stype)
1591 : {
1592 59 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
1593 : }
1594 : else
1595 : _r1 = _o1[0];
1596 59 : res_op0 = _r1;
1597 : }
1598 59 : tree res_op1;
1599 59 : res_op1 = build_zero_cst (stype);
1600 59 : tree _r;
1601 59 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1602 59 : if (TREE_SIDE_EFFECTS (captures[2]))
1603 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1604 59 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 448, __FILE__, __LINE__, true);
1605 59 : return _r;
1606 : }
1607 0 : next_after_fail557:;
1608 : }
1609 : }
1610 : else
1611 : {
1612 243 : if (wi::to_wide (captures[2]) == TYPE_PRECISION (TREE_TYPE (captures[1])) - 1
1613 : )
1614 : {
1615 79 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail558;
1616 79 : {
1617 79 : tree res_op0;
1618 79 : res_op0 = captures[1];
1619 79 : tree res_op1;
1620 79 : res_op1 = build_one_cst (TREE_TYPE (captures[1]));
1621 79 : tree _r;
1622 79 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1623 79 : if (TREE_SIDE_EFFECTS (captures[2]))
1624 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1625 79 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 449, __FILE__, __LINE__, true);
1626 79 : return _r;
1627 : }
1628 0 : next_after_fail558:;
1629 : }
1630 : }
1631 : }
1632 : return NULL_TREE;
1633 : }
1634 :
1635 : tree
1636 45 : generic_simplify_301 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1637 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1638 : const enum tree_code ARG_UNUSED (cmp),
1639 : const enum tree_code ARG_UNUSED (rep),
1640 : const combined_fn ARG_UNUSED (popcount))
1641 : {
1642 45 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1643 45 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail565;
1644 45 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail565;
1645 45 : {
1646 45 : tree res_op0;
1647 45 : res_op0 = captures[0];
1648 45 : tree res_op1;
1649 45 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
1650 45 : tree _r;
1651 45 : _r = fold_build2_loc (loc, rep, type, res_op0, res_op1);
1652 45 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 456, __FILE__, __LINE__, true);
1653 : return _r;
1654 : }
1655 : next_after_fail565:;
1656 : return NULL_TREE;
1657 : }
1658 :
1659 : tree
1660 283372 : generic_simplify_306 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1661 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1662 : const enum tree_code ARG_UNUSED (cmp))
1663 : {
1664 283372 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1665 283372 : if (cmp != NE_EXPR
1666 278169 : || ! FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1667 295748 : || ! tree_expr_maybe_nan_p (captures[0])
1668 : )
1669 : {
1670 276810 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail573;
1671 276810 : {
1672 276810 : tree _r;
1673 276810 : _r = constant_boolean_node (false, type);
1674 276810 : if (TREE_SIDE_EFFECTS (captures[0]))
1675 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1676 276810 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 464, __FILE__, __LINE__, true);
1677 276810 : return _r;
1678 : }
1679 0 : next_after_fail573:;
1680 : }
1681 : return NULL_TREE;
1682 : }
1683 :
1684 : tree
1685 0 : generic_simplify_310 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1686 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1687 : const combined_fn ARG_UNUSED (COPYSIGN_ALL))
1688 : {
1689 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1690 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail577;
1691 0 : {
1692 0 : tree _r;
1693 0 : _r = captures[0];
1694 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 468, __FILE__, __LINE__, true);
1695 : return _r;
1696 : }
1697 0 : next_after_fail577:;
1698 0 : return NULL_TREE;
1699 : }
1700 :
1701 : tree
1702 14453 : generic_simplify_317 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1703 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1704 : const enum tree_code ARG_UNUSED (div))
1705 : {
1706 14453 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1707 14453 : if (INTEGRAL_TYPE_P (type)
1708 14419 : && ssa_name_has_boolean_range (captures[1])
1709 14453 : && !flag_non_call_exceptions
1710 : )
1711 : {
1712 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail586;
1713 0 : {
1714 0 : tree _r;
1715 0 : _r = captures[0];
1716 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1717 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1718 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 475, __FILE__, __LINE__, true);
1719 0 : return _r;
1720 : }
1721 0 : next_after_fail586:;
1722 : }
1723 : return NULL_TREE;
1724 : }
1725 :
1726 : tree
1727 25285 : generic_simplify_323 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1728 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1729 : const enum tree_code ARG_UNUSED (div))
1730 : {
1731 25285 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1732 25285 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) && TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1733 : )
1734 : {
1735 25137 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail593;
1736 25137 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail593;
1737 25137 : {
1738 25137 : tree res_op0;
1739 25137 : res_op0 = captures[0];
1740 25137 : tree res_op1;
1741 25137 : res_op1 = wide_int_to_tree
1742 50274 : (type, wi::mask (TYPE_PRECISION (type)
1743 25137 : - wi::exact_log2 (wi::to_wide (captures[1])),
1744 25137 : false, TYPE_PRECISION (type)));
1745 25137 : tree _r;
1746 25137 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
1747 25137 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 482, __FILE__, __LINE__, true);
1748 25137 : return _r;
1749 : }
1750 : next_after_fail593:;
1751 : }
1752 : return NULL_TREE;
1753 : }
1754 :
1755 : tree
1756 922 : generic_simplify_327 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1757 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1758 : const enum tree_code ARG_UNUSED (mod))
1759 : {
1760 922 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1761 922 : if (!integer_zerop (captures[1])
1762 : )
1763 : {
1764 785 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail597;
1765 785 : {
1766 785 : tree _r;
1767 785 : _r = captures[0];
1768 785 : if (TREE_SIDE_EFFECTS (captures[1]))
1769 74 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1770 785 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 486, __FILE__, __LINE__, true);
1771 785 : return _r;
1772 : }
1773 0 : next_after_fail597:;
1774 : }
1775 : return NULL_TREE;
1776 : }
1777 :
1778 : tree
1779 0 : generic_simplify_336 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1780 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1781 : const combined_fn ARG_UNUSED (SQRT))
1782 : {
1783 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1784 0 : if (flag_unsafe_math_optimizations
1785 : )
1786 : {
1787 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail608;
1788 0 : {
1789 0 : tree res_op0;
1790 0 : res_op0 = captures[0];
1791 0 : tree _r;
1792 0 : _r = maybe_build_call_expr_loc (loc, SQRT, type, 1, res_op0);
1793 0 : if (!_r)
1794 0 : goto next_after_fail608;
1795 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 497, __FILE__, __LINE__, true);
1796 0 : return _r;
1797 : }
1798 : next_after_fail608:;
1799 : }
1800 : return NULL_TREE;
1801 : }
1802 :
1803 : tree
1804 4 : generic_simplify_343 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1805 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1806 : const combined_fn ARG_UNUSED (POW))
1807 : {
1808 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1809 4 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1810 : )
1811 : {
1812 4 : if (!TREE_OVERFLOW (captures[2])
1813 : )
1814 : {
1815 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail615;
1816 4 : {
1817 4 : tree res_op0;
1818 4 : res_op0 = captures[1];
1819 4 : tree res_op1;
1820 4 : {
1821 4 : tree _o1[2], _r1;
1822 4 : _o1[0] = captures[2];
1823 4 : _o1[1] = build_one_cst (type);
1824 4 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1825 4 : res_op1 = _r1;
1826 : }
1827 4 : tree _r;
1828 4 : _r = maybe_build_call_expr_loc (loc, POW, type, 2, res_op0, res_op1);
1829 4 : if (!_r)
1830 0 : goto next_after_fail615;
1831 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 504, __FILE__, __LINE__, true);
1832 4 : return _r;
1833 : }
1834 : next_after_fail615:;
1835 : }
1836 : }
1837 : return NULL_TREE;
1838 : }
1839 :
1840 : tree
1841 9 : generic_simplify_351 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1842 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures))
1843 : {
1844 9 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1845 9 : if (INTEGRAL_TYPE_P (type)
1846 9 : && !TYPE_UNSIGNED (type)
1847 : )
1848 : {
1849 9 : {
1850 9 : tree utype = unsigned_type_for (type);
1851 9 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail629;
1852 9 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail629;
1853 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail629;
1854 9 : {
1855 9 : tree res_op0;
1856 9 : {
1857 9 : tree _o1[2], _r1;
1858 9 : {
1859 9 : tree _o2[1], _r2;
1860 9 : _o2[0] = captures[0];
1861 9 : if (TREE_TYPE (_o2[0]) != utype)
1862 : {
1863 9 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
1864 : }
1865 : else
1866 : _r2 = _o2[0];
1867 9 : _o1[0] = _r2;
1868 : }
1869 9 : {
1870 9 : tree _o2[1], _r2;
1871 9 : _o2[0] = captures[1];
1872 9 : if (TREE_TYPE (_o2[0]) != utype)
1873 : {
1874 9 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
1875 : }
1876 : else
1877 : _r2 = _o2[0];
1878 9 : _o1[1] = _r2;
1879 : }
1880 9 : _r1 = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1881 9 : res_op0 = _r1;
1882 : }
1883 9 : tree _r;
1884 9 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1885 9 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 518, __FILE__, __LINE__, true);
1886 9 : return _r;
1887 : }
1888 : next_after_fail629:;
1889 : }
1890 : }
1891 : return NULL_TREE;
1892 : }
1893 :
1894 : tree
1895 0 : generic_simplify_358 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1896 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1897 : const enum tree_code ARG_UNUSED (op))
1898 : {
1899 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1900 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail636;
1901 0 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail636;
1902 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail636;
1903 0 : {
1904 0 : tree _r;
1905 0 : _r = captures[2];
1906 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 525, __FILE__, __LINE__, true);
1907 : return _r;
1908 : }
1909 : next_after_fail636:;
1910 : return NULL_TREE;
1911 : }
1912 :
1913 : tree
1914 0 : generic_simplify_365 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1915 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures))
1916 : {
1917 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1918 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail643;
1919 0 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail643;
1920 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail643;
1921 0 : {
1922 0 : tree _r;
1923 0 : _r = captures[2];
1924 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 532, __FILE__, __LINE__, true);
1925 : return _r;
1926 : }
1927 : next_after_fail643:;
1928 : return NULL_TREE;
1929 : }
1930 :
1931 : tree
1932 9 : generic_simplify_371 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1933 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1934 : const combined_fn ARG_UNUSED (func))
1935 : {
1936 9 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1937 9 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail650;
1938 9 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail650;
1939 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail650;
1940 9 : {
1941 9 : tree _r;
1942 9 : _r = captures[2];
1943 9 : if (TREE_SIDE_EFFECTS (captures[1]))
1944 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1945 9 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 539, __FILE__, __LINE__, true);
1946 : return _r;
1947 : }
1948 : next_after_fail650:;
1949 : return NULL_TREE;
1950 : }
1951 :
1952 : tree
1953 26 : generic_simplify_379 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1954 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1955 : const enum tree_code ARG_UNUSED (ltge),
1956 : const enum tree_code ARG_UNUSED (gelt))
1957 : {
1958 26 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1959 26 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail661;
1960 26 : {
1961 26 : tree res_op0;
1962 26 : res_op0 = captures[1];
1963 26 : tree res_op1;
1964 26 : res_op1 = build_zero_cst (TREE_TYPE (captures[1]));
1965 26 : tree _r;
1966 26 : _r = fold_build2_loc (loc, gelt, type, res_op0, res_op1);
1967 26 : if (TREE_SIDE_EFFECTS (captures[0]))
1968 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1969 26 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 548, __FILE__, __LINE__, true);
1970 : return _r;
1971 : }
1972 0 : next_after_fail661:;
1973 0 : return NULL_TREE;
1974 : }
1975 :
1976 : tree
1977 433 : generic_simplify_385 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1978 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1979 : const enum tree_code ARG_UNUSED (op))
1980 : {
1981 433 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1982 866 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1983 866 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
1984 : )
1985 : {
1986 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail668;
1987 0 : {
1988 0 : tree res_op0;
1989 0 : res_op0 = captures[2];
1990 0 : tree res_op1;
1991 0 : res_op1 = captures[1];
1992 0 : tree _r;
1993 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1994 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1995 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1996 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 555, __FILE__, __LINE__, true);
1997 0 : return _r;
1998 : }
1999 0 : next_after_fail668:;
2000 : }
2001 : return NULL_TREE;
2002 : }
2003 :
2004 : tree
2005 6 : generic_simplify_391 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2006 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2007 : const enum tree_code ARG_UNUSED (cmp))
2008 : {
2009 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2010 12 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2011 12 : && TYPE_UNSIGNED (TREE_TYPE (captures[1]))
2012 : )
2013 : {
2014 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail675;
2015 6 : {
2016 6 : tree res_op0;
2017 6 : res_op0 = captures[0];
2018 6 : tree res_op1;
2019 6 : res_op1 = captures[1];
2020 6 : tree _r;
2021 6 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2022 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 562, __FILE__, __LINE__, true);
2023 6 : return _r;
2024 : }
2025 0 : next_after_fail675:;
2026 : }
2027 : return NULL_TREE;
2028 : }
2029 :
2030 : tree
2031 178 : generic_simplify_398 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2032 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2033 : const enum tree_code ARG_UNUSED (cmp),
2034 : const enum tree_code ARG_UNUSED (out))
2035 : {
2036 178 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2037 178 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))
2038 178 : && types_match (TREE_TYPE (captures[3]), TREE_TYPE (captures[0]))
2039 105 : && tree_nop_conversion_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[3]))
2040 178 : && wi::to_wide (captures[4]) != 0
2041 0 : && single_use (captures[1])
2042 : )
2043 : {
2044 105 : {
2045 105 : unsigned int prec = TYPE_PRECISION (TREE_TYPE (captures[3]));
2046 105 : signop sign = TYPE_SIGN (TREE_TYPE (captures[3]));
2047 105 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail714;
2048 105 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail714;
2049 105 : {
2050 105 : tree res_op0;
2051 105 : res_op0 = captures[3];
2052 105 : tree res_op1;
2053 105 : res_op1 = wide_int_to_tree (TREE_TYPE (captures[3]),
2054 105 : wi::max_value (prec, sign)
2055 315 : - wi::to_wide (captures[4]));
2056 105 : tree _r;
2057 105 : _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
2058 105 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 564, __FILE__, __LINE__, true);
2059 105 : return _r;
2060 : }
2061 : next_after_fail714:;
2062 : }
2063 : }
2064 : return NULL_TREE;
2065 : }
2066 :
2067 : tree
2068 50 : generic_simplify_406 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2069 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2070 : const enum tree_code ARG_UNUSED (op),
2071 : const enum tree_code ARG_UNUSED (cmp),
2072 : const combined_fn ARG_UNUSED (ctz))
2073 : {
2074 50 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2075 50 : {
2076 50 : bool ok = true;
2077 50 : HOST_WIDE_INT val = 0;
2078 50 : if (sanitize_flags_p (SANITIZE_BUILTIN)
2079 50 : && (!cfun
2080 32 : || (cfun->curr_properties & PROP_ssa) == 0))
2081 : ok = false;
2082 18 : else if (!tree_fits_shwi_p (captures[2]))
2083 : ok = false;
2084 : else
2085 : {
2086 18 : val = tree_to_shwi (captures[2]);
2087 18 : if (op == GT_EXPR || op == LE_EXPR)
2088 : {
2089 10 : if (val == HOST_WIDE_INT_MAX)
2090 : ok = false;
2091 : else
2092 10 : val++;
2093 : }
2094 : }
2095 50 : tree type0 = TREE_TYPE (captures[1]);
2096 50 : int prec = TYPE_PRECISION (type0);
2097 68 : if (ok && prec <= MAX_FIXED_MODE_SIZE
2098 : )
2099 : {
2100 18 : if (val <= 0
2101 : )
2102 : {
2103 8 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail725;
2104 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail725;
2105 8 : {
2106 8 : tree _r;
2107 8 : _r = constant_boolean_node (cmp == EQ_EXPR ? true : false, type);
2108 8 : if (TREE_SIDE_EFFECTS (captures[1]))
2109 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2110 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 595, __FILE__, __LINE__, true);
2111 8 : return _r;
2112 : }
2113 : next_after_fail725:;
2114 : }
2115 : else
2116 : {
2117 10 : if (val >= prec
2118 : )
2119 : {
2120 5 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail726;
2121 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail726;
2122 5 : {
2123 5 : tree _r;
2124 5 : _r = constant_boolean_node (cmp == EQ_EXPR ? false : true, type);
2125 5 : if (TREE_SIDE_EFFECTS (captures[1]))
2126 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2127 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 596, __FILE__, __LINE__, true);
2128 5 : return _r;
2129 : }
2130 : next_after_fail726:;
2131 : }
2132 : else
2133 : {
2134 5 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail727;
2135 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail727;
2136 5 : {
2137 5 : tree res_op0;
2138 5 : {
2139 5 : tree _o1[2], _r1;
2140 5 : _o1[0] = captures[1];
2141 5 : _o1[1] = wide_int_to_tree (type0,
2142 5 : wi::mask (val, false, prec));
2143 5 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2144 5 : res_op0 = _r1;
2145 : }
2146 5 : tree res_op1;
2147 5 : res_op1 = build_zero_cst (type0);
2148 5 : tree _r;
2149 5 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2150 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 597, __FILE__, __LINE__, true);
2151 5 : return _r;
2152 : }
2153 : next_after_fail727:;
2154 : }
2155 : }
2156 : }
2157 : }
2158 : return NULL_TREE;
2159 : }
2160 :
2161 : tree
2162 94 : generic_simplify_419 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2163 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2164 : {
2165 94 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2166 188 : if (INTEGRAL_TYPE_P (type)
2167 93 : && !TYPE_UNSIGNED (type)
2168 93 : && !TYPE_OVERFLOW_TRAPS (type)
2169 93 : && tree_nop_conversion_p (type, TREE_TYPE (captures[2]))
2170 281 : && (expr_not_equal_to (captures[0], wi::to_wide (TYPE_MIN_VALUE (type)))
2171 187 : || expr_not_equal_to (captures[2], wi::minus_one (TYPE_PRECISION
2172 : (TREE_TYPE (captures[2]))),
2173 : gimple_match_ctx (captures[1])))
2174 : )
2175 : {
2176 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail746;
2177 0 : {
2178 0 : tree res_op0;
2179 0 : res_op0 = captures[0];
2180 0 : tree res_op1;
2181 0 : {
2182 0 : tree _o1[1], _r1;
2183 0 : _o1[0] = captures[2];
2184 0 : if (TREE_TYPE (_o1[0]) != type)
2185 : {
2186 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2187 : }
2188 : else
2189 : _r1 = _o1[0];
2190 0 : res_op1 = _r1;
2191 : }
2192 0 : tree _r;
2193 0 : _r = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, res_op0, res_op1);
2194 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 612, __FILE__, __LINE__, true);
2195 0 : return _r;
2196 : }
2197 0 : next_after_fail746:;
2198 : }
2199 : return NULL_TREE;
2200 : }
2201 :
2202 : tree
2203 0 : generic_simplify_426 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2204 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2205 : const enum tree_code ARG_UNUSED (shiftrotate))
2206 : {
2207 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2208 0 : {
2209 0 : tree tem = uniform_vector_p (captures[1]);
2210 0 : if (tem
2211 : )
2212 : {
2213 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail753;
2214 0 : {
2215 0 : tree res_op0;
2216 0 : res_op0 = captures[0];
2217 0 : tree res_op1;
2218 0 : res_op1 = tem;
2219 0 : tree _r;
2220 0 : _r = fold_build2_loc (loc, shiftrotate, type, res_op0, res_op1);
2221 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2222 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2223 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 618, __FILE__, __LINE__, true);
2224 0 : return _r;
2225 : }
2226 0 : next_after_fail753:;
2227 : }
2228 : }
2229 : return NULL_TREE;
2230 : }
2231 :
2232 : tree
2233 3714681 : generic_simplify_433 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2234 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2235 : const enum tree_code ARG_UNUSED (bitop))
2236 : {
2237 3714681 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2238 3714681 : if (0
2239 : && INTEGRAL_TYPE_P (type)
2240 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2241 : && TREE_CODE (captures[3]) != INTEGER_CST
2242 : && tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
2243 : && TYPE_PRECISION (TREE_TYPE (captures[2])) > TYPE_PRECISION (type)
2244 : )
2245 : {
2246 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail767;
2247 : {
2248 : tree res_op0;
2249 : {
2250 : tree _o1[1], _r1;
2251 : _o1[0] = captures[2];
2252 : if (TREE_TYPE (_o1[0]) != type)
2253 : {
2254 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2255 : }
2256 : else
2257 : _r1 = _o1[0];
2258 : res_op0 = _r1;
2259 : }
2260 : tree res_op1;
2261 : {
2262 : tree _o1[1], _r1;
2263 : _o1[0] = captures[3];
2264 : if (TREE_TYPE (_o1[0]) != type)
2265 : {
2266 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2267 : }
2268 : else
2269 : _r1 = _o1[0];
2270 : res_op1 = _r1;
2271 : }
2272 : tree _r;
2273 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
2274 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 631, __FILE__, __LINE__, true);
2275 : return _r;
2276 : }
2277 : next_after_fail767:;
2278 : }
2279 : else
2280 : {
2281 3714681 : if (0
2282 : && INTEGRAL_TYPE_P (type)
2283 : && types_match (type, TREE_TYPE (captures[2]))
2284 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (type)
2285 : )
2286 : {
2287 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail768;
2288 : {
2289 : tree res_op0;
2290 : res_op0 = captures[2];
2291 : tree res_op1;
2292 : {
2293 : tree _o1[1], _r1;
2294 : _o1[0] = captures[3];
2295 : if (TREE_TYPE (_o1[0]) != type)
2296 : {
2297 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2298 : }
2299 : else
2300 : _r1 = _o1[0];
2301 : res_op1 = _r1;
2302 : }
2303 : tree _r;
2304 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
2305 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 632, __FILE__, __LINE__, true);
2306 : return _r;
2307 : }
2308 : next_after_fail768:;
2309 : }
2310 : }
2311 3714681 : return NULL_TREE;
2312 : }
2313 :
2314 : tree
2315 22117216 : generic_simplify_440 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2316 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2317 : const enum tree_code ARG_UNUSED (op))
2318 : {
2319 22117216 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2320 22117216 : if (INTEGRAL_TYPE_P (type)
2321 20564713 : && op != MULT_EXPR
2322 20564713 : && op != RDIV_EXPR
2323 11316861 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2324 11316861 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2325 11316861 : && type_has_mode_precision_p (TREE_TYPE (captures[2]))
2326 11315553 : && type_has_mode_precision_p (TREE_TYPE (captures[4]))
2327 11315553 : && type_has_mode_precision_p (type)
2328 11281258 : && TYPE_PRECISION (TREE_TYPE (captures[1])) > TYPE_PRECISION (TREE_TYPE (captures[2]))
2329 0 : && types_match (captures[2], type)
2330 22117216 : && (types_match (captures[2], captures[4])
2331 0 : || poly_int_tree_p (captures[3]))
2332 : )
2333 : {
2334 0 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))
2335 : )
2336 : {
2337 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail785;
2338 0 : {
2339 0 : tree res_op0;
2340 0 : res_op0 = captures[2];
2341 0 : tree res_op1;
2342 0 : {
2343 0 : tree _o1[1], _r1;
2344 0 : _o1[0] = captures[4];
2345 0 : if (TREE_TYPE (_o1[0]) != type)
2346 : {
2347 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2348 : }
2349 : else
2350 : _r1 = _o1[0];
2351 0 : res_op1 = _r1;
2352 : }
2353 0 : tree _r;
2354 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2355 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 637, __FILE__, __LINE__, true);
2356 0 : return _r;
2357 : }
2358 0 : next_after_fail785:;
2359 : }
2360 : else
2361 : {
2362 0 : {
2363 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
2364 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail786;
2365 0 : {
2366 0 : tree res_op0;
2367 0 : {
2368 0 : tree _o1[2], _r1;
2369 0 : {
2370 0 : tree _o2[1], _r2;
2371 0 : _o2[0] = captures[2];
2372 0 : if (TREE_TYPE (_o2[0]) != utype)
2373 : {
2374 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2375 : }
2376 : else
2377 : _r2 = _o2[0];
2378 0 : _o1[0] = _r2;
2379 : }
2380 0 : {
2381 0 : tree _o2[1], _r2;
2382 0 : _o2[0] = captures[4];
2383 0 : if (TREE_TYPE (_o2[0]) != utype)
2384 : {
2385 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2386 : }
2387 : else
2388 : _r2 = _o2[0];
2389 0 : _o1[1] = _r2;
2390 : }
2391 0 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2392 0 : res_op0 = _r1;
2393 : }
2394 0 : tree _r;
2395 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2396 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 638, __FILE__, __LINE__, true);
2397 0 : return _r;
2398 : }
2399 0 : next_after_fail786:;
2400 : }
2401 : }
2402 : }
2403 : else
2404 : {
2405 22065468 : if (FLOAT_TYPE_P (type)
2406 22168964 : && DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
2407 51748 : == DECIMAL_FLOAT_TYPE_P (type)
2408 : )
2409 : {
2410 51708 : {
2411 51708 : tree arg0 = strip_float_extensions (captures[2]);
2412 51708 : tree arg1 = strip_float_extensions (captures[4]);
2413 51708 : tree itype = TREE_TYPE (captures[0]);
2414 51708 : tree ty1 = TREE_TYPE (arg0);
2415 51708 : tree ty2 = TREE_TYPE (arg1);
2416 51708 : enum tree_code code = TREE_CODE (itype);
2417 0 : if (FLOAT_TYPE_P (ty1)
2418 51708 : && FLOAT_TYPE_P (ty2)
2419 : )
2420 : {
2421 51708 : {
2422 51708 : tree newtype = type;
2423 51708 : if (TYPE_MODE (ty1) == SDmode
2424 51440 : || TYPE_MODE (ty2) == SDmode
2425 103148 : || TYPE_MODE (type) == SDmode)
2426 283 : newtype = dfloat32_type_node;
2427 51708 : if (TYPE_MODE (ty1) == DDmode
2428 51562 : || TYPE_MODE (ty2) == DDmode
2429 103143 : || TYPE_MODE (type) == DDmode)
2430 275 : newtype = dfloat64_type_node;
2431 51708 : if (TYPE_MODE (ty1) == TDmode
2432 51707 : || TYPE_MODE (ty2) == TDmode
2433 103163 : || TYPE_MODE (type) == TDmode)
2434 268 : newtype = dfloat128_type_node;
2435 51708 : if ((newtype == dfloat32_type_node
2436 51704 : || newtype == dfloat64_type_node
2437 51561 : || newtype == dfloat128_type_node)
2438 415 : && newtype == type
2439 51719 : && types_match (newtype, type)
2440 : )
2441 : {
2442 11 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail787;
2443 5 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail787;
2444 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail787;
2445 5 : {
2446 5 : tree res_op0;
2447 5 : {
2448 5 : tree _o1[1], _r1;
2449 5 : _o1[0] = captures[2];
2450 5 : if (TREE_TYPE (_o1[0]) != newtype)
2451 : {
2452 5 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
2453 : }
2454 : else
2455 : _r1 = _o1[0];
2456 5 : res_op0 = _r1;
2457 : }
2458 5 : tree res_op1;
2459 5 : {
2460 5 : tree _o1[1], _r1;
2461 5 : _o1[0] = captures[4];
2462 5 : if (TREE_TYPE (_o1[0]) != newtype)
2463 : {
2464 5 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
2465 : }
2466 : else
2467 : _r1 = _o1[0];
2468 5 : res_op1 = _r1;
2469 : }
2470 5 : tree _r;
2471 5 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2472 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 639, __FILE__, __LINE__, true);
2473 5 : return _r;
2474 : }
2475 : next_after_fail787:;
2476 : }
2477 : else
2478 : {
2479 51697 : {
2480 51697 : if (element_precision (ty1) > element_precision (newtype))
2481 11722 : newtype = ty1;
2482 51697 : if (element_precision (ty2) > element_precision (newtype))
2483 4848 : newtype = ty2;
2484 51697 : if (element_precision (newtype) < element_precision (itype)
2485 14505 : && (!VECTOR_MODE_P (TYPE_MODE (newtype))
2486 0 : || target_supports_op_p (newtype, op, optab_default))
2487 14505 : && (flag_unsafe_math_optimizations
2488 14497 : || (element_precision (newtype) == element_precision (type)
2489 14468 : && real_can_shorten_arithmetic (element_mode (itype),
2490 : element_mode (type))
2491 4559 : && !excess_precision_type (newtype)))
2492 51852 : && !types_match (itype, newtype)
2493 : )
2494 : {
2495 155 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail788;
2496 154 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail788;
2497 136 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail788;
2498 136 : {
2499 136 : tree res_op0;
2500 136 : {
2501 136 : tree _o1[2], _r1;
2502 136 : {
2503 136 : tree _o2[1], _r2;
2504 136 : _o2[0] = captures[2];
2505 136 : if (TREE_TYPE (_o2[0]) != newtype)
2506 : {
2507 136 : _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
2508 : }
2509 : else
2510 : _r2 = _o2[0];
2511 136 : _o1[0] = _r2;
2512 : }
2513 136 : {
2514 136 : tree _o2[1], _r2;
2515 136 : _o2[0] = captures[4];
2516 136 : if (TREE_TYPE (_o2[0]) != newtype)
2517 : {
2518 136 : _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
2519 : }
2520 : else
2521 : _r2 = _o2[0];
2522 136 : _o1[1] = _r2;
2523 : }
2524 136 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2525 136 : res_op0 = _r1;
2526 : }
2527 136 : tree _r;
2528 136 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2529 136 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 640, __FILE__, __LINE__, true);
2530 136 : return _r;
2531 : }
2532 : next_after_fail788:;
2533 : }
2534 : }
2535 : }
2536 : }
2537 : }
2538 : }
2539 : }
2540 : }
2541 : return NULL_TREE;
2542 : }
2543 :
2544 : tree
2545 0 : generic_simplify_472 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2546 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2547 : const enum tree_code ARG_UNUSED (cmp))
2548 : {
2549 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2550 0 : if (fold_before_rtl_expansion_p ()
2551 : )
2552 : {
2553 0 : if (INTEGRAL_TYPE_P (type)
2554 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2555 : )
2556 : {
2557 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail820;
2558 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail820;
2559 0 : {
2560 0 : tree res_op0;
2561 0 : res_op0 = captures[0];
2562 0 : tree res_op1;
2563 0 : res_op1 = captures[3];
2564 0 : tree res_op2;
2565 0 : res_op2 = build_zero_cst (type);
2566 0 : tree _r;
2567 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
2568 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 671, __FILE__, __LINE__, true);
2569 0 : return _r;
2570 : }
2571 : next_after_fail820:;
2572 : }
2573 : }
2574 : return NULL_TREE;
2575 : }
2576 :
2577 : tree
2578 0 : generic_simplify_482 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2579 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2580 : const enum tree_code ARG_UNUSED (eqne))
2581 : {
2582 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2583 0 : if (eqne == EQ_EXPR
2584 : )
2585 : {
2586 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail851;
2587 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail851;
2588 0 : {
2589 0 : tree _r;
2590 0 : _r = constant_boolean_node (false, type);
2591 0 : if (TREE_SIDE_EFFECTS (captures[2]))
2592 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2593 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 675, __FILE__, __LINE__, true);
2594 0 : return _r;
2595 : }
2596 : next_after_fail851:;
2597 : }
2598 : else
2599 : {
2600 0 : if (eqne == NE_EXPR
2601 : )
2602 : {
2603 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail852;
2604 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail852;
2605 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail852;
2606 0 : {
2607 0 : tree _r;
2608 0 : _r = captures[0];
2609 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 676, __FILE__, __LINE__, true);
2610 0 : return _r;
2611 : }
2612 : next_after_fail852:;
2613 : }
2614 : }
2615 : return NULL_TREE;
2616 : }
2617 :
2618 : tree
2619 4 : generic_simplify_490 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2620 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2621 : {
2622 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2623 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail872;
2624 4 : {
2625 4 : tree res_op0;
2626 4 : res_op0 = captures[1];
2627 4 : tree res_op1;
2628 4 : {
2629 4 : tree _o1[2], _r1;
2630 4 : _o1[0] = captures[2];
2631 4 : _o1[1] = captures[3];
2632 4 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2633 4 : if (EXPR_P (_r1))
2634 2 : goto next_after_fail872;
2635 2 : res_op1 = _r1;
2636 : }
2637 2 : tree _r;
2638 2 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
2639 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 694, __FILE__, __LINE__, true);
2640 : return _r;
2641 : }
2642 : next_after_fail872:;
2643 : return NULL_TREE;
2644 : }
2645 :
2646 : tree
2647 41220 : generic_simplify_494 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2648 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2649 : const enum tree_code ARG_UNUSED (shift))
2650 : {
2651 41220 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2652 41220 : if (tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
2653 23631 : && TYPE_PRECISION (type) <= HOST_BITS_PER_WIDE_INT
2654 23631 : && tree_fits_uhwi_p (captures[4])
2655 23631 : && tree_to_uhwi (captures[4]) > 0
2656 64849 : && tree_to_uhwi (captures[4]) < TYPE_PRECISION (type)
2657 : )
2658 : {
2659 23629 : {
2660 23629 : unsigned int shiftc = tree_to_uhwi (captures[4]);
2661 23629 : unsigned HOST_WIDE_INT mask = TREE_INT_CST_LOW (captures[5]);
2662 23629 : unsigned HOST_WIDE_INT newmask, zerobits = 0;
2663 23629 : tree shift_type = TREE_TYPE (captures[2]);
2664 23629 : unsigned int prec;
2665 23629 : if (shift == LSHIFT_EXPR)
2666 0 : zerobits = ((HOST_WIDE_INT_1U << shiftc) - 1);
2667 23629 : else if (shift == RSHIFT_EXPR
2668 23629 : && type_has_mode_precision_p (shift_type))
2669 : {
2670 23629 : prec = TYPE_PRECISION (TREE_TYPE (captures[2]));
2671 23629 : tree arg00 = captures[3];
2672 23629 : if (captures[2] != captures[3]
2673 23629 : && TYPE_UNSIGNED (TREE_TYPE (captures[3])))
2674 : {
2675 0 : tree inner_type = TREE_TYPE (captures[3]);
2676 0 : if (type_has_mode_precision_p (inner_type)
2677 0 : && TYPE_PRECISION (inner_type) < prec)
2678 : {
2679 0 : prec = TYPE_PRECISION (inner_type);
2680 0 : if (shiftc < prec)
2681 0 : shift_type = inner_type;
2682 : }
2683 : }
2684 23629 : zerobits = HOST_WIDE_INT_M1U;
2685 23629 : if (shiftc < prec)
2686 : {
2687 23629 : zerobits >>= HOST_BITS_PER_WIDE_INT - shiftc;
2688 23629 : zerobits <<= prec - shiftc;
2689 : }
2690 23629 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[2]))
2691 23629 : && prec == TYPE_PRECISION (TREE_TYPE (captures[2])))
2692 : {
2693 98 : if ((mask & zerobits) == 0)
2694 82 : shift_type = unsigned_type_for (TREE_TYPE (captures[2]));
2695 : else
2696 : zerobits = 0;
2697 : }
2698 : }
2699 23613 : if ((mask & zerobits) == mask
2700 : )
2701 : {
2702 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail882;
2703 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail882;
2704 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail882;
2705 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail882;
2706 0 : {
2707 0 : tree _r;
2708 0 : _r = build_int_cst (type, 0);
2709 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 695, __FILE__, __LINE__, true);
2710 0 : return _r;
2711 : }
2712 : next_after_fail882:;
2713 : }
2714 : else
2715 : {
2716 23629 : {
2717 23629 : newmask = mask | zerobits;
2718 23629 : if (newmask != mask && (newmask & (newmask + 1)) == 0
2719 : )
2720 : {
2721 : {
2722 109 : for (prec = BITS_PER_UNIT;
2723 181 : prec < HOST_BITS_PER_WIDE_INT; prec <<= 1)
2724 171 : if (newmask == (HOST_WIDE_INT_1U << prec) - 1)
2725 : break;
2726 72 : if (prec < HOST_BITS_PER_WIDE_INT
2727 10 : || newmask == HOST_WIDE_INT_M1U
2728 : )
2729 : {
2730 72 : {
2731 72 : tree newmaskt = build_int_cst_type (TREE_TYPE (captures[5]), newmask);
2732 72 : if (!tree_int_cst_equal (newmaskt, captures[5])
2733 : )
2734 : {
2735 72 : if (shift_type != TREE_TYPE (captures[2])
2736 : )
2737 : {
2738 11 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail883;
2739 11 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail883;
2740 11 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail883;
2741 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail883;
2742 11 : {
2743 11 : tree res_op0;
2744 11 : {
2745 11 : tree _o1[1], _r1;
2746 11 : {
2747 11 : tree _o2[2], _r2;
2748 11 : {
2749 11 : tree _o3[1], _r3;
2750 11 : _o3[0] = captures[2];
2751 11 : if (TREE_TYPE (_o3[0]) != shift_type)
2752 : {
2753 11 : _r3 = fold_build1_loc (loc, NOP_EXPR, shift_type, _o3[0]);
2754 : }
2755 : else
2756 : _r3 = _o3[0];
2757 11 : _o2[0] = _r3;
2758 : }
2759 11 : _o2[1] = captures[4];
2760 11 : _r2 = fold_build2_loc (loc, shift, shift_type, _o2[0], _o2[1]);
2761 11 : _o1[0] = _r2;
2762 : }
2763 11 : if (TREE_TYPE (_o1[0]) != type)
2764 : {
2765 11 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2766 : }
2767 : else
2768 : _r1 = _o1[0];
2769 11 : res_op0 = _r1;
2770 : }
2771 11 : tree res_op1;
2772 11 : res_op1 = newmaskt;
2773 11 : tree _r;
2774 11 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2775 11 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 696, __FILE__, __LINE__, true);
2776 11 : return _r;
2777 : }
2778 : next_after_fail883:;
2779 : }
2780 : else
2781 : {
2782 61 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail884;
2783 61 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail884;
2784 61 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail884;
2785 61 : {
2786 61 : tree res_op0;
2787 61 : res_op0 = captures[0];
2788 61 : tree res_op1;
2789 61 : res_op1 = newmaskt;
2790 61 : tree _r;
2791 61 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2792 61 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 697, __FILE__, __LINE__, true);
2793 61 : return _r;
2794 : }
2795 : next_after_fail884:;
2796 : }
2797 : }
2798 : }
2799 : }
2800 : }
2801 : }
2802 : }
2803 : }
2804 : }
2805 : }
2806 : return NULL_TREE;
2807 : }
2808 :
2809 : tree
2810 17 : generic_simplify_505 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2811 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2812 : {
2813 17 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2814 17 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail897;
2815 17 : {
2816 17 : tree res_op0;
2817 17 : res_op0 = captures[0];
2818 17 : tree res_op1;
2819 17 : res_op1 = captures[1];
2820 17 : tree _r;
2821 17 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
2822 17 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 709, __FILE__, __LINE__, true);
2823 : return _r;
2824 : }
2825 0 : next_after_fail897:;
2826 0 : return NULL_TREE;
2827 : }
2828 :
2829 : tree
2830 4 : generic_simplify_511 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2831 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2832 : {
2833 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2834 4 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[2]))
2835 7 : && (element_precision (TREE_TYPE (captures[2]))
2836 3 : <= element_precision (TREE_TYPE (captures[3]))
2837 0 : || !TYPE_UNSIGNED (TREE_TYPE (captures[3])))
2838 : )
2839 : {
2840 3 : {
2841 3 : tree shift_type = TREE_TYPE (captures[2]);
2842 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail903;
2843 3 : {
2844 3 : tree res_op0;
2845 3 : {
2846 3 : tree _o1[2], _r1;
2847 3 : {
2848 3 : tree _o2[1], _r2;
2849 3 : _o2[0] = captures[3];
2850 3 : if (TREE_TYPE (_o2[0]) != shift_type)
2851 : {
2852 1 : _r2 = fold_build1_loc (loc, NOP_EXPR, shift_type, _o2[0]);
2853 : }
2854 : else
2855 : _r2 = _o2[0];
2856 3 : _o1[0] = _r2;
2857 : }
2858 3 : _o1[1] = captures[4];
2859 3 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2860 3 : res_op0 = _r1;
2861 : }
2862 3 : tree _r;
2863 3 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2864 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 711, __FILE__, __LINE__, true);
2865 3 : return _r;
2866 : }
2867 0 : next_after_fail903:;
2868 : }
2869 : }
2870 : return NULL_TREE;
2871 : }
2872 :
2873 : tree
2874 1829 : generic_simplify_520 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2875 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2876 : {
2877 1829 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2878 1829 : if (! TYPE_UNSIGNED (type)
2879 1434 : && ! HONOR_SIGN_DEPENDENT_ROUNDING (type)
2880 1829 : && single_use (captures[0])
2881 : )
2882 : {
2883 1434 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail913;
2884 1434 : {
2885 1434 : tree res_op0;
2886 1434 : res_op0 = captures[1];
2887 1434 : tree res_op1;
2888 1434 : {
2889 1434 : tree _o1[1], _r1;
2890 1434 : _o1[0] = captures[2];
2891 1434 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2892 1434 : res_op1 = _r1;
2893 : }
2894 1434 : tree _r;
2895 1434 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
2896 1434 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 723, __FILE__, __LINE__, true);
2897 1434 : return _r;
2898 : }
2899 0 : next_after_fail913:;
2900 : }
2901 : return NULL_TREE;
2902 : }
2903 :
2904 : tree
2905 0 : generic_simplify_530 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2906 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2907 : const enum tree_code ARG_UNUSED (minmax))
2908 : {
2909 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2910 0 : if (INTEGRAL_TYPE_P (type)
2911 0 : && TYPE_OVERFLOW_UNDEFINED (type)
2912 0 : && !TYPE_OVERFLOW_SANITIZED (type)
2913 : )
2914 : {
2915 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail924;
2916 0 : {
2917 0 : tree res_op0;
2918 0 : {
2919 0 : tree _o1[2], _r1;
2920 0 : _o1[0] = captures[1];
2921 0 : _o1[1] = captures[4];
2922 0 : _r1 = fold_build2_loc (loc, minmax, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2923 0 : res_op0 = _r1;
2924 : }
2925 0 : tree res_op1;
2926 0 : res_op1 = captures[2];
2927 0 : tree _r;
2928 0 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
2929 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 733, __FILE__, __LINE__, true);
2930 0 : return _r;
2931 : }
2932 0 : next_after_fail924:;
2933 : }
2934 : return NULL_TREE;
2935 : }
2936 :
2937 : tree
2938 2 : generic_simplify_539 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2939 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2940 : {
2941 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2942 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail947;
2943 2 : {
2944 2 : tree _r;
2945 2 : _r = captures[1];
2946 2 : if (TREE_SIDE_EFFECTS (captures[0]))
2947 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2948 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 744, __FILE__, __LINE__, true);
2949 : return _r;
2950 : }
2951 0 : next_after_fail947:;
2952 0 : return NULL_TREE;
2953 : }
2954 :
2955 : tree
2956 0 : generic_simplify_544 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2957 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2958 : const combined_fn ARG_UNUSED (FMAX_ALL))
2959 : {
2960 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2961 0 : if (flag_finite_math_only
2962 : )
2963 : {
2964 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail952;
2965 0 : {
2966 0 : tree res_op0;
2967 0 : res_op0 = captures[0];
2968 0 : tree res_op1;
2969 0 : res_op1 = captures[1];
2970 0 : tree _r;
2971 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
2972 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 749, __FILE__, __LINE__, true);
2973 0 : return _r;
2974 : }
2975 0 : next_after_fail952:;
2976 : }
2977 : return NULL_TREE;
2978 : }
2979 :
2980 : tree
2981 0 : generic_simplify_550 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2982 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
2983 : const combined_fn ARG_UNUSED (cond_op))
2984 : {
2985 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2986 0 : {
2987 0 : tree op_type = TREE_TYPE (captures[3]);
2988 0 : if (element_precision (type) == element_precision (op_type)
2989 : )
2990 : {
2991 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail958;
2992 0 : {
2993 0 : tree res_op0;
2994 0 : {
2995 0 : tree _o1[4], _r1;
2996 0 : _o1[0] = captures[0];
2997 0 : _o1[1] = captures[1];
2998 0 : _o1[2] = captures[2];
2999 0 : {
3000 0 : tree _o2[1], _r2;
3001 0 : _o2[0] = captures[4];
3002 0 : if (TREE_TYPE (_o2[0]) != op_type)
3003 : {
3004 0 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
3005 : }
3006 : else
3007 : _r2 = _o2[0];
3008 0 : _o1[3] = _r2;
3009 : }
3010 0 : _r1 = maybe_build_call_expr_loc (loc, cond_op, TREE_TYPE (_o1[1]), 4, _o1[0], _o1[1], _o1[2], _o1[3]);
3011 0 : if (!_r1)
3012 0 : goto next_after_fail958;
3013 0 : res_op0 = _r1;
3014 : }
3015 0 : tree _r;
3016 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3017 0 : if (TREE_SIDE_EFFECTS (captures[3]))
3018 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
3019 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 750, __FILE__, __LINE__, true);
3020 0 : return _r;
3021 : }
3022 : next_after_fail958:;
3023 : }
3024 : }
3025 : return NULL_TREE;
3026 : }
3027 :
3028 : tree
3029 0 : generic_simplify_560 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3030 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
3031 : const enum tree_code ARG_UNUSED (rotate))
3032 : {
3033 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3034 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail968;
3035 0 : {
3036 0 : tree _r;
3037 0 : _r = captures[0];
3038 0 : if (TREE_SIDE_EFFECTS (captures[1]))
3039 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3040 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 760, __FILE__, __LINE__, true);
3041 : return _r;
3042 : }
3043 0 : next_after_fail968:;
3044 0 : return NULL_TREE;
3045 : }
3046 :
3047 : tree
3048 60 : generic_simplify_569 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3049 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
3050 : const enum tree_code ARG_UNUSED (cmp))
3051 : {
3052 60 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3053 60 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail980;
3054 60 : {
3055 60 : tree _r;
3056 60 : _r = constant_boolean_node (true, type);
3057 60 : if (TREE_SIDE_EFFECTS (captures[0]))
3058 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3059 60 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 772, __FILE__, __LINE__, true);
3060 : return _r;
3061 : }
3062 0 : next_after_fail980:;
3063 0 : return NULL_TREE;
3064 : }
3065 :
3066 : tree
3067 0 : generic_simplify_576 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3068 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3069 : const combined_fn ARG_UNUSED (sins),
3070 : const combined_fn ARG_UNUSED (atans),
3071 : const combined_fn ARG_UNUSED (sqrts),
3072 : const combined_fn ARG_UNUSED (copysigns))
3073 : {
3074 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3075 0 : {
3076 0 : REAL_VALUE_TYPE r_cst;
3077 0 : build_sinatan_real (&r_cst, type);
3078 0 : tree t_cst = build_real (type, r_cst);
3079 0 : tree t_one = build_one_cst (type);
3080 0 : if (SCALAR_FLOAT_TYPE_P (type)
3081 : )
3082 : {
3083 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail987;
3084 0 : {
3085 0 : if (! tree_invariant_p (captures[1])) goto next_after_fail987;
3086 0 : tree res_op0;
3087 0 : {
3088 0 : tree _o1[2], _r1;
3089 0 : {
3090 0 : tree _o2[1], _r2;
3091 0 : _o2[0] = unshare_expr (captures[1]);
3092 0 : _r2 = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
3093 0 : _o1[0] = _r2;
3094 : }
3095 0 : _o1[1] = t_cst;
3096 0 : _r1 = fold_build2_loc (loc, LT_EXPR, boolean_type_node, _o1[0], _o1[1]);
3097 0 : res_op0 = _r1;
3098 : }
3099 0 : tree res_op1;
3100 0 : {
3101 0 : tree _o1[2], _r1;
3102 0 : _o1[0] = unshare_expr (captures[1]);
3103 0 : {
3104 0 : tree _o2[1], _r2;
3105 0 : {
3106 0 : tree _o3[2], _r3;
3107 0 : {
3108 0 : tree _o4[2], _r4;
3109 0 : _o4[0] = unshare_expr (captures[1]);
3110 0 : _o4[1] = unshare_expr (captures[1]);
3111 0 : _r4 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o4[0]), _o4[0], _o4[1]);
3112 0 : _o3[0] = _r4;
3113 : }
3114 0 : _o3[1] = t_one;
3115 0 : _r3 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
3116 0 : _o2[0] = _r3;
3117 : }
3118 0 : _r2 = maybe_build_call_expr_loc (loc, sqrts, TREE_TYPE (_o2[0]), 1, _o2[0]);
3119 0 : if (!_r2)
3120 0 : goto next_after_fail987;
3121 0 : _o1[1] = _r2;
3122 : }
3123 0 : _r1 = fold_build2_loc (loc, RDIV_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3124 0 : res_op1 = _r1;
3125 : }
3126 0 : tree res_op2;
3127 0 : {
3128 0 : tree _o1[2], _r1;
3129 0 : _o1[0] = t_one;
3130 0 : _o1[1] = captures[1];
3131 0 : _r1 = maybe_build_call_expr_loc (loc, copysigns, TREE_TYPE (_o1[0]), 2, _o1[0], _o1[1]);
3132 0 : if (!_r1)
3133 0 : goto next_after_fail987;
3134 0 : res_op2 = _r1;
3135 : }
3136 0 : tree _r;
3137 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
3138 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 779, __FILE__, __LINE__, true);
3139 0 : return _r;
3140 : }
3141 0 : next_after_fail987:;
3142 : }
3143 : }
3144 0 : return NULL_TREE;
3145 : }
3146 :
3147 : tree
3148 0 : generic_simplify_599 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3149 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures))
3150 : {
3151 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3152 0 : if (canonicalize_math_after_vectorization_p ()
3153 : )
3154 : {
3155 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1010;
3156 : {
3157 : tree res_op0;
3158 : res_op0 = captures[0];
3159 : tree res_op1;
3160 : res_op1 = captures[1];
3161 : tree res_op2;
3162 : res_op2 = captures[2];
3163 : tree _r;
3164 : _r = maybe_build_call_expr_loc (loc, CFN_FNMA, type, 3, res_op0, res_op1, res_op2);
3165 : if (!_r)
3166 : goto next_after_fail1010;
3167 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 802, __FILE__, __LINE__, true);
3168 : return _r;
3169 : }
3170 0 : next_after_fail1010:;
3171 : }
3172 0 : return NULL_TREE;
3173 : }
3174 :
3175 : tree
3176 0 : generic_simplify_608 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3177 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree ARG_UNUSED (_p3), tree ARG_UNUSED (_p4), tree *ARG_UNUSED (captures))
3178 : {
3179 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3180 0 : if (canonicalize_math_after_vectorization_p ()
3181 : )
3182 : {
3183 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1019;
3184 : {
3185 : tree res_op0;
3186 : res_op0 = captures[0];
3187 : tree res_op1;
3188 : res_op1 = captures[1];
3189 : tree res_op2;
3190 : res_op2 = captures[2];
3191 : tree res_op3;
3192 : res_op3 = captures[3];
3193 : tree res_op4;
3194 : res_op4 = captures[4];
3195 : tree _r;
3196 : _r = maybe_build_call_expr_loc (loc, CFN_COND_FMA, type, 5, res_op0, res_op1, res_op2, res_op3, res_op4);
3197 : if (!_r)
3198 : goto next_after_fail1019;
3199 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 811, __FILE__, __LINE__, true);
3200 : return _r;
3201 : }
3202 0 : next_after_fail1019:;
3203 : }
3204 0 : return NULL_TREE;
3205 : }
3206 :
3207 : tree
3208 0 : generic_simplify_617 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3209 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3210 : const enum tree_code ARG_UNUSED (rot),
3211 : const combined_fn ARG_UNUSED (popcount))
3212 : {
3213 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3214 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3215 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
3216 0 : && (
3217 :
3218 0 : || !TREE_SIDE_EFFECTS (captures[3]))
3219 : )
3220 : {
3221 0 : {
3222 0 : tree type0 = TREE_TYPE (captures[0]);
3223 0 : tree type1 = TREE_TYPE (captures[1]);
3224 0 : unsigned int prec0 = TYPE_PRECISION (type0);
3225 0 : unsigned int prec1 = TYPE_PRECISION (type1);
3226 0 : if (prec0 == prec1 || (prec0 > prec1 && TYPE_UNSIGNED (type1))
3227 : )
3228 : {
3229 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1028;
3230 0 : {
3231 0 : tree res_op0;
3232 0 : {
3233 0 : tree _o1[1], _r1;
3234 0 : _o1[0] = captures[2];
3235 0 : if (TREE_TYPE (_o1[0]) != type0)
3236 : {
3237 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type0, _o1[0]);
3238 : }
3239 : else
3240 : _r1 = _o1[0];
3241 0 : res_op0 = _r1;
3242 : }
3243 0 : tree _r;
3244 0 : _r = maybe_build_call_expr_loc (loc, popcount, type, 1, res_op0);
3245 0 : if (!_r)
3246 0 : goto next_after_fail1028;
3247 0 : if (TREE_SIDE_EFFECTS (captures[3]))
3248 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
3249 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 817, __FILE__, __LINE__, true);
3250 0 : return _r;
3251 : }
3252 : next_after_fail1028:;
3253 : }
3254 : }
3255 : }
3256 : return NULL_TREE;
3257 : }
3258 :
3259 : tree
3260 0 : generic_simplify_628 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3261 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3262 : const combined_fn ARG_UNUSED (reduc))
3263 : {
3264 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3265 0 : {
3266 0 : tree ctor = (TREE_CODE (captures[0]) == SSA_NAME
3267 0 : ? gimple_assign_rhs1 (SSA_NAME_DEF_STMT (captures[0])) : captures[0]);
3268 0 : tree elt = ctor_single_nonzero_element (ctor);
3269 0 : if (elt
3270 0 : && types_match (type, TREE_TYPE (elt))
3271 0 : && !HONOR_SNANS (type)
3272 0 : && !HONOR_SIGNED_ZEROS (type)
3273 : )
3274 : {
3275 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1040;
3276 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1040;
3277 0 : {
3278 0 : tree _r;
3279 0 : _r = elt;
3280 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 825, __FILE__, __LINE__, true);
3281 0 : return _r;
3282 : }
3283 : next_after_fail1040:;
3284 : }
3285 : }
3286 : return NULL_TREE;
3287 : }
3288 :
3289 : tree
3290 481031236 : generic_simplify_VIEW_CONVERT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0)
3291 : {
3292 481031236 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3293 481031236 : {
3294 481031236 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3295 962062472 : if ((
3296 :
3297 : && useless_type_conversion_p (type, TREE_TYPE (captures[0])))
3298 : || (
3299 : 1
3300 481031236 : && type == TREE_TYPE (captures[0]))
3301 : )
3302 : {
3303 218551292 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1114;
3304 218551292 : {
3305 218551292 : tree _r;
3306 218551292 : _r = captures[0];
3307 218551292 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 839, __FILE__, __LINE__, true);
3308 218551292 : return _r;
3309 : }
3310 0 : next_after_fail1114:;
3311 : }
3312 : }
3313 262479944 : switch (TREE_CODE (_p0))
3314 : {
3315 28907297 : case VIEW_CONVERT_EXPR:
3316 28907297 : {
3317 28907297 : tree _q20 = TREE_OPERAND (_p0, 0);
3318 28907297 : {
3319 28907297 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3320 28907297 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1115;
3321 28907297 : {
3322 28907297 : tree res_op0;
3323 28907297 : res_op0 = captures[0];
3324 28907297 : tree _r;
3325 28907297 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3326 28907297 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 873, __FILE__, __LINE__, true);
3327 481031236 : return _r;
3328 : }
3329 0 : next_after_fail1115:;
3330 : }
3331 0 : break;
3332 : }
3333 0 : case BIT_FIELD_REF:
3334 0 : {
3335 0 : tree _q20 = TREE_OPERAND (_p0, 0);
3336 0 : tree _q21 = TREE_OPERAND (_p0, 1);
3337 0 : tree _q22 = TREE_OPERAND (_p0, 2);
3338 0 : {
3339 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
3340 0 : if (is_gimple_reg_type (type)
3341 0 : && (!INTEGRAL_TYPE_P (type)
3342 0 : || type_has_mode_precision_p (type))
3343 0 : && (!INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3344 0 : || type_has_mode_precision_p (TREE_TYPE (captures[0])))
3345 : )
3346 : {
3347 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1116;
3348 0 : {
3349 0 : tree res_op0;
3350 0 : res_op0 = captures[1];
3351 0 : tree res_op1;
3352 0 : res_op1 = captures[2];
3353 0 : tree res_op2;
3354 0 : res_op2 = captures[3];
3355 0 : tree _r;
3356 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
3357 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 874, __FILE__, __LINE__, true);
3358 0 : return _r;
3359 : }
3360 0 : next_after_fail1116:;
3361 : }
3362 : }
3363 0 : break;
3364 : }
3365 233572647 : default:;
3366 : }
3367 233572647 : {
3368 233572647 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3369 231769735 : if ((INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
3370 2864686 : && (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0])))
3371 236158226 : && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (captures[0]))
3372 : )
3373 : {
3374 2205610 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1117;
3375 2205610 : {
3376 2205610 : tree res_op0;
3377 2205610 : res_op0 = captures[0];
3378 2205610 : tree _r;
3379 2205610 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3380 2205610 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 875, __FILE__, __LINE__, true);
3381 2205610 : return _r;
3382 : }
3383 0 : next_after_fail1117:;
3384 : }
3385 : }
3386 231367037 : switch (TREE_CODE (_p0))
3387 : {
3388 3498 : CASE_CONVERT:
3389 3498 : {
3390 3498 : tree _q20 = TREE_OPERAND (_p0, 0);
3391 3498 : {
3392 3498 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3393 3498 : {
3394 3498 : bool extended_bitint = false;
3395 3498 : if (BITINT_TYPE_P (TREE_TYPE (captures[0])))
3396 : {
3397 0 : struct bitint_info info;
3398 0 : extended_bitint
3399 0 : = targetm.c.bitint_type_info (TYPE_PRECISION (TREE_TYPE (captures[0])),
3400 : &info);
3401 0 : extended_bitint = extended_bitint && info.extended;
3402 : }
3403 6996 : if ((INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0])))
3404 71 : && (INTEGRAL_TYPE_P (TREE_TYPE (captures[1])) || POINTER_TYPE_P (TREE_TYPE (captures[1])))
3405 71 : && !extended_bitint
3406 71 : && TYPE_SIZE (TREE_TYPE (captures[0])) == TYPE_SIZE (TREE_TYPE (captures[1]))
3407 3498 : && (TYPE_PRECISION (TREE_TYPE (captures[0])) == TYPE_PRECISION (TREE_TYPE (captures[1]))
3408 0 : || (TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (TREE_TYPE (captures[1]))
3409 0 : && TYPE_UNSIGNED (TREE_TYPE (captures[1]))))
3410 : )
3411 : {
3412 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1118;
3413 0 : {
3414 0 : tree res_op0;
3415 0 : res_op0 = captures[1];
3416 0 : tree _r;
3417 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3418 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
3419 0 : return _r;
3420 : }
3421 0 : next_after_fail1118:;
3422 : }
3423 : }
3424 : }
3425 3498 : break;
3426 : }
3427 83614 : case CONSTRUCTOR:
3428 83614 : {
3429 83614 : {
3430 83614 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3431 83614 : {
3432 83614 : tree ctor = (TREE_CODE (captures[0]) == SSA_NAME
3433 : ? gimple_assign_rhs1 (SSA_NAME_DEF_STMT (captures[0])) : captures[0]);
3434 83614 : if (CONSTRUCTOR_NELTS (ctor) == 0
3435 : )
3436 : {
3437 6 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1119;
3438 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1119;
3439 6 : {
3440 6 : tree _r;
3441 6 : _r = build_zero_cst (type);
3442 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
3443 6 : return _r;
3444 : }
3445 : next_after_fail1119:;
3446 : }
3447 : else
3448 : {
3449 83608 : if (CONSTRUCTOR_NELTS (ctor) == 1
3450 40 : && VECTOR_TYPE_P (TREE_TYPE (ctor))
3451 83643 : && operand_equal_p (TYPE_SIZE (type),
3452 35 : TYPE_SIZE (TREE_TYPE
3453 : (CONSTRUCTOR_ELT (ctor, 0)->value)))
3454 : )
3455 : {
3456 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1120;
3457 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1120;
3458 0 : {
3459 0 : tree res_op0;
3460 0 : res_op0 = CONSTRUCTOR_ELT (ctor, 0)->value;
3461 0 : tree _r;
3462 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3463 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
3464 0 : return _r;
3465 : }
3466 : next_after_fail1120:;
3467 : }
3468 : }
3469 : }
3470 : }
3471 : break;
3472 : }
3473 289759 : case VEC_COND_EXPR:
3474 289759 : {
3475 289759 : tree _q20 = TREE_OPERAND (_p0, 0);
3476 289759 : tree _q21 = TREE_OPERAND (_p0, 1);
3477 289759 : tree _q22 = TREE_OPERAND (_p0, 2);
3478 289759 : {
3479 289759 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
3480 289710 : if (VECTOR_TYPE_P (type) && VECTOR_TYPE_P (TREE_TYPE (captures[2]))
3481 290116 : && known_eq (TYPE_VECTOR_SUBPARTS (type),
3482 : TYPE_VECTOR_SUBPARTS (TREE_TYPE (captures[2])))
3483 42260 : && tree_nop_conversion_p (TREE_TYPE (type), TREE_TYPE (TREE_TYPE (captures[2])))
3484 331662 : && (expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
3485 371 : || !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1])))
3486 : )
3487 : {
3488 41903 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1121;
3489 41903 : {
3490 41903 : tree res_op0;
3491 41903 : res_op0 = captures[1];
3492 41903 : tree res_op1;
3493 41903 : {
3494 41903 : tree _o1[1], _r1;
3495 41903 : _o1[0] = captures[2];
3496 41903 : if (TREE_TYPE (_o1[0]) != type)
3497 : {
3498 41903 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
3499 41903 : if (EXPR_P (_r1))
3500 166 : goto next_after_fail1121;
3501 : }
3502 : else
3503 : _r1 = _o1[0];
3504 41737 : res_op1 = _r1;
3505 : }
3506 41737 : tree res_op2;
3507 41737 : {
3508 41737 : tree _o1[1], _r1;
3509 41737 : _o1[0] = captures[3];
3510 41737 : if (TREE_TYPE (_o1[0]) != type)
3511 : {
3512 41737 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
3513 41737 : if (EXPR_P (_r1))
3514 0 : goto next_after_fail1121;
3515 : }
3516 : else
3517 : _r1 = _o1[0];
3518 41737 : res_op2 = _r1;
3519 : }
3520 41737 : tree _r;
3521 41737 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
3522 41737 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 879, __FILE__, __LINE__, true);
3523 41737 : return _r;
3524 : }
3525 248022 : next_after_fail1121:;
3526 : }
3527 : }
3528 248022 : break;
3529 : }
3530 : default:;
3531 : }
3532 : return NULL_TREE;
3533 : }
3534 :
3535 : tree
3536 1756259048 : generic_simplify (location_t loc, enum tree_code code, const tree type ATTRIBUTE_UNUSED, tree _p0)
3537 : {
3538 1756259048 : switch (code)
3539 : {
3540 2777901 : case ABS_EXPR:
3541 2777901 : return generic_simplify_ABS_EXPR (loc, code, type, _p0);
3542 874903615 : CASE_CONVERT:
3543 874903615 : return generic_simplify_CONVERT_EXPR (loc, code, type, _p0);
3544 2715352 : case BIT_NOT_EXPR:
3545 2715352 : return generic_simplify_BIT_NOT_EXPR (loc, code, type, _p0);
3546 943 : case ABSU_EXPR:
3547 943 : return generic_simplify_ABSU_EXPR (loc, code, type, _p0);
3548 4352480 : case NEGATE_EXPR:
3549 4352480 : return generic_simplify_NEGATE_EXPR (loc, code, type, _p0);
3550 6600030 : case FLOAT_EXPR:
3551 6600030 : return generic_simplify_FLOAT_EXPR (loc, code, type, _p0);
3552 481031236 : case VIEW_CONVERT_EXPR:
3553 481031236 : return generic_simplify_VIEW_CONVERT_EXPR (loc, code, type, _p0);
3554 516002 : case FIX_TRUNC_EXPR:
3555 516002 : return generic_simplify_FIX_TRUNC_EXPR (loc, code, type, _p0);
3556 3678 : case PAREN_EXPR:
3557 3678 : return generic_simplify_PAREN_EXPR (loc, code, type, _p0);
3558 1937744 : case REALPART_EXPR:
3559 1937744 : return generic_simplify_REALPART_EXPR (loc, code, type, _p0);
3560 2206243 : case IMAGPART_EXPR:
3561 2206243 : return generic_simplify_IMAGPART_EXPR (loc, code, type, _p0);
3562 1330 : case CONJ_EXPR:
3563 1330 : return generic_simplify_CONJ_EXPR (loc, code, type, _p0);
3564 : default:;
3565 : }
3566 : return NULL_TREE;
3567 : }
3568 :
3569 : tree
3570 80635510 : 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)
3571 : {
3572 80635510 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3573 80635510 : if (integer_zerop (_p1))
3574 : {
3575 2739492 : {
3576 2739492 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3577 2739492 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1263;
3578 2739492 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1263;
3579 2739492 : {
3580 2739492 : tree res_op0;
3581 2739492 : res_op0 = captures[0];
3582 2739492 : tree _r;
3583 2739492 : _r = non_lvalue_loc (loc, res_op0);
3584 2739492 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
3585 2739492 : return _r;
3586 : }
3587 : next_after_fail1263:;
3588 : }
3589 : }
3590 77896018 : switch (TREE_CODE (_p0))
3591 : {
3592 5948740 : case POINTER_PLUS_EXPR:
3593 5948740 : {
3594 5948740 : tree _q20 = TREE_OPERAND (_p0, 0);
3595 5948740 : tree _q21 = TREE_OPERAND (_p0, 1);
3596 5948740 : {
3597 5948740 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
3598 5948740 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1264;
3599 5948740 : {
3600 5948740 : tree res_op0;
3601 5948740 : res_op0 = captures[1];
3602 5948740 : tree res_op1;
3603 5948740 : {
3604 5948740 : tree _o1[2], _r1;
3605 5948740 : _o1[0] = captures[2];
3606 5948740 : _o1[1] = captures[3];
3607 5948740 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3608 5948740 : res_op1 = _r1;
3609 : }
3610 5948740 : tree _r;
3611 5948740 : _r = fold_build2_loc (loc, POINTER_PLUS_EXPR, type, res_op0, res_op1);
3612 5948740 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 907, __FILE__, __LINE__, true);
3613 5948740 : return _r;
3614 : }
3615 0 : next_after_fail1264:;
3616 : }
3617 0 : break;
3618 : }
3619 47790510 : CASE_CONVERT:
3620 47790510 : {
3621 47790510 : tree _q20 = TREE_OPERAND (_p0, 0);
3622 47790510 : switch (TREE_CODE (_q20))
3623 : {
3624 27476 : case POINTER_PLUS_EXPR:
3625 27476 : {
3626 27476 : tree _q30 = TREE_OPERAND (_q20, 0);
3627 27476 : tree _q31 = TREE_OPERAND (_q20, 1);
3628 27476 : {
3629 27476 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
3630 27476 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1265;
3631 27476 : {
3632 27476 : tree res_op0;
3633 27476 : {
3634 27476 : tree _o1[1], _r1;
3635 27476 : _o1[0] = captures[2];
3636 27476 : if (TREE_TYPE (_o1[0]) != type)
3637 : {
3638 27368 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3639 : }
3640 : else
3641 : _r1 = _o1[0];
3642 27476 : res_op0 = _r1;
3643 : }
3644 27476 : tree res_op1;
3645 27476 : {
3646 27476 : tree _o1[2], _r1;
3647 27476 : _o1[0] = captures[3];
3648 27476 : _o1[1] = captures[4];
3649 27476 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3650 27476 : res_op1 = _r1;
3651 : }
3652 27476 : tree _r;
3653 27476 : _r = fold_build2_loc (loc, POINTER_PLUS_EXPR, type, res_op0, res_op1);
3654 27476 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 908, __FILE__, __LINE__, true);
3655 27476 : return _r;
3656 : }
3657 0 : next_after_fail1265:;
3658 : }
3659 0 : break;
3660 : }
3661 : default:;
3662 : }
3663 : break;
3664 : }
3665 71919802 : default:;
3666 : }
3667 71919802 : if (integer_zerop (_p0))
3668 : {
3669 649 : {
3670 649 : tree captures[1] ATTRIBUTE_UNUSED = { _p1 };
3671 649 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1266;
3672 649 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1266;
3673 649 : {
3674 649 : tree res_op0;
3675 649 : {
3676 649 : tree _o1[1], _r1;
3677 649 : _o1[0] = captures[0];
3678 649 : if (TREE_TYPE (_o1[0]) != type)
3679 : {
3680 649 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3681 : }
3682 : else
3683 : _r1 = _o1[0];
3684 649 : res_op0 = _r1;
3685 : }
3686 649 : tree _r;
3687 649 : _r = non_lvalue_loc (loc, res_op0);
3688 649 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
3689 649 : return _r;
3690 : }
3691 : next_after_fail1266:;
3692 : }
3693 : }
3694 71919153 : switch (TREE_CODE (_p1))
3695 : {
3696 9576621 : CASE_CONVERT:
3697 9576621 : {
3698 9576621 : tree _q30 = TREE_OPERAND (_p1, 0);
3699 9576621 : switch (TREE_CODE (_q30))
3700 : {
3701 208472 : case MINUS_EXPR:
3702 208472 : {
3703 208472 : tree _q40 = TREE_OPERAND (_q30, 0);
3704 208472 : tree _q41 = TREE_OPERAND (_q30, 1);
3705 208472 : switch (TREE_CODE (_q40))
3706 : {
3707 93977 : CASE_CONVERT:
3708 93977 : {
3709 93977 : tree _q50 = TREE_OPERAND (_q40, 0);
3710 93977 : switch (TREE_CODE (_q41))
3711 : {
3712 7291 : CASE_CONVERT:
3713 7291 : {
3714 7291 : tree _q70 = TREE_OPERAND (_q41, 0);
3715 7291 : if ((_q70 == _p0 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _p0, 0) && types_match (_q70, _p0)))
3716 : {
3717 4406 : {
3718 4406 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q50 };
3719 4406 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (TREE_TYPE (captures[2]))
3720 4406 : && ((
3721 :
3722 : && useless_type_conversion_p (type, TREE_TYPE (captures[3])))
3723 : || (
3724 : 1
3725 4406 : && type == TREE_TYPE (captures[3])))
3726 : )
3727 : {
3728 2832 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1267;
3729 2832 : {
3730 2832 : tree _r;
3731 2832 : _r = captures[3];
3732 2832 : if (TREE_SIDE_EFFECTS (captures[0]))
3733 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3734 2832 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 910, __FILE__, __LINE__, true);
3735 2832 : return _r;
3736 : }
3737 0 : next_after_fail1267:;
3738 : }
3739 : }
3740 : }
3741 : break;
3742 : }
3743 : default:;
3744 : }
3745 : break;
3746 : }
3747 : default:;
3748 : }
3749 : break;
3750 : }
3751 596 : case POINTER_DIFF_EXPR:
3752 596 : {
3753 596 : tree _q40 = TREE_OPERAND (_q30, 0);
3754 596 : tree _q41 = TREE_OPERAND (_q30, 1);
3755 596 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _p0, 0))
3756 : {
3757 7 : {
3758 7 : tree captures[5] ATTRIBUTE_UNUSED = { _q41, _p1, _q30, _q40, _p0 };
3759 7 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) >= TYPE_PRECISION (TREE_TYPE (captures[2]))
3760 : )
3761 : {
3762 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1268;
3763 7 : {
3764 7 : tree res_op0;
3765 7 : res_op0 = captures[3];
3766 7 : tree _r;
3767 7 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3768 7 : if (TREE_SIDE_EFFECTS (captures[4]))
3769 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
3770 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 911, __FILE__, __LINE__, true);
3771 7 : return _r;
3772 : }
3773 0 : next_after_fail1268:;
3774 : }
3775 : }
3776 : }
3777 : break;
3778 : }
3779 : default:;
3780 : }
3781 : break;
3782 : }
3783 46236 : case MINUS_EXPR:
3784 46236 : {
3785 46236 : tree _q30 = TREE_OPERAND (_p1, 0);
3786 46236 : tree _q31 = TREE_OPERAND (_p1, 1);
3787 46236 : switch (TREE_CODE (_q30))
3788 : {
3789 42779 : CASE_CONVERT:
3790 42779 : {
3791 42779 : tree _q40 = TREE_OPERAND (_q30, 0);
3792 42779 : switch (TREE_CODE (_q31))
3793 : {
3794 25761 : CASE_CONVERT:
3795 25761 : {
3796 25761 : tree _q60 = TREE_OPERAND (_q31, 0);
3797 25761 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
3798 : {
3799 24 : {
3800 24 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p1, _p1, _q40 };
3801 24 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (TREE_TYPE (captures[2]))
3802 24 : && ((
3803 :
3804 : && useless_type_conversion_p (type, TREE_TYPE (captures[3])))
3805 : || (
3806 : 1
3807 24 : && type == TREE_TYPE (captures[3])))
3808 : )
3809 : {
3810 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1269;
3811 0 : {
3812 0 : tree _r;
3813 0 : _r = captures[3];
3814 0 : if (TREE_SIDE_EFFECTS (captures[0]))
3815 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3816 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 910, __FILE__, __LINE__, true);
3817 0 : return _r;
3818 : }
3819 0 : next_after_fail1269:;
3820 : }
3821 : }
3822 : }
3823 : break;
3824 : }
3825 : default:;
3826 : }
3827 : break;
3828 : }
3829 438 : case INTEGER_CST:
3830 438 : {
3831 438 : switch (TREE_CODE (_q31))
3832 : {
3833 16 : case BIT_AND_EXPR:
3834 16 : {
3835 16 : tree _q50 = TREE_OPERAND (_q31, 0);
3836 16 : tree _q51 = TREE_OPERAND (_q31, 1);
3837 16 : switch (TREE_CODE (_q50))
3838 : {
3839 16 : CASE_CONVERT:
3840 16 : {
3841 16 : tree _q60 = TREE_OPERAND (_q50, 0);
3842 16 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
3843 : {
3844 0 : switch (TREE_CODE (_q51))
3845 : {
3846 0 : case INTEGER_CST:
3847 0 : {
3848 0 : {
3849 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q51 };
3850 0 : if (tree_int_cst_min_precision (captures[3], UNSIGNED) <= tree_ctz (captures[2])
3851 : )
3852 : {
3853 0 : {
3854 0 : tree algn = wide_int_to_tree (TREE_TYPE (captures[0]), ~wi::to_wide (captures[3]));
3855 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1270;
3856 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1270;
3857 0 : {
3858 0 : tree res_op0;
3859 0 : {
3860 0 : tree _o1[2], _r1;
3861 0 : _o1[0] = captures[0];
3862 0 : _o1[1] = algn;
3863 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3864 0 : res_op0 = _r1;
3865 : }
3866 0 : tree res_op1;
3867 0 : res_op1 = captures[2];
3868 0 : tree _r;
3869 0 : _r = fold_build2_loc (loc, POINTER_PLUS_EXPR, type, res_op0, res_op1);
3870 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 912, __FILE__, __LINE__, true);
3871 0 : return _r;
3872 : }
3873 0 : next_after_fail1270:;
3874 : }
3875 : }
3876 : }
3877 0 : break;
3878 : }
3879 : default:;
3880 : }
3881 : }
3882 16 : switch (TREE_CODE (_q60))
3883 : {
3884 0 : case POINTER_PLUS_EXPR:
3885 0 : {
3886 0 : tree _q70 = TREE_OPERAND (_q60, 0);
3887 0 : tree _q71 = TREE_OPERAND (_q60, 1);
3888 0 : if ((_q70 == _p0 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _p0, 0) && types_match (_q70, _p0)))
3889 : {
3890 0 : switch (TREE_CODE (_q71))
3891 : {
3892 0 : case INTEGER_CST:
3893 0 : {
3894 0 : switch (TREE_CODE (_q51))
3895 : {
3896 0 : case INTEGER_CST:
3897 0 : {
3898 0 : {
3899 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q71, _q51 };
3900 0 : {
3901 0 : auto mask_width = tree_int_cst_min_precision (captures[4], UNSIGNED);
3902 0 : if (mask_width <= tree_ctz (captures[2]) && mask_width <= tree_ctz (captures[3])
3903 : )
3904 : {
3905 0 : {
3906 0 : tree algn = wide_int_to_tree (TREE_TYPE (captures[0]), ~wi::to_wide (captures[4]));
3907 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1271;
3908 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1271;
3909 0 : {
3910 0 : tree res_op0;
3911 0 : {
3912 0 : tree _o1[2], _r1;
3913 0 : _o1[0] = captures[0];
3914 0 : _o1[1] = algn;
3915 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3916 0 : res_op0 = _r1;
3917 : }
3918 0 : tree res_op1;
3919 0 : res_op1 = captures[2];
3920 0 : tree _r;
3921 0 : _r = fold_build2_loc (loc, POINTER_PLUS_EXPR, type, res_op0, res_op1);
3922 0 : if (TREE_SIDE_EFFECTS (captures[3]))
3923 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
3924 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 913, __FILE__, __LINE__, true);
3925 0 : return _r;
3926 : }
3927 0 : next_after_fail1271:;
3928 : }
3929 : }
3930 : }
3931 : }
3932 0 : break;
3933 : }
3934 : default:;
3935 : }
3936 : break;
3937 : }
3938 : default:;
3939 : }
3940 : }
3941 : break;
3942 : }
3943 : default:;
3944 : }
3945 : break;
3946 : }
3947 : default:;
3948 : }
3949 : break;
3950 : }
3951 : default:;
3952 : }
3953 : break;
3954 : }
3955 : default:;
3956 : }
3957 : break;
3958 : }
3959 0 : case POINTER_DIFF_EXPR:
3960 0 : {
3961 0 : tree _q30 = TREE_OPERAND (_p1, 0);
3962 0 : tree _q31 = TREE_OPERAND (_p1, 1);
3963 0 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || operand_equal_p (_q31, _p0, 0))
3964 : {
3965 0 : {
3966 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q31, _p1, _p1, _q30, _p0 };
3967 0 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) >= TYPE_PRECISION (TREE_TYPE (captures[2]))
3968 : )
3969 : {
3970 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1272;
3971 0 : {
3972 0 : tree res_op0;
3973 0 : res_op0 = captures[3];
3974 0 : tree _r;
3975 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3976 0 : if (TREE_SIDE_EFFECTS (captures[4]))
3977 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
3978 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 911, __FILE__, __LINE__, true);
3979 0 : return _r;
3980 : }
3981 0 : next_after_fail1272:;
3982 : }
3983 : }
3984 : }
3985 : break;
3986 : }
3987 369681 : case NEGATE_EXPR:
3988 369681 : {
3989 369681 : tree _q30 = TREE_OPERAND (_p1, 0);
3990 369681 : switch (TREE_CODE (_q30))
3991 : {
3992 22 : case BIT_AND_EXPR:
3993 22 : {
3994 22 : tree _q40 = TREE_OPERAND (_q30, 0);
3995 22 : tree _q41 = TREE_OPERAND (_q30, 1);
3996 22 : switch (TREE_CODE (_q40))
3997 : {
3998 22 : CASE_CONVERT:
3999 22 : {
4000 22 : tree _q50 = TREE_OPERAND (_q40, 0);
4001 22 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
4002 : {
4003 1 : switch (TREE_CODE (_q41))
4004 : {
4005 1 : case INTEGER_CST:
4006 1 : {
4007 1 : {
4008 1 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
4009 1 : {
4010 1 : tree algn = wide_int_to_tree (TREE_TYPE (captures[0]), ~wi::to_wide (captures[1]));
4011 1 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1273;
4012 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1273;
4013 1 : {
4014 1 : tree res_op0;
4015 1 : res_op0 = captures[0];
4016 1 : tree res_op1;
4017 1 : res_op1 = algn;
4018 1 : tree _r;
4019 1 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
4020 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 914, __FILE__, __LINE__, true);
4021 1 : return _r;
4022 : }
4023 0 : next_after_fail1273:;
4024 : }
4025 : }
4026 0 : break;
4027 : }
4028 : default:;
4029 : }
4030 : }
4031 21 : switch (TREE_CODE (_q50))
4032 : {
4033 0 : case POINTER_PLUS_EXPR:
4034 0 : {
4035 0 : tree _q60 = TREE_OPERAND (_q50, 0);
4036 0 : tree _q61 = TREE_OPERAND (_q50, 1);
4037 0 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
4038 : {
4039 0 : switch (TREE_CODE (_q61))
4040 : {
4041 0 : case INTEGER_CST:
4042 0 : {
4043 0 : switch (TREE_CODE (_q41))
4044 : {
4045 0 : case INTEGER_CST:
4046 0 : {
4047 0 : {
4048 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q61, _q41 };
4049 0 : if (tree_int_cst_min_precision (captures[2], UNSIGNED) <= tree_ctz (captures[1])
4050 : )
4051 : {
4052 0 : {
4053 0 : tree algn = wide_int_to_tree (TREE_TYPE (captures[0]), ~wi::to_wide (captures[2]));
4054 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1274;
4055 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1274;
4056 0 : {
4057 0 : tree res_op0;
4058 0 : res_op0 = captures[0];
4059 0 : tree res_op1;
4060 0 : res_op1 = algn;
4061 0 : tree _r;
4062 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
4063 0 : if (TREE_SIDE_EFFECTS (captures[1]))
4064 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4065 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 915, __FILE__, __LINE__, true);
4066 0 : return _r;
4067 : }
4068 0 : next_after_fail1274:;
4069 : }
4070 : }
4071 : }
4072 0 : break;
4073 : }
4074 : default:;
4075 : }
4076 : break;
4077 : }
4078 : default:;
4079 : }
4080 : }
4081 : break;
4082 : }
4083 : default:;
4084 : }
4085 : break;
4086 : }
4087 : default:;
4088 : }
4089 : break;
4090 : }
4091 : default:;
4092 : }
4093 : break;
4094 : }
4095 : default:;
4096 : }
4097 : return NULL_TREE;
4098 : }
4099 :
4100 : tree
4101 38926730 : generic_simplify_NE_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
4102 : {
4103 38926730 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4104 38926730 : switch (TREE_CODE (_p1))
4105 : {
4106 2267 : case NEGATE_EXPR:
4107 2267 : {
4108 2267 : tree _q30 = TREE_OPERAND (_p1, 0);
4109 2267 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
4110 : {
4111 0 : {
4112 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4113 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4114 0 : if (res) return res;
4115 : }
4116 : }
4117 : break;
4118 : }
4119 38926730 : default:;
4120 : }
4121 38926730 : switch (TREE_CODE (_p0))
4122 : {
4123 6192 : case NEGATE_EXPR:
4124 6192 : {
4125 6192 : tree _q20 = TREE_OPERAND (_p0, 0);
4126 6192 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4127 : {
4128 88 : {
4129 88 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4130 88 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4131 88 : if (res) return res;
4132 : }
4133 : }
4134 : break;
4135 : }
4136 0 : case CEIL_MOD_EXPR:
4137 0 : {
4138 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4139 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4140 0 : if (integer_pow2p (_q21))
4141 : {
4142 0 : if (integer_zerop (_p1))
4143 : {
4144 0 : {
4145 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4146 0 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR, CEIL_MOD_EXPR);
4147 0 : if (res) return res;
4148 : }
4149 : }
4150 : }
4151 : break;
4152 : }
4153 1623 : case FLOOR_MOD_EXPR:
4154 1623 : {
4155 1623 : tree _q20 = TREE_OPERAND (_p0, 0);
4156 1623 : tree _q21 = TREE_OPERAND (_p0, 1);
4157 1623 : if (integer_pow2p (_q21))
4158 : {
4159 20 : if (integer_zerop (_p1))
4160 : {
4161 20 : {
4162 20 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4163 20 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR, FLOOR_MOD_EXPR);
4164 20 : if (res) return res;
4165 : }
4166 : }
4167 : }
4168 : break;
4169 : }
4170 0 : case ROUND_MOD_EXPR:
4171 0 : {
4172 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4173 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4174 0 : if (integer_pow2p (_q21))
4175 : {
4176 0 : if (integer_zerop (_p1))
4177 : {
4178 0 : {
4179 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4180 0 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR, ROUND_MOD_EXPR);
4181 0 : if (res) return res;
4182 : }
4183 : }
4184 : }
4185 : break;
4186 : }
4187 85160 : case TRUNC_MOD_EXPR:
4188 85160 : {
4189 85160 : tree _q20 = TREE_OPERAND (_p0, 0);
4190 85160 : tree _q21 = TREE_OPERAND (_p0, 1);
4191 85160 : if (integer_pow2p (_q21))
4192 : {
4193 21721 : if (integer_zerop (_p1))
4194 : {
4195 20279 : {
4196 20279 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4197 20279 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR, TRUNC_MOD_EXPR);
4198 20279 : if (res) return res;
4199 : }
4200 : }
4201 : }
4202 : break;
4203 : }
4204 8708823 : CASE_CONVERT:
4205 8708823 : {
4206 8708823 : tree _q20 = TREE_OPERAND (_p0, 0);
4207 8708823 : switch (TREE_CODE (_p1))
4208 : {
4209 69 : case LSHIFT_EXPR:
4210 69 : {
4211 69 : tree _q40 = TREE_OPERAND (_p1, 0);
4212 69 : tree _q41 = TREE_OPERAND (_p1, 1);
4213 69 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
4214 : {
4215 0 : {
4216 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
4217 0 : tree res = generic_simplify_209 (loc, type, _p0, _p1, captures, NE_EXPR);
4218 0 : if (res) return res;
4219 : }
4220 : }
4221 : break;
4222 : }
4223 8708823 : default:;
4224 : }
4225 8708823 : {
4226 8708823 : tree _p1_pops[1];
4227 8708823 : if (tree_nop_convert (_p1, _p1_pops))
4228 : {
4229 4725990 : tree _q40 = _p1_pops[0];
4230 4725990 : switch (TREE_CODE (_q40))
4231 : {
4232 0 : case LSHIFT_EXPR:
4233 0 : {
4234 0 : tree _q50 = TREE_OPERAND (_q40, 0);
4235 0 : tree _q51 = TREE_OPERAND (_q40, 1);
4236 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4237 : {
4238 0 : {
4239 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q20 };
4240 0 : tree res = generic_simplify_209 (loc, type, _p0, _p1, captures, NE_EXPR);
4241 0 : if (res) return res;
4242 : }
4243 : }
4244 : break;
4245 : }
4246 : default:;
4247 : }
4248 : }
4249 : }
4250 8708823 : switch (TREE_CODE (_q20))
4251 : {
4252 0 : case EXACT_DIV_EXPR:
4253 0 : {
4254 0 : tree _q30 = TREE_OPERAND (_q20, 0);
4255 0 : tree _q31 = TREE_OPERAND (_q20, 1);
4256 0 : switch (TREE_CODE (_q31))
4257 : {
4258 0 : case INTEGER_CST:
4259 0 : {
4260 0 : switch (TREE_CODE (_p1))
4261 : {
4262 0 : CASE_CONVERT:
4263 0 : {
4264 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4265 0 : switch (TREE_CODE (_q60))
4266 : {
4267 0 : case EXACT_DIV_EXPR:
4268 0 : {
4269 0 : tree _q70 = TREE_OPERAND (_q60, 0);
4270 0 : tree _q71 = TREE_OPERAND (_q60, 1);
4271 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
4272 : {
4273 0 : {
4274 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q70 };
4275 0 : tree res = generic_simplify_211 (loc, type, _p0, _p1, captures, NE_EXPR);
4276 0 : if (res) return res;
4277 : }
4278 : }
4279 : break;
4280 : }
4281 : default:;
4282 : }
4283 : break;
4284 : }
4285 : default:;
4286 : }
4287 : break;
4288 : }
4289 : default:;
4290 : }
4291 : break;
4292 : }
4293 8708823 : default:;
4294 : }
4295 8708823 : switch (TREE_CODE (_p1))
4296 : {
4297 20777 : case PLUS_EXPR:
4298 20777 : {
4299 20777 : tree _q40 = TREE_OPERAND (_p1, 0);
4300 20777 : tree _q41 = TREE_OPERAND (_p1, 1);
4301 20777 : switch (TREE_CODE (_q41))
4302 : {
4303 203 : CASE_CONVERT:
4304 203 : {
4305 203 : tree _q60 = TREE_OPERAND (_q41, 0);
4306 203 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4307 : {
4308 0 : {
4309 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q40, _q20 };
4310 0 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR);
4311 0 : if (res) return res;
4312 : }
4313 : }
4314 : break;
4315 : }
4316 20777 : default:;
4317 : }
4318 20777 : switch (TREE_CODE (_q40))
4319 : {
4320 800 : CASE_CONVERT:
4321 800 : {
4322 800 : tree _q50 = TREE_OPERAND (_q40, 0);
4323 800 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4324 : {
4325 15 : {
4326 15 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q41, _q20 };
4327 15 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR);
4328 15 : if (res) return res;
4329 : }
4330 : }
4331 : break;
4332 : }
4333 20770 : default:;
4334 : }
4335 20770 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
4336 : {
4337 0 : {
4338 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q40, _q20 };
4339 0 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR);
4340 0 : if (res) return res;
4341 : }
4342 : }
4343 20770 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
4344 : {
4345 0 : {
4346 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q41, _q20 };
4347 0 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR);
4348 0 : if (res) return res;
4349 : }
4350 : }
4351 : break;
4352 : }
4353 8708816 : default:;
4354 : }
4355 8708816 : {
4356 8708816 : tree _p1_pops[1];
4357 8708816 : if (tree_nop_convert (_p1, _p1_pops))
4358 : {
4359 4725990 : tree _q40 = _p1_pops[0];
4360 4725990 : switch (TREE_CODE (_q40))
4361 : {
4362 174 : case PLUS_EXPR:
4363 174 : {
4364 174 : tree _q50 = TREE_OPERAND (_q40, 0);
4365 174 : tree _q51 = TREE_OPERAND (_q40, 1);
4366 174 : switch (TREE_CODE (_q51))
4367 : {
4368 0 : CASE_CONVERT:
4369 0 : {
4370 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4371 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4372 : {
4373 0 : {
4374 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q20 };
4375 0 : tree res = generic_simplify_210 (loc, type, _p0, _p1, captures, NE_EXPR);
4376 0 : if (res) return res;
4377 : }
4378 : }
4379 : break;
4380 : }
4381 174 : default:;
4382 : }
4383 174 : switch (TREE_CODE (_q50))
4384 : {
4385 89 : CASE_CONVERT:
4386 89 : {
4387 89 : tree _q60 = TREE_OPERAND (_q50, 0);
4388 89 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4389 : {
4390 0 : {
4391 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q51, _q20 };
4392 0 : tree res = generic_simplify_210 (loc, type, _p0, _p1, captures, NE_EXPR);
4393 0 : if (res) return res;
4394 : }
4395 : }
4396 : break;
4397 : }
4398 174 : default:;
4399 : }
4400 174 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4401 : {
4402 0 : {
4403 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q20 };
4404 0 : tree res = generic_simplify_210 (loc, type, _p0, _p1, captures, NE_EXPR);
4405 0 : if (res) return res;
4406 : }
4407 : }
4408 174 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4409 : {
4410 0 : {
4411 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q51, _q20 };
4412 0 : tree res = generic_simplify_210 (loc, type, _p0, _p1, captures, NE_EXPR);
4413 0 : if (res) return res;
4414 : }
4415 : }
4416 : break;
4417 : }
4418 : default:;
4419 : }
4420 : }
4421 : }
4422 8708816 : break;
4423 : }
4424 38906424 : default:;
4425 : }
4426 38906424 : {
4427 38906424 : tree _p0_pops[1];
4428 38906424 : if (tree_nop_convert (_p0, _p0_pops))
4429 : {
4430 6428736 : tree _q20 = _p0_pops[0];
4431 6428736 : switch (TREE_CODE (_q20))
4432 : {
4433 15 : case LSHIFT_EXPR:
4434 15 : {
4435 15 : tree _q30 = TREE_OPERAND (_q20, 0);
4436 15 : tree _q31 = TREE_OPERAND (_q20, 1);
4437 15 : switch (TREE_CODE (_p1))
4438 : {
4439 1 : CASE_CONVERT:
4440 1 : {
4441 1 : tree _q60 = TREE_OPERAND (_p1, 0);
4442 1 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
4443 : {
4444 0 : {
4445 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
4446 0 : tree res = generic_simplify_209 (loc, type, _p0, _p1, captures, NE_EXPR);
4447 0 : if (res) return res;
4448 : }
4449 : }
4450 : break;
4451 : }
4452 15 : default:;
4453 : }
4454 15 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
4455 : {
4456 1 : {
4457 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
4458 1 : tree res = generic_simplify_209 (loc, type, _p0, _p1, captures, NE_EXPR);
4459 1 : if (res) return res;
4460 : }
4461 : }
4462 : break;
4463 : }
4464 30434 : case PLUS_EXPR:
4465 30434 : {
4466 30434 : tree _q30 = TREE_OPERAND (_q20, 0);
4467 30434 : tree _q31 = TREE_OPERAND (_q20, 1);
4468 30434 : switch (TREE_CODE (_q31))
4469 : {
4470 37 : CASE_CONVERT:
4471 37 : {
4472 37 : tree _q50 = TREE_OPERAND (_q31, 0);
4473 37 : switch (TREE_CODE (_p1))
4474 : {
4475 0 : CASE_CONVERT:
4476 0 : {
4477 0 : tree _q70 = TREE_OPERAND (_p1, 0);
4478 0 : if ((_q70 == _q50 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q50, 0) && types_match (_q70, _q50)))
4479 : {
4480 0 : {
4481 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50 };
4482 0 : tree res = generic_simplify_210 (loc, type, _p0, _p1, captures, NE_EXPR);
4483 0 : if (res) return res;
4484 : }
4485 : }
4486 : break;
4487 : }
4488 : default:;
4489 : }
4490 : break;
4491 : }
4492 30434 : default:;
4493 : }
4494 30434 : switch (TREE_CODE (_q30))
4495 : {
4496 26177 : CASE_CONVERT:
4497 26177 : {
4498 26177 : tree _q40 = TREE_OPERAND (_q30, 0);
4499 26177 : switch (TREE_CODE (_p1))
4500 : {
4501 353 : CASE_CONVERT:
4502 353 : {
4503 353 : tree _q70 = TREE_OPERAND (_p1, 0);
4504 353 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
4505 : {
4506 100 : {
4507 100 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q40 };
4508 100 : tree res = generic_simplify_210 (loc, type, _p0, _p1, captures, NE_EXPR);
4509 100 : if (res) return res;
4510 : }
4511 : }
4512 : break;
4513 : }
4514 26077 : default:;
4515 : }
4516 26077 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
4517 : {
4518 20 : {
4519 20 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q40 };
4520 20 : tree res = generic_simplify_210 (loc, type, _p0, _p1, captures, NE_EXPR);
4521 20 : if (res) return res;
4522 : }
4523 : }
4524 : break;
4525 : }
4526 30314 : default:;
4527 : }
4528 30314 : switch (TREE_CODE (_q31))
4529 : {
4530 37 : CASE_CONVERT:
4531 37 : {
4532 37 : tree _q50 = TREE_OPERAND (_q31, 0);
4533 37 : if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
4534 : {
4535 0 : {
4536 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50 };
4537 0 : tree res = generic_simplify_210 (loc, type, _p0, _p1, captures, NE_EXPR);
4538 0 : if (res) return res;
4539 : }
4540 : }
4541 : break;
4542 : }
4543 30314 : default:;
4544 : }
4545 30314 : switch (TREE_CODE (_p1))
4546 : {
4547 325 : CASE_CONVERT:
4548 325 : {
4549 325 : tree _q60 = TREE_OPERAND (_p1, 0);
4550 325 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
4551 : {
4552 0 : {
4553 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
4554 0 : tree res = generic_simplify_210 (loc, type, _p0, _p1, captures, NE_EXPR);
4555 0 : if (res) return res;
4556 : }
4557 : }
4558 325 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
4559 : {
4560 62 : {
4561 62 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q30 };
4562 62 : tree res = generic_simplify_210 (loc, type, _p0, _p1, captures, NE_EXPR);
4563 62 : if (res) return res;
4564 : }
4565 : }
4566 : break;
4567 : }
4568 30252 : default:;
4569 : }
4570 30252 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
4571 : {
4572 0 : {
4573 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
4574 0 : tree res = generic_simplify_210 (loc, type, _p0, _p1, captures, NE_EXPR);
4575 0 : if (res) return res;
4576 : }
4577 : }
4578 30252 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
4579 : {
4580 0 : {
4581 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q30 };
4582 0 : tree res = generic_simplify_210 (loc, type, _p0, _p1, captures, NE_EXPR);
4583 0 : if (res) return res;
4584 : }
4585 : }
4586 : break;
4587 : }
4588 : default:;
4589 : }
4590 : }
4591 : }
4592 38906241 : {
4593 38906241 : tree _p1_pops[1];
4594 38906241 : if (tree_nop_convert (_p1, _p1_pops))
4595 : {
4596 5094969 : tree _q30 = _p1_pops[0];
4597 5094969 : switch (TREE_CODE (_q30))
4598 : {
4599 0 : case LSHIFT_EXPR:
4600 0 : {
4601 0 : tree _q40 = TREE_OPERAND (_q30, 0);
4602 0 : tree _q41 = TREE_OPERAND (_q30, 1);
4603 0 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
4604 : {
4605 0 : {
4606 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _p0 };
4607 0 : tree res = generic_simplify_209 (loc, type, _p0, _p1, captures, NE_EXPR);
4608 0 : if (res) return res;
4609 : }
4610 : }
4611 : break;
4612 : }
4613 : default:;
4614 : }
4615 : }
4616 : }
4617 38906241 : switch (TREE_CODE (_p0))
4618 : {
4619 5099 : case LSHIFT_EXPR:
4620 5099 : {
4621 5099 : tree _q20 = TREE_OPERAND (_p0, 0);
4622 5099 : tree _q21 = TREE_OPERAND (_p0, 1);
4623 5099 : switch (TREE_CODE (_p1))
4624 : {
4625 35 : CASE_CONVERT:
4626 35 : {
4627 35 : tree _q50 = TREE_OPERAND (_p1, 0);
4628 35 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4629 : {
4630 4 : {
4631 4 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4632 4 : tree res = generic_simplify_209 (loc, type, _p0, _p1, captures, NE_EXPR);
4633 4 : if (res) return res;
4634 : }
4635 : }
4636 : break;
4637 : }
4638 5098 : default:;
4639 : }
4640 5098 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
4641 : {
4642 27 : {
4643 27 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4644 27 : tree res = generic_simplify_209 (loc, type, _p0, _p1, captures, NE_EXPR);
4645 27 : if (res) return res;
4646 : }
4647 : }
4648 5094 : if (tree_zero_one_valued_p (_q20))
4649 : {
4650 479 : switch (TREE_CODE (_q21))
4651 : {
4652 117 : case INTEGER_CST:
4653 117 : {
4654 117 : if (integer_zerop (_p1))
4655 : {
4656 5 : {
4657 5 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4658 5 : if (tree_fits_shwi_p (captures[1])
4659 5 : && tree_to_shwi (captures[1]) > 0
4660 10 : && tree_to_shwi (captures[1]) < TYPE_PRECISION (TREE_TYPE (captures[0]))
4661 : )
4662 : {
4663 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1532;
4664 5 : {
4665 5 : tree res_op0;
4666 5 : res_op0 = captures[0];
4667 5 : tree _r;
4668 5 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4669 5 : if (TREE_SIDE_EFFECTS (captures[1]))
4670 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4671 5 : if (TREE_SIDE_EFFECTS (captures[2]))
4672 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4673 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 994, __FILE__, __LINE__, true);
4674 5 : return _r;
4675 : }
4676 0 : next_after_fail1532:;
4677 : }
4678 : }
4679 : }
4680 : break;
4681 : }
4682 : default:;
4683 : }
4684 : }
4685 : break;
4686 : }
4687 38906231 : default:;
4688 : }
4689 38906231 : switch (TREE_CODE (_p1))
4690 : {
4691 264 : case LSHIFT_EXPR:
4692 264 : {
4693 264 : tree _q30 = TREE_OPERAND (_p1, 0);
4694 264 : tree _q31 = TREE_OPERAND (_p1, 1);
4695 264 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
4696 : {
4697 0 : {
4698 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
4699 0 : tree res = generic_simplify_209 (loc, type, _p0, _p1, captures, NE_EXPR);
4700 0 : if (res) return res;
4701 : }
4702 : }
4703 : break;
4704 : }
4705 38906231 : default:;
4706 : }
4707 38906231 : switch (TREE_CODE (_p0))
4708 : {
4709 255 : case VIEW_CONVERT_EXPR:
4710 255 : {
4711 255 : tree _q20 = TREE_OPERAND (_p0, 0);
4712 255 : if (tree_zero_one_valued_p (_q20))
4713 : {
4714 0 : if (integer_zerop (_p1))
4715 : {
4716 0 : {
4717 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
4718 0 : tree res = generic_simplify_215 (loc, type, _p0, _p1, captures, NE_EXPR);
4719 0 : if (res) return res;
4720 : }
4721 : }
4722 : }
4723 : break;
4724 : }
4725 21014 : case RSHIFT_EXPR:
4726 21014 : {
4727 21014 : tree _q20 = TREE_OPERAND (_p0, 0);
4728 21014 : tree _q21 = TREE_OPERAND (_p0, 1);
4729 21014 : switch (TREE_CODE (_q21))
4730 : {
4731 18664 : case INTEGER_CST:
4732 18664 : {
4733 18664 : switch (TREE_CODE (_p1))
4734 : {
4735 210 : case RSHIFT_EXPR:
4736 210 : {
4737 210 : tree _q50 = TREE_OPERAND (_p1, 0);
4738 210 : tree _q51 = TREE_OPERAND (_p1, 1);
4739 210 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4740 : {
4741 15 : switch (TREE_CODE (_q51))
4742 : {
4743 15 : case INTEGER_CST:
4744 15 : {
4745 15 : {
4746 15 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4747 15 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR);
4748 15 : if (res) return res;
4749 : }
4750 3 : break;
4751 : }
4752 : default:;
4753 : }
4754 : }
4755 : break;
4756 : }
4757 18652 : default:;
4758 : }
4759 18652 : if (integer_zerop (_p1))
4760 : {
4761 8005 : {
4762 8005 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
4763 8005 : tree res = generic_simplify_217 (loc, type, _p0, _p1, captures, NE_EXPR, LT_EXPR);
4764 8005 : if (res) return res;
4765 : }
4766 : }
4767 : break;
4768 : }
4769 : default:;
4770 : }
4771 : break;
4772 : }
4773 97784 : case MULT_EXPR:
4774 97784 : {
4775 97784 : tree _q20 = TREE_OPERAND (_p0, 0);
4776 97784 : tree _q21 = TREE_OPERAND (_p0, 1);
4777 97784 : switch (TREE_CODE (_p1))
4778 : {
4779 3343 : case MULT_EXPR:
4780 3343 : {
4781 3343 : tree _q50 = TREE_OPERAND (_p1, 0);
4782 3343 : tree _q51 = TREE_OPERAND (_p1, 1);
4783 3343 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4784 : {
4785 1658 : {
4786 1658 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4787 1658 : tree res = generic_simplify_218 (loc, type, _p0, _p1, captures, NE_EXPR);
4788 1658 : if (res) return res;
4789 : }
4790 : }
4791 3339 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4792 : {
4793 53 : {
4794 53 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
4795 53 : tree res = generic_simplify_218 (loc, type, _p0, _p1, captures, NE_EXPR);
4796 53 : if (res) return res;
4797 : }
4798 : }
4799 3339 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4800 : {
4801 22 : {
4802 22 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
4803 22 : tree res = generic_simplify_218 (loc, type, _p0, _p1, captures, NE_EXPR);
4804 22 : if (res) return res;
4805 : }
4806 : }
4807 3339 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4808 : {
4809 260 : {
4810 260 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
4811 260 : tree res = generic_simplify_218 (loc, type, _p0, _p1, captures, NE_EXPR);
4812 260 : if (res) return res;
4813 : }
4814 : }
4815 : break;
4816 : }
4817 97780 : default:;
4818 : }
4819 97780 : switch (TREE_CODE (_q21))
4820 : {
4821 78975 : case INTEGER_CST:
4822 78975 : {
4823 78975 : switch (TREE_CODE (_p1))
4824 : {
4825 2481 : case MULT_EXPR:
4826 2481 : {
4827 2481 : tree _q50 = TREE_OPERAND (_p1, 0);
4828 2481 : tree _q51 = TREE_OPERAND (_p1, 1);
4829 2481 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4830 : {
4831 1126 : {
4832 1126 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4833 1126 : tree res = generic_simplify_219 (loc, type, _p0, _p1, captures, NE_EXPR);
4834 1126 : if (res) return res;
4835 : }
4836 : }
4837 : break;
4838 : }
4839 : default:;
4840 : }
4841 : break;
4842 : }
4843 : default:;
4844 : }
4845 : break;
4846 : }
4847 2043 : case EXACT_DIV_EXPR:
4848 2043 : {
4849 2043 : tree _q20 = TREE_OPERAND (_p0, 0);
4850 2043 : tree _q21 = TREE_OPERAND (_p0, 1);
4851 2043 : switch (TREE_CODE (_q21))
4852 : {
4853 2043 : case INTEGER_CST:
4854 2043 : {
4855 2043 : switch (TREE_CODE (_p1))
4856 : {
4857 22 : case EXACT_DIV_EXPR:
4858 22 : {
4859 22 : tree _q50 = TREE_OPERAND (_p1, 0);
4860 22 : tree _q51 = TREE_OPERAND (_p1, 1);
4861 22 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4862 : {
4863 12 : {
4864 12 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
4865 12 : tree res = generic_simplify_211 (loc, type, _p0, _p1, captures, NE_EXPR);
4866 12 : if (res) return res;
4867 : }
4868 : }
4869 : break;
4870 : }
4871 : default:;
4872 : }
4873 : break;
4874 : }
4875 : default:;
4876 : }
4877 : break;
4878 : }
4879 11205 : case TRUNC_DIV_EXPR:
4880 11205 : {
4881 11205 : tree _q20 = TREE_OPERAND (_p0, 0);
4882 11205 : tree _q21 = TREE_OPERAND (_p0, 1);
4883 11205 : switch (TREE_CODE (_q21))
4884 : {
4885 8405 : case INTEGER_CST:
4886 8405 : {
4887 8405 : switch (TREE_CODE (_p1))
4888 : {
4889 2241 : case INTEGER_CST:
4890 2241 : {
4891 2241 : {
4892 2241 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
4893 2241 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, NE_EXPR);
4894 2241 : if (res) return res;
4895 : }
4896 126 : break;
4897 : }
4898 : default:;
4899 : }
4900 : break;
4901 : }
4902 : default:;
4903 : }
4904 : break;
4905 : }
4906 1545951 : case PLUS_EXPR:
4907 1545951 : {
4908 1545951 : tree _q20 = TREE_OPERAND (_p0, 0);
4909 1545951 : tree _q21 = TREE_OPERAND (_p0, 1);
4910 1545951 : switch (TREE_CODE (_p1))
4911 : {
4912 195064 : case PLUS_EXPR:
4913 195064 : {
4914 195064 : tree _q50 = TREE_OPERAND (_p1, 0);
4915 195064 : tree _q51 = TREE_OPERAND (_p1, 1);
4916 195064 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4917 : {
4918 948 : {
4919 948 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4920 1896 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4921 1865 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
4922 834 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
4923 : )
4924 : {
4925 917 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1533;
4926 917 : {
4927 917 : tree res_op0;
4928 917 : res_op0 = captures[0];
4929 917 : tree res_op1;
4930 917 : res_op1 = captures[2];
4931 917 : tree _r;
4932 917 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
4933 917 : if (TREE_SIDE_EFFECTS (captures[1]))
4934 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4935 917 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 930, __FILE__, __LINE__, true);
4936 917 : return _r;
4937 : }
4938 0 : next_after_fail1533:;
4939 : }
4940 : }
4941 : }
4942 194147 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4943 : {
4944 0 : {
4945 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
4946 0 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4947 0 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
4948 0 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
4949 : )
4950 : {
4951 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1534;
4952 0 : {
4953 0 : tree res_op0;
4954 0 : res_op0 = captures[0];
4955 0 : tree res_op1;
4956 0 : res_op1 = captures[2];
4957 0 : tree _r;
4958 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
4959 0 : if (TREE_SIDE_EFFECTS (captures[1]))
4960 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4961 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 930, __FILE__, __LINE__, true);
4962 0 : return _r;
4963 : }
4964 0 : next_after_fail1534:;
4965 : }
4966 : }
4967 : }
4968 194147 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4969 : {
4970 96 : {
4971 96 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
4972 192 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4973 192 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
4974 96 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
4975 : )
4976 : {
4977 96 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1535;
4978 96 : {
4979 96 : tree res_op0;
4980 96 : res_op0 = captures[0];
4981 96 : tree res_op1;
4982 96 : res_op1 = captures[2];
4983 96 : tree _r;
4984 96 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
4985 96 : if (TREE_SIDE_EFFECTS (captures[1]))
4986 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4987 96 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 930, __FILE__, __LINE__, true);
4988 96 : return _r;
4989 : }
4990 0 : next_after_fail1535:;
4991 : }
4992 : }
4993 : }
4994 194051 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4995 : {
4996 110686 : {
4997 110686 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
4998 221372 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4999 221349 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5000 110663 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
5001 : )
5002 : {
5003 110663 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1536;
5004 110663 : {
5005 110663 : tree res_op0;
5006 110663 : res_op0 = captures[0];
5007 110663 : tree res_op1;
5008 110663 : res_op1 = captures[2];
5009 110663 : tree _r;
5010 110663 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
5011 110663 : if (TREE_SIDE_EFFECTS (captures[1]))
5012 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5013 110663 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 930, __FILE__, __LINE__, true);
5014 110663 : return _r;
5015 : }
5016 0 : next_after_fail1536:;
5017 : }
5018 : }
5019 : }
5020 : break;
5021 : }
5022 1434275 : default:;
5023 : }
5024 1434275 : switch (TREE_CODE (_q21))
5025 : {
5026 813 : CASE_CONVERT:
5027 813 : {
5028 813 : tree _q40 = TREE_OPERAND (_q21, 0);
5029 813 : switch (TREE_CODE (_p1))
5030 : {
5031 88 : CASE_CONVERT:
5032 88 : {
5033 88 : tree _q60 = TREE_OPERAND (_p1, 0);
5034 88 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
5035 : {
5036 0 : {
5037 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40 };
5038 0 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR);
5039 0 : if (res) return res;
5040 : }
5041 : }
5042 : break;
5043 : }
5044 : default:;
5045 : }
5046 : break;
5047 : }
5048 1434275 : default:;
5049 : }
5050 1434275 : switch (TREE_CODE (_q20))
5051 : {
5052 143432 : CASE_CONVERT:
5053 143432 : {
5054 143432 : tree _q30 = TREE_OPERAND (_q20, 0);
5055 143432 : switch (TREE_CODE (_p1))
5056 : {
5057 3933 : CASE_CONVERT:
5058 3933 : {
5059 3933 : tree _q60 = TREE_OPERAND (_p1, 0);
5060 3933 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
5061 : {
5062 406 : {
5063 406 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q30 };
5064 406 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR);
5065 406 : if (res) return res;
5066 : }
5067 : }
5068 : break;
5069 : }
5070 143026 : default:;
5071 : }
5072 143026 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
5073 : {
5074 0 : {
5075 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q30 };
5076 0 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR);
5077 0 : if (res) return res;
5078 : }
5079 : }
5080 : break;
5081 : }
5082 1433869 : default:;
5083 : }
5084 1433869 : switch (TREE_CODE (_q21))
5085 : {
5086 813 : CASE_CONVERT:
5087 813 : {
5088 813 : tree _q40 = TREE_OPERAND (_q21, 0);
5089 813 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
5090 : {
5091 0 : {
5092 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40 };
5093 0 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR);
5094 0 : if (res) return res;
5095 : }
5096 : }
5097 : break;
5098 : }
5099 1433869 : default:;
5100 : }
5101 1433869 : switch (TREE_CODE (_p1))
5102 : {
5103 43302 : CASE_CONVERT:
5104 43302 : {
5105 43302 : tree _q50 = TREE_OPERAND (_p1, 0);
5106 43302 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5107 : {
5108 0 : {
5109 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
5110 0 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR);
5111 0 : if (res) return res;
5112 : }
5113 : }
5114 43302 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5115 : {
5116 0 : {
5117 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q20 };
5118 0 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR);
5119 0 : if (res) return res;
5120 : }
5121 : }
5122 : break;
5123 : }
5124 1433869 : default:;
5125 : }
5126 1433869 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5127 : {
5128 76111 : {
5129 76111 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
5130 76111 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR);
5131 76111 : if (res) return res;
5132 : }
5133 : }
5134 1358466 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5135 : {
5136 19404 : {
5137 19404 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q20 };
5138 19404 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR);
5139 19404 : if (res) return res;
5140 : }
5141 : }
5142 : break;
5143 : }
5144 548228 : case POINTER_PLUS_EXPR:
5145 548228 : {
5146 548228 : tree _q20 = TREE_OPERAND (_p0, 0);
5147 548228 : tree _q21 = TREE_OPERAND (_p0, 1);
5148 548228 : switch (TREE_CODE (_p1))
5149 : {
5150 36874 : case POINTER_PLUS_EXPR:
5151 36874 : {
5152 36874 : tree _q50 = TREE_OPERAND (_p1, 0);
5153 36874 : tree _q51 = TREE_OPERAND (_p1, 1);
5154 36874 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5155 : {
5156 9609 : {
5157 9609 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5158 9609 : tree res = generic_simplify_221 (loc, type, _p0, _p1, captures, NE_EXPR);
5159 9609 : if (res) return res;
5160 : }
5161 : }
5162 : break;
5163 : }
5164 538619 : default:;
5165 : }
5166 538619 : switch (TREE_CODE (_q20))
5167 : {
5168 78438 : CASE_CONVERT:
5169 78438 : {
5170 78438 : tree _q30 = TREE_OPERAND (_q20, 0);
5171 78438 : switch (TREE_CODE (_p1))
5172 : {
5173 195 : CASE_CONVERT:
5174 195 : {
5175 195 : tree _q60 = TREE_OPERAND (_p1, 0);
5176 195 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
5177 : {
5178 0 : {
5179 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q30, _q21 };
5180 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, NE_EXPR);
5181 0 : if (res) return res;
5182 : }
5183 : }
5184 : break;
5185 : }
5186 78438 : default:;
5187 : }
5188 78438 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
5189 : {
5190 63 : {
5191 63 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q30, _q21 };
5192 63 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, NE_EXPR);
5193 63 : if (res) return res;
5194 : }
5195 : }
5196 : break;
5197 : }
5198 538556 : default:;
5199 : }
5200 538556 : switch (TREE_CODE (_p1))
5201 : {
5202 3258 : CASE_CONVERT:
5203 3258 : {
5204 3258 : tree _q50 = TREE_OPERAND (_p1, 0);
5205 3258 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5206 : {
5207 0 : {
5208 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
5209 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, NE_EXPR);
5210 0 : if (res) return res;
5211 : }
5212 : }
5213 : break;
5214 : }
5215 538556 : default:;
5216 : }
5217 538556 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5218 : {
5219 11290 : {
5220 11290 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
5221 11290 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, NE_EXPR);
5222 11290 : if (res) return res;
5223 : }
5224 : }
5225 : break;
5226 : }
5227 106958 : case MINUS_EXPR:
5228 106958 : {
5229 106958 : tree _q20 = TREE_OPERAND (_p0, 0);
5230 106958 : tree _q21 = TREE_OPERAND (_p0, 1);
5231 106958 : switch (TREE_CODE (_p1))
5232 : {
5233 5716 : case MINUS_EXPR:
5234 5716 : {
5235 5716 : tree _q50 = TREE_OPERAND (_p1, 0);
5236 5716 : tree _q51 = TREE_OPERAND (_p1, 1);
5237 5716 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5238 : {
5239 170 : {
5240 170 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5241 340 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
5242 173 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5243 0 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
5244 : )
5245 : {
5246 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1537;
5247 3 : {
5248 3 : tree res_op0;
5249 3 : res_op0 = captures[0];
5250 3 : tree res_op1;
5251 3 : res_op1 = captures[2];
5252 3 : tree _r;
5253 3 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
5254 3 : if (TREE_SIDE_EFFECTS (captures[1]))
5255 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5256 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 931, __FILE__, __LINE__, true);
5257 3 : return _r;
5258 : }
5259 0 : next_after_fail1537:;
5260 : }
5261 : }
5262 : }
5263 5713 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5264 : {
5265 166 : {
5266 166 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5267 332 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
5268 166 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
5269 0 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1])))
5270 : )
5271 : {
5272 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1538;
5273 0 : {
5274 0 : tree res_op0;
5275 0 : res_op0 = captures[2];
5276 0 : tree res_op1;
5277 0 : res_op1 = captures[1];
5278 0 : tree _r;
5279 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
5280 0 : if (TREE_SIDE_EFFECTS (captures[0]))
5281 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
5282 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 932, __FILE__, __LINE__, true);
5283 0 : return _r;
5284 : }
5285 0 : next_after_fail1538:;
5286 : }
5287 : }
5288 : }
5289 : break;
5290 : }
5291 106955 : default:;
5292 : }
5293 106955 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5294 : {
5295 1754 : {
5296 1754 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
5297 1754 : tree res = generic_simplify_223 (loc, type, _p0, _p1, captures, NE_EXPR);
5298 1754 : if (res) return res;
5299 : }
5300 : }
5301 : break;
5302 : }
5303 26081 : case POINTER_DIFF_EXPR:
5304 26081 : {
5305 26081 : tree _q20 = TREE_OPERAND (_p0, 0);
5306 26081 : tree _q21 = TREE_OPERAND (_p0, 1);
5307 26081 : switch (TREE_CODE (_p1))
5308 : {
5309 2314 : case POINTER_DIFF_EXPR:
5310 2314 : {
5311 2314 : tree _q50 = TREE_OPERAND (_p1, 0);
5312 2314 : tree _q51 = TREE_OPERAND (_p1, 1);
5313 2314 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5314 : {
5315 0 : {
5316 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
5317 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5318 0 : if (res) return res;
5319 : }
5320 : }
5321 2314 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5322 : {
5323 0 : {
5324 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
5325 0 : tree res = generic_simplify_225 (loc, type, _p0, _p1, captures, NE_EXPR);
5326 0 : if (res) return res;
5327 : }
5328 : }
5329 : break;
5330 : }
5331 : default:;
5332 : }
5333 : break;
5334 : }
5335 38674367 : default:;
5336 : }
5337 38674367 : {
5338 38674367 : tree _p0_pops[1];
5339 38674367 : if (tree_logical_inverted_value (_p0, _p0_pops))
5340 : {
5341 591628 : tree _q20 = _p0_pops[0];
5342 591628 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5343 : {
5344 24 : if (tree_truth_valued_p (_p1))
5345 : {
5346 0 : {
5347 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
5348 0 : tree res = generic_simplify_213 (loc, type, _p0, _p1, captures, NE_EXPR);
5349 0 : if (res) return res;
5350 : }
5351 : }
5352 : }
5353 : }
5354 : }
5355 38674367 : if (tree_truth_valued_p (_p0))
5356 : {
5357 5592138 : {
5358 5592138 : tree _p1_pops[1];
5359 5592138 : if (tree_logical_inverted_value (_p1, _p1_pops))
5360 : {
5361 1153 : tree _q30 = _p1_pops[0];
5362 1153 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5363 : {
5364 0 : {
5365 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
5366 0 : tree res = generic_simplify_213 (loc, type, _p0, _p1, captures, NE_EXPR);
5367 0 : if (res) return res;
5368 : }
5369 : }
5370 : }
5371 : }
5372 : }
5373 38674367 : switch (TREE_CODE (_p1))
5374 : {
5375 124919 : case PLUS_EXPR:
5376 124919 : {
5377 124919 : tree _q30 = TREE_OPERAND (_p1, 0);
5378 124919 : tree _q31 = TREE_OPERAND (_p1, 1);
5379 124919 : switch (TREE_CODE (_q31))
5380 : {
5381 372 : CASE_CONVERT:
5382 372 : {
5383 372 : tree _q50 = TREE_OPERAND (_q31, 0);
5384 372 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
5385 : {
5386 0 : {
5387 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0 };
5388 0 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR);
5389 0 : if (res) return res;
5390 : }
5391 : }
5392 : break;
5393 : }
5394 124919 : default:;
5395 : }
5396 124919 : switch (TREE_CODE (_q30))
5397 : {
5398 6246 : CASE_CONVERT:
5399 6246 : {
5400 6246 : tree _q40 = TREE_OPERAND (_q30, 0);
5401 6246 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
5402 : {
5403 0 : {
5404 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q31, _p0 };
5405 0 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR);
5406 0 : if (res) return res;
5407 : }
5408 : }
5409 : break;
5410 : }
5411 124919 : default:;
5412 : }
5413 124919 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5414 : {
5415 0 : {
5416 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0 };
5417 0 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR);
5418 0 : if (res) return res;
5419 : }
5420 : }
5421 124919 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5422 : {
5423 8 : {
5424 8 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q31, _p0 };
5425 8 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR);
5426 8 : if (res) return res;
5427 : }
5428 : }
5429 : break;
5430 : }
5431 38674359 : default:;
5432 : }
5433 38674359 : {
5434 38674359 : tree _p1_pops[1];
5435 38674359 : if (tree_nop_convert (_p1, _p1_pops))
5436 : {
5437 5094561 : tree _q30 = _p1_pops[0];
5438 5094561 : switch (TREE_CODE (_q30))
5439 : {
5440 1743 : case PLUS_EXPR:
5441 1743 : {
5442 1743 : tree _q40 = TREE_OPERAND (_q30, 0);
5443 1743 : tree _q41 = TREE_OPERAND (_q30, 1);
5444 1743 : switch (TREE_CODE (_q41))
5445 : {
5446 3 : CASE_CONVERT:
5447 3 : {
5448 3 : tree _q60 = TREE_OPERAND (_q41, 0);
5449 3 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
5450 : {
5451 0 : {
5452 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0 };
5453 0 : tree res = generic_simplify_210 (loc, type, _p0, _p1, captures, NE_EXPR);
5454 0 : if (res) return res;
5455 : }
5456 : }
5457 : break;
5458 : }
5459 1743 : default:;
5460 : }
5461 1743 : switch (TREE_CODE (_q40))
5462 : {
5463 1169 : CASE_CONVERT:
5464 1169 : {
5465 1169 : tree _q50 = TREE_OPERAND (_q40, 0);
5466 1169 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
5467 : {
5468 0 : {
5469 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q41, _p0 };
5470 0 : tree res = generic_simplify_210 (loc, type, _p0, _p1, captures, NE_EXPR);
5471 0 : if (res) return res;
5472 : }
5473 : }
5474 : break;
5475 : }
5476 1743 : default:;
5477 : }
5478 1743 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
5479 : {
5480 0 : {
5481 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0 };
5482 0 : tree res = generic_simplify_210 (loc, type, _p0, _p1, captures, NE_EXPR);
5483 0 : if (res) return res;
5484 : }
5485 : }
5486 1743 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
5487 : {
5488 0 : {
5489 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q41, _p0 };
5490 0 : tree res = generic_simplify_210 (loc, type, _p0, _p1, captures, NE_EXPR);
5491 0 : if (res) return res;
5492 : }
5493 : }
5494 : break;
5495 : }
5496 : default:;
5497 : }
5498 : }
5499 : }
5500 38674359 : switch (TREE_CODE (_p0))
5501 : {
5502 8708625 : CASE_CONVERT:
5503 8708625 : {
5504 8708625 : tree _q20 = TREE_OPERAND (_p0, 0);
5505 8708625 : switch (TREE_CODE (_p1))
5506 : {
5507 164 : case POINTER_PLUS_EXPR:
5508 164 : {
5509 164 : tree _q40 = TREE_OPERAND (_p1, 0);
5510 164 : tree _q41 = TREE_OPERAND (_p1, 1);
5511 164 : switch (TREE_CODE (_q40))
5512 : {
5513 48 : CASE_CONVERT:
5514 48 : {
5515 48 : tree _q50 = TREE_OPERAND (_q40, 0);
5516 48 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5517 : {
5518 0 : {
5519 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q20, _q41 };
5520 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, NE_EXPR);
5521 0 : if (res) return res;
5522 : }
5523 : }
5524 : break;
5525 : }
5526 164 : default:;
5527 : }
5528 164 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
5529 : {
5530 0 : {
5531 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q20, _q41 };
5532 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, NE_EXPR);
5533 0 : if (res) return res;
5534 : }
5535 : }
5536 : break;
5537 : }
5538 8708625 : default:;
5539 : }
5540 8708625 : {
5541 8708625 : tree _p1_pops[1];
5542 8708625 : if (tree_nop_convert (_p1, _p1_pops))
5543 : {
5544 4725828 : tree _q40 = _p1_pops[0];
5545 4725828 : switch (TREE_CODE (_q40))
5546 : {
5547 48 : case POINTER_PLUS_EXPR:
5548 48 : {
5549 48 : tree _q50 = TREE_OPERAND (_q40, 0);
5550 48 : tree _q51 = TREE_OPERAND (_q40, 1);
5551 48 : switch (TREE_CODE (_q50))
5552 : {
5553 8 : CASE_CONVERT:
5554 8 : {
5555 8 : tree _q60 = TREE_OPERAND (_q50, 0);
5556 8 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
5557 : {
5558 0 : {
5559 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q20, _q51 };
5560 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
5561 0 : if (res) return res;
5562 : }
5563 : }
5564 : break;
5565 : }
5566 48 : default:;
5567 : }
5568 48 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5569 : {
5570 0 : {
5571 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q20, _q51 };
5572 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
5573 0 : if (res) return res;
5574 : }
5575 : }
5576 : break;
5577 : }
5578 : default:;
5579 : }
5580 : }
5581 : }
5582 8708625 : break;
5583 : }
5584 38674359 : default:;
5585 : }
5586 38674359 : {
5587 38674359 : tree _p0_pops[1];
5588 38674359 : if (tree_nop_convert (_p0, _p0_pops))
5589 : {
5590 6428553 : tree _q20 = _p0_pops[0];
5591 6428553 : switch (TREE_CODE (_q20))
5592 : {
5593 185 : case POINTER_PLUS_EXPR:
5594 185 : {
5595 185 : tree _q30 = TREE_OPERAND (_q20, 0);
5596 185 : tree _q31 = TREE_OPERAND (_q20, 1);
5597 185 : switch (TREE_CODE (_q30))
5598 : {
5599 24 : CASE_CONVERT:
5600 24 : {
5601 24 : tree _q40 = TREE_OPERAND (_q30, 0);
5602 24 : switch (TREE_CODE (_p1))
5603 : {
5604 8 : CASE_CONVERT:
5605 8 : {
5606 8 : tree _q70 = TREE_OPERAND (_p1, 0);
5607 8 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
5608 : {
5609 0 : {
5610 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31 };
5611 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
5612 0 : if (res) return res;
5613 : }
5614 : }
5615 : break;
5616 : }
5617 24 : default:;
5618 : }
5619 24 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
5620 : {
5621 0 : {
5622 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31 };
5623 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
5624 0 : if (res) return res;
5625 : }
5626 : }
5627 : break;
5628 : }
5629 185 : default:;
5630 : }
5631 185 : switch (TREE_CODE (_p1))
5632 : {
5633 50 : CASE_CONVERT:
5634 50 : {
5635 50 : tree _q60 = TREE_OPERAND (_p1, 0);
5636 50 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
5637 : {
5638 0 : {
5639 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
5640 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
5641 0 : if (res) return res;
5642 : }
5643 : }
5644 : break;
5645 : }
5646 185 : default:;
5647 : }
5648 185 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
5649 : {
5650 0 : {
5651 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
5652 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
5653 0 : if (res) return res;
5654 : }
5655 : }
5656 : break;
5657 : }
5658 : default:;
5659 : }
5660 : }
5661 : }
5662 38674359 : switch (TREE_CODE (_p1))
5663 : {
5664 32027 : case POINTER_PLUS_EXPR:
5665 32027 : {
5666 32027 : tree _q30 = TREE_OPERAND (_p1, 0);
5667 32027 : tree _q31 = TREE_OPERAND (_p1, 1);
5668 32027 : switch (TREE_CODE (_q30))
5669 : {
5670 3536 : CASE_CONVERT:
5671 3536 : {
5672 3536 : tree _q40 = TREE_OPERAND (_q30, 0);
5673 3536 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
5674 : {
5675 0 : {
5676 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _p0, _q31 };
5677 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, NE_EXPR);
5678 0 : if (res) return res;
5679 : }
5680 : }
5681 : break;
5682 : }
5683 32027 : default:;
5684 : }
5685 32027 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5686 : {
5687 0 : {
5688 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _p0, _q31 };
5689 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, NE_EXPR);
5690 0 : if (res) return res;
5691 : }
5692 : }
5693 : break;
5694 : }
5695 38674359 : default:;
5696 : }
5697 38674359 : {
5698 38674359 : tree _p1_pops[1];
5699 38674359 : if (tree_nop_convert (_p1, _p1_pops))
5700 : {
5701 5094561 : tree _q30 = _p1_pops[0];
5702 5094561 : switch (TREE_CODE (_q30))
5703 : {
5704 387 : case POINTER_PLUS_EXPR:
5705 387 : {
5706 387 : tree _q40 = TREE_OPERAND (_q30, 0);
5707 387 : tree _q41 = TREE_OPERAND (_q30, 1);
5708 387 : switch (TREE_CODE (_q40))
5709 : {
5710 8 : CASE_CONVERT:
5711 8 : {
5712 8 : tree _q50 = TREE_OPERAND (_q40, 0);
5713 8 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
5714 : {
5715 0 : {
5716 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _p0, _q41 };
5717 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
5718 0 : if (res) return res;
5719 : }
5720 : }
5721 : break;
5722 : }
5723 387 : default:;
5724 : }
5725 387 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
5726 : {
5727 0 : {
5728 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _p0, _q41 };
5729 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
5730 0 : if (res) return res;
5731 : }
5732 : }
5733 : break;
5734 : }
5735 : default:;
5736 : }
5737 : }
5738 : }
5739 38674359 : switch (TREE_CODE (_p0))
5740 : {
5741 527266 : case POINTER_PLUS_EXPR:
5742 527266 : {
5743 527266 : tree _q20 = TREE_OPERAND (_p0, 0);
5744 527266 : tree _q21 = TREE_OPERAND (_p0, 1);
5745 527266 : switch (TREE_CODE (_p1))
5746 : {
5747 51964 : case ADDR_EXPR:
5748 51964 : {
5749 51964 : {
5750 51964 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5751 51964 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, NE_EXPR);
5752 51964 : if (res) return res;
5753 : }
5754 36022 : break;
5755 : }
5756 511324 : default:;
5757 : }
5758 511324 : switch (TREE_CODE (_q20))
5759 : {
5760 5407 : case ADDR_EXPR:
5761 5407 : {
5762 5407 : switch (TREE_CODE (_p1))
5763 : {
5764 411 : case POINTER_PLUS_EXPR:
5765 411 : {
5766 411 : tree _q50 = TREE_OPERAND (_p1, 0);
5767 411 : tree _q51 = TREE_OPERAND (_p1, 1);
5768 411 : switch (TREE_CODE (_q50))
5769 : {
5770 0 : case ADDR_EXPR:
5771 0 : {
5772 0 : {
5773 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51 };
5774 0 : tree res = generic_simplify_228 (loc, type, _p0, _p1, captures, NE_EXPR);
5775 0 : if (res) return res;
5776 : }
5777 0 : break;
5778 : }
5779 : default:;
5780 : }
5781 : break;
5782 : }
5783 : default:;
5784 : }
5785 : break;
5786 : }
5787 : default:;
5788 : }
5789 : break;
5790 : }
5791 207014 : case ADDR_EXPR:
5792 207014 : {
5793 207014 : switch (TREE_CODE (_p1))
5794 : {
5795 0 : case POINTER_PLUS_EXPR:
5796 0 : {
5797 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5798 0 : tree _q31 = TREE_OPERAND (_p1, 1);
5799 0 : {
5800 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
5801 0 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, NE_EXPR);
5802 0 : if (res) return res;
5803 : }
5804 0 : break;
5805 : }
5806 : default:;
5807 : }
5808 : break;
5809 : }
5810 38658417 : default:;
5811 : }
5812 38658417 : switch (TREE_CODE (_p1))
5813 : {
5814 30246 : case MINUS_EXPR:
5815 30246 : {
5816 30246 : tree _q30 = TREE_OPERAND (_p1, 0);
5817 30246 : tree _q31 = TREE_OPERAND (_p1, 1);
5818 30246 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5819 : {
5820 0 : {
5821 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
5822 0 : tree res = generic_simplify_223 (loc, type, _p0, _p1, captures, NE_EXPR);
5823 0 : if (res) return res;
5824 : }
5825 : }
5826 : break;
5827 : }
5828 38658417 : default:;
5829 : }
5830 38658417 : switch (TREE_CODE (_p0))
5831 : {
5832 9090 : case TRUNC_DIV_EXPR:
5833 9090 : {
5834 9090 : tree _q20 = TREE_OPERAND (_p0, 0);
5835 9090 : tree _q21 = TREE_OPERAND (_p0, 1);
5836 9090 : if (tree_expr_nonnegative_p (_q20))
5837 : {
5838 3429 : if (tree_expr_nonnegative_p (_q21))
5839 : {
5840 3205 : if (integer_zerop (_p1))
5841 : {
5842 182 : {
5843 182 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5844 182 : tree res = generic_simplify_229 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR);
5845 182 : if (res) return res;
5846 : }
5847 : }
5848 : }
5849 : }
5850 : break;
5851 : }
5852 8708625 : CASE_CONVERT:
5853 8708625 : {
5854 8708625 : tree _q20 = TREE_OPERAND (_p0, 0);
5855 8708625 : switch (TREE_CODE (_p1))
5856 : {
5857 4866477 : CASE_CONVERT:
5858 4866477 : {
5859 4866477 : tree _q40 = TREE_OPERAND (_p1, 0);
5860 4866477 : switch (TREE_CODE (_q40))
5861 : {
5862 0 : case MINUS_EXPR:
5863 0 : {
5864 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5865 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5866 0 : switch (TREE_CODE (_q50))
5867 : {
5868 0 : case INTEGER_CST:
5869 0 : {
5870 0 : switch (TREE_CODE (_q51))
5871 : {
5872 0 : CASE_CONVERT:
5873 0 : {
5874 0 : tree _q70 = TREE_OPERAND (_q51, 0);
5875 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
5876 : {
5877 0 : {
5878 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
5879 0 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
5880 0 : if (res) return res;
5881 : }
5882 : }
5883 : break;
5884 : }
5885 : default:;
5886 : }
5887 : break;
5888 : }
5889 : default:;
5890 : }
5891 : break;
5892 : }
5893 : default:;
5894 : }
5895 : break;
5896 : }
5897 8708625 : default:;
5898 : }
5899 8708625 : switch (TREE_CODE (_q20))
5900 : {
5901 99 : case MINUS_EXPR:
5902 99 : {
5903 99 : tree _q30 = TREE_OPERAND (_q20, 0);
5904 99 : tree _q31 = TREE_OPERAND (_q20, 1);
5905 99 : switch (TREE_CODE (_q30))
5906 : {
5907 49 : case INTEGER_CST:
5908 49 : {
5909 49 : switch (TREE_CODE (_q31))
5910 : {
5911 0 : CASE_CONVERT:
5912 0 : {
5913 0 : tree _q50 = TREE_OPERAND (_q31, 0);
5914 0 : switch (TREE_CODE (_p1))
5915 : {
5916 0 : CASE_CONVERT:
5917 0 : {
5918 0 : tree _q70 = TREE_OPERAND (_p1, 0);
5919 0 : if ((_q70 == _q50 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q50, 0) && types_match (_q70, _q50)))
5920 : {
5921 0 : {
5922 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
5923 0 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
5924 0 : if (res) return res;
5925 : }
5926 : }
5927 : break;
5928 : }
5929 0 : default:;
5930 : }
5931 0 : if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
5932 : {
5933 0 : {
5934 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
5935 0 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
5936 0 : if (res) return res;
5937 : }
5938 : }
5939 : break;
5940 : }
5941 49 : default:;
5942 : }
5943 49 : switch (TREE_CODE (_p1))
5944 : {
5945 0 : CASE_CONVERT:
5946 0 : {
5947 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5948 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
5949 : {
5950 0 : {
5951 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q30 };
5952 0 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
5953 0 : if (res) return res;
5954 : }
5955 : }
5956 : break;
5957 : }
5958 49 : default:;
5959 : }
5960 49 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
5961 : {
5962 0 : {
5963 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q30 };
5964 0 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
5965 0 : if (res) return res;
5966 : }
5967 : }
5968 : break;
5969 : }
5970 : default:;
5971 : }
5972 : break;
5973 : }
5974 8708625 : default:;
5975 : }
5976 8708625 : switch (TREE_CODE (_p1))
5977 : {
5978 4866477 : CASE_CONVERT:
5979 4866477 : {
5980 4866477 : tree _q40 = TREE_OPERAND (_p1, 0);
5981 4866477 : switch (TREE_CODE (_q40))
5982 : {
5983 0 : case MINUS_EXPR:
5984 0 : {
5985 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5986 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5987 0 : switch (TREE_CODE (_q50))
5988 : {
5989 0 : case INTEGER_CST:
5990 0 : {
5991 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5992 : {
5993 0 : {
5994 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
5995 0 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
5996 0 : if (res) return res;
5997 : }
5998 : }
5999 : break;
6000 : }
6001 : default:;
6002 : }
6003 : break;
6004 : }
6005 : default:;
6006 : }
6007 : break;
6008 : }
6009 21620 : case MINUS_EXPR:
6010 21620 : {
6011 21620 : tree _q40 = TREE_OPERAND (_p1, 0);
6012 21620 : tree _q41 = TREE_OPERAND (_p1, 1);
6013 21620 : switch (TREE_CODE (_q40))
6014 : {
6015 401 : case INTEGER_CST:
6016 401 : {
6017 401 : switch (TREE_CODE (_q41))
6018 : {
6019 20 : CASE_CONVERT:
6020 20 : {
6021 20 : tree _q60 = TREE_OPERAND (_q41, 0);
6022 20 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6023 : {
6024 0 : {
6025 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6026 0 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
6027 0 : if (res) return res;
6028 : }
6029 : }
6030 : break;
6031 : }
6032 401 : default:;
6033 : }
6034 401 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
6035 : {
6036 0 : {
6037 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6038 0 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
6039 0 : if (res) return res;
6040 : }
6041 : }
6042 : break;
6043 : }
6044 : default:;
6045 : }
6046 : break;
6047 : }
6048 : default:;
6049 : }
6050 : break;
6051 : }
6052 105243 : case MINUS_EXPR:
6053 105243 : {
6054 105243 : tree _q20 = TREE_OPERAND (_p0, 0);
6055 105243 : tree _q21 = TREE_OPERAND (_p0, 1);
6056 105243 : switch (TREE_CODE (_q20))
6057 : {
6058 2256 : case INTEGER_CST:
6059 2256 : {
6060 2256 : switch (TREE_CODE (_q21))
6061 : {
6062 190 : CASE_CONVERT:
6063 190 : {
6064 190 : tree _q40 = TREE_OPERAND (_q21, 0);
6065 190 : switch (TREE_CODE (_p1))
6066 : {
6067 0 : CASE_CONVERT:
6068 0 : {
6069 0 : tree _q60 = TREE_OPERAND (_p1, 0);
6070 0 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
6071 : {
6072 0 : {
6073 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
6074 0 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
6075 0 : if (res) return res;
6076 : }
6077 : }
6078 : break;
6079 : }
6080 190 : default:;
6081 : }
6082 190 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
6083 : {
6084 0 : {
6085 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
6086 0 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
6087 0 : if (res) return res;
6088 : }
6089 : }
6090 : break;
6091 : }
6092 2256 : default:;
6093 : }
6094 2256 : switch (TREE_CODE (_p1))
6095 : {
6096 306 : CASE_CONVERT:
6097 306 : {
6098 306 : tree _q50 = TREE_OPERAND (_p1, 0);
6099 306 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6100 : {
6101 0 : {
6102 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6103 0 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
6104 0 : if (res) return res;
6105 : }
6106 : }
6107 : break;
6108 : }
6109 2256 : default:;
6110 : }
6111 2256 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
6112 : {
6113 19 : {
6114 19 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6115 19 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
6116 19 : if (res) return res;
6117 : }
6118 : }
6119 : break;
6120 : }
6121 : default:;
6122 : }
6123 : break;
6124 : }
6125 38658245 : default:;
6126 : }
6127 38658245 : switch (TREE_CODE (_p1))
6128 : {
6129 5263472 : CASE_CONVERT:
6130 5263472 : {
6131 5263472 : tree _q30 = TREE_OPERAND (_p1, 0);
6132 5263472 : switch (TREE_CODE (_q30))
6133 : {
6134 556 : case MINUS_EXPR:
6135 556 : {
6136 556 : tree _q40 = TREE_OPERAND (_q30, 0);
6137 556 : tree _q41 = TREE_OPERAND (_q30, 1);
6138 556 : switch (TREE_CODE (_q40))
6139 : {
6140 17 : case INTEGER_CST:
6141 17 : {
6142 17 : switch (TREE_CODE (_q41))
6143 : {
6144 0 : CASE_CONVERT:
6145 0 : {
6146 0 : tree _q60 = TREE_OPERAND (_q41, 0);
6147 0 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
6148 : {
6149 0 : {
6150 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
6151 0 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
6152 0 : if (res) return res;
6153 : }
6154 : }
6155 : break;
6156 : }
6157 17 : default:;
6158 : }
6159 17 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
6160 : {
6161 0 : {
6162 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
6163 0 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
6164 0 : if (res) return res;
6165 : }
6166 : }
6167 : break;
6168 : }
6169 : default:;
6170 : }
6171 : break;
6172 : }
6173 : default:;
6174 : }
6175 : break;
6176 : }
6177 30246 : case MINUS_EXPR:
6178 30246 : {
6179 30246 : tree _q30 = TREE_OPERAND (_p1, 0);
6180 30246 : tree _q31 = TREE_OPERAND (_p1, 1);
6181 30246 : switch (TREE_CODE (_q30))
6182 : {
6183 655 : case INTEGER_CST:
6184 655 : {
6185 655 : switch (TREE_CODE (_q31))
6186 : {
6187 28 : CASE_CONVERT:
6188 28 : {
6189 28 : tree _q50 = TREE_OPERAND (_q31, 0);
6190 28 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
6191 : {
6192 0 : {
6193 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
6194 0 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
6195 0 : if (res) return res;
6196 : }
6197 : }
6198 : break;
6199 : }
6200 655 : default:;
6201 : }
6202 655 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6203 : {
6204 0 : {
6205 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
6206 0 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
6207 0 : if (res) return res;
6208 : }
6209 : }
6210 : break;
6211 : }
6212 : default:;
6213 : }
6214 : break;
6215 : }
6216 38658245 : default:;
6217 : }
6218 38658245 : switch (TREE_CODE (_p0))
6219 : {
6220 18288 : case LT_EXPR:
6221 18288 : {
6222 18288 : tree _q20 = TREE_OPERAND (_p0, 0);
6223 18288 : tree _q21 = TREE_OPERAND (_p0, 1);
6224 18288 : switch (TREE_CODE (_p1))
6225 : {
6226 18 : case GT_EXPR:
6227 18 : {
6228 18 : tree _q50 = TREE_OPERAND (_p1, 0);
6229 18 : tree _q51 = TREE_OPERAND (_p1, 1);
6230 18 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6231 : {
6232 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6233 : {
6234 0 : {
6235 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6236 0 : const enum tree_code cmp1 = LT_EXPR;
6237 0 : const enum tree_code cmp2 = GT_EXPR;
6238 0 : const enum tree_code rcmp = NE_EXPR;
6239 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6240 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6241 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6242 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6243 : )
6244 : {
6245 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1539;
6246 0 : {
6247 0 : tree res_op0;
6248 0 : res_op0 = captures[0];
6249 0 : tree res_op1;
6250 0 : res_op1 = captures[1];
6251 0 : tree _r;
6252 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6253 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6254 0 : return _r;
6255 : }
6256 0 : next_after_fail1539:;
6257 : }
6258 : }
6259 : }
6260 : }
6261 : break;
6262 : }
6263 23 : case EQ_EXPR:
6264 23 : {
6265 23 : tree _q50 = TREE_OPERAND (_p1, 0);
6266 23 : tree _q51 = TREE_OPERAND (_p1, 1);
6267 23 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6268 : {
6269 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6270 : {
6271 0 : {
6272 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6273 0 : const enum tree_code cmp1 = LT_EXPR;
6274 0 : const enum tree_code cmp2 = EQ_EXPR;
6275 0 : const enum tree_code rcmp = LE_EXPR;
6276 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6277 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6278 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6279 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6280 : )
6281 : {
6282 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1540;
6283 0 : {
6284 0 : tree res_op0;
6285 0 : res_op0 = captures[0];
6286 0 : tree res_op1;
6287 0 : res_op1 = captures[1];
6288 0 : tree _r;
6289 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6290 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6291 0 : return _r;
6292 : }
6293 0 : next_after_fail1540:;
6294 : }
6295 : }
6296 : }
6297 : }
6298 : break;
6299 : }
6300 23 : case NE_EXPR:
6301 23 : {
6302 23 : tree _q50 = TREE_OPERAND (_p1, 0);
6303 23 : tree _q51 = TREE_OPERAND (_p1, 1);
6304 23 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6305 : {
6306 9 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6307 : {
6308 0 : {
6309 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6310 0 : const enum tree_code cmp1 = LT_EXPR;
6311 0 : const enum tree_code cmp2 = NE_EXPR;
6312 0 : const enum tree_code rcmp = GT_EXPR;
6313 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6314 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6315 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6316 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6317 : )
6318 : {
6319 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1541;
6320 0 : {
6321 0 : tree res_op0;
6322 0 : res_op0 = captures[0];
6323 0 : tree res_op1;
6324 0 : res_op1 = captures[1];
6325 0 : tree _r;
6326 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6327 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6328 0 : return _r;
6329 : }
6330 0 : next_after_fail1541:;
6331 : }
6332 : }
6333 : }
6334 : }
6335 : break;
6336 : }
6337 : default:;
6338 : }
6339 : break;
6340 : }
6341 12034 : case LE_EXPR:
6342 12034 : {
6343 12034 : tree _q20 = TREE_OPERAND (_p0, 0);
6344 12034 : tree _q21 = TREE_OPERAND (_p0, 1);
6345 12034 : switch (TREE_CODE (_p1))
6346 : {
6347 25 : case GE_EXPR:
6348 25 : {
6349 25 : tree _q50 = TREE_OPERAND (_p1, 0);
6350 25 : tree _q51 = TREE_OPERAND (_p1, 1);
6351 25 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6352 : {
6353 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6354 : {
6355 0 : {
6356 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6357 0 : const enum tree_code cmp1 = LE_EXPR;
6358 0 : const enum tree_code cmp2 = GE_EXPR;
6359 0 : const enum tree_code rcmp = NE_EXPR;
6360 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6361 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6362 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6363 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6364 : )
6365 : {
6366 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1542;
6367 0 : {
6368 0 : tree res_op0;
6369 0 : res_op0 = captures[0];
6370 0 : tree res_op1;
6371 0 : res_op1 = captures[1];
6372 0 : tree _r;
6373 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6374 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6375 0 : return _r;
6376 : }
6377 0 : next_after_fail1542:;
6378 : }
6379 : }
6380 : }
6381 : }
6382 : break;
6383 : }
6384 41 : case EQ_EXPR:
6385 41 : {
6386 41 : tree _q50 = TREE_OPERAND (_p1, 0);
6387 41 : tree _q51 = TREE_OPERAND (_p1, 1);
6388 41 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6389 : {
6390 9 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6391 : {
6392 0 : {
6393 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6394 0 : const enum tree_code cmp1 = LE_EXPR;
6395 0 : const enum tree_code cmp2 = EQ_EXPR;
6396 0 : const enum tree_code rcmp = LT_EXPR;
6397 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6398 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6399 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6400 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6401 : )
6402 : {
6403 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1543;
6404 0 : {
6405 0 : tree res_op0;
6406 0 : res_op0 = captures[0];
6407 0 : tree res_op1;
6408 0 : res_op1 = captures[1];
6409 0 : tree _r;
6410 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6411 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6412 0 : return _r;
6413 : }
6414 0 : next_after_fail1543:;
6415 : }
6416 : }
6417 : }
6418 : }
6419 : break;
6420 : }
6421 13 : case NE_EXPR:
6422 13 : {
6423 13 : tree _q50 = TREE_OPERAND (_p1, 0);
6424 13 : tree _q51 = TREE_OPERAND (_p1, 1);
6425 13 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6426 : {
6427 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6428 : {
6429 0 : {
6430 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6431 0 : const enum tree_code cmp1 = LE_EXPR;
6432 0 : const enum tree_code cmp2 = NE_EXPR;
6433 0 : const enum tree_code rcmp = GE_EXPR;
6434 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6435 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6436 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6437 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6438 : )
6439 : {
6440 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1544;
6441 0 : {
6442 0 : tree res_op0;
6443 0 : res_op0 = captures[0];
6444 0 : tree res_op1;
6445 0 : res_op1 = captures[1];
6446 0 : tree _r;
6447 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6448 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6449 0 : return _r;
6450 : }
6451 0 : next_after_fail1544:;
6452 : }
6453 : }
6454 : }
6455 : }
6456 : break;
6457 : }
6458 : default:;
6459 : }
6460 : break;
6461 : }
6462 35985 : case GT_EXPR:
6463 35985 : {
6464 35985 : tree _q20 = TREE_OPERAND (_p0, 0);
6465 35985 : tree _q21 = TREE_OPERAND (_p0, 1);
6466 35985 : switch (TREE_CODE (_p1))
6467 : {
6468 77 : case GT_EXPR:
6469 77 : {
6470 77 : tree _q50 = TREE_OPERAND (_p1, 0);
6471 77 : tree _q51 = TREE_OPERAND (_p1, 1);
6472 77 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6473 : {
6474 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6475 : {
6476 0 : {
6477 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6478 0 : const enum tree_code cmp1 = LT_EXPR;
6479 0 : const enum tree_code cmp2 = GT_EXPR;
6480 0 : const enum tree_code rcmp = NE_EXPR;
6481 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6482 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6483 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6484 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6485 : )
6486 : {
6487 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1545;
6488 0 : {
6489 0 : tree res_op0;
6490 0 : res_op0 = captures[0];
6491 0 : tree res_op1;
6492 0 : res_op1 = captures[1];
6493 0 : tree _r;
6494 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6495 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6496 0 : return _r;
6497 : }
6498 0 : next_after_fail1545:;
6499 : }
6500 : }
6501 0 : {
6502 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6503 0 : const enum tree_code cmp1 = LT_EXPR;
6504 0 : const enum tree_code cmp2 = GT_EXPR;
6505 0 : const enum tree_code rcmp = NE_EXPR;
6506 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6507 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6508 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6509 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6510 : )
6511 : {
6512 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1546;
6513 0 : {
6514 0 : tree res_op0;
6515 0 : res_op0 = captures[0];
6516 0 : tree res_op1;
6517 0 : res_op1 = captures[1];
6518 0 : tree _r;
6519 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6520 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6521 0 : return _r;
6522 : }
6523 0 : next_after_fail1546:;
6524 : }
6525 : }
6526 : }
6527 : }
6528 : break;
6529 : }
6530 29 : case EQ_EXPR:
6531 29 : {
6532 29 : tree _q50 = TREE_OPERAND (_p1, 0);
6533 29 : tree _q51 = TREE_OPERAND (_p1, 1);
6534 29 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6535 : {
6536 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6537 : {
6538 0 : {
6539 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6540 0 : const enum tree_code cmp1 = LT_EXPR;
6541 0 : const enum tree_code cmp2 = EQ_EXPR;
6542 0 : const enum tree_code rcmp = LE_EXPR;
6543 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6544 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6545 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6546 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6547 : )
6548 : {
6549 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1547;
6550 0 : {
6551 0 : tree res_op0;
6552 0 : res_op0 = captures[0];
6553 0 : tree res_op1;
6554 0 : res_op1 = captures[1];
6555 0 : tree _r;
6556 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6557 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6558 0 : return _r;
6559 : }
6560 0 : next_after_fail1547:;
6561 : }
6562 : }
6563 : }
6564 : }
6565 : break;
6566 : }
6567 53 : case NE_EXPR:
6568 53 : {
6569 53 : tree _q50 = TREE_OPERAND (_p1, 0);
6570 53 : tree _q51 = TREE_OPERAND (_p1, 1);
6571 53 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6572 : {
6573 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6574 : {
6575 0 : {
6576 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6577 0 : const enum tree_code cmp1 = LT_EXPR;
6578 0 : const enum tree_code cmp2 = NE_EXPR;
6579 0 : const enum tree_code rcmp = GT_EXPR;
6580 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6581 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6582 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6583 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6584 : )
6585 : {
6586 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1548;
6587 0 : {
6588 0 : tree res_op0;
6589 0 : res_op0 = captures[0];
6590 0 : tree res_op1;
6591 0 : res_op1 = captures[1];
6592 0 : tree _r;
6593 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6594 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6595 0 : return _r;
6596 : }
6597 0 : next_after_fail1548:;
6598 : }
6599 : }
6600 : }
6601 : }
6602 : break;
6603 : }
6604 32 : case LT_EXPR:
6605 32 : {
6606 32 : tree _q50 = TREE_OPERAND (_p1, 0);
6607 32 : tree _q51 = TREE_OPERAND (_p1, 1);
6608 32 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6609 : {
6610 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6611 : {
6612 0 : {
6613 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6614 0 : const enum tree_code cmp1 = LT_EXPR;
6615 0 : const enum tree_code cmp2 = GT_EXPR;
6616 0 : const enum tree_code rcmp = NE_EXPR;
6617 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6618 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6619 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6620 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6621 : )
6622 : {
6623 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1549;
6624 0 : {
6625 0 : tree res_op0;
6626 0 : res_op0 = captures[0];
6627 0 : tree res_op1;
6628 0 : res_op1 = captures[1];
6629 0 : tree _r;
6630 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6631 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6632 0 : return _r;
6633 : }
6634 0 : next_after_fail1549:;
6635 : }
6636 : }
6637 : }
6638 : }
6639 : break;
6640 : }
6641 : default:;
6642 : }
6643 : break;
6644 : }
6645 6149 : case GE_EXPR:
6646 6149 : {
6647 6149 : tree _q20 = TREE_OPERAND (_p0, 0);
6648 6149 : tree _q21 = TREE_OPERAND (_p0, 1);
6649 6149 : switch (TREE_CODE (_p1))
6650 : {
6651 76 : case GE_EXPR:
6652 76 : {
6653 76 : tree _q50 = TREE_OPERAND (_p1, 0);
6654 76 : tree _q51 = TREE_OPERAND (_p1, 1);
6655 76 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6656 : {
6657 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6658 : {
6659 0 : {
6660 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6661 0 : const enum tree_code cmp1 = LE_EXPR;
6662 0 : const enum tree_code cmp2 = GE_EXPR;
6663 0 : const enum tree_code rcmp = NE_EXPR;
6664 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6665 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6666 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6667 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6668 : )
6669 : {
6670 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1550;
6671 0 : {
6672 0 : tree res_op0;
6673 0 : res_op0 = captures[0];
6674 0 : tree res_op1;
6675 0 : res_op1 = captures[1];
6676 0 : tree _r;
6677 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6678 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6679 0 : return _r;
6680 : }
6681 0 : next_after_fail1550:;
6682 : }
6683 : }
6684 0 : {
6685 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6686 0 : const enum tree_code cmp1 = LE_EXPR;
6687 0 : const enum tree_code cmp2 = GE_EXPR;
6688 0 : const enum tree_code rcmp = NE_EXPR;
6689 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6690 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6691 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6692 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6693 : )
6694 : {
6695 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1551;
6696 0 : {
6697 0 : tree res_op0;
6698 0 : res_op0 = captures[0];
6699 0 : tree res_op1;
6700 0 : res_op1 = captures[1];
6701 0 : tree _r;
6702 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6703 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6704 0 : return _r;
6705 : }
6706 0 : next_after_fail1551:;
6707 : }
6708 : }
6709 : }
6710 : }
6711 : break;
6712 : }
6713 52 : case EQ_EXPR:
6714 52 : {
6715 52 : tree _q50 = TREE_OPERAND (_p1, 0);
6716 52 : tree _q51 = TREE_OPERAND (_p1, 1);
6717 52 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6718 : {
6719 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6720 : {
6721 0 : {
6722 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6723 0 : const enum tree_code cmp1 = LE_EXPR;
6724 0 : const enum tree_code cmp2 = EQ_EXPR;
6725 0 : const enum tree_code rcmp = LT_EXPR;
6726 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6727 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6728 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6729 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6730 : )
6731 : {
6732 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1552;
6733 0 : {
6734 0 : tree res_op0;
6735 0 : res_op0 = captures[0];
6736 0 : tree res_op1;
6737 0 : res_op1 = captures[1];
6738 0 : tree _r;
6739 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6740 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6741 0 : return _r;
6742 : }
6743 0 : next_after_fail1552:;
6744 : }
6745 : }
6746 : }
6747 : }
6748 : break;
6749 : }
6750 11 : case NE_EXPR:
6751 11 : {
6752 11 : tree _q50 = TREE_OPERAND (_p1, 0);
6753 11 : tree _q51 = TREE_OPERAND (_p1, 1);
6754 11 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6755 : {
6756 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6757 : {
6758 0 : {
6759 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6760 0 : const enum tree_code cmp1 = LE_EXPR;
6761 0 : const enum tree_code cmp2 = NE_EXPR;
6762 0 : const enum tree_code rcmp = GE_EXPR;
6763 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6764 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6765 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6766 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6767 : )
6768 : {
6769 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1553;
6770 0 : {
6771 0 : tree res_op0;
6772 0 : res_op0 = captures[0];
6773 0 : tree res_op1;
6774 0 : res_op1 = captures[1];
6775 0 : tree _r;
6776 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6777 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6778 0 : return _r;
6779 : }
6780 0 : next_after_fail1553:;
6781 : }
6782 : }
6783 : }
6784 : }
6785 : break;
6786 : }
6787 16 : case LE_EXPR:
6788 16 : {
6789 16 : tree _q50 = TREE_OPERAND (_p1, 0);
6790 16 : tree _q51 = TREE_OPERAND (_p1, 1);
6791 16 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6792 : {
6793 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6794 : {
6795 0 : {
6796 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6797 0 : const enum tree_code cmp1 = LE_EXPR;
6798 0 : const enum tree_code cmp2 = GE_EXPR;
6799 0 : const enum tree_code rcmp = NE_EXPR;
6800 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6801 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6802 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6803 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6804 : )
6805 : {
6806 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1554;
6807 0 : {
6808 0 : tree res_op0;
6809 0 : res_op0 = captures[0];
6810 0 : tree res_op1;
6811 0 : res_op1 = captures[1];
6812 0 : tree _r;
6813 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6814 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6815 0 : return _r;
6816 : }
6817 0 : next_after_fail1554:;
6818 : }
6819 : }
6820 : }
6821 : }
6822 : break;
6823 : }
6824 : default:;
6825 : }
6826 : break;
6827 : }
6828 64019 : case EQ_EXPR:
6829 64019 : {
6830 64019 : tree _q20 = TREE_OPERAND (_p0, 0);
6831 64019 : tree _q21 = TREE_OPERAND (_p0, 1);
6832 64019 : switch (TREE_CODE (_p1))
6833 : {
6834 5 : case LT_EXPR:
6835 5 : {
6836 5 : tree _q50 = TREE_OPERAND (_p1, 0);
6837 5 : tree _q51 = TREE_OPERAND (_p1, 1);
6838 5 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6839 : {
6840 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6841 : {
6842 0 : {
6843 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6844 0 : const enum tree_code cmp1 = LT_EXPR;
6845 0 : const enum tree_code cmp2 = EQ_EXPR;
6846 0 : const enum tree_code rcmp = LE_EXPR;
6847 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6848 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6849 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6850 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6851 : )
6852 : {
6853 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1555;
6854 0 : {
6855 0 : tree res_op0;
6856 0 : res_op0 = captures[0];
6857 0 : tree res_op1;
6858 0 : res_op1 = captures[1];
6859 0 : tree _r;
6860 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6861 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6862 0 : return _r;
6863 : }
6864 0 : next_after_fail1555:;
6865 : }
6866 : }
6867 : }
6868 : }
6869 : break;
6870 : }
6871 42 : case LE_EXPR:
6872 42 : {
6873 42 : tree _q50 = TREE_OPERAND (_p1, 0);
6874 42 : tree _q51 = TREE_OPERAND (_p1, 1);
6875 42 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6876 : {
6877 7 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6878 : {
6879 0 : {
6880 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6881 0 : const enum tree_code cmp1 = LE_EXPR;
6882 0 : const enum tree_code cmp2 = EQ_EXPR;
6883 0 : const enum tree_code rcmp = LT_EXPR;
6884 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6885 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6886 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6887 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6888 : )
6889 : {
6890 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1556;
6891 0 : {
6892 0 : tree res_op0;
6893 0 : res_op0 = captures[0];
6894 0 : tree res_op1;
6895 0 : res_op1 = captures[1];
6896 0 : tree _r;
6897 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6898 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6899 0 : return _r;
6900 : }
6901 0 : next_after_fail1556:;
6902 : }
6903 : }
6904 : }
6905 : }
6906 : break;
6907 : }
6908 7 : case GT_EXPR:
6909 7 : {
6910 7 : tree _q50 = TREE_OPERAND (_p1, 0);
6911 7 : tree _q51 = TREE_OPERAND (_p1, 1);
6912 7 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6913 : {
6914 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6915 : {
6916 0 : {
6917 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6918 0 : const enum tree_code cmp1 = LT_EXPR;
6919 0 : const enum tree_code cmp2 = EQ_EXPR;
6920 0 : const enum tree_code rcmp = LE_EXPR;
6921 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6922 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6923 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6924 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6925 : )
6926 : {
6927 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1557;
6928 0 : {
6929 0 : tree res_op0;
6930 0 : res_op0 = captures[0];
6931 0 : tree res_op1;
6932 0 : res_op1 = captures[1];
6933 0 : tree _r;
6934 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6935 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6936 0 : return _r;
6937 : }
6938 0 : next_after_fail1557:;
6939 : }
6940 : }
6941 : }
6942 : }
6943 : break;
6944 : }
6945 14 : case GE_EXPR:
6946 14 : {
6947 14 : tree _q50 = TREE_OPERAND (_p1, 0);
6948 14 : tree _q51 = TREE_OPERAND (_p1, 1);
6949 14 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6950 : {
6951 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6952 : {
6953 0 : {
6954 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6955 0 : const enum tree_code cmp1 = LE_EXPR;
6956 0 : const enum tree_code cmp2 = EQ_EXPR;
6957 0 : const enum tree_code rcmp = LT_EXPR;
6958 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6959 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6960 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6961 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6962 : )
6963 : {
6964 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1558;
6965 0 : {
6966 0 : tree res_op0;
6967 0 : res_op0 = captures[0];
6968 0 : tree res_op1;
6969 0 : res_op1 = captures[1];
6970 0 : tree _r;
6971 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6972 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
6973 0 : return _r;
6974 : }
6975 0 : next_after_fail1558:;
6976 : }
6977 : }
6978 : }
6979 : }
6980 : break;
6981 : }
6982 : default:;
6983 : }
6984 : break;
6985 : }
6986 69492 : case NE_EXPR:
6987 69492 : {
6988 69492 : tree _q20 = TREE_OPERAND (_p0, 0);
6989 69492 : tree _q21 = TREE_OPERAND (_p0, 1);
6990 69492 : switch (TREE_CODE (_p1))
6991 : {
6992 7 : case LT_EXPR:
6993 7 : {
6994 7 : tree _q50 = TREE_OPERAND (_p1, 0);
6995 7 : tree _q51 = TREE_OPERAND (_p1, 1);
6996 7 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6997 : {
6998 7 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6999 : {
7000 0 : {
7001 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7002 0 : const enum tree_code cmp1 = LT_EXPR;
7003 0 : const enum tree_code cmp2 = NE_EXPR;
7004 0 : const enum tree_code rcmp = GT_EXPR;
7005 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
7006 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
7007 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
7008 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
7009 : )
7010 : {
7011 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1559;
7012 0 : {
7013 0 : tree res_op0;
7014 0 : res_op0 = captures[0];
7015 0 : tree res_op1;
7016 0 : res_op1 = captures[1];
7017 0 : tree _r;
7018 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
7019 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
7020 0 : return _r;
7021 : }
7022 0 : next_after_fail1559:;
7023 : }
7024 : }
7025 : }
7026 : }
7027 : break;
7028 : }
7029 302 : case LE_EXPR:
7030 302 : {
7031 302 : tree _q50 = TREE_OPERAND (_p1, 0);
7032 302 : tree _q51 = TREE_OPERAND (_p1, 1);
7033 302 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7034 : {
7035 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7036 : {
7037 0 : {
7038 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7039 0 : const enum tree_code cmp1 = LE_EXPR;
7040 0 : const enum tree_code cmp2 = NE_EXPR;
7041 0 : const enum tree_code rcmp = GE_EXPR;
7042 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
7043 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
7044 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
7045 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
7046 : )
7047 : {
7048 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1560;
7049 0 : {
7050 0 : tree res_op0;
7051 0 : res_op0 = captures[0];
7052 0 : tree res_op1;
7053 0 : res_op1 = captures[1];
7054 0 : tree _r;
7055 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
7056 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
7057 0 : return _r;
7058 : }
7059 0 : next_after_fail1560:;
7060 : }
7061 : }
7062 : }
7063 : }
7064 : break;
7065 : }
7066 323 : case GT_EXPR:
7067 323 : {
7068 323 : tree _q50 = TREE_OPERAND (_p1, 0);
7069 323 : tree _q51 = TREE_OPERAND (_p1, 1);
7070 323 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7071 : {
7072 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7073 : {
7074 0 : {
7075 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7076 0 : const enum tree_code cmp1 = LT_EXPR;
7077 0 : const enum tree_code cmp2 = NE_EXPR;
7078 0 : const enum tree_code rcmp = GT_EXPR;
7079 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
7080 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
7081 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
7082 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
7083 : )
7084 : {
7085 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1561;
7086 0 : {
7087 0 : tree res_op0;
7088 0 : res_op0 = captures[0];
7089 0 : tree res_op1;
7090 0 : res_op1 = captures[1];
7091 0 : tree _r;
7092 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
7093 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
7094 0 : return _r;
7095 : }
7096 0 : next_after_fail1561:;
7097 : }
7098 : }
7099 : }
7100 : }
7101 : break;
7102 : }
7103 2 : case GE_EXPR:
7104 2 : {
7105 2 : tree _q50 = TREE_OPERAND (_p1, 0);
7106 2 : tree _q51 = TREE_OPERAND (_p1, 1);
7107 2 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7108 : {
7109 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7110 : {
7111 0 : {
7112 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7113 0 : const enum tree_code cmp1 = LE_EXPR;
7114 0 : const enum tree_code cmp2 = NE_EXPR;
7115 0 : const enum tree_code rcmp = GE_EXPR;
7116 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
7117 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
7118 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
7119 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
7120 : )
7121 : {
7122 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1562;
7123 0 : {
7124 0 : tree res_op0;
7125 0 : res_op0 = captures[0];
7126 0 : tree res_op1;
7127 0 : res_op1 = captures[1];
7128 0 : tree _r;
7129 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
7130 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
7131 0 : return _r;
7132 : }
7133 0 : next_after_fail1562:;
7134 : }
7135 : }
7136 : }
7137 : }
7138 : break;
7139 : }
7140 : default:;
7141 : }
7142 : break;
7143 : }
7144 8526 : case MIN_EXPR:
7145 8526 : {
7146 8526 : tree _q20 = TREE_OPERAND (_p0, 0);
7147 8526 : tree _q21 = TREE_OPERAND (_p0, 1);
7148 8526 : switch (TREE_CODE (_p1))
7149 : {
7150 0 : case MAX_EXPR:
7151 0 : {
7152 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7153 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7154 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7155 : {
7156 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7157 : {
7158 0 : {
7159 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7160 0 : if (!HONOR_NANS (captures[0])
7161 : )
7162 : {
7163 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1563;
7164 0 : {
7165 0 : tree res_op0;
7166 0 : res_op0 = captures[0];
7167 0 : tree res_op1;
7168 0 : res_op1 = captures[1];
7169 0 : tree _r;
7170 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
7171 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
7172 0 : return _r;
7173 : }
7174 0 : next_after_fail1563:;
7175 : }
7176 : }
7177 : }
7178 : }
7179 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7180 : {
7181 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7182 : {
7183 0 : {
7184 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
7185 0 : if (!HONOR_NANS (captures[0])
7186 : )
7187 : {
7188 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1564;
7189 0 : {
7190 0 : tree res_op0;
7191 0 : res_op0 = captures[0];
7192 0 : tree res_op1;
7193 0 : res_op1 = captures[1];
7194 0 : tree _r;
7195 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
7196 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
7197 0 : return _r;
7198 : }
7199 0 : next_after_fail1564:;
7200 : }
7201 : }
7202 : }
7203 : }
7204 : break;
7205 : }
7206 8526 : default:;
7207 : }
7208 8526 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
7209 : {
7210 0 : {
7211 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7212 0 : tree res = generic_simplify_233 (loc, type, _p0, _p1, captures, MIN_EXPR, NE_EXPR, GT_EXPR);
7213 0 : if (res) return res;
7214 : }
7215 : }
7216 8526 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
7217 : {
7218 616 : {
7219 616 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
7220 616 : tree res = generic_simplify_233 (loc, type, _p0, _p1, captures, MIN_EXPR, NE_EXPR, GT_EXPR);
7221 616 : if (res) return res;
7222 : }
7223 : }
7224 : break;
7225 : }
7226 7834 : case MAX_EXPR:
7227 7834 : {
7228 7834 : tree _q20 = TREE_OPERAND (_p0, 0);
7229 7834 : tree _q21 = TREE_OPERAND (_p0, 1);
7230 7834 : switch (TREE_CODE (_p1))
7231 : {
7232 0 : case MIN_EXPR:
7233 0 : {
7234 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7235 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7236 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7237 : {
7238 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7239 : {
7240 0 : {
7241 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7242 0 : if (!HONOR_NANS (captures[0])
7243 : )
7244 : {
7245 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1565;
7246 0 : {
7247 0 : tree res_op0;
7248 0 : res_op0 = captures[0];
7249 0 : tree res_op1;
7250 0 : res_op1 = captures[1];
7251 0 : tree _r;
7252 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
7253 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
7254 0 : return _r;
7255 : }
7256 0 : next_after_fail1565:;
7257 : }
7258 : }
7259 : }
7260 : }
7261 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7262 : {
7263 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7264 : {
7265 0 : {
7266 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7267 0 : if (!HONOR_NANS (captures[0])
7268 : )
7269 : {
7270 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1566;
7271 0 : {
7272 0 : tree res_op0;
7273 0 : res_op0 = captures[0];
7274 0 : tree res_op1;
7275 0 : res_op1 = captures[1];
7276 0 : tree _r;
7277 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
7278 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
7279 0 : return _r;
7280 : }
7281 0 : next_after_fail1566:;
7282 : }
7283 : }
7284 : }
7285 : }
7286 : break;
7287 : }
7288 7834 : default:;
7289 : }
7290 7834 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
7291 : {
7292 0 : {
7293 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7294 0 : tree res = generic_simplify_233 (loc, type, _p0, _p1, captures, MAX_EXPR, NE_EXPR, LT_EXPR);
7295 0 : if (res) return res;
7296 : }
7297 : }
7298 7834 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
7299 : {
7300 425 : {
7301 425 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
7302 425 : tree res = generic_simplify_233 (loc, type, _p0, _p1, captures, MAX_EXPR, NE_EXPR, LT_EXPR);
7303 425 : if (res) return res;
7304 : }
7305 : }
7306 : break;
7307 : }
7308 38658116 : default:;
7309 : }
7310 38658116 : if (tree_with_possible_nonzero_bits (_p0))
7311 : {
7312 15810142 : if (tree_with_known_nonzero_bits (_p1))
7313 : {
7314 14292834 : {
7315 14292834 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
7316 14292834 : tree res = generic_simplify_231 (loc, type, _p0, _p1, captures, NE_EXPR);
7317 14292834 : if (res) return res;
7318 : }
7319 : }
7320 : }
7321 38599613 : if (tree_with_known_nonzero_bits (_p0))
7322 : {
7323 11592112 : if (tree_with_possible_nonzero_bits (_p1))
7324 : {
7325 11543323 : {
7326 11543323 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _p0 };
7327 11543323 : tree res = generic_simplify_231 (loc, type, _p0, _p1, captures, NE_EXPR);
7328 11543323 : if (res) return res;
7329 : }
7330 : }
7331 : }
7332 38598218 : switch (TREE_CODE (_p1))
7333 : {
7334 144 : case MIN_EXPR:
7335 144 : {
7336 144 : tree _q30 = TREE_OPERAND (_p1, 0);
7337 144 : tree _q31 = TREE_OPERAND (_p1, 1);
7338 144 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
7339 : {
7340 0 : {
7341 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
7342 0 : tree res = generic_simplify_233 (loc, type, _p0, _p1, captures, MIN_EXPR, NE_EXPR, GT_EXPR);
7343 0 : if (res) return res;
7344 : }
7345 : }
7346 144 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
7347 : {
7348 0 : {
7349 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
7350 0 : tree res = generic_simplify_233 (loc, type, _p0, _p1, captures, MIN_EXPR, NE_EXPR, GT_EXPR);
7351 0 : if (res) return res;
7352 : }
7353 : }
7354 : break;
7355 : }
7356 1631 : case MAX_EXPR:
7357 1631 : {
7358 1631 : tree _q30 = TREE_OPERAND (_p1, 0);
7359 1631 : tree _q31 = TREE_OPERAND (_p1, 1);
7360 1631 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
7361 : {
7362 0 : {
7363 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
7364 0 : tree res = generic_simplify_233 (loc, type, _p0, _p1, captures, MAX_EXPR, NE_EXPR, LT_EXPR);
7365 0 : if (res) return res;
7366 : }
7367 : }
7368 1631 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
7369 : {
7370 0 : {
7371 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
7372 0 : tree res = generic_simplify_233 (loc, type, _p0, _p1, captures, MAX_EXPR, NE_EXPR, LT_EXPR);
7373 0 : if (res) return res;
7374 : }
7375 : }
7376 : break;
7377 : }
7378 38598218 : default:;
7379 : }
7380 38598218 : switch (TREE_CODE (_p0))
7381 : {
7382 8526 : case MIN_EXPR:
7383 8526 : {
7384 8526 : tree _q20 = TREE_OPERAND (_p0, 0);
7385 8526 : tree _q21 = TREE_OPERAND (_p0, 1);
7386 8526 : switch (TREE_CODE (_q21))
7387 : {
7388 674 : case INTEGER_CST:
7389 674 : {
7390 674 : switch (TREE_CODE (_p1))
7391 : {
7392 0 : case INTEGER_CST:
7393 0 : {
7394 0 : {
7395 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7396 0 : tree res = generic_simplify_234 (loc, type, _p0, _p1, captures, NE_EXPR);
7397 0 : if (res) return res;
7398 : }
7399 0 : break;
7400 : }
7401 : default:;
7402 : }
7403 : break;
7404 : }
7405 : default:;
7406 : }
7407 : break;
7408 : }
7409 7705 : case MAX_EXPR:
7410 7705 : {
7411 7705 : tree _q20 = TREE_OPERAND (_p0, 0);
7412 7705 : tree _q21 = TREE_OPERAND (_p0, 1);
7413 7705 : switch (TREE_CODE (_q21))
7414 : {
7415 6665 : case INTEGER_CST:
7416 6665 : {
7417 6665 : switch (TREE_CODE (_p1))
7418 : {
7419 684 : case INTEGER_CST:
7420 684 : {
7421 684 : {
7422 684 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7423 684 : tree res = generic_simplify_235 (loc, type, _p0, _p1, captures, NE_EXPR);
7424 684 : if (res) return res;
7425 : }
7426 0 : break;
7427 : }
7428 : default:;
7429 : }
7430 : break;
7431 : }
7432 7021 : default:;
7433 : }
7434 7021 : if (tree_expr_nonnegative_p (_q20))
7435 : {
7436 276 : if (tree_expr_nonnegative_p (_q21))
7437 : {
7438 264 : if (integer_zerop (_p1))
7439 : {
7440 0 : {
7441 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7442 0 : tree res = generic_simplify_236 (loc, type, _p0, _p1, captures, NE_EXPR);
7443 0 : if (res) return res;
7444 : }
7445 : }
7446 : }
7447 : }
7448 : break;
7449 : }
7450 1306575 : case BIT_AND_EXPR:
7451 1306575 : {
7452 1306575 : tree _q20 = TREE_OPERAND (_p0, 0);
7453 1306575 : tree _q21 = TREE_OPERAND (_p0, 1);
7454 1306575 : switch (TREE_CODE (_q20))
7455 : {
7456 3538 : case LSHIFT_EXPR:
7457 3538 : {
7458 3538 : tree _q30 = TREE_OPERAND (_q20, 0);
7459 3538 : tree _q31 = TREE_OPERAND (_q20, 1);
7460 3538 : if (integer_pow2p (_q30))
7461 : {
7462 3518 : if (integer_pow2p (_q21))
7463 : {
7464 5 : if (integer_zerop (_p1))
7465 : {
7466 5 : {
7467 5 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q21 };
7468 5 : tree res = generic_simplify_237 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
7469 5 : if (res) return res;
7470 : }
7471 : }
7472 : }
7473 : }
7474 3533 : switch (TREE_CODE (_q31))
7475 : {
7476 13 : case INTEGER_CST:
7477 13 : {
7478 13 : switch (TREE_CODE (_q21))
7479 : {
7480 13 : case INTEGER_CST:
7481 13 : {
7482 13 : switch (TREE_CODE (_p1))
7483 : {
7484 13 : case INTEGER_CST:
7485 13 : {
7486 13 : {
7487 13 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1 };
7488 13 : tree res = generic_simplify_238 (loc, type, _p0, _p1, captures, NE_EXPR);
7489 13 : if (res) return res;
7490 : }
7491 0 : break;
7492 : }
7493 : default:;
7494 : }
7495 : break;
7496 : }
7497 : default:;
7498 : }
7499 : break;
7500 : }
7501 3520 : default:;
7502 : }
7503 3520 : if (integer_onep (_q30))
7504 : {
7505 3512 : if (integer_pow2p (_q21))
7506 : {
7507 0 : if (integer_zerop (_p1))
7508 : {
7509 0 : {
7510 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q21 };
7511 0 : tree res = generic_simplify_239 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
7512 0 : if (res) return res;
7513 : }
7514 : }
7515 : }
7516 : }
7517 : break;
7518 : }
7519 4769 : case RSHIFT_EXPR:
7520 4769 : {
7521 4769 : tree _q30 = TREE_OPERAND (_q20, 0);
7522 4769 : tree _q31 = TREE_OPERAND (_q20, 1);
7523 4769 : if (integer_pow2p (_q30))
7524 : {
7525 33 : if (integer_pow2p (_q21))
7526 : {
7527 1 : if (integer_zerop (_p1))
7528 : {
7529 1 : {
7530 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q21 };
7531 1 : tree res = generic_simplify_240 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
7532 1 : if (res) return res;
7533 : }
7534 : }
7535 : }
7536 : }
7537 4768 : switch (TREE_CODE (_q31))
7538 : {
7539 329 : case INTEGER_CST:
7540 329 : {
7541 329 : switch (TREE_CODE (_q21))
7542 : {
7543 305 : case INTEGER_CST:
7544 305 : {
7545 305 : switch (TREE_CODE (_p1))
7546 : {
7547 280 : case INTEGER_CST:
7548 280 : {
7549 280 : {
7550 280 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1 };
7551 280 : tree res = generic_simplify_241 (loc, type, _p0, _p1, captures, NE_EXPR);
7552 280 : if (res) return res;
7553 : }
7554 14 : break;
7555 : }
7556 : default:;
7557 : }
7558 : break;
7559 : }
7560 : default:;
7561 : }
7562 : break;
7563 : }
7564 : default:;
7565 : }
7566 : break;
7567 : }
7568 1306290 : default:;
7569 : }
7570 1306290 : {
7571 1306290 : tree _q20_pops[1];
7572 1306290 : if (tree_nop_convert (_q20, _q20_pops))
7573 : {
7574 142205 : tree _q30 = _q20_pops[0];
7575 142205 : switch (TREE_CODE (_q30))
7576 : {
7577 37190 : case LSHIFT_EXPR:
7578 37190 : {
7579 37190 : tree _q40 = TREE_OPERAND (_q30, 0);
7580 37190 : tree _q41 = TREE_OPERAND (_q30, 1);
7581 37190 : if (integer_onep (_q40))
7582 : {
7583 37190 : if (integer_pow2p (_q21))
7584 : {
7585 0 : if (integer_zerop (_p1))
7586 : {
7587 0 : {
7588 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q41, _q21 };
7589 0 : tree res = generic_simplify_239 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
7590 0 : if (res) return res;
7591 : }
7592 : }
7593 : }
7594 : }
7595 : break;
7596 : }
7597 : default:;
7598 : }
7599 : }
7600 : }
7601 1306290 : break;
7602 : }
7603 5089 : case LSHIFT_EXPR:
7604 5089 : {
7605 5089 : tree _q20 = TREE_OPERAND (_p0, 0);
7606 5089 : tree _q21 = TREE_OPERAND (_p0, 1);
7607 5089 : switch (TREE_CODE (_q20))
7608 : {
7609 536 : case INTEGER_CST:
7610 536 : {
7611 536 : switch (TREE_CODE (_p1))
7612 : {
7613 159 : case INTEGER_CST:
7614 159 : {
7615 159 : {
7616 159 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7617 159 : tree res = generic_simplify_242 (loc, type, _p0, _p1, captures, NE_EXPR);
7618 159 : if (res) return res;
7619 : }
7620 88 : break;
7621 : }
7622 : default:;
7623 : }
7624 : break;
7625 : }
7626 : default:;
7627 : }
7628 : break;
7629 : }
7630 393 : case LROTATE_EXPR:
7631 393 : {
7632 393 : tree _q20 = TREE_OPERAND (_p0, 0);
7633 393 : tree _q21 = TREE_OPERAND (_p0, 1);
7634 393 : switch (TREE_CODE (_p1))
7635 : {
7636 0 : case LROTATE_EXPR:
7637 0 : {
7638 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7639 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7640 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7641 : {
7642 0 : {
7643 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
7644 0 : tree res = generic_simplify_243 (loc, type, _p0, _p1, captures, LROTATE_EXPR, RROTATE_EXPR, NE_EXPR);
7645 0 : if (res) return res;
7646 : }
7647 : }
7648 : break;
7649 : }
7650 393 : default:;
7651 : }
7652 393 : switch (TREE_CODE (_q21))
7653 : {
7654 112 : case INTEGER_CST:
7655 112 : {
7656 112 : switch (TREE_CODE (_p1))
7657 : {
7658 112 : case INTEGER_CST:
7659 112 : {
7660 112 : {
7661 112 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7662 112 : tree res = generic_simplify_244 (loc, type, _p0, _p1, captures, LROTATE_EXPR, RROTATE_EXPR, NE_EXPR);
7663 112 : if (res) return res;
7664 : }
7665 0 : break;
7666 : }
7667 : default:;
7668 : }
7669 : break;
7670 : }
7671 281 : default:;
7672 : }
7673 281 : switch (TREE_CODE (_p1))
7674 : {
7675 193 : case INTEGER_CST:
7676 193 : {
7677 193 : {
7678 193 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7679 193 : tree res = generic_simplify_245 (loc, type, _p0, _p1, captures, LROTATE_EXPR, RROTATE_EXPR, NE_EXPR);
7680 193 : if (res) return res;
7681 : }
7682 193 : break;
7683 : }
7684 : default:;
7685 : }
7686 : break;
7687 : }
7688 439 : case RROTATE_EXPR:
7689 439 : {
7690 439 : tree _q20 = TREE_OPERAND (_p0, 0);
7691 439 : tree _q21 = TREE_OPERAND (_p0, 1);
7692 439 : switch (TREE_CODE (_p1))
7693 : {
7694 0 : case RROTATE_EXPR:
7695 0 : {
7696 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7697 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7698 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7699 : {
7700 0 : {
7701 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
7702 0 : tree res = generic_simplify_243 (loc, type, _p0, _p1, captures, RROTATE_EXPR, LROTATE_EXPR, NE_EXPR);
7703 0 : if (res) return res;
7704 : }
7705 : }
7706 : break;
7707 : }
7708 439 : default:;
7709 : }
7710 439 : switch (TREE_CODE (_q21))
7711 : {
7712 233 : case INTEGER_CST:
7713 233 : {
7714 233 : switch (TREE_CODE (_p1))
7715 : {
7716 12 : case INTEGER_CST:
7717 12 : {
7718 12 : {
7719 12 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7720 12 : tree res = generic_simplify_244 (loc, type, _p0, _p1, captures, RROTATE_EXPR, LROTATE_EXPR, NE_EXPR);
7721 12 : if (res) return res;
7722 : }
7723 0 : break;
7724 : }
7725 : default:;
7726 : }
7727 : break;
7728 : }
7729 427 : default:;
7730 : }
7731 427 : switch (TREE_CODE (_p1))
7732 : {
7733 190 : case INTEGER_CST:
7734 190 : {
7735 190 : {
7736 190 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7737 190 : tree res = generic_simplify_245 (loc, type, _p0, _p1, captures, RROTATE_EXPR, LROTATE_EXPR, NE_EXPR);
7738 190 : if (res) return res;
7739 : }
7740 190 : break;
7741 : }
7742 : default:;
7743 : }
7744 : break;
7745 : }
7746 352 : case VEC_COND_EXPR:
7747 352 : {
7748 352 : tree _q20 = TREE_OPERAND (_p0, 0);
7749 352 : tree _q21 = TREE_OPERAND (_p0, 1);
7750 352 : tree _q22 = TREE_OPERAND (_p0, 2);
7751 352 : switch (TREE_CODE (_p1))
7752 : {
7753 16 : case VEC_COND_EXPR:
7754 16 : {
7755 16 : tree _q60 = TREE_OPERAND (_p1, 0);
7756 16 : tree _q61 = TREE_OPERAND (_p1, 1);
7757 16 : tree _q62 = TREE_OPERAND (_p1, 2);
7758 16 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7759 : {
7760 0 : {
7761 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
7762 0 : if (VECTOR_TYPE_P (type)
7763 0 : && (TREE_CODE_CLASS (NE_EXPR) != tcc_comparison
7764 0 : || types_match (type, TREE_TYPE (captures[2]))
7765 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
7766 : || (optimize_vectors_before_lowering_p ()
7767 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
7768 : )
7769 : {
7770 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1567;
7771 0 : {
7772 0 : tree res_op0;
7773 0 : res_op0 = captures[1];
7774 0 : tree res_op1;
7775 0 : {
7776 0 : tree _o1[2], _r1;
7777 0 : _o1[0] = captures[2];
7778 0 : _o1[1] = captures[5];
7779 0 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7780 0 : if (EXPR_P (_r1))
7781 0 : goto next_after_fail1567;
7782 0 : res_op1 = _r1;
7783 : }
7784 0 : tree res_op2;
7785 0 : {
7786 0 : tree _o1[2], _r1;
7787 0 : _o1[0] = captures[3];
7788 0 : _o1[1] = captures[6];
7789 0 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7790 0 : if (EXPR_P (_r1))
7791 0 : goto next_after_fail1567;
7792 0 : res_op2 = _r1;
7793 : }
7794 0 : tree _r;
7795 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7796 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 898, __FILE__, __LINE__, true);
7797 0 : return _r;
7798 : }
7799 0 : next_after_fail1567:;
7800 : }
7801 : }
7802 : }
7803 : break;
7804 : }
7805 352 : default:;
7806 : }
7807 352 : {
7808 352 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
7809 352 : if (VECTOR_TYPE_P (type)
7810 352 : && (TREE_CODE_CLASS (NE_EXPR) != tcc_comparison
7811 350 : || types_match (type, TREE_TYPE (captures[2]))
7812 350 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
7813 : || (optimize_vectors_before_lowering_p ()
7814 27 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
7815 : )
7816 : {
7817 350 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1568;
7818 350 : {
7819 350 : if (! tree_invariant_p (captures[4])) goto next_after_fail1568;
7820 88 : tree res_op0;
7821 88 : res_op0 = captures[1];
7822 88 : tree res_op1;
7823 88 : {
7824 88 : tree _o1[2], _r1;
7825 88 : _o1[0] = captures[2];
7826 88 : _o1[1] = unshare_expr (captures[4]);
7827 88 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7828 88 : if (EXPR_P (_r1))
7829 16 : goto next_after_fail1568;
7830 72 : res_op1 = _r1;
7831 : }
7832 72 : tree res_op2;
7833 72 : {
7834 72 : tree _o1[2], _r1;
7835 72 : _o1[0] = captures[3];
7836 72 : _o1[1] = captures[4];
7837 72 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7838 72 : if (EXPR_P (_r1))
7839 0 : goto next_after_fail1568;
7840 72 : res_op2 = _r1;
7841 : }
7842 72 : tree _r;
7843 72 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7844 72 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 900, __FILE__, __LINE__, true);
7845 72 : return _r;
7846 : }
7847 280 : next_after_fail1568:;
7848 : }
7849 : }
7850 280 : break;
7851 : }
7852 2480767 : case CALL_EXPR:
7853 2480767 : switch (get_call_combined_fn (_p0))
7854 : {
7855 0 : case CFN_BUILT_IN_BITREVERSE128:
7856 0 : if (call_expr_nargs (_p0) == 1)
7857 : {
7858 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7859 0 : switch (TREE_CODE (_p1))
7860 : {
7861 0 : case INTEGER_CST:
7862 0 : {
7863 0 : {
7864 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7865 0 : tree res = generic_simplify_248 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE128);
7866 0 : if (res) return res;
7867 : }
7868 0 : break;
7869 : }
7870 0 : case CALL_EXPR:
7871 0 : switch (get_call_combined_fn (_p1))
7872 : {
7873 0 : case CFN_BUILT_IN_BITREVERSE128:
7874 0 : if (call_expr_nargs (_p1) == 1)
7875 : {
7876 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7877 0 : {
7878 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7879 0 : tree res = generic_simplify_247 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE128);
7880 0 : if (res) return res;
7881 : }
7882 : }
7883 : break;
7884 : default:;
7885 : }
7886 : break;
7887 : default:;
7888 : }
7889 : }
7890 : break;
7891 0 : case CFN_BUILT_IN_BITREVERSE16:
7892 0 : if (call_expr_nargs (_p0) == 1)
7893 : {
7894 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7895 0 : switch (TREE_CODE (_p1))
7896 : {
7897 0 : case INTEGER_CST:
7898 0 : {
7899 0 : {
7900 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7901 0 : tree res = generic_simplify_248 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE16);
7902 0 : if (res) return res;
7903 : }
7904 0 : break;
7905 : }
7906 0 : case CALL_EXPR:
7907 0 : switch (get_call_combined_fn (_p1))
7908 : {
7909 0 : case CFN_BUILT_IN_BITREVERSE16:
7910 0 : if (call_expr_nargs (_p1) == 1)
7911 : {
7912 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7913 0 : {
7914 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7915 0 : tree res = generic_simplify_247 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE16);
7916 0 : if (res) return res;
7917 : }
7918 : }
7919 : break;
7920 : default:;
7921 : }
7922 : break;
7923 : default:;
7924 : }
7925 : }
7926 : break;
7927 0 : case CFN_BUILT_IN_BITREVERSE32:
7928 0 : if (call_expr_nargs (_p0) == 1)
7929 : {
7930 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7931 0 : switch (TREE_CODE (_p1))
7932 : {
7933 0 : case INTEGER_CST:
7934 0 : {
7935 0 : {
7936 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7937 0 : tree res = generic_simplify_248 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE32);
7938 0 : if (res) return res;
7939 : }
7940 0 : break;
7941 : }
7942 0 : case CALL_EXPR:
7943 0 : switch (get_call_combined_fn (_p1))
7944 : {
7945 0 : case CFN_BUILT_IN_BITREVERSE32:
7946 0 : if (call_expr_nargs (_p1) == 1)
7947 : {
7948 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7949 0 : {
7950 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7951 0 : tree res = generic_simplify_247 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE32);
7952 0 : if (res) return res;
7953 : }
7954 : }
7955 : break;
7956 : default:;
7957 : }
7958 : break;
7959 : default:;
7960 : }
7961 : }
7962 : break;
7963 0 : case CFN_BUILT_IN_BITREVERSE64:
7964 0 : if (call_expr_nargs (_p0) == 1)
7965 : {
7966 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7967 0 : switch (TREE_CODE (_p1))
7968 : {
7969 0 : case INTEGER_CST:
7970 0 : {
7971 0 : {
7972 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7973 0 : tree res = generic_simplify_248 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE64);
7974 0 : if (res) return res;
7975 : }
7976 0 : break;
7977 : }
7978 0 : case CALL_EXPR:
7979 0 : switch (get_call_combined_fn (_p1))
7980 : {
7981 0 : case CFN_BUILT_IN_BITREVERSE64:
7982 0 : if (call_expr_nargs (_p1) == 1)
7983 : {
7984 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7985 0 : {
7986 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7987 0 : tree res = generic_simplify_247 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE64);
7988 0 : if (res) return res;
7989 : }
7990 : }
7991 : break;
7992 : default:;
7993 : }
7994 : break;
7995 : default:;
7996 : }
7997 : }
7998 : break;
7999 0 : case CFN_BITREVERSE:
8000 0 : if (call_expr_nargs (_p0) == 1)
8001 : {
8002 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8003 0 : switch (TREE_CODE (_p1))
8004 : {
8005 0 : case INTEGER_CST:
8006 0 : {
8007 0 : {
8008 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
8009 0 : tree res = generic_simplify_248 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BITREVERSE);
8010 0 : if (res) return res;
8011 : }
8012 0 : break;
8013 : }
8014 0 : case CALL_EXPR:
8015 0 : switch (get_call_combined_fn (_p1))
8016 : {
8017 0 : case CFN_BITREVERSE:
8018 0 : if (call_expr_nargs (_p1) == 1)
8019 : {
8020 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8021 0 : {
8022 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
8023 0 : tree res = generic_simplify_247 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BITREVERSE);
8024 0 : if (res) return res;
8025 : }
8026 : }
8027 : break;
8028 : default:;
8029 : }
8030 : break;
8031 : default:;
8032 : }
8033 : }
8034 : break;
8035 0 : case CFN_BSWAP:
8036 0 : if (call_expr_nargs (_p0) == 1)
8037 : {
8038 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8039 0 : switch (TREE_CODE (_p1))
8040 : {
8041 0 : case INTEGER_CST:
8042 0 : {
8043 0 : {
8044 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
8045 0 : tree res = generic_simplify_248 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BSWAP);
8046 0 : if (res) return res;
8047 : }
8048 0 : break;
8049 : }
8050 0 : case CALL_EXPR:
8051 0 : switch (get_call_combined_fn (_p1))
8052 : {
8053 0 : case CFN_BSWAP:
8054 0 : if (call_expr_nargs (_p1) == 1)
8055 : {
8056 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8057 0 : {
8058 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
8059 0 : tree res = generic_simplify_247 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BSWAP);
8060 0 : if (res) return res;
8061 : }
8062 : }
8063 : break;
8064 : default:;
8065 : }
8066 : break;
8067 : default:;
8068 : }
8069 : }
8070 : break;
8071 2 : case CFN_BUILT_IN_BSWAP128:
8072 2 : if (call_expr_nargs (_p0) == 1)
8073 : {
8074 2 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8075 2 : switch (TREE_CODE (_p1))
8076 : {
8077 0 : case INTEGER_CST:
8078 0 : {
8079 0 : {
8080 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
8081 0 : tree res = generic_simplify_248 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP128);
8082 0 : if (res) return res;
8083 : }
8084 0 : break;
8085 : }
8086 1 : case CALL_EXPR:
8087 1 : switch (get_call_combined_fn (_p1))
8088 : {
8089 0 : case CFN_BUILT_IN_BSWAP128:
8090 0 : if (call_expr_nargs (_p1) == 1)
8091 : {
8092 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8093 0 : {
8094 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
8095 0 : tree res = generic_simplify_247 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP128);
8096 0 : if (res) return res;
8097 : }
8098 : }
8099 : break;
8100 : default:;
8101 : }
8102 : break;
8103 : default:;
8104 : }
8105 : }
8106 : break;
8107 0 : case CFN_BUILT_IN_BITREVERSE8:
8108 0 : if (call_expr_nargs (_p0) == 1)
8109 : {
8110 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8111 0 : switch (TREE_CODE (_p1))
8112 : {
8113 0 : case INTEGER_CST:
8114 0 : {
8115 0 : {
8116 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
8117 0 : tree res = generic_simplify_248 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE8);
8118 0 : if (res) return res;
8119 : }
8120 0 : break;
8121 : }
8122 0 : case CALL_EXPR:
8123 0 : switch (get_call_combined_fn (_p1))
8124 : {
8125 0 : case CFN_BUILT_IN_BITREVERSE8:
8126 0 : if (call_expr_nargs (_p1) == 1)
8127 : {
8128 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8129 0 : {
8130 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
8131 0 : tree res = generic_simplify_247 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE8);
8132 0 : if (res) return res;
8133 : }
8134 : }
8135 : break;
8136 : default:;
8137 : }
8138 : break;
8139 : default:;
8140 : }
8141 : }
8142 : break;
8143 11 : case CFN_BUILT_IN_BSWAP16:
8144 11 : if (call_expr_nargs (_p0) == 1)
8145 : {
8146 11 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8147 11 : switch (TREE_CODE (_p1))
8148 : {
8149 9 : case INTEGER_CST:
8150 9 : {
8151 9 : {
8152 9 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
8153 9 : tree res = generic_simplify_248 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP16);
8154 9 : if (res) return res;
8155 : }
8156 9 : break;
8157 : }
8158 1 : case CALL_EXPR:
8159 1 : switch (get_call_combined_fn (_p1))
8160 : {
8161 1 : case CFN_BUILT_IN_BSWAP16:
8162 1 : if (call_expr_nargs (_p1) == 1)
8163 : {
8164 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8165 1 : {
8166 1 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
8167 1 : tree res = generic_simplify_247 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP16);
8168 1 : if (res) return res;
8169 : }
8170 : }
8171 : break;
8172 : default:;
8173 : }
8174 : break;
8175 : default:;
8176 : }
8177 : }
8178 : break;
8179 7 : case CFN_BUILT_IN_BSWAP32:
8180 7 : if (call_expr_nargs (_p0) == 1)
8181 : {
8182 7 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8183 7 : switch (TREE_CODE (_p1))
8184 : {
8185 3 : case INTEGER_CST:
8186 3 : {
8187 3 : {
8188 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
8189 3 : tree res = generic_simplify_248 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP32);
8190 3 : if (res) return res;
8191 : }
8192 3 : break;
8193 : }
8194 3 : case CALL_EXPR:
8195 3 : switch (get_call_combined_fn (_p1))
8196 : {
8197 3 : case CFN_BUILT_IN_BSWAP32:
8198 3 : if (call_expr_nargs (_p1) == 1)
8199 : {
8200 3 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8201 3 : {
8202 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
8203 3 : tree res = generic_simplify_247 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP32);
8204 3 : if (res) return res;
8205 : }
8206 : }
8207 : break;
8208 : default:;
8209 : }
8210 : break;
8211 : default:;
8212 : }
8213 : }
8214 : break;
8215 7 : case CFN_BUILT_IN_BSWAP64:
8216 7 : if (call_expr_nargs (_p0) == 1)
8217 : {
8218 7 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8219 7 : switch (TREE_CODE (_p1))
8220 : {
8221 3 : case INTEGER_CST:
8222 3 : {
8223 3 : {
8224 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
8225 3 : tree res = generic_simplify_248 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP64);
8226 3 : if (res) return res;
8227 : }
8228 3 : break;
8229 : }
8230 3 : case CALL_EXPR:
8231 3 : switch (get_call_combined_fn (_p1))
8232 : {
8233 3 : case CFN_BUILT_IN_BSWAP64:
8234 3 : if (call_expr_nargs (_p1) == 1)
8235 : {
8236 3 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8237 3 : {
8238 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
8239 3 : tree res = generic_simplify_247 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP64);
8240 3 : if (res) return res;
8241 : }
8242 : }
8243 : break;
8244 : default:;
8245 : }
8246 : break;
8247 : default:;
8248 : }
8249 : }
8250 : break;
8251 : default:;
8252 : }
8253 : break;
8254 38596975 : default:;
8255 : }
8256 38596975 : switch (TREE_CODE (_p1))
8257 : {
8258 40 : case VEC_COND_EXPR:
8259 40 : {
8260 40 : tree _q30 = TREE_OPERAND (_p1, 0);
8261 40 : tree _q31 = TREE_OPERAND (_p1, 1);
8262 40 : tree _q32 = TREE_OPERAND (_p1, 2);
8263 40 : {
8264 40 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
8265 40 : if (VECTOR_TYPE_P (type)
8266 40 : && (TREE_CODE_CLASS (NE_EXPR) != tcc_comparison
8267 40 : || types_match (type, TREE_TYPE (captures[3]))
8268 40 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
8269 : || (optimize_vectors_before_lowering_p ()
8270 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
8271 : )
8272 : {
8273 40 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1569;
8274 40 : {
8275 40 : if (! tree_invariant_p (captures[0])) goto next_after_fail1569;
8276 0 : tree res_op0;
8277 0 : res_op0 = captures[2];
8278 0 : tree res_op1;
8279 0 : {
8280 0 : tree _o1[2], _r1;
8281 0 : _o1[0] = unshare_expr (captures[0]);
8282 0 : _o1[1] = captures[3];
8283 0 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
8284 0 : if (EXPR_P (_r1))
8285 0 : goto next_after_fail1569;
8286 0 : res_op1 = _r1;
8287 : }
8288 0 : tree res_op2;
8289 0 : {
8290 0 : tree _o1[2], _r1;
8291 0 : _o1[0] = captures[0];
8292 0 : _o1[1] = captures[4];
8293 0 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
8294 0 : if (EXPR_P (_r1))
8295 0 : goto next_after_fail1569;
8296 0 : res_op2 = _r1;
8297 : }
8298 0 : tree _r;
8299 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8300 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 901, __FILE__, __LINE__, true);
8301 0 : return _r;
8302 : }
8303 40 : next_after_fail1569:;
8304 : }
8305 : }
8306 40 : break;
8307 : }
8308 38596975 : default:;
8309 : }
8310 38596975 : switch (TREE_CODE (_p0))
8311 : {
8312 97958 : case COND_EXPR:
8313 97958 : {
8314 97958 : tree _q20 = TREE_OPERAND (_p0, 0);
8315 97958 : tree _q21 = TREE_OPERAND (_p0, 1);
8316 97958 : tree _q22 = TREE_OPERAND (_p0, 2);
8317 97958 : switch (TREE_CODE (_p1))
8318 : {
8319 276 : case COND_EXPR:
8320 276 : {
8321 276 : tree _q60 = TREE_OPERAND (_p1, 0);
8322 276 : tree _q61 = TREE_OPERAND (_p1, 1);
8323 276 : tree _q62 = TREE_OPERAND (_p1, 2);
8324 276 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
8325 : {
8326 72 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
8327 : {
8328 72 : {
8329 72 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
8330 72 : const enum tree_code eqne = NE_EXPR;
8331 72 : if (!HONOR_NANS (captures[1])
8332 56 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
8333 49 : && types_match (type, TREE_TYPE (captures[0]))
8334 49 : && expr_no_side_effects_p (captures[1])
8335 114 : && expr_no_side_effects_p (captures[2])
8336 : )
8337 : {
8338 42 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1570;
8339 42 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1570;
8340 42 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1570;
8341 42 : {
8342 42 : tree res_op0;
8343 42 : {
8344 42 : tree _o1[2], _r1;
8345 42 : {
8346 42 : tree _o2[2], _r2;
8347 42 : _o2[0] = captures[0];
8348 42 : _o2[1] = captures[3];
8349 42 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8350 42 : _o1[0] = _r2;
8351 : }
8352 42 : {
8353 42 : tree _o2[2], _r2;
8354 42 : _o2[0] = captures[1];
8355 42 : _o2[1] = captures[2];
8356 42 : _r2 = fold_build2_loc (loc, NE_EXPR, type, _o2[0], _o2[1]);
8357 42 : _o1[1] = _r2;
8358 : }
8359 42 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8360 42 : res_op0 = _r1;
8361 : }
8362 42 : tree res_op1;
8363 42 : res_op1 = constant_boolean_node (eqne == NE_EXPR, type);
8364 42 : tree res_op2;
8365 42 : res_op2 = constant_boolean_node (eqne != NE_EXPR, type);
8366 42 : tree _r;
8367 42 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
8368 42 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 988, __FILE__, __LINE__, true);
8369 42 : return _r;
8370 : }
8371 30 : next_after_fail1570:;
8372 : }
8373 : }
8374 : }
8375 : }
8376 234 : if ((_q61 == _q22 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q22, 0) && types_match (_q61, _q22)))
8377 : {
8378 0 : if ((_q62 == _q21 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q21, 0) && types_match (_q62, _q21)))
8379 : {
8380 0 : {
8381 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
8382 0 : const enum tree_code eqne = NE_EXPR;
8383 0 : if (!HONOR_NANS (captures[1])
8384 0 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
8385 0 : && types_match (type, TREE_TYPE (captures[0]))
8386 0 : && expr_no_side_effects_p (captures[1])
8387 0 : && expr_no_side_effects_p (captures[2])
8388 : )
8389 : {
8390 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1571;
8391 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1571;
8392 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1571;
8393 0 : {
8394 0 : tree res_op0;
8395 0 : {
8396 0 : tree _o1[2], _r1;
8397 0 : {
8398 0 : tree _o2[2], _r2;
8399 0 : _o2[0] = captures[0];
8400 0 : _o2[1] = captures[3];
8401 0 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8402 0 : _o1[0] = _r2;
8403 : }
8404 0 : {
8405 0 : tree _o2[2], _r2;
8406 0 : _o2[0] = captures[1];
8407 0 : _o2[1] = captures[2];
8408 0 : _r2 = fold_build2_loc (loc, EQ_EXPR, type, _o2[0], _o2[1]);
8409 0 : _o1[1] = _r2;
8410 : }
8411 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8412 0 : res_op0 = _r1;
8413 : }
8414 0 : tree res_op1;
8415 0 : res_op1 = constant_boolean_node (eqne != NE_EXPR, type);
8416 0 : tree res_op2;
8417 0 : res_op2 = constant_boolean_node (eqne == NE_EXPR, type);
8418 0 : tree _r;
8419 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
8420 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 989, __FILE__, __LINE__, true);
8421 0 : return _r;
8422 : }
8423 0 : next_after_fail1571:;
8424 : }
8425 : }
8426 : }
8427 : }
8428 : break;
8429 : }
8430 : default:;
8431 : }
8432 : break;
8433 : }
8434 280 : case VEC_COND_EXPR:
8435 280 : {
8436 280 : tree _q20 = TREE_OPERAND (_p0, 0);
8437 280 : tree _q21 = TREE_OPERAND (_p0, 1);
8438 280 : tree _q22 = TREE_OPERAND (_p0, 2);
8439 280 : switch (TREE_CODE (_p1))
8440 : {
8441 16 : case VEC_COND_EXPR:
8442 16 : {
8443 16 : tree _q60 = TREE_OPERAND (_p1, 0);
8444 16 : tree _q61 = TREE_OPERAND (_p1, 1);
8445 16 : tree _q62 = TREE_OPERAND (_p1, 2);
8446 16 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
8447 : {
8448 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
8449 : {
8450 0 : {
8451 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
8452 0 : const enum tree_code eqne = NE_EXPR;
8453 0 : if (!HONOR_NANS (captures[1])
8454 0 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
8455 0 : && types_match (type, TREE_TYPE (captures[0]))
8456 0 : && expr_no_side_effects_p (captures[1])
8457 0 : && expr_no_side_effects_p (captures[2])
8458 : )
8459 : {
8460 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1572;
8461 0 : {
8462 0 : tree res_op0;
8463 0 : {
8464 0 : tree _o1[2], _r1;
8465 0 : {
8466 0 : tree _o2[2], _r2;
8467 0 : _o2[0] = captures[0];
8468 0 : _o2[1] = captures[3];
8469 0 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8470 0 : _o1[0] = _r2;
8471 : }
8472 0 : {
8473 0 : tree _o2[2], _r2;
8474 0 : _o2[0] = captures[1];
8475 0 : _o2[1] = captures[2];
8476 0 : _r2 = fold_build2_loc (loc, NE_EXPR, type, _o2[0], _o2[1]);
8477 0 : _o1[1] = _r2;
8478 : }
8479 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8480 0 : res_op0 = _r1;
8481 : }
8482 0 : tree res_op1;
8483 0 : res_op1 = constant_boolean_node (eqne == NE_EXPR, type);
8484 0 : tree res_op2;
8485 0 : res_op2 = constant_boolean_node (eqne != NE_EXPR, type);
8486 0 : tree _r;
8487 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8488 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 988, __FILE__, __LINE__, true);
8489 0 : return _r;
8490 : }
8491 0 : next_after_fail1572:;
8492 : }
8493 : }
8494 : }
8495 : }
8496 16 : if ((_q61 == _q22 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q22, 0) && types_match (_q61, _q22)))
8497 : {
8498 16 : if ((_q62 == _q21 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q21, 0) && types_match (_q62, _q21)))
8499 : {
8500 16 : {
8501 16 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
8502 16 : const enum tree_code eqne = NE_EXPR;
8503 16 : if (!HONOR_NANS (captures[1])
8504 0 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
8505 0 : && types_match (type, TREE_TYPE (captures[0]))
8506 0 : && expr_no_side_effects_p (captures[1])
8507 16 : && expr_no_side_effects_p (captures[2])
8508 : )
8509 : {
8510 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1573;
8511 0 : {
8512 0 : tree res_op0;
8513 0 : {
8514 0 : tree _o1[2], _r1;
8515 0 : {
8516 0 : tree _o2[2], _r2;
8517 0 : _o2[0] = captures[0];
8518 0 : _o2[1] = captures[3];
8519 0 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8520 0 : _o1[0] = _r2;
8521 : }
8522 0 : {
8523 0 : tree _o2[2], _r2;
8524 0 : _o2[0] = captures[1];
8525 0 : _o2[1] = captures[2];
8526 0 : _r2 = fold_build2_loc (loc, EQ_EXPR, type, _o2[0], _o2[1]);
8527 0 : _o1[1] = _r2;
8528 : }
8529 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8530 0 : res_op0 = _r1;
8531 : }
8532 0 : tree res_op1;
8533 0 : res_op1 = constant_boolean_node (eqne != NE_EXPR, type);
8534 0 : tree res_op2;
8535 0 : res_op2 = constant_boolean_node (eqne == NE_EXPR, type);
8536 0 : tree _r;
8537 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8538 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 989, __FILE__, __LINE__, true);
8539 0 : return _r;
8540 : }
8541 0 : next_after_fail1573:;
8542 : }
8543 : }
8544 : }
8545 : }
8546 : break;
8547 : }
8548 : default:;
8549 : }
8550 : break;
8551 : }
8552 18288 : case LT_EXPR:
8553 18288 : {
8554 18288 : tree _q20 = TREE_OPERAND (_p0, 0);
8555 18288 : tree _q21 = TREE_OPERAND (_p0, 1);
8556 18288 : if (integer_zerop (_p1))
8557 : {
8558 16764 : {
8559 16764 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8560 16764 : tree res = generic_simplify_304 (loc, type, _p0, _p1, captures, LT_EXPR, GE_EXPR, UNGE_EXPR);
8561 16764 : if (res) return res;
8562 : }
8563 : }
8564 15334 : if (integer_truep (_p1))
8565 : {
8566 563 : {
8567 563 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8568 563 : tree res = generic_simplify_305 (loc, type, _p0, _p1, captures, LT_EXPR, GE_EXPR, UNGE_EXPR);
8569 563 : if (res) return res;
8570 : }
8571 : }
8572 : break;
8573 : }
8574 12034 : case LE_EXPR:
8575 12034 : {
8576 12034 : tree _q20 = TREE_OPERAND (_p0, 0);
8577 12034 : tree _q21 = TREE_OPERAND (_p0, 1);
8578 12034 : if (integer_zerop (_p1))
8579 : {
8580 9468 : {
8581 9468 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8582 9468 : tree res = generic_simplify_304 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR, UNGT_EXPR);
8583 9468 : if (res) return res;
8584 : }
8585 : }
8586 11242 : if (integer_truep (_p1))
8587 : {
8588 473 : {
8589 473 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8590 473 : tree res = generic_simplify_305 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR, UNGT_EXPR);
8591 473 : if (res) return res;
8592 : }
8593 : }
8594 : break;
8595 : }
8596 64019 : case EQ_EXPR:
8597 64019 : {
8598 64019 : tree _q20 = TREE_OPERAND (_p0, 0);
8599 64019 : tree _q21 = TREE_OPERAND (_p0, 1);
8600 64019 : if (integer_zerop (_p1))
8601 : {
8602 36316 : {
8603 36316 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8604 36316 : tree res = generic_simplify_304 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR, NE_EXPR);
8605 36316 : if (res) return res;
8606 : }
8607 : }
8608 62898 : if (integer_truep (_p1))
8609 : {
8610 21941 : {
8611 21941 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8612 21941 : tree res = generic_simplify_305 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR, NE_EXPR);
8613 21941 : if (res) return res;
8614 : }
8615 : }
8616 : break;
8617 : }
8618 69492 : case NE_EXPR:
8619 69492 : {
8620 69492 : tree _q20 = TREE_OPERAND (_p0, 0);
8621 69492 : tree _q21 = TREE_OPERAND (_p0, 1);
8622 69492 : if (integer_zerop (_p1))
8623 : {
8624 57493 : {
8625 57493 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8626 57493 : tree res = generic_simplify_304 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR, EQ_EXPR);
8627 57493 : if (res) return res;
8628 : }
8629 : }
8630 34754 : if (integer_truep (_p1))
8631 : {
8632 141 : {
8633 141 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8634 141 : tree res = generic_simplify_305 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR, EQ_EXPR);
8635 141 : if (res) return res;
8636 : }
8637 : }
8638 : break;
8639 : }
8640 6149 : case GE_EXPR:
8641 6149 : {
8642 6149 : tree _q20 = TREE_OPERAND (_p0, 0);
8643 6149 : tree _q21 = TREE_OPERAND (_p0, 1);
8644 6149 : if (integer_zerop (_p1))
8645 : {
8646 4196 : {
8647 4196 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8648 4196 : tree res = generic_simplify_304 (loc, type, _p0, _p1, captures, GE_EXPR, LT_EXPR, UNLT_EXPR);
8649 4196 : if (res) return res;
8650 : }
8651 : }
8652 5491 : if (integer_truep (_p1))
8653 : {
8654 489 : {
8655 489 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8656 489 : tree res = generic_simplify_305 (loc, type, _p0, _p1, captures, GE_EXPR, LT_EXPR, UNLT_EXPR);
8657 489 : if (res) return res;
8658 : }
8659 : }
8660 : break;
8661 : }
8662 35985 : case GT_EXPR:
8663 35985 : {
8664 35985 : tree _q20 = TREE_OPERAND (_p0, 0);
8665 35985 : tree _q21 = TREE_OPERAND (_p0, 1);
8666 35985 : if (integer_zerop (_p1))
8667 : {
8668 33922 : {
8669 33922 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8670 33922 : tree res = generic_simplify_304 (loc, type, _p0, _p1, captures, GT_EXPR, LE_EXPR, UNLE_EXPR);
8671 33922 : if (res) return res;
8672 : }
8673 : }
8674 29940 : if (integer_truep (_p1))
8675 : {
8676 324 : {
8677 324 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8678 324 : tree res = generic_simplify_305 (loc, type, _p0, _p1, captures, GT_EXPR, LE_EXPR, UNLE_EXPR);
8679 324 : if (res) return res;
8680 : }
8681 : }
8682 : break;
8683 : }
8684 138185 : case UNORDERED_EXPR:
8685 138185 : {
8686 138185 : tree _q20 = TREE_OPERAND (_p0, 0);
8687 138185 : tree _q21 = TREE_OPERAND (_p0, 1);
8688 138185 : if (integer_zerop (_p1))
8689 : {
8690 136037 : {
8691 136037 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8692 136037 : tree res = generic_simplify_304 (loc, type, _p0, _p1, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR);
8693 136037 : if (res) return res;
8694 : }
8695 : }
8696 137795 : if (integer_truep (_p1))
8697 : {
8698 42 : {
8699 42 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8700 42 : tree res = generic_simplify_305 (loc, type, _p0, _p1, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR);
8701 42 : if (res) return res;
8702 : }
8703 : }
8704 : break;
8705 : }
8706 113 : case ORDERED_EXPR:
8707 113 : {
8708 113 : tree _q20 = TREE_OPERAND (_p0, 0);
8709 113 : tree _q21 = TREE_OPERAND (_p0, 1);
8710 113 : if (integer_zerop (_p1))
8711 : {
8712 42 : {
8713 42 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8714 42 : tree res = generic_simplify_304 (loc, type, _p0, _p1, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR);
8715 42 : if (res) return res;
8716 : }
8717 : }
8718 71 : if (integer_truep (_p1))
8719 : {
8720 0 : {
8721 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8722 0 : tree res = generic_simplify_305 (loc, type, _p0, _p1, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR);
8723 0 : if (res) return res;
8724 : }
8725 : }
8726 : break;
8727 : }
8728 213 : case UNLT_EXPR:
8729 213 : {
8730 213 : tree _q20 = TREE_OPERAND (_p0, 0);
8731 213 : tree _q21 = TREE_OPERAND (_p0, 1);
8732 213 : if (integer_zerop (_p1))
8733 : {
8734 28 : {
8735 28 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8736 28 : tree res = generic_simplify_304 (loc, type, _p0, _p1, captures, UNLT_EXPR, GE_EXPR, GE_EXPR);
8737 28 : if (res) return res;
8738 : }
8739 : }
8740 185 : if (integer_truep (_p1))
8741 : {
8742 161 : {
8743 161 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8744 161 : tree res = generic_simplify_305 (loc, type, _p0, _p1, captures, UNLT_EXPR, GE_EXPR, GE_EXPR);
8745 161 : if (res) return res;
8746 : }
8747 : }
8748 : break;
8749 : }
8750 1474 : case UNLE_EXPR:
8751 1474 : {
8752 1474 : tree _q20 = TREE_OPERAND (_p0, 0);
8753 1474 : tree _q21 = TREE_OPERAND (_p0, 1);
8754 1474 : if (integer_zerop (_p1))
8755 : {
8756 104 : {
8757 104 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8758 104 : tree res = generic_simplify_304 (loc, type, _p0, _p1, captures, UNLE_EXPR, GT_EXPR, GT_EXPR);
8759 104 : if (res) return res;
8760 : }
8761 : }
8762 1370 : if (integer_truep (_p1))
8763 : {
8764 1346 : {
8765 1346 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8766 1346 : tree res = generic_simplify_305 (loc, type, _p0, _p1, captures, UNLE_EXPR, GT_EXPR, GT_EXPR);
8767 1346 : if (res) return res;
8768 : }
8769 : }
8770 : break;
8771 : }
8772 2652 : case UNGT_EXPR:
8773 2652 : {
8774 2652 : tree _q20 = TREE_OPERAND (_p0, 0);
8775 2652 : tree _q21 = TREE_OPERAND (_p0, 1);
8776 2652 : if (integer_zerop (_p1))
8777 : {
8778 96 : {
8779 96 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8780 96 : tree res = generic_simplify_304 (loc, type, _p0, _p1, captures, UNGT_EXPR, LE_EXPR, LE_EXPR);
8781 96 : if (res) return res;
8782 : }
8783 : }
8784 2556 : if (integer_truep (_p1))
8785 : {
8786 2421 : {
8787 2421 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8788 2421 : tree res = generic_simplify_305 (loc, type, _p0, _p1, captures, UNGT_EXPR, LE_EXPR, LE_EXPR);
8789 2421 : if (res) return res;
8790 : }
8791 : }
8792 : break;
8793 : }
8794 391 : case UNGE_EXPR:
8795 391 : {
8796 391 : tree _q20 = TREE_OPERAND (_p0, 0);
8797 391 : tree _q21 = TREE_OPERAND (_p0, 1);
8798 391 : if (integer_zerop (_p1))
8799 : {
8800 16 : {
8801 16 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8802 16 : tree res = generic_simplify_304 (loc, type, _p0, _p1, captures, UNGE_EXPR, LT_EXPR, LT_EXPR);
8803 16 : if (res) return res;
8804 : }
8805 : }
8806 375 : if (integer_truep (_p1))
8807 : {
8808 211 : {
8809 211 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8810 211 : tree res = generic_simplify_305 (loc, type, _p0, _p1, captures, UNGE_EXPR, LT_EXPR, LT_EXPR);
8811 211 : if (res) return res;
8812 : }
8813 : }
8814 : break;
8815 : }
8816 161 : case UNEQ_EXPR:
8817 161 : {
8818 161 : tree _q20 = TREE_OPERAND (_p0, 0);
8819 161 : tree _q21 = TREE_OPERAND (_p0, 1);
8820 161 : if (integer_zerop (_p1))
8821 : {
8822 0 : {
8823 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8824 0 : tree res = generic_simplify_304 (loc, type, _p0, _p1, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR);
8825 0 : if (res) return res;
8826 : }
8827 : }
8828 161 : if (integer_truep (_p1))
8829 : {
8830 124 : {
8831 124 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8832 124 : tree res = generic_simplify_305 (loc, type, _p0, _p1, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR);
8833 124 : if (res) return res;
8834 : }
8835 : }
8836 : break;
8837 : }
8838 24 : case LTGT_EXPR:
8839 24 : {
8840 24 : tree _q20 = TREE_OPERAND (_p0, 0);
8841 24 : tree _q21 = TREE_OPERAND (_p0, 1);
8842 24 : if (integer_zerop (_p1))
8843 : {
8844 6 : {
8845 6 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8846 6 : tree res = generic_simplify_304 (loc, type, _p0, _p1, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR);
8847 6 : if (res) return res;
8848 : }
8849 : }
8850 24 : if (integer_truep (_p1))
8851 : {
8852 0 : {
8853 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8854 0 : tree res = generic_simplify_305 (loc, type, _p0, _p1, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR);
8855 0 : if (res) return res;
8856 : }
8857 : }
8858 : break;
8859 : }
8860 105242 : case MINUS_EXPR:
8861 105242 : {
8862 105242 : tree _q20 = TREE_OPERAND (_p0, 0);
8863 105242 : tree _q21 = TREE_OPERAND (_p0, 1);
8864 105242 : if (integer_zerop (_p1))
8865 : {
8866 36972 : {
8867 36972 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8868 36972 : tree res = generic_simplify_251 (loc, type, _p0, _p1, captures, NE_EXPR);
8869 36972 : if (res) return res;
8870 : }
8871 : }
8872 : break;
8873 : }
8874 26081 : case POINTER_DIFF_EXPR:
8875 26081 : {
8876 26081 : tree _q20 = TREE_OPERAND (_p0, 0);
8877 26081 : tree _q21 = TREE_OPERAND (_p0, 1);
8878 26081 : if (integer_zerop (_p1))
8879 : {
8880 13294 : {
8881 13294 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8882 13294 : tree res = generic_simplify_252 (loc, type, _p0, _p1, captures, NE_EXPR);
8883 13294 : if (res) return res;
8884 : }
8885 : }
8886 : break;
8887 : }
8888 97770 : case MULT_EXPR:
8889 97770 : {
8890 97770 : tree _q20 = TREE_OPERAND (_p0, 0);
8891 97770 : tree _q21 = TREE_OPERAND (_p0, 1);
8892 97770 : switch (TREE_CODE (_q21))
8893 : {
8894 78965 : case INTEGER_CST:
8895 78965 : {
8896 78965 : switch (TREE_CODE (_p1))
8897 : {
8898 51446 : case INTEGER_CST:
8899 51446 : {
8900 51446 : {
8901 51446 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8902 51446 : tree res = generic_simplify_254 (loc, type, _p0, _p1, captures, NE_EXPR);
8903 51446 : if (res) return res;
8904 : }
8905 34536 : break;
8906 : }
8907 62055 : default:;
8908 : }
8909 62055 : if (integer_zerop (_p1))
8910 : {
8911 10912 : {
8912 10912 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
8913 10912 : tree res = generic_simplify_253 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
8914 10912 : if (res) return res;
8915 : }
8916 : }
8917 : break;
8918 : }
8919 : default:;
8920 : }
8921 : break;
8922 : }
8923 38460737 : default:;
8924 : }
8925 38460737 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
8926 : {
8927 278169 : {
8928 278169 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8929 278169 : tree res = generic_simplify_306 (loc, type, _p0, _p1, captures, NE_EXPR);
8930 278169 : if (res) return res;
8931 : }
8932 : }
8933 38189130 : switch (TREE_CODE (_p0))
8934 : {
8935 8456742 : CASE_CONVERT:
8936 8456742 : {
8937 8456742 : tree _q20 = TREE_OPERAND (_p0, 0);
8938 8456742 : switch (TREE_CODE (_p1))
8939 : {
8940 4614652 : CASE_CONVERT:
8941 4614652 : {
8942 4614652 : tree _q40 = TREE_OPERAND (_p1, 0);
8943 4614652 : {
8944 4614652 : tree _q40_pops[1];
8945 4614652 : if (tree_maybe_bit_not (_q40, _q40_pops))
8946 : {
8947 0 : tree _q50 = _q40_pops[0];
8948 0 : {
8949 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
8950 0 : tree res = generic_simplify_256 (loc, type, _p0, _p1, captures, NE_EXPR);
8951 0 : if (res) return res;
8952 : }
8953 : }
8954 : }
8955 4614652 : break;
8956 : }
8957 8456742 : default:;
8958 : }
8959 8456742 : {
8960 8456742 : tree _q20_pops[1];
8961 8456742 : if (tree_maybe_bit_not (_q20, _q20_pops))
8962 : {
8963 13781 : tree _q30 = _q20_pops[0];
8964 13781 : switch (TREE_CODE (_p1))
8965 : {
8966 0 : CASE_CONVERT:
8967 0 : {
8968 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8969 0 : {
8970 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
8971 0 : tree res = generic_simplify_256 (loc, type, _p0, _p1, captures, NE_EXPR);
8972 0 : if (res) return res;
8973 : }
8974 0 : break;
8975 : }
8976 : default:;
8977 : }
8978 : }
8979 : }
8980 8456742 : break;
8981 : }
8982 38189130 : default:;
8983 : }
8984 38189130 : {
8985 38189130 : tree _p1_pops[1];
8986 38189130 : if (tree_maybe_bit_not (_p1, _p1_pops))
8987 : {
8988 26706463 : tree _q30 = _p1_pops[0];
8989 26706463 : {
8990 26706463 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
8991 26706463 : tree res = generic_simplify_256 (loc, type, _p0, _p1, captures, NE_EXPR);
8992 26706463 : if (res) return res;
8993 : }
8994 : }
8995 : }
8996 38189130 : switch (TREE_CODE (_p0))
8997 : {
8998 14168 : case BIT_NOT_EXPR:
8999 14168 : {
9000 14168 : tree _q20 = TREE_OPERAND (_p0, 0);
9001 14168 : switch (TREE_CODE (_p1))
9002 : {
9003 1 : case BIT_NOT_EXPR:
9004 1 : {
9005 1 : tree _q40 = TREE_OPERAND (_p1, 0);
9006 1 : {
9007 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _p1, _q40 };
9008 1 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, NE_EXPR);
9009 1 : if (res) return res;
9010 : }
9011 0 : break;
9012 : }
9013 14167 : default:;
9014 : }
9015 14167 : {
9016 14167 : tree _p1_pops[1];
9017 14167 : if (tree_nop_convert (_p1, _p1_pops))
9018 : {
9019 80 : tree _q40 = _p1_pops[0];
9020 80 : switch (TREE_CODE (_q40))
9021 : {
9022 0 : case BIT_NOT_EXPR:
9023 0 : {
9024 0 : tree _q50 = TREE_OPERAND (_q40, 0);
9025 0 : {
9026 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40, _q50 };
9027 0 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, NE_EXPR);
9028 0 : if (res) return res;
9029 : }
9030 0 : break;
9031 : }
9032 : default:;
9033 : }
9034 : }
9035 : }
9036 14167 : if (CONSTANT_CLASS_P (_p1))
9037 : {
9038 13023 : {
9039 13023 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9040 13023 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
9041 13023 : if (res) return res;
9042 : }
9043 : }
9044 : break;
9045 : }
9046 38176106 : default:;
9047 : }
9048 38176106 : {
9049 38176106 : tree _p0_pops[1];
9050 38176106 : if (tree_maybe_bit_not (_p0, _p0_pops))
9051 : {
9052 296318 : tree _q20 = _p0_pops[0];
9053 296318 : {
9054 296318 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _q20 };
9055 296318 : tree res = generic_simplify_256 (loc, type, _p0, _p1, captures, NE_EXPR);
9056 296318 : if (res) return res;
9057 : }
9058 : }
9059 : }
9060 38176104 : {
9061 38176104 : tree _p0_pops[1];
9062 38176104 : if (tree_nop_convert (_p0, _p0_pops))
9063 : {
9064 6176728 : tree _q20 = _p0_pops[0];
9065 6176728 : switch (TREE_CODE (_q20))
9066 : {
9067 1 : case BIT_NOT_EXPR:
9068 1 : {
9069 1 : tree _q30 = TREE_OPERAND (_q20, 0);
9070 1 : switch (TREE_CODE (_p1))
9071 : {
9072 0 : case BIT_NOT_EXPR:
9073 0 : {
9074 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9075 0 : {
9076 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _p1, _q50 };
9077 0 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, NE_EXPR);
9078 0 : if (res) return res;
9079 : }
9080 0 : break;
9081 : }
9082 1 : default:;
9083 : }
9084 1 : {
9085 1 : tree _p1_pops[1];
9086 1 : if (tree_nop_convert (_p1, _p1_pops))
9087 : {
9088 0 : tree _q50 = _p1_pops[0];
9089 0 : switch (TREE_CODE (_q50))
9090 : {
9091 0 : case BIT_NOT_EXPR:
9092 0 : {
9093 0 : tree _q60 = TREE_OPERAND (_q50, 0);
9094 0 : {
9095 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50, _q60 };
9096 0 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, NE_EXPR);
9097 0 : if (res) return res;
9098 : }
9099 0 : break;
9100 : }
9101 : default:;
9102 : }
9103 : }
9104 : }
9105 1 : if (CONSTANT_CLASS_P (_p1))
9106 : {
9107 1 : {
9108 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
9109 1 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
9110 1 : if (res) return res;
9111 : }
9112 : }
9113 : break;
9114 : }
9115 : default:;
9116 : }
9117 : }
9118 : }
9119 38176103 : switch (TREE_CODE (_p1))
9120 : {
9121 712830 : case REAL_CST:
9122 712830 : {
9123 712830 : {
9124 712830 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9125 712830 : tree res = generic_simplify_260 (loc, type, _p0, _p1, captures, NE_EXPR);
9126 712830 : if (res) return res;
9127 : }
9128 640428 : break;
9129 : }
9130 38103701 : default:;
9131 : }
9132 38103701 : switch (TREE_CODE (_p0))
9133 : {
9134 1339078 : case PLUS_EXPR:
9135 1339078 : {
9136 1339078 : tree _q20 = TREE_OPERAND (_p0, 0);
9137 1339078 : tree _q21 = TREE_OPERAND (_p0, 1);
9138 1339078 : switch (TREE_CODE (_q21))
9139 : {
9140 3849 : case REAL_CST:
9141 3849 : {
9142 3849 : switch (TREE_CODE (_p1))
9143 : {
9144 3073 : case REAL_CST:
9145 3073 : {
9146 3073 : {
9147 3073 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
9148 3073 : tree res = generic_simplify_261 (loc, type, _p0, _p1, captures, PLUS_EXPR, NE_EXPR);
9149 3073 : if (res) return res;
9150 : }
9151 3073 : break;
9152 : }
9153 : default:;
9154 : }
9155 : break;
9156 : }
9157 : default:;
9158 : }
9159 : break;
9160 : }
9161 68266 : case MINUS_EXPR:
9162 68266 : {
9163 68266 : tree _q20 = TREE_OPERAND (_p0, 0);
9164 68266 : tree _q21 = TREE_OPERAND (_p0, 1);
9165 68266 : switch (TREE_CODE (_q21))
9166 : {
9167 3215 : case REAL_CST:
9168 3215 : {
9169 3215 : switch (TREE_CODE (_p1))
9170 : {
9171 2849 : case REAL_CST:
9172 2849 : {
9173 2849 : {
9174 2849 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
9175 2849 : tree res = generic_simplify_261 (loc, type, _p0, _p1, captures, MINUS_EXPR, NE_EXPR);
9176 2849 : if (res) return res;
9177 : }
9178 2849 : break;
9179 : }
9180 : default:;
9181 : }
9182 : break;
9183 : }
9184 68266 : default:;
9185 : }
9186 68266 : switch (TREE_CODE (_q20))
9187 : {
9188 87 : case REAL_CST:
9189 87 : {
9190 87 : switch (TREE_CODE (_p1))
9191 : {
9192 44 : case REAL_CST:
9193 44 : {
9194 44 : {
9195 44 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
9196 44 : tree res = generic_simplify_262 (loc, type, _p0, _p1, captures, NE_EXPR);
9197 44 : if (res) return res;
9198 : }
9199 44 : break;
9200 : }
9201 : default:;
9202 : }
9203 : break;
9204 : }
9205 : default:;
9206 : }
9207 : break;
9208 : }
9209 10563 : case FLOAT_EXPR:
9210 10563 : {
9211 10563 : tree _q20 = TREE_OPERAND (_p0, 0);
9212 10563 : switch (TREE_CODE (_p1))
9213 : {
9214 1116 : case FLOAT_EXPR:
9215 1116 : {
9216 1116 : tree _q40 = TREE_OPERAND (_p1, 0);
9217 1116 : {
9218 1116 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
9219 1116 : tree res = generic_simplify_265 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
9220 1116 : if (res) return res;
9221 : }
9222 972 : break;
9223 : }
9224 2159 : case REAL_CST:
9225 2159 : {
9226 2159 : {
9227 2159 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
9228 2159 : tree res = generic_simplify_266 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
9229 2159 : if (res) return res;
9230 : }
9231 1909 : break;
9232 : }
9233 : default:;
9234 : }
9235 : break;
9236 : }
9237 2031 : case EXACT_DIV_EXPR:
9238 2031 : {
9239 2031 : tree _q20 = TREE_OPERAND (_p0, 0);
9240 2031 : tree _q21 = TREE_OPERAND (_p0, 1);
9241 2031 : switch (TREE_CODE (_p1))
9242 : {
9243 36 : case INTEGER_CST:
9244 36 : {
9245 36 : {
9246 36 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
9247 36 : tree res = generic_simplify_267 (loc, type, _p0, _p1, captures, NE_EXPR);
9248 36 : if (res) return res;
9249 : }
9250 0 : break;
9251 : }
9252 : default:;
9253 : }
9254 : break;
9255 : }
9256 6192 : case NEGATE_EXPR:
9257 6192 : {
9258 6192 : tree _q20 = TREE_OPERAND (_p0, 0);
9259 6192 : switch (TREE_CODE (_p1))
9260 : {
9261 4 : case NEGATE_EXPR:
9262 4 : {
9263 4 : tree _q40 = TREE_OPERAND (_p1, 0);
9264 4 : {
9265 4 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9266 4 : tree res = generic_simplify_268 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
9267 4 : if (res) return res;
9268 : }
9269 0 : break;
9270 : }
9271 6188 : default:;
9272 : }
9273 6188 : if (CONSTANT_CLASS_P (_p1))
9274 : {
9275 577 : {
9276 577 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9277 577 : tree res = generic_simplify_269 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
9278 577 : if (res) return res;
9279 : }
9280 : }
9281 : break;
9282 : }
9283 1940 : case ABS_EXPR:
9284 1940 : {
9285 1940 : tree _q20 = TREE_OPERAND (_p0, 0);
9286 1940 : if (zerop (_p1))
9287 : {
9288 72 : {
9289 72 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9290 72 : const enum tree_code eqne = NE_EXPR;
9291 72 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1574;
9292 72 : {
9293 72 : tree res_op0;
9294 72 : res_op0 = captures[0];
9295 72 : tree res_op1;
9296 72 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
9297 72 : tree _r;
9298 72 : _r = fold_build2_loc (loc, eqne, type, res_op0, res_op1);
9299 72 : if (TREE_SIDE_EFFECTS (captures[1]))
9300 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
9301 72 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 990, __FILE__, __LINE__, true);
9302 72 : return _r;
9303 : }
9304 0 : next_after_fail1574:;
9305 : }
9306 : }
9307 : break;
9308 : }
9309 1698 : case ABSU_EXPR:
9310 1698 : {
9311 1698 : tree _q20 = TREE_OPERAND (_p0, 0);
9312 1698 : if (zerop (_p1))
9313 : {
9314 65 : {
9315 65 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9316 65 : const enum tree_code eqne = NE_EXPR;
9317 65 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1575;
9318 65 : {
9319 65 : tree res_op0;
9320 65 : res_op0 = captures[0];
9321 65 : tree res_op1;
9322 65 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
9323 65 : tree _r;
9324 65 : _r = fold_build2_loc (loc, eqne, type, res_op0, res_op1);
9325 65 : if (TREE_SIDE_EFFECTS (captures[1]))
9326 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
9327 65 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 990, __FILE__, __LINE__, true);
9328 65 : return _r;
9329 : }
9330 0 : next_after_fail1575:;
9331 : }
9332 : }
9333 : break;
9334 : }
9335 8456662 : CASE_CONVERT:
9336 8456662 : {
9337 8456662 : tree _q20 = TREE_OPERAND (_p0, 0);
9338 8456662 : switch (TREE_CODE (_p1))
9339 : {
9340 4614652 : CASE_CONVERT:
9341 4614652 : {
9342 4614652 : tree _q40 = TREE_OPERAND (_p1, 0);
9343 4614652 : {
9344 4614652 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
9345 4614652 : tree res = generic_simplify_270 (loc, type, _p0, _p1, captures, NE_EXPR);
9346 4614652 : if (res) return res;
9347 : }
9348 4408518 : break;
9349 : }
9350 8250528 : default:;
9351 : }
9352 8250528 : {
9353 8250528 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
9354 8250528 : tree res = generic_simplify_271 (loc, type, _p0, _p1, captures, NE_EXPR);
9355 8250528 : if (res) return res;
9356 : }
9357 6056616 : switch (TREE_CODE (_q20))
9358 : {
9359 12 : case BIT_IOR_EXPR:
9360 12 : {
9361 12 : tree _q30 = TREE_OPERAND (_q20, 0);
9362 12 : tree _q31 = TREE_OPERAND (_q20, 1);
9363 12 : switch (TREE_CODE (_q31))
9364 : {
9365 0 : case INTEGER_CST:
9366 0 : {
9367 0 : switch (TREE_CODE (_p1))
9368 : {
9369 0 : case INTEGER_CST:
9370 0 : {
9371 0 : {
9372 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _p1 };
9373 0 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, NE_EXPR);
9374 0 : if (res) return res;
9375 : }
9376 0 : break;
9377 : }
9378 : default:;
9379 : }
9380 : break;
9381 : }
9382 : default:;
9383 : }
9384 : break;
9385 : }
9386 : default:;
9387 : }
9388 : break;
9389 : }
9390 15101354 : case SSA_NAME:
9391 15101354 : {
9392 15101354 : switch (TREE_CODE (_p1))
9393 : {
9394 305773 : case ADDR_EXPR:
9395 305773 : {
9396 305773 : {
9397 305773 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9398 305773 : tree res = generic_simplify_273 (loc, type, _p0, _p1, captures, NE_EXPR);
9399 305773 : if (res) return res;
9400 : }
9401 305771 : break;
9402 : }
9403 : default:;
9404 : }
9405 : break;
9406 : }
9407 243788 : case BIT_IOR_EXPR:
9408 243788 : {
9409 243788 : tree _q20 = TREE_OPERAND (_p0, 0);
9410 243788 : tree _q21 = TREE_OPERAND (_p0, 1);
9411 243788 : switch (TREE_CODE (_q21))
9412 : {
9413 960 : case INTEGER_CST:
9414 960 : {
9415 960 : switch (TREE_CODE (_p1))
9416 : {
9417 223 : case INTEGER_CST:
9418 223 : {
9419 223 : {
9420 223 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
9421 223 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, NE_EXPR);
9422 223 : if (res) return res;
9423 : }
9424 223 : break;
9425 : }
9426 : default:;
9427 : }
9428 : break;
9429 : }
9430 : default:;
9431 : }
9432 : break;
9433 : }
9434 31475 : case BIT_XOR_EXPR:
9435 31475 : {
9436 31475 : tree _q20 = TREE_OPERAND (_p0, 0);
9437 31475 : tree _q21 = TREE_OPERAND (_p0, 1);
9438 31475 : if (integer_zerop (_p1))
9439 : {
9440 27146 : {
9441 27146 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9442 27146 : tree res = generic_simplify_274 (loc, type, _p0, _p1, captures, NE_EXPR);
9443 27146 : if (res) return res;
9444 : }
9445 : }
9446 4329 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9447 : {
9448 1 : {
9449 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9450 1 : tree res = generic_simplify_275 (loc, type, _p0, _p1, captures, NE_EXPR);
9451 1 : if (res) return res;
9452 : }
9453 : }
9454 4328 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
9455 : {
9456 2 : {
9457 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9458 2 : tree res = generic_simplify_275 (loc, type, _p0, _p1, captures, NE_EXPR);
9459 2 : if (res) return res;
9460 : }
9461 : }
9462 : break;
9463 : }
9464 2474673 : case CALL_EXPR:
9465 2474673 : switch (get_call_combined_fn (_p0))
9466 : {
9467 42 : case CFN_BUILT_IN_SQRTF:
9468 42 : if (call_expr_nargs (_p0) == 1)
9469 : {
9470 42 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9471 42 : switch (TREE_CODE (_p1))
9472 : {
9473 0 : case REAL_CST:
9474 0 : {
9475 0 : {
9476 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9477 0 : tree res = generic_simplify_263 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, NE_EXPR);
9478 0 : if (res) return res;
9479 : }
9480 0 : break;
9481 : }
9482 42 : case CALL_EXPR:
9483 42 : switch (get_call_combined_fn (_p1))
9484 : {
9485 0 : case CFN_BUILT_IN_SQRTF:
9486 0 : if (call_expr_nargs (_p1) == 1)
9487 : {
9488 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9489 0 : {
9490 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9491 0 : tree res = generic_simplify_264 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, NE_EXPR);
9492 0 : if (res) return res;
9493 : }
9494 : }
9495 : break;
9496 : default:;
9497 : }
9498 : break;
9499 : default:;
9500 : }
9501 : }
9502 : break;
9503 42 : case CFN_BUILT_IN_SQRTL:
9504 42 : if (call_expr_nargs (_p0) == 1)
9505 : {
9506 42 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9507 42 : switch (TREE_CODE (_p1))
9508 : {
9509 0 : case REAL_CST:
9510 0 : {
9511 0 : {
9512 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9513 0 : tree res = generic_simplify_263 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, NE_EXPR);
9514 0 : if (res) return res;
9515 : }
9516 0 : break;
9517 : }
9518 42 : case CALL_EXPR:
9519 42 : switch (get_call_combined_fn (_p1))
9520 : {
9521 0 : case CFN_BUILT_IN_SQRTL:
9522 0 : if (call_expr_nargs (_p1) == 1)
9523 : {
9524 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9525 0 : {
9526 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9527 0 : tree res = generic_simplify_264 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, NE_EXPR);
9528 0 : if (res) return res;
9529 : }
9530 : }
9531 : break;
9532 : default:;
9533 : }
9534 : break;
9535 : default:;
9536 : }
9537 : }
9538 : break;
9539 46 : case CFN_BUILT_IN_SQRT:
9540 46 : if (call_expr_nargs (_p0) == 1)
9541 : {
9542 46 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9543 46 : switch (TREE_CODE (_p1))
9544 : {
9545 2 : case REAL_CST:
9546 2 : {
9547 2 : {
9548 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9549 2 : tree res = generic_simplify_263 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, NE_EXPR);
9550 2 : if (res) return res;
9551 : }
9552 2 : break;
9553 : }
9554 43 : case CALL_EXPR:
9555 43 : switch (get_call_combined_fn (_p1))
9556 : {
9557 0 : case CFN_BUILT_IN_SQRT:
9558 0 : if (call_expr_nargs (_p1) == 1)
9559 : {
9560 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9561 0 : {
9562 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9563 0 : tree res = generic_simplify_264 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, NE_EXPR);
9564 0 : if (res) return res;
9565 : }
9566 : }
9567 : break;
9568 : default:;
9569 : }
9570 : break;
9571 : default:;
9572 : }
9573 : }
9574 : break;
9575 0 : case CFN_SQRT:
9576 0 : if (call_expr_nargs (_p0) == 1)
9577 : {
9578 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9579 0 : switch (TREE_CODE (_p1))
9580 : {
9581 0 : case REAL_CST:
9582 0 : {
9583 0 : {
9584 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9585 0 : tree res = generic_simplify_263 (loc, type, _p0, _p1, captures, CFN_SQRT, NE_EXPR);
9586 0 : if (res) return res;
9587 : }
9588 0 : break;
9589 : }
9590 0 : case CALL_EXPR:
9591 0 : switch (get_call_combined_fn (_p1))
9592 : {
9593 0 : case CFN_SQRT:
9594 0 : if (call_expr_nargs (_p1) == 1)
9595 : {
9596 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9597 0 : {
9598 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9599 0 : tree res = generic_simplify_264 (loc, type, _p0, _p1, captures, CFN_SQRT, NE_EXPR);
9600 0 : if (res) return res;
9601 : }
9602 : }
9603 : break;
9604 : default:;
9605 : }
9606 : break;
9607 : default:;
9608 : }
9609 : }
9610 : break;
9611 : default:;
9612 : }
9613 : break;
9614 35675374 : default:;
9615 : }
9616 35675374 : switch (TREE_CODE (_p1))
9617 : {
9618 840 : case BIT_XOR_EXPR:
9619 840 : {
9620 840 : tree _q30 = TREE_OPERAND (_p1, 0);
9621 840 : tree _q31 = TREE_OPERAND (_p1, 1);
9622 840 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9623 : {
9624 0 : {
9625 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
9626 0 : tree res = generic_simplify_275 (loc, type, _p0, _p1, captures, NE_EXPR);
9627 0 : if (res) return res;
9628 : }
9629 : }
9630 840 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
9631 : {
9632 0 : {
9633 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
9634 0 : tree res = generic_simplify_275 (loc, type, _p0, _p1, captures, NE_EXPR);
9635 0 : if (res) return res;
9636 : }
9637 : }
9638 : break;
9639 : }
9640 35675374 : default:;
9641 : }
9642 35675374 : switch (TREE_CODE (_p0))
9643 : {
9644 1306278 : case BIT_AND_EXPR:
9645 1306278 : {
9646 1306278 : tree _q20 = TREE_OPERAND (_p0, 0);
9647 1306278 : tree _q21 = TREE_OPERAND (_p0, 1);
9648 1306278 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9649 : {
9650 179 : {
9651 179 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9652 179 : tree res = generic_simplify_276 (loc, type, _p0, _p1, captures, NE_EXPR);
9653 179 : if (res) return res;
9654 : }
9655 : }
9656 1306250 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
9657 : {
9658 4906 : {
9659 4906 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9660 4906 : tree res = generic_simplify_276 (loc, type, _p0, _p1, captures, NE_EXPR);
9661 4906 : if (res) return res;
9662 : }
9663 : }
9664 : break;
9665 : }
9666 35675346 : default:;
9667 : }
9668 35675346 : switch (TREE_CODE (_p1))
9669 : {
9670 16313 : case BIT_AND_EXPR:
9671 16313 : {
9672 16313 : tree _q30 = TREE_OPERAND (_p1, 0);
9673 16313 : tree _q31 = TREE_OPERAND (_p1, 1);
9674 16313 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9675 : {
9676 0 : {
9677 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
9678 0 : tree res = generic_simplify_276 (loc, type, _p0, _p1, captures, NE_EXPR);
9679 0 : if (res) return res;
9680 : }
9681 : }
9682 16313 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
9683 : {
9684 0 : {
9685 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
9686 0 : tree res = generic_simplify_276 (loc, type, _p0, _p1, captures, NE_EXPR);
9687 0 : if (res) return res;
9688 : }
9689 : }
9690 : break;
9691 : }
9692 35675346 : default:;
9693 : }
9694 35675346 : switch (TREE_CODE (_p0))
9695 : {
9696 6056616 : CASE_CONVERT:
9697 6056616 : {
9698 6056616 : tree _q20 = TREE_OPERAND (_p0, 0);
9699 6056616 : switch (TREE_CODE (_q20))
9700 : {
9701 0 : case BIT_AND_EXPR:
9702 0 : {
9703 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9704 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9705 0 : switch (TREE_CODE (_q30))
9706 : {
9707 0 : CASE_CONVERT:
9708 0 : {
9709 0 : tree _q40 = TREE_OPERAND (_q30, 0);
9710 0 : switch (TREE_CODE (_q31))
9711 : {
9712 0 : case INTEGER_CST:
9713 0 : {
9714 0 : switch (TREE_CODE (_p1))
9715 : {
9716 0 : CASE_CONVERT:
9717 0 : {
9718 0 : tree _q70 = TREE_OPERAND (_p1, 0);
9719 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
9720 : {
9721 0 : {
9722 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q40, _q31 };
9723 0 : tree res = generic_simplify_277 (loc, type, _p0, _p1, captures, NE_EXPR);
9724 0 : if (res) return res;
9725 : }
9726 : }
9727 : break;
9728 : }
9729 : default:;
9730 : }
9731 : break;
9732 : }
9733 : default:;
9734 : }
9735 : break;
9736 : }
9737 : default:;
9738 : }
9739 : break;
9740 : }
9741 6056616 : default:;
9742 : }
9743 6056616 : switch (TREE_CODE (_p1))
9744 : {
9745 4408518 : CASE_CONVERT:
9746 4408518 : {
9747 4408518 : tree _q40 = TREE_OPERAND (_p1, 0);
9748 4408518 : switch (TREE_CODE (_q40))
9749 : {
9750 0 : case BIT_AND_EXPR:
9751 0 : {
9752 0 : tree _q50 = TREE_OPERAND (_q40, 0);
9753 0 : tree _q51 = TREE_OPERAND (_q40, 1);
9754 0 : switch (TREE_CODE (_q50))
9755 : {
9756 0 : CASE_CONVERT:
9757 0 : {
9758 0 : tree _q60 = TREE_OPERAND (_q50, 0);
9759 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9760 : {
9761 0 : switch (TREE_CODE (_q51))
9762 : {
9763 0 : case INTEGER_CST:
9764 0 : {
9765 0 : {
9766 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q50, _q20, _q51 };
9767 0 : tree res = generic_simplify_277 (loc, type, _p0, _p1, captures, NE_EXPR);
9768 0 : if (res) return res;
9769 : }
9770 0 : break;
9771 : }
9772 : default:;
9773 : }
9774 : }
9775 : break;
9776 : }
9777 : default:;
9778 : }
9779 : break;
9780 : }
9781 : default:;
9782 : }
9783 : break;
9784 : }
9785 : default:;
9786 : }
9787 : break;
9788 : }
9789 243788 : case BIT_IOR_EXPR:
9790 243788 : {
9791 243788 : tree _q20 = TREE_OPERAND (_p0, 0);
9792 243788 : tree _q21 = TREE_OPERAND (_p0, 1);
9793 243788 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
9794 : {
9795 126 : {
9796 126 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9797 126 : tree res = generic_simplify_278 (loc, type, _p0, _p1, captures, NE_EXPR);
9798 126 : if (res) return res;
9799 : }
9800 : }
9801 243780 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9802 : {
9803 255 : {
9804 255 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9805 255 : tree res = generic_simplify_278 (loc, type, _p0, _p1, captures, NE_EXPR);
9806 255 : if (res) return res;
9807 : }
9808 : }
9809 : break;
9810 : }
9811 35675338 : default:;
9812 : }
9813 35675338 : switch (TREE_CODE (_p1))
9814 : {
9815 566 : case BIT_IOR_EXPR:
9816 566 : {
9817 566 : tree _q30 = TREE_OPERAND (_p1, 0);
9818 566 : tree _q31 = TREE_OPERAND (_p1, 1);
9819 566 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
9820 : {
9821 0 : {
9822 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
9823 0 : tree res = generic_simplify_278 (loc, type, _p0, _p1, captures, NE_EXPR);
9824 0 : if (res) return res;
9825 : }
9826 : }
9827 566 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9828 : {
9829 0 : {
9830 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _p0 };
9831 0 : tree res = generic_simplify_278 (loc, type, _p0, _p1, captures, NE_EXPR);
9832 0 : if (res) return res;
9833 : }
9834 : }
9835 : break;
9836 : }
9837 35675338 : default:;
9838 : }
9839 35675338 : switch (TREE_CODE (_p0))
9840 : {
9841 6056616 : CASE_CONVERT:
9842 6056616 : {
9843 6056616 : tree _q20 = TREE_OPERAND (_p0, 0);
9844 6056616 : switch (TREE_CODE (_q20))
9845 : {
9846 698 : case BIT_XOR_EXPR:
9847 698 : {
9848 698 : tree _q30 = TREE_OPERAND (_q20, 0);
9849 698 : tree _q31 = TREE_OPERAND (_q20, 1);
9850 698 : switch (TREE_CODE (_q31))
9851 : {
9852 0 : case INTEGER_CST:
9853 0 : {
9854 0 : switch (TREE_CODE (_p1))
9855 : {
9856 0 : case INTEGER_CST:
9857 0 : {
9858 0 : {
9859 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _p1 };
9860 0 : tree res = generic_simplify_279 (loc, type, _p0, _p1, captures, NE_EXPR);
9861 0 : if (res) return res;
9862 : }
9863 0 : break;
9864 : }
9865 : default:;
9866 : }
9867 : break;
9868 : }
9869 : default:;
9870 : }
9871 : break;
9872 : }
9873 : default:;
9874 : }
9875 : break;
9876 : }
9877 4326 : case BIT_XOR_EXPR:
9878 4326 : {
9879 4326 : tree _q20 = TREE_OPERAND (_p0, 0);
9880 4326 : tree _q21 = TREE_OPERAND (_p0, 1);
9881 4326 : switch (TREE_CODE (_q21))
9882 : {
9883 881 : case INTEGER_CST:
9884 881 : {
9885 881 : switch (TREE_CODE (_p1))
9886 : {
9887 10 : case INTEGER_CST:
9888 10 : {
9889 10 : {
9890 10 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
9891 10 : tree res = generic_simplify_279 (loc, type, _p0, _p1, captures, NE_EXPR);
9892 10 : if (res) return res;
9893 : }
9894 0 : break;
9895 : }
9896 : default:;
9897 : }
9898 : break;
9899 : }
9900 : default:;
9901 : }
9902 : break;
9903 : }
9904 35675328 : default:;
9905 : }
9906 35675328 : {
9907 35675328 : tree _p0_pops[1];
9908 35675328 : if (tree_nop_convert (_p0, _p0_pops))
9909 : {
9910 5332163 : tree _q20 = _p0_pops[0];
9911 5332163 : if (integer_zerop (_p1))
9912 : {
9913 827210 : {
9914 827210 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9915 827210 : tree res = generic_simplify_280 (loc, type, _p0, _p1, captures, NE_EXPR);
9916 827210 : if (res) return res;
9917 : }
9918 : }
9919 : }
9920 : }
9921 35219264 : if (integer_zerop (_p1))
9922 : {
9923 18921806 : {
9924 18921806 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
9925 18921806 : tree res = generic_simplify_280 (loc, type, _p0, _p1, captures, NE_EXPR);
9926 18921806 : if (res) return res;
9927 : }
9928 : }
9929 35037853 : switch (TREE_CODE (_p0))
9930 : {
9931 1306250 : case BIT_AND_EXPR:
9932 1306250 : {
9933 1306250 : tree _q20 = TREE_OPERAND (_p0, 0);
9934 1306250 : tree _q21 = TREE_OPERAND (_p0, 1);
9935 1306250 : switch (TREE_CODE (_p1))
9936 : {
9937 14902 : case BIT_AND_EXPR:
9938 14902 : {
9939 14902 : tree _q50 = TREE_OPERAND (_p1, 0);
9940 14902 : tree _q51 = TREE_OPERAND (_p1, 1);
9941 14902 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9942 : {
9943 14657 : {
9944 14657 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
9945 14657 : tree res = generic_simplify_281 (loc, type, _p0, _p1, captures, NE_EXPR);
9946 14657 : if (res) return res;
9947 : }
9948 : }
9949 245 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9950 : {
9951 2 : {
9952 2 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
9953 2 : tree res = generic_simplify_281 (loc, type, _p0, _p1, captures, NE_EXPR);
9954 2 : if (res) return res;
9955 : }
9956 : }
9957 243 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9958 : {
9959 1 : {
9960 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q50 };
9961 1 : tree res = generic_simplify_281 (loc, type, _p0, _p1, captures, NE_EXPR);
9962 1 : if (res) return res;
9963 : }
9964 : }
9965 242 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9966 : {
9967 7 : {
9968 7 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q51 };
9969 7 : tree res = generic_simplify_281 (loc, type, _p0, _p1, captures, NE_EXPR);
9970 7 : if (res) return res;
9971 : }
9972 : }
9973 : break;
9974 : }
9975 1291583 : default:;
9976 : }
9977 1291583 : if (integer_pow2p (_q21))
9978 : {
9979 666234 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
9980 : {
9981 579 : {
9982 579 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
9983 579 : tree res = generic_simplify_282 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
9984 579 : if (res) return res;
9985 : }
9986 : }
9987 : }
9988 1291008 : switch (TREE_CODE (_q20))
9989 : {
9990 200505 : CASE_CONVERT:
9991 200505 : {
9992 200505 : tree _q30 = TREE_OPERAND (_q20, 0);
9993 200505 : if (integer_pow2p (_q21))
9994 : {
9995 100681 : if (integer_zerop (_p1))
9996 : {
9997 100586 : {
9998 100586 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q21 };
9999 100586 : tree res = generic_simplify_283 (loc, type, _p0, _p1, captures, NE_EXPR, LT_EXPR);
10000 100586 : if (res) return res;
10001 : }
10002 : }
10003 : }
10004 : break;
10005 : }
10006 1285618 : default:;
10007 : }
10008 1285618 : if (integer_pow2p (_q21))
10009 : {
10010 660269 : if (integer_zerop (_p1))
10011 : {
10012 656879 : {
10013 656879 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q20, _q21 };
10014 656879 : tree res = generic_simplify_284 (loc, type, _p0, _p1, captures, NE_EXPR, LT_EXPR);
10015 656879 : if (res) return res;
10016 : }
10017 : }
10018 : }
10019 : break;
10020 : }
10021 5438 : case GE_EXPR:
10022 5438 : {
10023 5438 : tree _q20 = TREE_OPERAND (_p0, 0);
10024 5438 : tree _q21 = TREE_OPERAND (_p0, 1);
10025 5438 : if (integer_zerop (_q21))
10026 : {
10027 973 : switch (TREE_CODE (_p1))
10028 : {
10029 1 : case GE_EXPR:
10030 1 : {
10031 1 : tree _q50 = TREE_OPERAND (_p1, 0);
10032 1 : tree _q51 = TREE_OPERAND (_p1, 1);
10033 1 : if (integer_zerop (_q51))
10034 : {
10035 1 : {
10036 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
10037 1 : tree res = generic_simplify_285 (loc, type, _p0, _p1, captures, GE_EXPR, NE_EXPR, LT_EXPR);
10038 1 : if (res) return res;
10039 : }
10040 : }
10041 : break;
10042 : }
10043 3 : case LT_EXPR:
10044 3 : {
10045 3 : tree _q50 = TREE_OPERAND (_p1, 0);
10046 3 : tree _q51 = TREE_OPERAND (_p1, 1);
10047 3 : if (integer_zerop (_q51))
10048 : {
10049 3 : {
10050 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
10051 3 : tree res = generic_simplify_286 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR);
10052 3 : if (res) return res;
10053 : }
10054 : }
10055 : break;
10056 : }
10057 : default:;
10058 : }
10059 : }
10060 : break;
10061 : }
10062 15278 : case LT_EXPR:
10063 15278 : {
10064 15278 : tree _q20 = TREE_OPERAND (_p0, 0);
10065 15278 : tree _q21 = TREE_OPERAND (_p0, 1);
10066 15278 : if (integer_zerop (_q21))
10067 : {
10068 8620 : switch (TREE_CODE (_p1))
10069 : {
10070 79 : case LT_EXPR:
10071 79 : {
10072 79 : tree _q50 = TREE_OPERAND (_p1, 0);
10073 79 : tree _q51 = TREE_OPERAND (_p1, 1);
10074 79 : if (integer_zerop (_q51))
10075 : {
10076 79 : {
10077 79 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
10078 79 : tree res = generic_simplify_285 (loc, type, _p0, _p1, captures, LT_EXPR, NE_EXPR, LT_EXPR);
10079 79 : if (res) return res;
10080 : }
10081 : }
10082 : break;
10083 : }
10084 17 : case GE_EXPR:
10085 17 : {
10086 17 : tree _q50 = TREE_OPERAND (_p1, 0);
10087 17 : tree _q51 = TREE_OPERAND (_p1, 1);
10088 17 : if (integer_zerop (_q51))
10089 : {
10090 17 : {
10091 17 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
10092 17 : tree res = generic_simplify_287 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR);
10093 17 : if (res) return res;
10094 : }
10095 : }
10096 : break;
10097 : }
10098 : default:;
10099 : }
10100 : }
10101 : break;
10102 : }
10103 243780 : case BIT_IOR_EXPR:
10104 243780 : {
10105 243780 : tree _q20 = TREE_OPERAND (_p0, 0);
10106 243780 : tree _q21 = TREE_OPERAND (_p0, 1);
10107 243780 : switch (TREE_CODE (_q21))
10108 : {
10109 291 : CASE_CONVERT:
10110 291 : {
10111 291 : tree _q40 = TREE_OPERAND (_q21, 0);
10112 291 : switch (TREE_CODE (_q40))
10113 : {
10114 0 : case NE_EXPR:
10115 0 : {
10116 0 : tree _q50 = TREE_OPERAND (_q40, 0);
10117 0 : tree _q51 = TREE_OPERAND (_q40, 1);
10118 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10119 : {
10120 0 : if (integer_zerop (_q51))
10121 : {
10122 0 : if (integer_zerop (_p1))
10123 : {
10124 0 : {
10125 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10126 0 : tree res = generic_simplify_288 (loc, type, _p0, _p1, captures, NE_EXPR);
10127 0 : if (res) return res;
10128 : }
10129 : }
10130 : }
10131 : }
10132 : break;
10133 : }
10134 : default:;
10135 : }
10136 : break;
10137 : }
10138 243780 : default:;
10139 : }
10140 243780 : switch (TREE_CODE (_q20))
10141 : {
10142 800 : CASE_CONVERT:
10143 800 : {
10144 800 : tree _q30 = TREE_OPERAND (_q20, 0);
10145 800 : switch (TREE_CODE (_q30))
10146 : {
10147 0 : case NE_EXPR:
10148 0 : {
10149 0 : tree _q40 = TREE_OPERAND (_q30, 0);
10150 0 : tree _q41 = TREE_OPERAND (_q30, 1);
10151 0 : if (integer_zerop (_q41))
10152 : {
10153 0 : if ((_q21 == _q40 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q40, 0) && types_match (_q21, _q40)))
10154 : {
10155 0 : if (integer_zerop (_p1))
10156 : {
10157 0 : {
10158 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q40 };
10159 0 : tree res = generic_simplify_288 (loc, type, _p0, _p1, captures, NE_EXPR);
10160 0 : if (res) return res;
10161 : }
10162 : }
10163 : }
10164 : }
10165 : break;
10166 : }
10167 : default:;
10168 : }
10169 : break;
10170 : }
10171 243780 : default:;
10172 : }
10173 243780 : switch (TREE_CODE (_q21))
10174 : {
10175 24 : case NE_EXPR:
10176 24 : {
10177 24 : tree _q40 = TREE_OPERAND (_q21, 0);
10178 24 : tree _q41 = TREE_OPERAND (_q21, 1);
10179 24 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
10180 : {
10181 0 : if (integer_zerop (_q41))
10182 : {
10183 0 : if (integer_zerop (_p1))
10184 : {
10185 0 : {
10186 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10187 0 : tree res = generic_simplify_288 (loc, type, _p0, _p1, captures, NE_EXPR);
10188 0 : if (res) return res;
10189 : }
10190 : }
10191 : }
10192 : }
10193 : break;
10194 : }
10195 243780 : default:;
10196 : }
10197 243780 : switch (TREE_CODE (_q20))
10198 : {
10199 2 : case NE_EXPR:
10200 2 : {
10201 2 : tree _q30 = TREE_OPERAND (_q20, 0);
10202 2 : tree _q31 = TREE_OPERAND (_q20, 1);
10203 2 : if (integer_zerop (_q31))
10204 : {
10205 1 : if ((_q21 == _q30 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q30, 0) && types_match (_q21, _q30)))
10206 : {
10207 0 : if (integer_zerop (_p1))
10208 : {
10209 0 : {
10210 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
10211 0 : tree res = generic_simplify_288 (loc, type, _p0, _p1, captures, NE_EXPR);
10212 0 : if (res) return res;
10213 : }
10214 : }
10215 : }
10216 : }
10217 : break;
10218 : }
10219 : default:;
10220 : }
10221 : break;
10222 : }
10223 5600552 : CASE_CONVERT:
10224 5600552 : {
10225 5600552 : tree _q20 = TREE_OPERAND (_p0, 0);
10226 5600552 : switch (TREE_CODE (_q20))
10227 : {
10228 4310201 : case ADDR_EXPR:
10229 4310201 : {
10230 4310201 : switch (TREE_CODE (_p1))
10231 : {
10232 4280310 : CASE_CONVERT:
10233 4280310 : {
10234 4280310 : tree _q40 = TREE_OPERAND (_p1, 0);
10235 4280310 : switch (TREE_CODE (_q40))
10236 : {
10237 4280310 : case ADDR_EXPR:
10238 4280310 : {
10239 4280310 : {
10240 4280310 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
10241 4280310 : tree res = generic_simplify_289 (loc, type, _p0, _p1, captures, NE_EXPR);
10242 4280310 : if (res) return res;
10243 : }
10244 33 : break;
10245 : }
10246 : default:;
10247 : }
10248 : break;
10249 : }
10250 21272 : case ADDR_EXPR:
10251 21272 : {
10252 21272 : {
10253 21272 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10254 21272 : tree res = generic_simplify_289 (loc, type, _p0, _p1, captures, NE_EXPR);
10255 21272 : if (res) return res;
10256 : }
10257 7935 : break;
10258 : }
10259 : default:;
10260 : }
10261 : break;
10262 : }
10263 : default:;
10264 : }
10265 : break;
10266 : }
10267 65964 : case ADDR_EXPR:
10268 65964 : {
10269 65964 : switch (TREE_CODE (_p1))
10270 : {
10271 383 : CASE_CONVERT:
10272 383 : {
10273 383 : tree _q30 = TREE_OPERAND (_p1, 0);
10274 383 : switch (TREE_CODE (_q30))
10275 : {
10276 383 : case ADDR_EXPR:
10277 383 : {
10278 383 : {
10279 383 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q30 };
10280 383 : tree res = generic_simplify_290 (loc, type, _p0, _p1, captures, NE_EXPR);
10281 383 : if (res) return res;
10282 : }
10283 143 : break;
10284 : }
10285 : default:;
10286 : }
10287 : break;
10288 : }
10289 56848 : case ADDR_EXPR:
10290 56848 : {
10291 56848 : {
10292 56848 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
10293 56848 : tree res = generic_simplify_290 (loc, type, _p0, _p1, captures, NE_EXPR);
10294 56848 : if (res) return res;
10295 : }
10296 4520 : break;
10297 : }
10298 : default:;
10299 : }
10300 : break;
10301 : }
10302 30656550 : default:;
10303 : }
10304 30656550 : {
10305 30656550 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
10306 30656550 : tree res = generic_simplify_291 (loc, type, _p0, _p1, captures, NE_EXPR);
10307 30656550 : if (res) return res;
10308 : }
10309 30647571 : switch (TREE_CODE (_p0))
10310 : {
10311 1306938 : CASE_CONVERT:
10312 1306938 : {
10313 1306938 : tree _q20 = TREE_OPERAND (_p0, 0);
10314 1306938 : switch (TREE_CODE (_p1))
10315 : {
10316 845467 : case INTEGER_CST:
10317 845467 : {
10318 845467 : {
10319 845467 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
10320 845467 : tree res = generic_simplify_292 (loc, type, _p0, _p1, captures, NE_EXPR);
10321 845467 : if (res) return res;
10322 : }
10323 836326 : break;
10324 : }
10325 1297797 : default:;
10326 : }
10327 1297797 : switch (TREE_CODE (_q20))
10328 : {
10329 8 : case NE_EXPR:
10330 8 : {
10331 8 : tree _q30 = TREE_OPERAND (_q20, 0);
10332 8 : tree _q31 = TREE_OPERAND (_q20, 1);
10333 8 : switch (TREE_CODE (_q31))
10334 : {
10335 8 : case INTEGER_CST:
10336 8 : {
10337 8 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
10338 : {
10339 0 : {
10340 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
10341 0 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
10342 0 : if (res) return res;
10343 : }
10344 : }
10345 : break;
10346 : }
10347 : default:;
10348 : }
10349 : break;
10350 : }
10351 0 : case EQ_EXPR:
10352 0 : {
10353 0 : tree _q30 = TREE_OPERAND (_q20, 0);
10354 0 : tree _q31 = TREE_OPERAND (_q20, 1);
10355 0 : switch (TREE_CODE (_q31))
10356 : {
10357 0 : case INTEGER_CST:
10358 0 : {
10359 0 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
10360 : {
10361 0 : {
10362 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
10363 0 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR);
10364 0 : if (res) return res;
10365 : }
10366 : }
10367 : break;
10368 : }
10369 : default:;
10370 : }
10371 : break;
10372 : }
10373 : default:;
10374 : }
10375 : break;
10376 : }
10377 30638430 : default:;
10378 : }
10379 30638430 : switch (TREE_CODE (_p1))
10380 : {
10381 524996 : CASE_CONVERT:
10382 524996 : {
10383 524996 : tree _q30 = TREE_OPERAND (_p1, 0);
10384 524996 : switch (TREE_CODE (_q30))
10385 : {
10386 0 : case NE_EXPR:
10387 0 : {
10388 0 : tree _q40 = TREE_OPERAND (_q30, 0);
10389 0 : tree _q41 = TREE_OPERAND (_q30, 1);
10390 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
10391 : {
10392 0 : switch (TREE_CODE (_q41))
10393 : {
10394 0 : case INTEGER_CST:
10395 0 : {
10396 0 : {
10397 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
10398 0 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
10399 0 : if (res) return res;
10400 : }
10401 0 : break;
10402 : }
10403 : default:;
10404 : }
10405 : }
10406 : break;
10407 : }
10408 0 : case EQ_EXPR:
10409 0 : {
10410 0 : tree _q40 = TREE_OPERAND (_q30, 0);
10411 0 : tree _q41 = TREE_OPERAND (_q30, 1);
10412 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
10413 : {
10414 0 : switch (TREE_CODE (_q41))
10415 : {
10416 0 : case INTEGER_CST:
10417 0 : {
10418 0 : {
10419 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
10420 0 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR);
10421 0 : if (res) return res;
10422 : }
10423 0 : break;
10424 : }
10425 : default:;
10426 : }
10427 : }
10428 : break;
10429 : }
10430 : default:;
10431 : }
10432 : break;
10433 : }
10434 30638430 : default:;
10435 : }
10436 30638430 : if (integer_zerop (_p1))
10437 : {
10438 18711554 : {
10439 18711554 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10440 18711554 : if (TREE_CODE (TREE_TYPE (captures[0])) == BOOLEAN_TYPE
10441 18711554 : && types_match (type, TREE_TYPE (captures[0]))
10442 : )
10443 : {
10444 3442102 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1576;
10445 3442102 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1576;
10446 3442102 : {
10447 3442102 : tree res_op0;
10448 3442102 : res_op0 = captures[0];
10449 3442102 : tree _r;
10450 3442102 : _r = non_lvalue_loc (loc, res_op0);
10451 3442102 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 995, __FILE__, __LINE__, true);
10452 3442102 : return _r;
10453 : }
10454 : next_after_fail1576:;
10455 : }
10456 : }
10457 : }
10458 27196328 : switch (TREE_CODE (_p0))
10459 : {
10460 987664 : case BIT_AND_EXPR:
10461 987664 : {
10462 987664 : tree _q20 = TREE_OPERAND (_p0, 0);
10463 987664 : tree _q21 = TREE_OPERAND (_p0, 1);
10464 987664 : switch (TREE_CODE (_q21))
10465 : {
10466 2052 : case VECTOR_CST:
10467 2052 : {
10468 2052 : if (integer_zerop (_p1))
10469 : {
10470 2052 : {
10471 2052 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
10472 2052 : const enum tree_code cmp = NE_EXPR;
10473 2052 : const enum tree_code icmp = GT_EXPR;
10474 2052 : {
10475 2052 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
10476 2052 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
10477 : )
10478 : {
10479 13 : {
10480 13 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
10481 13 : ? optab_vector : optab_default;
10482 13 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
10483 13 : if (target_supports_op_p (utype, icmp, optab)
10484 13 : || (optimize_vectors_before_lowering_p ()
10485 7 : && (!target_supports_op_p (type, cmp, optab)
10486 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
10487 : )
10488 : {
10489 7 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
10490 : )
10491 : {
10492 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1577;
10493 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1577;
10494 0 : {
10495 0 : tree res_op0;
10496 0 : res_op0 = captures[1];
10497 0 : tree res_op1;
10498 0 : res_op1 = csts;
10499 0 : tree _r;
10500 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10501 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10502 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10503 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 992, __FILE__, __LINE__, true);
10504 0 : return _r;
10505 : }
10506 2045 : next_after_fail1577:;
10507 : }
10508 : else
10509 : {
10510 7 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1578;
10511 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1578;
10512 7 : {
10513 7 : tree res_op0;
10514 7 : {
10515 7 : tree _o1[1], _r1;
10516 7 : _o1[0] = captures[1];
10517 7 : if (TREE_TYPE (_o1[0]) != utype)
10518 : {
10519 7 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, utype, _o1[0]);
10520 : }
10521 : else
10522 : _r1 = _o1[0];
10523 7 : res_op0 = _r1;
10524 : }
10525 7 : tree res_op1;
10526 7 : res_op1 = csts;
10527 7 : tree _r;
10528 7 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10529 7 : if (TREE_SIDE_EFFECTS (captures[2]))
10530 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10531 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 993, __FILE__, __LINE__, true);
10532 7 : return _r;
10533 : }
10534 2045 : next_after_fail1578:;
10535 : }
10536 : }
10537 : }
10538 : }
10539 : }
10540 : }
10541 : }
10542 : break;
10543 : }
10544 787920 : case INTEGER_CST:
10545 787920 : {
10546 787920 : if (integer_zerop (_p1))
10547 : {
10548 754072 : {
10549 754072 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
10550 754072 : const enum tree_code cmp = NE_EXPR;
10551 754072 : const enum tree_code icmp = GT_EXPR;
10552 754072 : {
10553 754072 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
10554 754072 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
10555 : )
10556 : {
10557 1272 : {
10558 1272 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
10559 1272 : ? optab_vector : optab_default;
10560 1272 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
10561 1272 : if (target_supports_op_p (utype, icmp, optab)
10562 1272 : || (optimize_vectors_before_lowering_p ()
10563 1103 : && (!target_supports_op_p (type, cmp, optab)
10564 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
10565 : )
10566 : {
10567 1103 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
10568 : )
10569 : {
10570 989 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1579;
10571 989 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1579;
10572 989 : {
10573 989 : tree res_op0;
10574 989 : res_op0 = captures[1];
10575 989 : tree res_op1;
10576 989 : res_op1 = csts;
10577 989 : tree _r;
10578 989 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10579 989 : if (TREE_SIDE_EFFECTS (captures[2]))
10580 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10581 989 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 992, __FILE__, __LINE__, true);
10582 989 : return _r;
10583 : }
10584 752969 : next_after_fail1579:;
10585 : }
10586 : else
10587 : {
10588 114 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1580;
10589 114 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1580;
10590 114 : {
10591 114 : tree res_op0;
10592 114 : {
10593 114 : tree _o1[1], _r1;
10594 114 : _o1[0] = captures[1];
10595 114 : if (TREE_TYPE (_o1[0]) != utype)
10596 : {
10597 114 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, utype, _o1[0]);
10598 : }
10599 : else
10600 : _r1 = _o1[0];
10601 114 : res_op0 = _r1;
10602 : }
10603 114 : tree res_op1;
10604 114 : res_op1 = csts;
10605 114 : tree _r;
10606 114 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10607 114 : if (TREE_SIDE_EFFECTS (captures[2]))
10608 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10609 114 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 993, __FILE__, __LINE__, true);
10610 114 : return _r;
10611 : }
10612 752969 : next_after_fail1580:;
10613 : }
10614 : }
10615 : }
10616 : }
10617 : }
10618 : }
10619 : }
10620 : break;
10621 : }
10622 986554 : default:;
10623 : }
10624 986554 : switch (TREE_CODE (_q20))
10625 : {
10626 0 : case VECTOR_CST:
10627 0 : {
10628 0 : if (integer_zerop (_p1))
10629 : {
10630 0 : {
10631 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
10632 0 : const enum tree_code cmp = NE_EXPR;
10633 0 : const enum tree_code icmp = GT_EXPR;
10634 0 : {
10635 0 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
10636 0 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
10637 : )
10638 : {
10639 0 : {
10640 0 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
10641 0 : ? optab_vector : optab_default;
10642 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
10643 0 : if (target_supports_op_p (utype, icmp, optab)
10644 0 : || (optimize_vectors_before_lowering_p ()
10645 0 : && (!target_supports_op_p (type, cmp, optab)
10646 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
10647 : )
10648 : {
10649 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
10650 : )
10651 : {
10652 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1581;
10653 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1581;
10654 0 : {
10655 0 : tree res_op0;
10656 0 : res_op0 = captures[1];
10657 0 : tree res_op1;
10658 0 : res_op1 = csts;
10659 0 : tree _r;
10660 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10661 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10662 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10663 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 992, __FILE__, __LINE__, true);
10664 0 : return _r;
10665 : }
10666 0 : next_after_fail1581:;
10667 : }
10668 : else
10669 : {
10670 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1582;
10671 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1582;
10672 0 : {
10673 0 : tree res_op0;
10674 0 : {
10675 0 : tree _o1[1], _r1;
10676 0 : _o1[0] = captures[1];
10677 0 : if (TREE_TYPE (_o1[0]) != utype)
10678 : {
10679 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, utype, _o1[0]);
10680 : }
10681 : else
10682 : _r1 = _o1[0];
10683 0 : res_op0 = _r1;
10684 : }
10685 0 : tree res_op1;
10686 0 : res_op1 = csts;
10687 0 : tree _r;
10688 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10689 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10690 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10691 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 993, __FILE__, __LINE__, true);
10692 0 : return _r;
10693 : }
10694 0 : next_after_fail1582:;
10695 : }
10696 : }
10697 : }
10698 : }
10699 : }
10700 : }
10701 : }
10702 : break;
10703 : }
10704 0 : case INTEGER_CST:
10705 0 : {
10706 0 : if (integer_zerop (_p1))
10707 : {
10708 0 : {
10709 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
10710 0 : const enum tree_code cmp = NE_EXPR;
10711 0 : const enum tree_code icmp = GT_EXPR;
10712 0 : {
10713 0 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
10714 0 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
10715 : )
10716 : {
10717 0 : {
10718 0 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
10719 0 : ? optab_vector : optab_default;
10720 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
10721 0 : if (target_supports_op_p (utype, icmp, optab)
10722 0 : || (optimize_vectors_before_lowering_p ()
10723 0 : && (!target_supports_op_p (type, cmp, optab)
10724 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
10725 : )
10726 : {
10727 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
10728 : )
10729 : {
10730 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1583;
10731 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1583;
10732 0 : {
10733 0 : tree res_op0;
10734 0 : res_op0 = captures[1];
10735 0 : tree res_op1;
10736 0 : res_op1 = csts;
10737 0 : tree _r;
10738 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10739 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10740 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10741 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 992, __FILE__, __LINE__, true);
10742 0 : return _r;
10743 : }
10744 0 : next_after_fail1583:;
10745 : }
10746 : else
10747 : {
10748 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1584;
10749 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1584;
10750 0 : {
10751 0 : tree res_op0;
10752 0 : {
10753 0 : tree _o1[1], _r1;
10754 0 : _o1[0] = captures[1];
10755 0 : if (TREE_TYPE (_o1[0]) != utype)
10756 : {
10757 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, utype, _o1[0]);
10758 : }
10759 : else
10760 : _r1 = _o1[0];
10761 0 : res_op0 = _r1;
10762 : }
10763 0 : tree res_op1;
10764 0 : res_op1 = csts;
10765 0 : tree _r;
10766 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10767 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10768 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10769 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 993, __FILE__, __LINE__, true);
10770 0 : return _r;
10771 : }
10772 0 : next_after_fail1584:;
10773 : }
10774 : }
10775 : }
10776 : }
10777 : }
10778 : }
10779 : }
10780 : break;
10781 : }
10782 : default:;
10783 : }
10784 : break;
10785 : }
10786 20823 : case RSHIFT_EXPR:
10787 20823 : {
10788 20823 : tree _q20 = TREE_OPERAND (_p0, 0);
10789 20823 : tree _q21 = TREE_OPERAND (_p0, 1);
10790 20823 : switch (TREE_CODE (_q20))
10791 : {
10792 7 : case MULT_EXPR:
10793 7 : {
10794 7 : tree _q30 = TREE_OPERAND (_q20, 0);
10795 7 : tree _q31 = TREE_OPERAND (_q20, 1);
10796 7 : switch (TREE_CODE (_q30))
10797 : {
10798 7 : CASE_CONVERT:
10799 7 : {
10800 7 : tree _q40 = TREE_OPERAND (_q30, 0);
10801 7 : switch (TREE_CODE (_q31))
10802 : {
10803 7 : CASE_CONVERT:
10804 7 : {
10805 7 : tree _q60 = TREE_OPERAND (_q31, 0);
10806 7 : switch (TREE_CODE (_q21))
10807 : {
10808 7 : case INTEGER_CST:
10809 7 : {
10810 7 : if (integer_zerop (_p1))
10811 : {
10812 7 : {
10813 7 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q30, _q40, _q60, _q21 };
10814 7 : tree res = generic_simplify_294 (loc, type, _p0, _p1, captures, NE_EXPR, GT_EXPR);
10815 7 : if (res) return res;
10816 : }
10817 : }
10818 : break;
10819 : }
10820 : default:;
10821 : }
10822 : break;
10823 : }
10824 : default:;
10825 : }
10826 : break;
10827 : }
10828 : default:;
10829 : }
10830 : break;
10831 : }
10832 : default:;
10833 : }
10834 : break;
10835 : }
10836 1339025 : case PLUS_EXPR:
10837 1339025 : {
10838 1339025 : tree _q20 = TREE_OPERAND (_p0, 0);
10839 1339025 : tree _q21 = TREE_OPERAND (_p0, 1);
10840 1339025 : switch (TREE_CODE (_q21))
10841 : {
10842 1213889 : case INTEGER_CST:
10843 1213889 : {
10844 1213889 : switch (TREE_CODE (_p1))
10845 : {
10846 719642 : case INTEGER_CST:
10847 719642 : {
10848 719642 : {
10849 719642 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
10850 719642 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, PLUS_EXPR, MINUS_EXPR, NE_EXPR);
10851 719642 : if (res) return res;
10852 : }
10853 361 : break;
10854 : }
10855 : default:;
10856 : }
10857 : break;
10858 : }
10859 : default:;
10860 : }
10861 : break;
10862 : }
10863 68266 : case MINUS_EXPR:
10864 68266 : {
10865 68266 : tree _q20 = TREE_OPERAND (_p0, 0);
10866 68266 : tree _q21 = TREE_OPERAND (_p0, 1);
10867 68266 : switch (TREE_CODE (_q21))
10868 : {
10869 193 : case INTEGER_CST:
10870 193 : {
10871 193 : switch (TREE_CODE (_p1))
10872 : {
10873 72 : case INTEGER_CST:
10874 72 : {
10875 72 : {
10876 72 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
10877 72 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, MINUS_EXPR, PLUS_EXPR, NE_EXPR);
10878 72 : if (res) return res;
10879 : }
10880 72 : break;
10881 : }
10882 : default:;
10883 : }
10884 : break;
10885 : }
10886 68266 : default:;
10887 : }
10888 68266 : switch (TREE_CODE (_q20))
10889 : {
10890 1867 : case INTEGER_CST:
10891 1867 : {
10892 1867 : switch (TREE_CODE (_p1))
10893 : {
10894 61 : case INTEGER_CST:
10895 61 : {
10896 61 : {
10897 61 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
10898 61 : tree res = generic_simplify_296 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
10899 61 : if (res) return res;
10900 : }
10901 0 : break;
10902 : }
10903 : default:;
10904 : }
10905 : break;
10906 : }
10907 : default:;
10908 : }
10909 : break;
10910 : }
10911 2471920 : case CALL_EXPR:
10912 2471920 : switch (get_call_combined_fn (_p0))
10913 : {
10914 224 : case CFN_BUILT_IN_CLZ:
10915 224 : if (call_expr_nargs (_p0) == 1)
10916 : {
10917 224 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10918 224 : switch (TREE_CODE (_p1))
10919 : {
10920 210 : case INTEGER_CST:
10921 210 : {
10922 210 : {
10923 210 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10924 210 : tree res = generic_simplify_297 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZ);
10925 210 : if (res) return res;
10926 : }
10927 135 : break;
10928 : }
10929 : default:;
10930 : }
10931 : }
10932 : break;
10933 246 : case CFN_BUILT_IN_CTZ:
10934 246 : if (call_expr_nargs (_p0) == 1)
10935 : {
10936 246 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10937 246 : switch (TREE_CODE (_p1))
10938 : {
10939 200 : case INTEGER_CST:
10940 200 : {
10941 200 : {
10942 200 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10943 200 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_CTZ);
10944 200 : if (res) return res;
10945 : }
10946 0 : break;
10947 : }
10948 : default:;
10949 : }
10950 : }
10951 : break;
10952 31 : case CFN_BUILT_IN_FFS:
10953 31 : if (call_expr_nargs (_p0) == 1)
10954 : {
10955 31 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10956 31 : switch (TREE_CODE (_p1))
10957 : {
10958 11 : case INTEGER_CST:
10959 11 : {
10960 11 : {
10961 11 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10962 11 : tree res = generic_simplify_302 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_FFS);
10963 11 : if (res) return res;
10964 : }
10965 0 : break;
10966 : }
10967 : default:;
10968 : }
10969 : }
10970 : break;
10971 0 : case CFN_REDUC_IOR:
10972 0 : if (call_expr_nargs (_p0) == 1)
10973 : {
10974 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10975 0 : if (integer_zerop (_p1))
10976 : {
10977 0 : {
10978 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10979 0 : tree res = generic_simplify_303 (loc, type, _p0, _p1, captures, NE_EXPR);
10980 0 : if (res) return res;
10981 : }
10982 : }
10983 : }
10984 : break;
10985 0 : case CFN_BUILT_IN_FFSIMAX:
10986 0 : if (call_expr_nargs (_p0) == 1)
10987 : {
10988 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10989 0 : switch (TREE_CODE (_p1))
10990 : {
10991 0 : case INTEGER_CST:
10992 0 : {
10993 0 : {
10994 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10995 0 : tree res = generic_simplify_302 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_FFSIMAX);
10996 0 : if (res) return res;
10997 : }
10998 0 : break;
10999 : }
11000 : default:;
11001 : }
11002 : }
11003 : break;
11004 13 : case CFN_BUILT_IN_POPCOUNT:
11005 13 : if (call_expr_nargs (_p0) == 1)
11006 : {
11007 13 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11008 13 : if (integer_zerop (_p1))
11009 : {
11010 1 : {
11011 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
11012 1 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNT);
11013 1 : if (res) return res;
11014 : }
11015 : }
11016 : }
11017 : break;
11018 87 : case CFN_BUILT_IN_CLZL:
11019 87 : if (call_expr_nargs (_p0) == 1)
11020 : {
11021 87 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11022 87 : switch (TREE_CODE (_p1))
11023 : {
11024 79 : case INTEGER_CST:
11025 79 : {
11026 79 : {
11027 79 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11028 79 : tree res = generic_simplify_297 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZL);
11029 79 : if (res) return res;
11030 : }
11031 43 : break;
11032 : }
11033 : default:;
11034 : }
11035 : }
11036 : break;
11037 85 : case CFN_BUILT_IN_CTZL:
11038 85 : if (call_expr_nargs (_p0) == 1)
11039 : {
11040 85 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11041 85 : switch (TREE_CODE (_p1))
11042 : {
11043 77 : case INTEGER_CST:
11044 77 : {
11045 77 : {
11046 77 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11047 77 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_CTZL);
11048 77 : if (res) return res;
11049 : }
11050 16 : break;
11051 : }
11052 : default:;
11053 : }
11054 : }
11055 : break;
11056 8 : case CFN_BUILT_IN_FFSL:
11057 8 : if (call_expr_nargs (_p0) == 1)
11058 : {
11059 8 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11060 8 : switch (TREE_CODE (_p1))
11061 : {
11062 0 : case INTEGER_CST:
11063 0 : {
11064 0 : {
11065 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11066 0 : tree res = generic_simplify_302 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_FFSL);
11067 0 : if (res) return res;
11068 : }
11069 0 : break;
11070 : }
11071 : default:;
11072 : }
11073 : }
11074 : break;
11075 11 : case CFN_BUILT_IN_POPCOUNTLL:
11076 11 : if (call_expr_nargs (_p0) == 1)
11077 : {
11078 11 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11079 11 : if (integer_zerop (_p1))
11080 : {
11081 1 : {
11082 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
11083 1 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNTLL);
11084 1 : if (res) return res;
11085 : }
11086 : }
11087 : }
11088 : break;
11089 0 : case CFN_BUILT_IN_CTZIMAX:
11090 0 : if (call_expr_nargs (_p0) == 1)
11091 : {
11092 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11093 0 : switch (TREE_CODE (_p1))
11094 : {
11095 0 : case INTEGER_CST:
11096 0 : {
11097 0 : {
11098 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11099 0 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_CTZIMAX);
11100 0 : if (res) return res;
11101 : }
11102 0 : break;
11103 : }
11104 : default:;
11105 : }
11106 : }
11107 : break;
11108 0 : case CFN_POPCOUNT:
11109 0 : if (call_expr_nargs (_p0) == 1)
11110 : {
11111 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11112 0 : if (integer_zerop (_p1))
11113 : {
11114 0 : {
11115 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
11116 0 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_POPCOUNT);
11117 0 : if (res) return res;
11118 : }
11119 : }
11120 : }
11121 : break;
11122 0 : case CFN_CLZ:
11123 0 : if (call_expr_nargs (_p0) == 1)
11124 : {
11125 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11126 0 : switch (TREE_CODE (_p1))
11127 : {
11128 0 : case INTEGER_CST:
11129 0 : {
11130 0 : {
11131 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11132 0 : tree res = generic_simplify_297 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_CLZ);
11133 0 : if (res) return res;
11134 : }
11135 0 : break;
11136 : }
11137 : default:;
11138 : }
11139 : }
11140 0 : if (call_expr_nargs (_p0) == 2)
11141 : {
11142 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11143 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
11144 0 : switch (TREE_CODE (_p1))
11145 : {
11146 0 : case INTEGER_CST:
11147 0 : {
11148 0 : {
11149 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
11150 0 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR);
11151 0 : if (res) return res;
11152 : }
11153 0 : break;
11154 : }
11155 : default:;
11156 : }
11157 : }
11158 : break;
11159 0 : case CFN_CTZ:
11160 0 : if (call_expr_nargs (_p0) == 1)
11161 : {
11162 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11163 0 : switch (TREE_CODE (_p1))
11164 : {
11165 0 : case INTEGER_CST:
11166 0 : {
11167 0 : {
11168 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11169 0 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_CTZ);
11170 0 : if (res) return res;
11171 : }
11172 0 : break;
11173 : }
11174 : default:;
11175 : }
11176 : }
11177 0 : if (call_expr_nargs (_p0) == 2)
11178 : {
11179 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11180 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
11181 0 : switch (TREE_CODE (_p1))
11182 : {
11183 0 : case INTEGER_CST:
11184 0 : {
11185 0 : {
11186 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
11187 0 : tree res = generic_simplify_300 (loc, type, _p0, _p1, captures, NE_EXPR);
11188 0 : if (res) return res;
11189 : }
11190 0 : break;
11191 : }
11192 : default:;
11193 : }
11194 : }
11195 : break;
11196 0 : case CFN_FFS:
11197 0 : if (call_expr_nargs (_p0) == 1)
11198 : {
11199 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11200 0 : switch (TREE_CODE (_p1))
11201 : {
11202 0 : case INTEGER_CST:
11203 0 : {
11204 0 : {
11205 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11206 0 : tree res = generic_simplify_302 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_FFS);
11207 0 : if (res) return res;
11208 : }
11209 0 : break;
11210 : }
11211 : default:;
11212 : }
11213 : }
11214 : break;
11215 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
11216 0 : if (call_expr_nargs (_p0) == 1)
11217 : {
11218 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11219 0 : if (integer_zerop (_p1))
11220 : {
11221 0 : {
11222 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
11223 0 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
11224 0 : if (res) return res;
11225 : }
11226 : }
11227 : }
11228 : break;
11229 0 : case CFN_BUILT_IN_CLZIMAX:
11230 0 : if (call_expr_nargs (_p0) == 1)
11231 : {
11232 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11233 0 : switch (TREE_CODE (_p1))
11234 : {
11235 0 : case INTEGER_CST:
11236 0 : {
11237 0 : {
11238 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11239 0 : tree res = generic_simplify_297 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZIMAX);
11240 0 : if (res) return res;
11241 : }
11242 0 : break;
11243 : }
11244 : default:;
11245 : }
11246 : }
11247 : break;
11248 12 : case CFN_BUILT_IN_POPCOUNTL:
11249 12 : if (call_expr_nargs (_p0) == 1)
11250 : {
11251 12 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11252 12 : if (integer_zerop (_p1))
11253 : {
11254 1 : {
11255 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
11256 1 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNTL);
11257 1 : if (res) return res;
11258 : }
11259 : }
11260 : }
11261 : break;
11262 52 : case CFN_BUILT_IN_CLZLL:
11263 52 : if (call_expr_nargs (_p0) == 1)
11264 : {
11265 52 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11266 52 : switch (TREE_CODE (_p1))
11267 : {
11268 42 : case INTEGER_CST:
11269 42 : {
11270 42 : {
11271 42 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11272 42 : tree res = generic_simplify_297 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZLL);
11273 42 : if (res) return res;
11274 : }
11275 18 : break;
11276 : }
11277 : default:;
11278 : }
11279 : }
11280 : break;
11281 74 : case CFN_BUILT_IN_CTZLL:
11282 74 : if (call_expr_nargs (_p0) == 1)
11283 : {
11284 74 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11285 74 : switch (TREE_CODE (_p1))
11286 : {
11287 64 : case INTEGER_CST:
11288 64 : {
11289 64 : {
11290 64 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11291 64 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_CTZLL);
11292 64 : if (res) return res;
11293 : }
11294 16 : break;
11295 : }
11296 : default:;
11297 : }
11298 : }
11299 : break;
11300 11 : case CFN_BUILT_IN_FFSLL:
11301 11 : if (call_expr_nargs (_p0) == 1)
11302 : {
11303 11 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11304 11 : switch (TREE_CODE (_p1))
11305 : {
11306 1 : case INTEGER_CST:
11307 1 : {
11308 1 : {
11309 1 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11310 1 : tree res = generic_simplify_302 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_FFSLL);
11311 1 : if (res) return res;
11312 : }
11313 0 : break;
11314 : }
11315 : default:;
11316 : }
11317 : }
11318 : break;
11319 : default:;
11320 : }
11321 : break;
11322 : default:;
11323 : }
11324 : return NULL_TREE;
11325 : }
11326 :
11327 : tree
11328 3444296 : generic_simplify_TRUTH_ORIF_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
11329 : {
11330 3444296 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
11331 3444296 : switch (TREE_CODE (_p0))
11332 : {
11333 365533 : case LE_EXPR:
11334 365533 : {
11335 365533 : tree _q20 = TREE_OPERAND (_p0, 0);
11336 365533 : tree _q21 = TREE_OPERAND (_p0, 1);
11337 365533 : switch (TREE_CODE (_q20))
11338 : {
11339 90 : case POINTER_PLUS_EXPR:
11340 90 : {
11341 90 : tree _q30 = TREE_OPERAND (_q20, 0);
11342 90 : tree _q31 = TREE_OPERAND (_q20, 1);
11343 90 : switch (TREE_CODE (_q31))
11344 : {
11345 2 : case INTEGER_CST:
11346 2 : {
11347 2 : switch (TREE_CODE (_p1))
11348 : {
11349 2 : case LE_EXPR:
11350 2 : {
11351 2 : tree _q70 = TREE_OPERAND (_p1, 0);
11352 2 : tree _q71 = TREE_OPERAND (_p1, 1);
11353 2 : switch (TREE_CODE (_q70))
11354 : {
11355 2 : case POINTER_PLUS_EXPR:
11356 2 : {
11357 2 : tree _q80 = TREE_OPERAND (_q70, 0);
11358 2 : tree _q81 = TREE_OPERAND (_q70, 1);
11359 2 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
11360 : {
11361 2 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
11362 : {
11363 2 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
11364 : {
11365 2 : {
11366 2 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70 };
11367 2 : const enum tree_code cmp = LE_EXPR;
11368 2 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11369 1 : && TYPE_OVERFLOW_WRAPS (sizetype)
11370 3 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11371 : )
11372 : {
11373 1 : {
11374 1 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11375 1 : offset_int rhs = off * 2;
11376 1 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11377 : )
11378 : {
11379 1 : {
11380 1 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11381 1 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11382 1 : if (cmp == LT_EXPR
11383 : )
11384 : {
11385 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1825;
11386 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1825;
11387 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1825;
11388 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1825;
11389 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1825;
11390 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1825;
11391 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1825;
11392 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1825;
11393 : {
11394 : tree res_op0;
11395 : {
11396 : tree _o1[1], _r1;
11397 : {
11398 : tree _o2[2], _r2;
11399 : _o2[0] = swap_p ? captures[6] : captures[1];
11400 : _o2[1] = swap_p ? captures[2] : captures[4];
11401 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11402 : _o1[0] = _r2;
11403 : }
11404 : if (TREE_TYPE (_o1[0]) != sizetype)
11405 : {
11406 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11407 : }
11408 : else
11409 : _r1 = _o1[0];
11410 : res_op0 = _r1;
11411 : }
11412 : tree res_op1;
11413 : res_op1 = rhs_tree;
11414 : tree _r;
11415 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11416 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 950, __FILE__, __LINE__, true);
11417 1 : return _r;
11418 : }
11419 : next_after_fail1825:;
11420 : }
11421 : else
11422 : {
11423 1 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1826;
11424 1 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1826;
11425 1 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1826;
11426 1 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1826;
11427 1 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1826;
11428 1 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1826;
11429 1 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1826;
11430 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1826;
11431 1 : {
11432 1 : tree res_op0;
11433 1 : {
11434 1 : tree _o1[1], _r1;
11435 1 : {
11436 1 : tree _o2[2], _r2;
11437 1 : {
11438 1 : tree _o3[2], _r3;
11439 1 : _o3[0] = swap_p ? captures[4] : captures[2];
11440 1 : _o3[1] = wide_int_to_tree (sizetype, off);
11441 1 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11442 1 : _o2[0] = _r3;
11443 : }
11444 1 : _o2[1] = swap_p ? captures[2] : captures[4];
11445 1 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11446 1 : _o1[0] = _r2;
11447 : }
11448 1 : if (TREE_TYPE (_o1[0]) != sizetype)
11449 : {
11450 1 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11451 : }
11452 : else
11453 : _r1 = _o1[0];
11454 1 : res_op0 = _r1;
11455 : }
11456 1 : tree res_op1;
11457 1 : res_op1 = rhs_tree;
11458 1 : tree _r;
11459 1 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11460 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 951, __FILE__, __LINE__, true);
11461 1 : return _r;
11462 : }
11463 0 : next_after_fail1826:;
11464 : }
11465 : }
11466 : }
11467 : }
11468 : }
11469 : }
11470 : }
11471 : }
11472 : }
11473 : break;
11474 : }
11475 : default:;
11476 : }
11477 : break;
11478 : }
11479 0 : case GE_EXPR:
11480 0 : {
11481 0 : tree _q70 = TREE_OPERAND (_p1, 0);
11482 0 : tree _q71 = TREE_OPERAND (_p1, 1);
11483 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
11484 : {
11485 0 : switch (TREE_CODE (_q71))
11486 : {
11487 0 : case POINTER_PLUS_EXPR:
11488 0 : {
11489 0 : tree _q90 = TREE_OPERAND (_q71, 0);
11490 0 : tree _q91 = TREE_OPERAND (_q71, 1);
11491 0 : if ((_q90 == _q21 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q21, 0) && types_match (_q90, _q21)))
11492 : {
11493 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
11494 : {
11495 0 : {
11496 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q71 };
11497 0 : const enum tree_code cmp = LE_EXPR;
11498 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11499 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
11500 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11501 : )
11502 : {
11503 0 : {
11504 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11505 0 : offset_int rhs = off * 2;
11506 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11507 : )
11508 : {
11509 0 : {
11510 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11511 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11512 0 : if (cmp == LT_EXPR
11513 : )
11514 : {
11515 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1827;
11516 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1827;
11517 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1827;
11518 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1827;
11519 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1827;
11520 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1827;
11521 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1827;
11522 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1827;
11523 : {
11524 : tree res_op0;
11525 : {
11526 : tree _o1[1], _r1;
11527 : {
11528 : tree _o2[2], _r2;
11529 : _o2[0] = swap_p ? captures[6] : captures[1];
11530 : _o2[1] = swap_p ? captures[2] : captures[4];
11531 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11532 : _o1[0] = _r2;
11533 : }
11534 : if (TREE_TYPE (_o1[0]) != sizetype)
11535 : {
11536 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11537 : }
11538 : else
11539 : _r1 = _o1[0];
11540 : res_op0 = _r1;
11541 : }
11542 : tree res_op1;
11543 : res_op1 = rhs_tree;
11544 : tree _r;
11545 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11546 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 950, __FILE__, __LINE__, true);
11547 0 : return _r;
11548 : }
11549 : next_after_fail1827:;
11550 : }
11551 : else
11552 : {
11553 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1828;
11554 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1828;
11555 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1828;
11556 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1828;
11557 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1828;
11558 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1828;
11559 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1828;
11560 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1828;
11561 0 : {
11562 0 : tree res_op0;
11563 0 : {
11564 0 : tree _o1[1], _r1;
11565 0 : {
11566 0 : tree _o2[2], _r2;
11567 0 : {
11568 0 : tree _o3[2], _r3;
11569 0 : _o3[0] = swap_p ? captures[4] : captures[2];
11570 0 : _o3[1] = wide_int_to_tree (sizetype, off);
11571 0 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11572 0 : _o2[0] = _r3;
11573 : }
11574 0 : _o2[1] = swap_p ? captures[2] : captures[4];
11575 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11576 0 : _o1[0] = _r2;
11577 : }
11578 0 : if (TREE_TYPE (_o1[0]) != sizetype)
11579 : {
11580 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11581 : }
11582 : else
11583 : _r1 = _o1[0];
11584 0 : res_op0 = _r1;
11585 : }
11586 0 : tree res_op1;
11587 0 : res_op1 = rhs_tree;
11588 0 : tree _r;
11589 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11590 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 951, __FILE__, __LINE__, true);
11591 0 : return _r;
11592 : }
11593 0 : next_after_fail1828:;
11594 : }
11595 : }
11596 : }
11597 : }
11598 : }
11599 : }
11600 : }
11601 : }
11602 : break;
11603 : }
11604 : default:;
11605 : }
11606 : }
11607 : break;
11608 : }
11609 : default:;
11610 : }
11611 : break;
11612 : }
11613 : default:;
11614 : }
11615 : break;
11616 : }
11617 : default:;
11618 : }
11619 : break;
11620 : }
11621 790088 : case LT_EXPR:
11622 790088 : {
11623 790088 : tree _q20 = TREE_OPERAND (_p0, 0);
11624 790088 : tree _q21 = TREE_OPERAND (_p0, 1);
11625 790088 : switch (TREE_CODE (_q20))
11626 : {
11627 13 : case POINTER_PLUS_EXPR:
11628 13 : {
11629 13 : tree _q30 = TREE_OPERAND (_q20, 0);
11630 13 : tree _q31 = TREE_OPERAND (_q20, 1);
11631 13 : switch (TREE_CODE (_q31))
11632 : {
11633 7 : case INTEGER_CST:
11634 7 : {
11635 7 : switch (TREE_CODE (_p1))
11636 : {
11637 2 : case LT_EXPR:
11638 2 : {
11639 2 : tree _q70 = TREE_OPERAND (_p1, 0);
11640 2 : tree _q71 = TREE_OPERAND (_p1, 1);
11641 2 : switch (TREE_CODE (_q70))
11642 : {
11643 2 : case POINTER_PLUS_EXPR:
11644 2 : {
11645 2 : tree _q80 = TREE_OPERAND (_q70, 0);
11646 2 : tree _q81 = TREE_OPERAND (_q70, 1);
11647 2 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
11648 : {
11649 2 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
11650 : {
11651 2 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
11652 : {
11653 2 : {
11654 2 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70 };
11655 2 : const enum tree_code cmp = LT_EXPR;
11656 2 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11657 1 : && TYPE_OVERFLOW_WRAPS (sizetype)
11658 3 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11659 : )
11660 : {
11661 1 : {
11662 1 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11663 1 : offset_int rhs = off * 2;
11664 1 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11665 : )
11666 : {
11667 1 : {
11668 1 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11669 1 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11670 1 : if (cmp == LT_EXPR
11671 : )
11672 : {
11673 1 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1829;
11674 1 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1829;
11675 1 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1829;
11676 1 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1829;
11677 1 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1829;
11678 1 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1829;
11679 1 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1829;
11680 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1829;
11681 1 : {
11682 1 : tree res_op0;
11683 1 : {
11684 1 : tree _o1[1], _r1;
11685 1 : {
11686 1 : tree _o2[2], _r2;
11687 1 : _o2[0] = swap_p ? captures[6] : captures[1];
11688 1 : _o2[1] = swap_p ? captures[2] : captures[4];
11689 1 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11690 1 : _o1[0] = _r2;
11691 : }
11692 1 : if (TREE_TYPE (_o1[0]) != sizetype)
11693 : {
11694 1 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11695 : }
11696 : else
11697 : _r1 = _o1[0];
11698 1 : res_op0 = _r1;
11699 : }
11700 1 : tree res_op1;
11701 1 : res_op1 = rhs_tree;
11702 1 : tree _r;
11703 1 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11704 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 950, __FILE__, __LINE__, true);
11705 1 : return _r;
11706 : }
11707 0 : next_after_fail1829:;
11708 : }
11709 : else
11710 : {
11711 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1830;
11712 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1830;
11713 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1830;
11714 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1830;
11715 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1830;
11716 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1830;
11717 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1830;
11718 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1830;
11719 : {
11720 : tree res_op0;
11721 : {
11722 : tree _o1[1], _r1;
11723 : {
11724 : tree _o2[2], _r2;
11725 : {
11726 : tree _o3[2], _r3;
11727 : _o3[0] = swap_p ? captures[4] : captures[2];
11728 : _o3[1] = wide_int_to_tree (sizetype, off);
11729 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11730 : _o2[0] = _r3;
11731 : }
11732 : _o2[1] = swap_p ? captures[2] : captures[4];
11733 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11734 : _o1[0] = _r2;
11735 : }
11736 : if (TREE_TYPE (_o1[0]) != sizetype)
11737 : {
11738 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11739 : }
11740 : else
11741 : _r1 = _o1[0];
11742 : res_op0 = _r1;
11743 : }
11744 : tree res_op1;
11745 : res_op1 = rhs_tree;
11746 : tree _r;
11747 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11748 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 951, __FILE__, __LINE__, true);
11749 : return _r;
11750 : }
11751 : next_after_fail1830:;
11752 : }
11753 : }
11754 : }
11755 : }
11756 : }
11757 : }
11758 : }
11759 : }
11760 : }
11761 : break;
11762 : }
11763 : default:;
11764 : }
11765 : break;
11766 : }
11767 0 : case GT_EXPR:
11768 0 : {
11769 0 : tree _q70 = TREE_OPERAND (_p1, 0);
11770 0 : tree _q71 = TREE_OPERAND (_p1, 1);
11771 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
11772 : {
11773 0 : switch (TREE_CODE (_q71))
11774 : {
11775 0 : case POINTER_PLUS_EXPR:
11776 0 : {
11777 0 : tree _q90 = TREE_OPERAND (_q71, 0);
11778 0 : tree _q91 = TREE_OPERAND (_q71, 1);
11779 0 : if ((_q90 == _q21 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q21, 0) && types_match (_q90, _q21)))
11780 : {
11781 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
11782 : {
11783 0 : {
11784 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q71 };
11785 0 : const enum tree_code cmp = LT_EXPR;
11786 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11787 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
11788 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11789 : )
11790 : {
11791 0 : {
11792 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11793 0 : offset_int rhs = off * 2;
11794 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11795 : )
11796 : {
11797 0 : {
11798 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11799 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11800 0 : if (cmp == LT_EXPR
11801 : )
11802 : {
11803 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1831;
11804 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1831;
11805 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1831;
11806 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1831;
11807 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1831;
11808 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1831;
11809 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1831;
11810 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1831;
11811 0 : {
11812 0 : tree res_op0;
11813 0 : {
11814 0 : tree _o1[1], _r1;
11815 0 : {
11816 0 : tree _o2[2], _r2;
11817 0 : _o2[0] = swap_p ? captures[6] : captures[1];
11818 0 : _o2[1] = swap_p ? captures[2] : captures[4];
11819 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11820 0 : _o1[0] = _r2;
11821 : }
11822 0 : if (TREE_TYPE (_o1[0]) != sizetype)
11823 : {
11824 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11825 : }
11826 : else
11827 : _r1 = _o1[0];
11828 0 : res_op0 = _r1;
11829 : }
11830 0 : tree res_op1;
11831 0 : res_op1 = rhs_tree;
11832 0 : tree _r;
11833 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11834 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 950, __FILE__, __LINE__, true);
11835 0 : return _r;
11836 : }
11837 0 : next_after_fail1831:;
11838 : }
11839 : else
11840 : {
11841 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1832;
11842 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1832;
11843 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1832;
11844 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1832;
11845 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1832;
11846 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1832;
11847 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1832;
11848 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1832;
11849 : {
11850 : tree res_op0;
11851 : {
11852 : tree _o1[1], _r1;
11853 : {
11854 : tree _o2[2], _r2;
11855 : {
11856 : tree _o3[2], _r3;
11857 : _o3[0] = swap_p ? captures[4] : captures[2];
11858 : _o3[1] = wide_int_to_tree (sizetype, off);
11859 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11860 : _o2[0] = _r3;
11861 : }
11862 : _o2[1] = swap_p ? captures[2] : captures[4];
11863 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11864 : _o1[0] = _r2;
11865 : }
11866 : if (TREE_TYPE (_o1[0]) != sizetype)
11867 : {
11868 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11869 : }
11870 : else
11871 : _r1 = _o1[0];
11872 : res_op0 = _r1;
11873 : }
11874 : tree res_op1;
11875 : res_op1 = rhs_tree;
11876 : tree _r;
11877 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11878 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 951, __FILE__, __LINE__, true);
11879 : return _r;
11880 : }
11881 : next_after_fail1832:;
11882 : }
11883 : }
11884 : }
11885 : }
11886 : }
11887 : }
11888 : }
11889 : }
11890 : break;
11891 : }
11892 : default:;
11893 : }
11894 : }
11895 : break;
11896 : }
11897 : default:;
11898 : }
11899 : break;
11900 : }
11901 : default:;
11902 : }
11903 : break;
11904 : }
11905 : default:;
11906 : }
11907 : break;
11908 : }
11909 20752 : case GE_EXPR:
11910 20752 : {
11911 20752 : tree _q20 = TREE_OPERAND (_p0, 0);
11912 20752 : tree _q21 = TREE_OPERAND (_p0, 1);
11913 20752 : switch (TREE_CODE (_q21))
11914 : {
11915 0 : case POINTER_PLUS_EXPR:
11916 0 : {
11917 0 : tree _q40 = TREE_OPERAND (_q21, 0);
11918 0 : tree _q41 = TREE_OPERAND (_q21, 1);
11919 0 : switch (TREE_CODE (_q41))
11920 : {
11921 0 : case INTEGER_CST:
11922 0 : {
11923 0 : switch (TREE_CODE (_p1))
11924 : {
11925 0 : case LE_EXPR:
11926 0 : {
11927 0 : tree _q70 = TREE_OPERAND (_p1, 0);
11928 0 : tree _q71 = TREE_OPERAND (_p1, 1);
11929 0 : switch (TREE_CODE (_q70))
11930 : {
11931 0 : case POINTER_PLUS_EXPR:
11932 0 : {
11933 0 : tree _q80 = TREE_OPERAND (_q70, 0);
11934 0 : tree _q81 = TREE_OPERAND (_q70, 1);
11935 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
11936 : {
11937 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
11938 : {
11939 0 : if ((_q71 == _q40 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q40, 0) && types_match (_q71, _q40)))
11940 : {
11941 0 : {
11942 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q70 };
11943 0 : const enum tree_code cmp = LE_EXPR;
11944 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11945 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
11946 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11947 : )
11948 : {
11949 0 : {
11950 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11951 0 : offset_int rhs = off * 2;
11952 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11953 : )
11954 : {
11955 0 : {
11956 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11957 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11958 0 : if (cmp == LT_EXPR
11959 : )
11960 : {
11961 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1833;
11962 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1833;
11963 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1833;
11964 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1833;
11965 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1833;
11966 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1833;
11967 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1833;
11968 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1833;
11969 : {
11970 : tree res_op0;
11971 : {
11972 : tree _o1[1], _r1;
11973 : {
11974 : tree _o2[2], _r2;
11975 : _o2[0] = swap_p ? captures[6] : captures[1];
11976 : _o2[1] = swap_p ? captures[2] : captures[4];
11977 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11978 : _o1[0] = _r2;
11979 : }
11980 : if (TREE_TYPE (_o1[0]) != sizetype)
11981 : {
11982 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11983 : }
11984 : else
11985 : _r1 = _o1[0];
11986 : res_op0 = _r1;
11987 : }
11988 : tree res_op1;
11989 : res_op1 = rhs_tree;
11990 : tree _r;
11991 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11992 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 950, __FILE__, __LINE__, true);
11993 0 : return _r;
11994 : }
11995 : next_after_fail1833:;
11996 : }
11997 : else
11998 : {
11999 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1834;
12000 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1834;
12001 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1834;
12002 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1834;
12003 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1834;
12004 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1834;
12005 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1834;
12006 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1834;
12007 0 : {
12008 0 : tree res_op0;
12009 0 : {
12010 0 : tree _o1[1], _r1;
12011 0 : {
12012 0 : tree _o2[2], _r2;
12013 0 : {
12014 0 : tree _o3[2], _r3;
12015 0 : _o3[0] = swap_p ? captures[4] : captures[2];
12016 0 : _o3[1] = wide_int_to_tree (sizetype, off);
12017 0 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
12018 0 : _o2[0] = _r3;
12019 : }
12020 0 : _o2[1] = swap_p ? captures[2] : captures[4];
12021 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12022 0 : _o1[0] = _r2;
12023 : }
12024 0 : if (TREE_TYPE (_o1[0]) != sizetype)
12025 : {
12026 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12027 : }
12028 : else
12029 : _r1 = _o1[0];
12030 0 : res_op0 = _r1;
12031 : }
12032 0 : tree res_op1;
12033 0 : res_op1 = rhs_tree;
12034 0 : tree _r;
12035 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12036 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 951, __FILE__, __LINE__, true);
12037 0 : return _r;
12038 : }
12039 0 : next_after_fail1834:;
12040 : }
12041 : }
12042 : }
12043 : }
12044 : }
12045 : }
12046 : }
12047 : }
12048 : }
12049 : break;
12050 : }
12051 : default:;
12052 : }
12053 : break;
12054 : }
12055 0 : case GE_EXPR:
12056 0 : {
12057 0 : tree _q70 = TREE_OPERAND (_p1, 0);
12058 0 : tree _q71 = TREE_OPERAND (_p1, 1);
12059 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
12060 : {
12061 0 : switch (TREE_CODE (_q71))
12062 : {
12063 0 : case POINTER_PLUS_EXPR:
12064 0 : {
12065 0 : tree _q90 = TREE_OPERAND (_q71, 0);
12066 0 : tree _q91 = TREE_OPERAND (_q71, 1);
12067 0 : if ((_q90 == _q20 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q20, 0) && types_match (_q90, _q20)))
12068 : {
12069 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
12070 : {
12071 0 : {
12072 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q71 };
12073 0 : const enum tree_code cmp = LE_EXPR;
12074 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
12075 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
12076 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
12077 : )
12078 : {
12079 0 : {
12080 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
12081 0 : offset_int rhs = off * 2;
12082 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
12083 : )
12084 : {
12085 0 : {
12086 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
12087 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
12088 0 : if (cmp == LT_EXPR
12089 : )
12090 : {
12091 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1835;
12092 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1835;
12093 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1835;
12094 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1835;
12095 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1835;
12096 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1835;
12097 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1835;
12098 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1835;
12099 : {
12100 : tree res_op0;
12101 : {
12102 : tree _o1[1], _r1;
12103 : {
12104 : tree _o2[2], _r2;
12105 : _o2[0] = swap_p ? captures[6] : captures[1];
12106 : _o2[1] = swap_p ? captures[2] : captures[4];
12107 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12108 : _o1[0] = _r2;
12109 : }
12110 : if (TREE_TYPE (_o1[0]) != sizetype)
12111 : {
12112 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12113 : }
12114 : else
12115 : _r1 = _o1[0];
12116 : res_op0 = _r1;
12117 : }
12118 : tree res_op1;
12119 : res_op1 = rhs_tree;
12120 : tree _r;
12121 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12122 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 950, __FILE__, __LINE__, true);
12123 0 : return _r;
12124 : }
12125 : next_after_fail1835:;
12126 : }
12127 : else
12128 : {
12129 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1836;
12130 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1836;
12131 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1836;
12132 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1836;
12133 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1836;
12134 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1836;
12135 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1836;
12136 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1836;
12137 0 : {
12138 0 : tree res_op0;
12139 0 : {
12140 0 : tree _o1[1], _r1;
12141 0 : {
12142 0 : tree _o2[2], _r2;
12143 0 : {
12144 0 : tree _o3[2], _r3;
12145 0 : _o3[0] = swap_p ? captures[4] : captures[2];
12146 0 : _o3[1] = wide_int_to_tree (sizetype, off);
12147 0 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
12148 0 : _o2[0] = _r3;
12149 : }
12150 0 : _o2[1] = swap_p ? captures[2] : captures[4];
12151 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12152 0 : _o1[0] = _r2;
12153 : }
12154 0 : if (TREE_TYPE (_o1[0]) != sizetype)
12155 : {
12156 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12157 : }
12158 : else
12159 : _r1 = _o1[0];
12160 0 : res_op0 = _r1;
12161 : }
12162 0 : tree res_op1;
12163 0 : res_op1 = rhs_tree;
12164 0 : tree _r;
12165 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12166 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 951, __FILE__, __LINE__, true);
12167 0 : return _r;
12168 : }
12169 0 : next_after_fail1836:;
12170 : }
12171 : }
12172 : }
12173 : }
12174 : }
12175 : }
12176 : }
12177 : }
12178 : break;
12179 : }
12180 : default:;
12181 : }
12182 : }
12183 : break;
12184 : }
12185 : default:;
12186 : }
12187 : break;
12188 : }
12189 : default:;
12190 : }
12191 : break;
12192 : }
12193 : default:;
12194 : }
12195 : break;
12196 : }
12197 66438 : case GT_EXPR:
12198 66438 : {
12199 66438 : tree _q20 = TREE_OPERAND (_p0, 0);
12200 66438 : tree _q21 = TREE_OPERAND (_p0, 1);
12201 66438 : switch (TREE_CODE (_q21))
12202 : {
12203 0 : case POINTER_PLUS_EXPR:
12204 0 : {
12205 0 : tree _q40 = TREE_OPERAND (_q21, 0);
12206 0 : tree _q41 = TREE_OPERAND (_q21, 1);
12207 0 : switch (TREE_CODE (_q41))
12208 : {
12209 0 : case INTEGER_CST:
12210 0 : {
12211 0 : switch (TREE_CODE (_p1))
12212 : {
12213 0 : case LT_EXPR:
12214 0 : {
12215 0 : tree _q70 = TREE_OPERAND (_p1, 0);
12216 0 : tree _q71 = TREE_OPERAND (_p1, 1);
12217 0 : switch (TREE_CODE (_q70))
12218 : {
12219 0 : case POINTER_PLUS_EXPR:
12220 0 : {
12221 0 : tree _q80 = TREE_OPERAND (_q70, 0);
12222 0 : tree _q81 = TREE_OPERAND (_q70, 1);
12223 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
12224 : {
12225 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
12226 : {
12227 0 : if ((_q71 == _q40 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q40, 0) && types_match (_q71, _q40)))
12228 : {
12229 0 : {
12230 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q70 };
12231 0 : const enum tree_code cmp = LT_EXPR;
12232 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
12233 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
12234 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
12235 : )
12236 : {
12237 0 : {
12238 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
12239 0 : offset_int rhs = off * 2;
12240 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
12241 : )
12242 : {
12243 0 : {
12244 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
12245 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
12246 0 : if (cmp == LT_EXPR
12247 : )
12248 : {
12249 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1837;
12250 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1837;
12251 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1837;
12252 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1837;
12253 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1837;
12254 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1837;
12255 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1837;
12256 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1837;
12257 0 : {
12258 0 : tree res_op0;
12259 0 : {
12260 0 : tree _o1[1], _r1;
12261 0 : {
12262 0 : tree _o2[2], _r2;
12263 0 : _o2[0] = swap_p ? captures[6] : captures[1];
12264 0 : _o2[1] = swap_p ? captures[2] : captures[4];
12265 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12266 0 : _o1[0] = _r2;
12267 : }
12268 0 : if (TREE_TYPE (_o1[0]) != sizetype)
12269 : {
12270 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12271 : }
12272 : else
12273 : _r1 = _o1[0];
12274 0 : res_op0 = _r1;
12275 : }
12276 0 : tree res_op1;
12277 0 : res_op1 = rhs_tree;
12278 0 : tree _r;
12279 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12280 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 950, __FILE__, __LINE__, true);
12281 0 : return _r;
12282 : }
12283 0 : next_after_fail1837:;
12284 : }
12285 : else
12286 : {
12287 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1838;
12288 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1838;
12289 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1838;
12290 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1838;
12291 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1838;
12292 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1838;
12293 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1838;
12294 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1838;
12295 : {
12296 : tree res_op0;
12297 : {
12298 : tree _o1[1], _r1;
12299 : {
12300 : tree _o2[2], _r2;
12301 : {
12302 : tree _o3[2], _r3;
12303 : _o3[0] = swap_p ? captures[4] : captures[2];
12304 : _o3[1] = wide_int_to_tree (sizetype, off);
12305 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
12306 : _o2[0] = _r3;
12307 : }
12308 : _o2[1] = swap_p ? captures[2] : captures[4];
12309 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12310 : _o1[0] = _r2;
12311 : }
12312 : if (TREE_TYPE (_o1[0]) != sizetype)
12313 : {
12314 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12315 : }
12316 : else
12317 : _r1 = _o1[0];
12318 : res_op0 = _r1;
12319 : }
12320 : tree res_op1;
12321 : res_op1 = rhs_tree;
12322 : tree _r;
12323 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12324 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 951, __FILE__, __LINE__, true);
12325 : return _r;
12326 : }
12327 : next_after_fail1838:;
12328 : }
12329 : }
12330 : }
12331 : }
12332 : }
12333 : }
12334 : }
12335 : }
12336 : }
12337 : break;
12338 : }
12339 : default:;
12340 : }
12341 : break;
12342 : }
12343 0 : case GT_EXPR:
12344 0 : {
12345 0 : tree _q70 = TREE_OPERAND (_p1, 0);
12346 0 : tree _q71 = TREE_OPERAND (_p1, 1);
12347 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
12348 : {
12349 0 : switch (TREE_CODE (_q71))
12350 : {
12351 0 : case POINTER_PLUS_EXPR:
12352 0 : {
12353 0 : tree _q90 = TREE_OPERAND (_q71, 0);
12354 0 : tree _q91 = TREE_OPERAND (_q71, 1);
12355 0 : if ((_q90 == _q20 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q20, 0) && types_match (_q90, _q20)))
12356 : {
12357 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
12358 : {
12359 0 : {
12360 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q71 };
12361 0 : const enum tree_code cmp = LT_EXPR;
12362 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
12363 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
12364 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
12365 : )
12366 : {
12367 0 : {
12368 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
12369 0 : offset_int rhs = off * 2;
12370 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
12371 : )
12372 : {
12373 0 : {
12374 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
12375 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
12376 0 : if (cmp == LT_EXPR
12377 : )
12378 : {
12379 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1839;
12380 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1839;
12381 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1839;
12382 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1839;
12383 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1839;
12384 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1839;
12385 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1839;
12386 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1839;
12387 0 : {
12388 0 : tree res_op0;
12389 0 : {
12390 0 : tree _o1[1], _r1;
12391 0 : {
12392 0 : tree _o2[2], _r2;
12393 0 : _o2[0] = swap_p ? captures[6] : captures[1];
12394 0 : _o2[1] = swap_p ? captures[2] : captures[4];
12395 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12396 0 : _o1[0] = _r2;
12397 : }
12398 0 : if (TREE_TYPE (_o1[0]) != sizetype)
12399 : {
12400 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12401 : }
12402 : else
12403 : _r1 = _o1[0];
12404 0 : res_op0 = _r1;
12405 : }
12406 0 : tree res_op1;
12407 0 : res_op1 = rhs_tree;
12408 0 : tree _r;
12409 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12410 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 950, __FILE__, __LINE__, true);
12411 0 : return _r;
12412 : }
12413 0 : next_after_fail1839:;
12414 : }
12415 : else
12416 : {
12417 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1840;
12418 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1840;
12419 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1840;
12420 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1840;
12421 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1840;
12422 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1840;
12423 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1840;
12424 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1840;
12425 : {
12426 : tree res_op0;
12427 : {
12428 : tree _o1[1], _r1;
12429 : {
12430 : tree _o2[2], _r2;
12431 : {
12432 : tree _o3[2], _r3;
12433 : _o3[0] = swap_p ? captures[4] : captures[2];
12434 : _o3[1] = wide_int_to_tree (sizetype, off);
12435 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
12436 : _o2[0] = _r3;
12437 : }
12438 : _o2[1] = swap_p ? captures[2] : captures[4];
12439 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
12440 : _o1[0] = _r2;
12441 : }
12442 : if (TREE_TYPE (_o1[0]) != sizetype)
12443 : {
12444 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
12445 : }
12446 : else
12447 : _r1 = _o1[0];
12448 : res_op0 = _r1;
12449 : }
12450 : tree res_op1;
12451 : res_op1 = rhs_tree;
12452 : tree _r;
12453 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
12454 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 951, __FILE__, __LINE__, true);
12455 : return _r;
12456 : }
12457 : next_after_fail1840:;
12458 : }
12459 : }
12460 : }
12461 : }
12462 : }
12463 : }
12464 : }
12465 : }
12466 : break;
12467 : }
12468 : default:;
12469 : }
12470 : }
12471 : break;
12472 : }
12473 : default:;
12474 : }
12475 : break;
12476 : }
12477 : default:;
12478 : }
12479 : break;
12480 : }
12481 : default:;
12482 : }
12483 : break;
12484 : }
12485 : default:;
12486 : }
12487 : return NULL_TREE;
12488 : }
12489 : #pragma GCC diagnostic pop
|
