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 164610505 : tree_maybe_bit_not (tree t, tree *res_ops)
11 : {
12 164610505 : const tree type = TREE_TYPE (t);
13 164610505 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 164610505 : if (TREE_SIDE_EFFECTS (t)) return false;
15 157195985 : switch (TREE_CODE (t))
16 : {
17 49761741 : case INTEGER_CST:
18 49761741 : {
19 49761741 : {
20 49761741 : tree captures[1] ATTRIBUTE_UNUSED = { t };
21 49761741 : {
22 49761741 : res_ops[0] = captures[0];
23 49761741 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 8, __FILE__, __LINE__, false);
24 : return true;
25 : }
26 : }
27 107434244 : break;
28 : }
29 107434244 : default:;
30 : }
31 107434244 : {
32 107434244 : tree t_pops[1];
33 107434244 : if (tree_bit_not_with_nop (t, t_pops))
34 : {
35 146178 : tree _p0 = t_pops[0];
36 146178 : {
37 146178 : tree captures[2] ATTRIBUTE_UNUSED = { t, _p0 };
38 146178 : {
39 146178 : res_ops[0] = captures[0];
40 146178 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 9, __FILE__, __LINE__, false);
41 146178 : return true;
42 : }
43 : }
44 : }
45 : }
46 107288066 : {
47 107288066 : tree t_pops[1];
48 107288066 : if (tree_maybe_cmp (t, t_pops))
49 : {
50 539704 : tree _p0 = t_pops[0];
51 539704 : {
52 539704 : tree captures[2] ATTRIBUTE_UNUSED = { t, _p0 };
53 539704 : {
54 539704 : res_ops[0] = captures[0];
55 539704 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 10, __FILE__, __LINE__, false);
56 539704 : return true;
57 : }
58 : }
59 : }
60 : }
61 106748362 : {
62 106748362 : tree t_pops[2];
63 106748362 : if (tree_bit_xor_cst (t, t_pops))
64 : {
65 1601 : tree _p0 = t_pops[0];
66 1601 : tree _p1 = t_pops[1];
67 1601 : {
68 1601 : tree captures[3] ATTRIBUTE_UNUSED = { t, _p0, _p1 };
69 1601 : {
70 1601 : res_ops[0] = captures[0];
71 1601 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 11, __FILE__, __LINE__, false);
72 1601 : return true;
73 : }
74 : }
75 : }
76 : }
77 106746761 : return false;
78 : }
79 :
80 : bool
81 2429 : tree_min_value (tree t)
82 : {
83 2429 : const tree type = TREE_TYPE (t);
84 2429 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
85 2429 : if (TREE_SIDE_EFFECTS (t)) return false;
86 2421 : if (uniform_integer_cst_p (t))
87 : {
88 2149 : {
89 2149 : {
90 2149 : tree int_cst = uniform_integer_cst_p (t);
91 2149 : tree inner_type = TREE_TYPE (int_cst);
92 4298 : if ((INTEGRAL_TYPE_P (inner_type)
93 17 : || POINTER_TYPE_P (inner_type))
94 4315 : && wi::eq_p (wi::to_wide (int_cst), wi::min_value (inner_type))
95 : )
96 : {
97 138 : {
98 138 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 41, __FILE__, __LINE__, false);
99 138 : 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 312 : 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 312 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
325 312 : if (real_zerop (captures[2])
326 34 : && real_zerop (captures[3])
327 346 : && !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 539 : 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 539 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
378 539 : if (!TYPE_SATURATING (type)
379 : )
380 : {
381 539 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
382 1078 : && !FIXED_POINT_TYPE_P (type)
383 : )
384 : {
385 539 : if (!TYPE_OVERFLOW_TRAPS (type)
386 : )
387 : {
388 539 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail158;
389 539 : {
390 539 : tree res_op0;
391 539 : res_op0 = build_all_ones_cst (TREE_TYPE (captures[0]));
392 539 : tree _r;
393 539 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
394 539 : if (TREE_SIDE_EFFECTS (captures[0]))
395 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
396 539 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 126, __FILE__, __LINE__, true);
397 539 : 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 18901 : 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 18901 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
432 18901 : 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 39739 : 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 39739 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
526 39739 : if (!TYPE_SATURATING (type)
527 : )
528 : {
529 39739 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
530 79478 : && !FIXED_POINT_TYPE_P (type)
531 : )
532 : {
533 0 : if (!ANY_INTEGRAL_TYPE_P (type)
534 39739 : || TYPE_OVERFLOW_WRAPS (type)
535 : )
536 : {
537 35970 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail190;
538 35970 : {
539 35970 : tree res_op0;
540 35970 : {
541 35970 : tree _o1[1], _r1;
542 35970 : _o1[0] = captures[1];
543 35970 : if (TREE_TYPE (_o1[0]) != type)
544 : {
545 192 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
546 : }
547 : else
548 : _r1 = _o1[0];
549 35970 : res_op0 = _r1;
550 : }
551 35970 : tree _r;
552 35970 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
553 35970 : if (TREE_SIDE_EFFECTS (captures[0]))
554 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
555 35970 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 157, __FILE__, __LINE__, true);
556 35970 : return _r;
557 : }
558 0 : next_after_fail190:;
559 : }
560 : else
561 : {
562 3769 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail191;
563 3769 : {
564 3769 : tree res_op0;
565 3769 : {
566 3769 : tree _o1[1], _r1;
567 3769 : _o1[0] = captures[1];
568 3769 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
569 3769 : res_op0 = _r1;
570 : }
571 3769 : tree _r;
572 3769 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
573 3769 : if (TREE_SIDE_EFFECTS (captures[0]))
574 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
575 3769 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 158, __FILE__, __LINE__, true);
576 3769 : 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 0 : generic_simplify_175 (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 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
848 0 : if (type_has_mode_precision_p (type)
849 0 : && tree_fits_uhwi_p (captures[1])
850 0 : && tree_fits_uhwi_p (captures[3])
851 0 : && tree_fits_uhwi_p (captures[4])
852 0 : && ((~((HOST_WIDE_INT_1U << tree_to_uhwi (captures[1])) - 1)) & tree_to_uhwi (captures[4])) == 0
853 0 : && (tree_to_uhwi (captures[1]) + tree_to_uhwi (captures[3])) == TYPE_PRECISION (type)
854 0 : && TYPE_UNSIGNED (type)
855 0 : && captures[0] == captures[2]
856 : )
857 : {
858 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail312;
859 0 : {
860 0 : tree res_op0;
861 0 : {
862 0 : tree _o1[2], _r1;
863 0 : _o1[0] = captures[0];
864 0 : _o1[1] = captures[3];
865 0 : _r1 = fold_build2_loc (loc, RROTATE_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
866 0 : res_op0 = _r1;
867 : }
868 0 : tree res_op1;
869 0 : res_op1 = captures[4];
870 0 : tree _r;
871 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
872 0 : if (TREE_SIDE_EFFECTS (captures[1]))
873 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
874 0 : if (TREE_SIDE_EFFECTS (captures[2]))
875 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
876 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 233, __FILE__, __LINE__, true);
877 0 : return _r;
878 : }
879 0 : next_after_fail312:;
880 : }
881 : return NULL_TREE;
882 : }
883 :
884 : tree
885 0 : generic_simplify_182 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
886 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
887 : const combined_fn ARG_UNUSED (copysigns))
888 : {
889 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
890 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail319;
891 0 : {
892 0 : if (! tree_invariant_p (captures[1])) goto next_after_fail319;
893 0 : tree res_op0;
894 0 : res_op0 = unshare_expr (captures[1]);
895 0 : tree res_op1;
896 0 : res_op1 = captures[1];
897 0 : tree _r;
898 0 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
899 0 : if (TREE_SIDE_EFFECTS (captures[2]))
900 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
901 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 238, __FILE__, __LINE__, true);
902 : return _r;
903 : }
904 : next_after_fail319:;
905 : return NULL_TREE;
906 : }
907 :
908 : tree
909 1206 : generic_simplify_189 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
910 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
911 : const enum tree_code ARG_UNUSED (cmp))
912 : {
913 1206 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
914 1206 : if (fold_before_rtl_expansion_p ()
915 : )
916 : {
917 0 : if (INTEGRAL_TYPE_P (type)
918 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
919 : )
920 : {
921 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail328;
922 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail328;
923 0 : {
924 0 : tree res_op0;
925 0 : res_op0 = captures[0];
926 0 : tree res_op1;
927 0 : res_op1 = captures[3];
928 0 : tree res_op2;
929 0 : res_op2 = build_zero_cst (type);
930 0 : tree _r;
931 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
932 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 244, __FILE__, __LINE__, true);
933 0 : return _r;
934 : }
935 : next_after_fail328:;
936 : }
937 : }
938 : return NULL_TREE;
939 : }
940 :
941 : tree
942 170544 : generic_simplify_193 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
943 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
944 : {
945 170544 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
946 170544 : {
947 170544 : poly_widest_int factor;
948 170544 : if (multiple_p (wi::to_poly_widest (captures[2]), wi::to_widest (captures[1]), &factor)
949 : )
950 : {
951 52132 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail332;
952 52132 : {
953 52132 : tree res_op0;
954 52132 : {
955 52132 : tree _o1[1], _r1;
956 52132 : _o1[0] = captures[0];
957 52132 : if (TREE_TYPE (_o1[0]) != type)
958 : {
959 9803 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
960 : }
961 : else
962 : _r1 = _o1[0];
963 52132 : res_op0 = _r1;
964 : }
965 52132 : tree res_op1;
966 52132 : res_op1 = wide_int_to_tree (type, factor);
967 52132 : tree _r;
968 52132 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
969 52132 : if (TREE_SIDE_EFFECTS (captures[1]))
970 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
971 52132 : if (TREE_SIDE_EFFECTS (captures[2]))
972 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
973 52132 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 247, __FILE__, __LINE__, true);
974 52132 : return _r;
975 : }
976 0 : next_after_fail332:;
977 : }
978 170544 : }
979 118412 : return NULL_TREE;
980 : }
981 :
982 : tree
983 2 : generic_simplify_202 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
984 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
985 : const combined_fn ARG_UNUSED (POW))
986 : {
987 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
988 2 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
989 : )
990 : {
991 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail342;
992 2 : {
993 2 : tree res_op0;
994 2 : {
995 2 : tree _o1[2], _r1;
996 2 : _o1[0] = captures[1];
997 2 : _o1[1] = captures[4];
998 2 : _r1 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
999 2 : res_op0 = _r1;
1000 : }
1001 2 : tree res_op1;
1002 2 : res_op1 = captures[2];
1003 2 : tree _r;
1004 2 : _r = maybe_build_call_expr_loc (loc, POW, type, 2, res_op0, res_op1);
1005 2 : if (!_r)
1006 0 : goto next_after_fail342;
1007 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 257, __FILE__, __LINE__, true);
1008 2 : return _r;
1009 : }
1010 : next_after_fail342:;
1011 : }
1012 : return NULL_TREE;
1013 : }
1014 :
1015 : tree
1016 0 : generic_simplify_209 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1017 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1018 : const enum tree_code ARG_UNUSED (op))
1019 : {
1020 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1021 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail352;
1022 0 : {
1023 0 : tree _r;
1024 0 : _r = constant_boolean_node (op == NE_EXPR ? true : false, type);
1025 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1026 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1027 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 266, __FILE__, __LINE__, true);
1028 : return _r;
1029 : }
1030 0 : next_after_fail352:;
1031 0 : return NULL_TREE;
1032 : }
1033 :
1034 : tree
1035 2518 : generic_simplify_214 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1036 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1037 : const enum tree_code ARG_UNUSED (cmp))
1038 : {
1039 2518 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1040 5036 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1041 3242 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
1042 4160 : && tree_expr_nonzero_p (captures[1])
1043 : )
1044 : {
1045 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail357;
1046 12 : {
1047 12 : tree res_op0;
1048 12 : res_op0 = captures[0];
1049 12 : tree res_op1;
1050 12 : res_op1 = captures[2];
1051 12 : tree _r;
1052 12 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1053 12 : if (TREE_SIDE_EFFECTS (captures[1]))
1054 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1055 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 271, __FILE__, __LINE__, true);
1056 12 : return _r;
1057 : }
1058 0 : next_after_fail357:;
1059 : }
1060 : return NULL_TREE;
1061 : }
1062 :
1063 : tree
1064 0 : generic_simplify_221 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1065 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1066 : const enum tree_code ARG_UNUSED (op))
1067 : {
1068 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1069 0 : if (!TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[1]))
1070 : )
1071 : {
1072 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail377;
1073 0 : {
1074 0 : tree res_op0;
1075 0 : res_op0 = captures[3];
1076 0 : tree res_op1;
1077 0 : res_op1 = captures[2];
1078 0 : tree _r;
1079 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1080 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1081 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1082 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 291, __FILE__, __LINE__, true);
1083 0 : return _r;
1084 : }
1085 0 : next_after_fail377:;
1086 : }
1087 : return NULL_TREE;
1088 : }
1089 :
1090 : tree
1091 1063 : generic_simplify_229 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1092 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1093 : const enum tree_code ARG_UNUSED (minmax),
1094 : const enum tree_code ARG_UNUSED (cmp),
1095 : const enum tree_code ARG_UNUSED (out))
1096 : {
1097 1063 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1098 2126 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1099 1208 : && (!VECTOR_TYPE_P (TREE_TYPE (captures[0]))
1100 1 : || (VECTOR_TYPE_P (type)
1101 0 : && (!expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, cmp)
1102 0 : || expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, out))))
1103 : )
1104 : {
1105 144 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail385;
1106 144 : {
1107 144 : tree res_op0;
1108 144 : res_op0 = captures[0];
1109 144 : tree res_op1;
1110 144 : res_op1 = captures[1];
1111 144 : tree _r;
1112 144 : _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
1113 144 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 298, __FILE__, __LINE__, true);
1114 144 : return _r;
1115 : }
1116 0 : next_after_fail385:;
1117 : }
1118 : return NULL_TREE;
1119 : }
1120 :
1121 : tree
1122 698 : generic_simplify_237 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1123 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1124 : const enum tree_code ARG_UNUSED (cmp))
1125 : {
1126 698 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1127 698 : if (tree_fits_shwi_p (captures[3])
1128 698 : && tree_to_shwi (captures[3]) > 0
1129 1382 : && tree_to_shwi (captures[3]) < TYPE_PRECISION (TREE_TYPE (captures[2]))
1130 : )
1131 : {
1132 684 : {
1133 684 : tree t0 = TREE_TYPE (captures[2]);
1134 684 : unsigned int prec = TYPE_PRECISION (t0);
1135 684 : wide_int c1 = wi::to_wide (captures[3]);
1136 684 : wide_int c2 = wi::to_wide (captures[4]);
1137 684 : wide_int c3 = wi::to_wide (captures[5]);
1138 684 : wide_int sb = wi::set_bit_in_zero (prec - 1, prec);
1139 684 : if ((c2 & c3) != c3
1140 : )
1141 : {
1142 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail398;
1143 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail398;
1144 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail398;
1145 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail398;
1146 0 : {
1147 0 : tree _r;
1148 0 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1149 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1150 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1151 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 311, __FILE__, __LINE__, true);
1152 0 : return _r;
1153 : }
1154 0 : next_after_fail398:;
1155 : }
1156 : else
1157 : {
1158 684 : if (TYPE_UNSIGNED (t0)
1159 : )
1160 : {
1161 562 : if ((c3 & wi::arshift (sb, c1 - 1)) != 0
1162 : )
1163 : {
1164 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail399;
1165 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail399;
1166 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail399;
1167 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail399;
1168 0 : {
1169 0 : tree _r;
1170 0 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1171 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1172 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1173 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 312, __FILE__, __LINE__, true);
1174 0 : return _r;
1175 : }
1176 0 : next_after_fail399:;
1177 : }
1178 : else
1179 : {
1180 562 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail400;
1181 562 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail400;
1182 562 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail400;
1183 562 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail400;
1184 562 : {
1185 562 : tree res_op0;
1186 562 : {
1187 562 : tree _o1[2], _r1;
1188 562 : _o1[0] = captures[2];
1189 562 : _o1[1] = wide_int_to_tree (t0, c2 << c1);
1190 562 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1191 562 : res_op0 = _r1;
1192 : }
1193 562 : tree res_op1;
1194 562 : res_op1 = wide_int_to_tree (t0, c3 << c1);
1195 562 : tree _r;
1196 562 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1197 562 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 313, __FILE__, __LINE__, true);
1198 562 : return _r;
1199 : }
1200 0 : next_after_fail400:;
1201 : }
1202 : }
1203 : else
1204 : {
1205 122 : {
1206 122 : wide_int smask = wi::arshift (sb, c1);
1207 122 : if ((c2 & smask) == 0
1208 : )
1209 : {
1210 120 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail401;
1211 120 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail401;
1212 120 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail401;
1213 120 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail401;
1214 120 : {
1215 120 : tree res_op0;
1216 120 : {
1217 120 : tree _o1[2], _r1;
1218 120 : _o1[0] = captures[2];
1219 120 : _o1[1] = wide_int_to_tree (t0, c2 << c1);
1220 120 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1221 120 : res_op0 = _r1;
1222 : }
1223 120 : tree res_op1;
1224 120 : res_op1 = wide_int_to_tree (t0, c3 << c1);
1225 120 : tree _r;
1226 120 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1227 120 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 314, __FILE__, __LINE__, true);
1228 120 : return _r;
1229 : }
1230 0 : next_after_fail401:;
1231 : }
1232 : else
1233 : {
1234 2 : if ((c3 & smask) == 0
1235 : )
1236 : {
1237 2 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail402;
1238 2 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail402;
1239 2 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail402;
1240 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail402;
1241 2 : {
1242 2 : tree res_op0;
1243 2 : {
1244 2 : tree _o1[2], _r1;
1245 2 : _o1[0] = captures[2];
1246 2 : _o1[1] = wide_int_to_tree (t0, (c2 << c1) | sb);
1247 2 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1248 2 : res_op0 = _r1;
1249 : }
1250 2 : tree res_op1;
1251 2 : res_op1 = wide_int_to_tree (t0, c3 << c1);
1252 2 : tree _r;
1253 2 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1254 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 315, __FILE__, __LINE__, true);
1255 2 : return _r;
1256 : }
1257 0 : next_after_fail402:;
1258 : }
1259 : else
1260 : {
1261 0 : if ((c2 & smask) != (c3 & smask)
1262 : )
1263 : {
1264 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail403;
1265 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail403;
1266 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail403;
1267 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail403;
1268 0 : {
1269 0 : tree _r;
1270 0 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1271 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1272 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1273 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 316, __FILE__, __LINE__, true);
1274 0 : return _r;
1275 : }
1276 0 : next_after_fail403:;
1277 : }
1278 : else
1279 : {
1280 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail404;
1281 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail404;
1282 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail404;
1283 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail404;
1284 0 : {
1285 0 : tree res_op0;
1286 0 : {
1287 0 : tree _o1[2], _r1;
1288 0 : _o1[0] = captures[2];
1289 0 : _o1[1] = wide_int_to_tree (t0, (c2 << c1) | sb);
1290 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1291 0 : res_op0 = _r1;
1292 : }
1293 0 : tree res_op1;
1294 0 : res_op1 = wide_int_to_tree (t0, (c3 << c1) | sb);
1295 0 : tree _r;
1296 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1297 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 317, __FILE__, __LINE__, true);
1298 0 : return _r;
1299 : }
1300 0 : next_after_fail404:;
1301 : }
1302 : }
1303 : }
1304 122 : }
1305 : }
1306 : }
1307 684 : }
1308 : }
1309 : return NULL_TREE;
1310 : }
1311 :
1312 : tree
1313 1101704 : generic_simplify_269 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1314 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1315 : const enum tree_code ARG_UNUSED (cmp))
1316 : {
1317 1101704 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1318 1101704 : {
1319 1101704 : poly_int64 off; tree base;
1320 1101704 : tree addr = (TREE_CODE (captures[1]) == SSA_NAME
1321 1101704 : ? gimple_assign_rhs1 (SSA_NAME_DEF_STMT (captures[1])) : captures[1]);
1322 1101704 : if (SSA_NAME_IS_DEFAULT_DEF (captures[0])
1323 46844 : && TREE_CODE (SSA_NAME_VAR (captures[0])) == PARM_DECL
1324 46686 : && (base = get_base_address (TREE_OPERAND (addr, 0)))
1325 46686 : && TREE_CODE (base) == VAR_DECL
1326 1104910 : && auto_var_in_fn_p (base, current_function_decl)
1327 : )
1328 : {
1329 0 : if (cmp == NE_EXPR
1330 : )
1331 : {
1332 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail498;
1333 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail498;
1334 0 : {
1335 0 : tree _r;
1336 0 : _r = constant_boolean_node (true, type);
1337 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1338 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1339 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 401, __FILE__, __LINE__, true);
1340 2 : return _r;
1341 : }
1342 1101702 : next_after_fail498:;
1343 : }
1344 : else
1345 : {
1346 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail499;
1347 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail499;
1348 0 : {
1349 0 : tree _r;
1350 0 : _r = constant_boolean_node (false, type);
1351 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1352 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1353 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 402, __FILE__, __LINE__, true);
1354 0 : return _r;
1355 : }
1356 1101702 : next_after_fail499:;
1357 : }
1358 : }
1359 : else
1360 : {
1361 1101704 : if ((base = get_addr_base_and_unit_offset (TREE_OPERAND (addr, 0), &off))
1362 1100359 : && TREE_CODE (base) == MEM_REF
1363 1264252 : && TREE_OPERAND (base, 0) == captures[0]
1364 : )
1365 : {
1366 2 : {
1367 2 : off += mem_ref_offset (base).force_shwi ();
1368 2 : if (known_ne (off, 0)
1369 : )
1370 : {
1371 2 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail500;
1372 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail500;
1373 2 : {
1374 2 : tree _r;
1375 2 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1376 2 : if (TREE_SIDE_EFFECTS (captures[0]))
1377 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1378 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 403, __FILE__, __LINE__, true);
1379 2 : return _r;
1380 : }
1381 1101702 : next_after_fail500:;
1382 : }
1383 : else
1384 : {
1385 0 : if (known_eq (off, 0)
1386 : )
1387 : {
1388 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail501;
1389 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail501;
1390 0 : {
1391 0 : tree _r;
1392 0 : _r = constant_boolean_node (cmp == EQ_EXPR, type);
1393 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1394 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1395 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 404, __FILE__, __LINE__, true);
1396 0 : return _r;
1397 : }
1398 1101702 : next_after_fail501:;
1399 : }
1400 : }
1401 : }
1402 : }
1403 : }
1404 : }
1405 1101702 : return NULL_TREE;
1406 : }
1407 :
1408 : tree
1409 4 : generic_simplify_282 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1410 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1411 : const enum tree_code ARG_UNUSED (cmp),
1412 : const enum tree_code ARG_UNUSED (ncmp))
1413 : {
1414 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1415 8 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1416 4 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1417 8 : && types_match (captures[0], captures[2])
1418 : )
1419 : {
1420 4 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail514;
1421 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail514;
1422 4 : {
1423 4 : tree res_op0;
1424 4 : {
1425 4 : tree _o1[2], _r1;
1426 4 : _o1[0] = captures[0];
1427 4 : _o1[1] = captures[2];
1428 4 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1429 4 : res_op0 = _r1;
1430 : }
1431 4 : tree res_op1;
1432 4 : res_op1 = captures[1];
1433 4 : tree _r;
1434 4 : _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
1435 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 416, __FILE__, __LINE__, true);
1436 4 : return _r;
1437 : }
1438 : next_after_fail514:;
1439 : }
1440 : return NULL_TREE;
1441 : }
1442 :
1443 : tree
1444 1067776 : generic_simplify_288 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1445 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1446 : const enum tree_code ARG_UNUSED (cmp))
1447 : {
1448 1067776 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1449 1631996 : if (((POINTER_TYPE_P (TREE_TYPE (captures[0]))
1450 505431 : && !FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (captures[0])))
1451 468182 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1452 9294 : && !(
1453 : 1
1454 9226 : && TREE_CODE (TREE_TYPE (captures[0])) == REFERENCE_TYPE
1455 68 : && (flag_sanitize & (SANITIZE_NULL | SANITIZE_ALIGNMENT))))
1456 1058562 : || (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1457 562216 : && POINTER_TYPE_P (TREE_TYPE (captures[1]))
1458 2255 : && !FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (captures[1])))))
1459 1078757 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == TYPE_PRECISION (TREE_TYPE (captures[1]))
1460 : )
1461 : {
1462 9883 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail534;
1463 9883 : {
1464 9883 : tree res_op0;
1465 9883 : res_op0 = captures[0];
1466 9883 : tree res_op1;
1467 9883 : {
1468 9883 : tree _o1[1], _r1;
1469 9883 : _o1[0] = captures[1];
1470 9883 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
1471 : {
1472 9883 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
1473 : }
1474 : else
1475 : _r1 = _o1[0];
1476 9883 : res_op1 = _r1;
1477 : }
1478 9883 : tree _r;
1479 9883 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1480 9883 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 427, __FILE__, __LINE__, true);
1481 9883 : return _r;
1482 : }
1483 0 : next_after_fail534:;
1484 : }
1485 : return NULL_TREE;
1486 : }
1487 :
1488 : tree
1489 591650 : generic_simplify_292 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1490 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1491 : const enum tree_code ARG_UNUSED (cmp),
1492 : const enum tree_code ARG_UNUSED (rcmp))
1493 : {
1494 591650 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1495 1183300 : if (!TREE_OVERFLOW (captures[0]) && !TREE_OVERFLOW (captures[2])
1496 1183300 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
1497 : )
1498 : {
1499 4398 : {
1500 4398 : tree res = int_const_binop (MINUS_EXPR, captures[0], captures[2]);
1501 4398 : if (TREE_OVERFLOW (res)
1502 : )
1503 : {
1504 48 : if (cmp == NE_EXPR
1505 : )
1506 : {
1507 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail543;
1508 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail543;
1509 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail543;
1510 0 : {
1511 0 : tree _r;
1512 0 : _r = constant_boolean_node (true, type);
1513 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1514 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1515 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 436, __FILE__, __LINE__, true);
1516 0 : return _r;
1517 : }
1518 : next_after_fail543:;
1519 : }
1520 : else
1521 : {
1522 48 : if (cmp == EQ_EXPR
1523 : )
1524 : {
1525 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail544;
1526 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail544;
1527 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail544;
1528 0 : {
1529 0 : tree _r;
1530 0 : _r = constant_boolean_node (false, type);
1531 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1532 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1533 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 437, __FILE__, __LINE__, true);
1534 0 : return _r;
1535 : }
1536 : next_after_fail544:;
1537 : }
1538 : else
1539 : {
1540 48 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail545;
1541 48 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail545;
1542 48 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail545;
1543 48 : {
1544 48 : tree _r;
1545 48 : bool less = cmp == LE_EXPR || cmp == LT_EXPR;
1546 48 : bool ovf_high = wi::lt_p (wi::to_wide (captures[0]), 0,
1547 48 : TYPE_SIGN (TREE_TYPE (captures[0]))); _r =
1548 48 : constant_boolean_node (less == ovf_high, type);
1549 48 : if (TREE_SIDE_EFFECTS (captures[1]))
1550 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1551 48 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 438, __FILE__, __LINE__, true);
1552 48 : return _r;
1553 : }
1554 : next_after_fail545:;
1555 : }
1556 : }
1557 : }
1558 : else
1559 : {
1560 4350 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail546;
1561 4350 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail546;
1562 4350 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail546;
1563 4350 : {
1564 4350 : tree res_op0;
1565 4350 : res_op0 = captures[1];
1566 4350 : tree res_op1;
1567 4350 : res_op1 = res;
1568 4350 : tree _r;
1569 4350 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
1570 4350 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 439, __FILE__, __LINE__, true);
1571 4350 : return _r;
1572 : }
1573 : next_after_fail546:;
1574 : }
1575 : }
1576 : }
1577 : else
1578 : {
1579 587252 : if (TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1580 : )
1581 : {
1582 587146 : if (cmp == EQ_EXPR || cmp == NE_EXPR
1583 : )
1584 : {
1585 37425 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail547;
1586 37425 : {
1587 37425 : tree res_op0;
1588 37425 : res_op0 = captures[1];
1589 37425 : tree res_op1;
1590 37425 : {
1591 37425 : tree _o1[2], _r1;
1592 37425 : _o1[0] = captures[0];
1593 37425 : _o1[1] = captures[2];
1594 37425 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1595 37425 : res_op1 = _r1;
1596 : }
1597 37425 : tree _r;
1598 37425 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1599 37425 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 440, __FILE__, __LINE__, true);
1600 37425 : return _r;
1601 : }
1602 0 : next_after_fail547:;
1603 : }
1604 : else
1605 : {
1606 549721 : if (cmp == LE_EXPR || cmp == GT_EXPR
1607 : )
1608 : {
1609 549721 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail548;
1610 549721 : {
1611 549721 : if (! tree_invariant_p (captures[2])) goto next_after_fail548;
1612 549721 : tree res_op0;
1613 549721 : {
1614 549721 : tree _o1[2], _r1;
1615 549721 : _o1[0] = captures[1];
1616 549721 : {
1617 549721 : tree _o2[2], _r2;
1618 549721 : _o2[0] = unshare_expr (captures[2]);
1619 549721 : _o2[1] = captures[0];
1620 549721 : _r2 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
1621 549721 : _o1[1] = _r2;
1622 : }
1623 549721 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1624 549721 : res_op0 = _r1;
1625 : }
1626 549721 : tree res_op1;
1627 549721 : res_op1 = captures[2];
1628 549721 : tree _r;
1629 549721 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1630 549721 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 441, __FILE__, __LINE__, true);
1631 549721 : return _r;
1632 : }
1633 : next_after_fail548:;
1634 : }
1635 : else
1636 : {
1637 0 : if (cmp == LT_EXPR || cmp == GE_EXPR
1638 : )
1639 : {
1640 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail549;
1641 0 : {
1642 0 : if (! tree_invariant_p (captures[2])) goto next_after_fail549;
1643 0 : tree res_op0;
1644 0 : {
1645 0 : tree _o1[2], _r1;
1646 0 : _o1[0] = captures[1];
1647 0 : {
1648 0 : tree _o2[2], _r2;
1649 0 : _o2[0] = unshare_expr (captures[2]);
1650 0 : {
1651 0 : tree _o3[2], _r3;
1652 0 : _o3[0] = captures[0];
1653 0 : _o3[1] = build_one_cst (TREE_TYPE (captures[1]));
1654 0 : _r3 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
1655 0 : _o2[1] = _r3;
1656 : }
1657 0 : _r2 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
1658 0 : _o1[1] = _r2;
1659 : }
1660 0 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1661 0 : res_op0 = _r1;
1662 : }
1663 0 : tree res_op1;
1664 0 : res_op1 = captures[2];
1665 0 : tree _r;
1666 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1667 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 442, __FILE__, __LINE__, true);
1668 0 : return _r;
1669 : }
1670 : next_after_fail549:;
1671 : }
1672 : }
1673 : }
1674 : }
1675 : else
1676 : {
1677 106 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1678 106 : && TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))
1679 : )
1680 : {
1681 106 : if (cmp == EQ_EXPR || cmp == NE_EXPR
1682 : )
1683 : {
1684 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail550;
1685 0 : {
1686 0 : tree res_op0;
1687 0 : res_op0 = captures[1];
1688 0 : tree res_op1;
1689 0 : {
1690 0 : tree _o1[2], _r1;
1691 0 : _o1[0] = captures[0];
1692 0 : _o1[1] = captures[2];
1693 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1694 0 : res_op1 = _r1;
1695 : }
1696 0 : tree _r;
1697 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1698 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 443, __FILE__, __LINE__, true);
1699 0 : return _r;
1700 : }
1701 0 : next_after_fail550:;
1702 : }
1703 : else
1704 : {
1705 106 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail551;
1706 106 : {
1707 106 : tree res_op0;
1708 106 : {
1709 106 : tree _o1[2], _r1;
1710 106 : _o1[0] = captures[1];
1711 106 : {
1712 106 : tree _o2[2], _r2;
1713 106 : _o2[0] = captures[0];
1714 106 : _o2[1] = build_one_cst (TREE_TYPE (captures[1]));
1715 106 : _r2 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
1716 106 : _o1[1] = _r2;
1717 : }
1718 106 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1719 106 : res_op0 = _r1;
1720 : }
1721 106 : tree res_op1;
1722 106 : {
1723 106 : tree _o1[1], _r1;
1724 106 : _o1[0] = captures[2];
1725 106 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
1726 106 : res_op1 = _r1;
1727 : }
1728 106 : tree _r;
1729 106 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
1730 106 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 444, __FILE__, __LINE__, true);
1731 106 : return _r;
1732 : }
1733 0 : next_after_fail551:;
1734 : }
1735 : }
1736 : }
1737 : }
1738 : return NULL_TREE;
1739 : }
1740 :
1741 : tree
1742 2 : generic_simplify_330 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1743 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
1744 : {
1745 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1746 0 : if (FLOAT_TYPE_P (type)
1747 2 : && ! HONOR_NANS (type)
1748 2 : && ! HONOR_INFINITIES (type)
1749 : )
1750 : {
1751 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail599;
1752 0 : {
1753 0 : tree _r;
1754 0 : _r = build_minus_one_cst (type);
1755 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1756 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1757 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 490, __FILE__, __LINE__, true);
1758 0 : return _r;
1759 : }
1760 0 : next_after_fail599:;
1761 : }
1762 : return NULL_TREE;
1763 : }
1764 :
1765 : tree
1766 6 : generic_simplify_338 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1767 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1768 : const combined_fn ARG_UNUSED (TAN),
1769 : const combined_fn ARG_UNUSED (SIN),
1770 : const combined_fn ARG_UNUSED (COS))
1771 : {
1772 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1773 6 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1774 : )
1775 : {
1776 6 : if (! HONOR_NANS (captures[1])
1777 6 : && ! HONOR_INFINITIES (captures[1])
1778 : )
1779 : {
1780 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail609;
1781 6 : {
1782 6 : tree res_op0;
1783 6 : res_op0 = build_one_cst (type);
1784 6 : tree res_op1;
1785 6 : {
1786 6 : tree _o1[1], _r1;
1787 6 : _o1[0] = captures[1];
1788 6 : _r1 = maybe_build_call_expr_loc (loc, COS, TREE_TYPE (_o1[0]), 1, _o1[0]);
1789 6 : if (!_r1)
1790 0 : goto next_after_fail609;
1791 6 : res_op1 = _r1;
1792 : }
1793 6 : tree _r;
1794 6 : _r = fold_build2_loc (loc, RDIV_EXPR, type, res_op0, res_op1);
1795 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 500, __FILE__, __LINE__, true);
1796 6 : return _r;
1797 : }
1798 : next_after_fail609:;
1799 : }
1800 : }
1801 : return NULL_TREE;
1802 : }
1803 :
1804 : tree
1805 9 : generic_simplify_348 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1806 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures))
1807 : {
1808 9 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1809 9 : if (INTEGRAL_TYPE_P (type)
1810 9 : && !TYPE_UNSIGNED (type)
1811 : )
1812 : {
1813 9 : {
1814 9 : tree utype = unsigned_type_for (type);
1815 9 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail625;
1816 9 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail625;
1817 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail625;
1818 9 : {
1819 9 : tree res_op0;
1820 9 : {
1821 9 : tree _o1[2], _r1;
1822 9 : {
1823 9 : tree _o2[1], _r2;
1824 9 : _o2[0] = captures[0];
1825 9 : if (TREE_TYPE (_o2[0]) != utype)
1826 : {
1827 9 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
1828 : }
1829 : else
1830 : _r2 = _o2[0];
1831 9 : _o1[0] = _r2;
1832 : }
1833 9 : {
1834 9 : tree _o2[1], _r2;
1835 9 : _o2[0] = captures[1];
1836 9 : if (TREE_TYPE (_o2[0]) != utype)
1837 : {
1838 9 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
1839 : }
1840 : else
1841 : _r2 = _o2[0];
1842 9 : _o1[1] = _r2;
1843 : }
1844 9 : _r1 = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1845 9 : res_op0 = _r1;
1846 : }
1847 9 : tree _r;
1848 9 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1849 9 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 516, __FILE__, __LINE__, true);
1850 9 : return _r;
1851 : }
1852 : next_after_fail625:;
1853 : }
1854 : }
1855 : return NULL_TREE;
1856 : }
1857 :
1858 : tree
1859 0 : generic_simplify_355 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1860 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1861 : const enum tree_code ARG_UNUSED (op))
1862 : {
1863 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1864 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail632;
1865 0 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail632;
1866 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail632;
1867 0 : {
1868 0 : tree _r;
1869 0 : _r = captures[2];
1870 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 523, __FILE__, __LINE__, true);
1871 : return _r;
1872 : }
1873 : next_after_fail632:;
1874 : return NULL_TREE;
1875 : }
1876 :
1877 : tree
1878 36 : generic_simplify_361 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1879 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1880 : const enum tree_code ARG_UNUSED (op))
1881 : {
1882 36 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1883 36 : {
1884 36 : auto c1 = wi::to_wide (captures[1]);
1885 36 : auto c2 = wi::to_wide (captures[2]);
1886 36 : if (wi::popcount (c1) == 1
1887 120 : && ((op == PLUS_EXPR && wi::eq_p (wi::neg (c2), c1))
1888 48 : || (op == BIT_AND_EXPR && wi::eq_p (wi::bit_not (c2), c1)))
1889 : )
1890 : {
1891 24 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail638;
1892 24 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail638;
1893 24 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail638;
1894 24 : {
1895 24 : tree res_op0;
1896 24 : res_op0 = captures[0];
1897 24 : tree res_op1;
1898 24 : res_op1 = captures[1];
1899 24 : tree _r;
1900 24 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
1901 24 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 529, __FILE__, __LINE__, true);
1902 24 : return _r;
1903 : }
1904 12 : next_after_fail638:;
1905 : }
1906 : }
1907 12 : return NULL_TREE;
1908 : }
1909 :
1910 : tree
1911 1995 : generic_simplify_372 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1912 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures))
1913 : {
1914 1995 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1915 1995 : if (INTEGRAL_TYPE_P (type)
1916 : )
1917 : {
1918 1995 : {
1919 1995 : tree itype = TREE_TYPE (captures[2]);
1920 1995 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail650;
1921 1995 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail650;
1922 1995 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail650;
1923 1995 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail650;
1924 1995 : {
1925 1995 : tree res_op0;
1926 1995 : {
1927 1995 : tree _o1[2], _r1;
1928 1995 : _o1[0] = captures[2];
1929 1995 : {
1930 1995 : tree _o2[1], _r2;
1931 1995 : _o2[0] = captures[0];
1932 1995 : if (TREE_TYPE (_o2[0]) != itype)
1933 : {
1934 1995 : _r2 = fold_build1_loc (loc, NOP_EXPR, itype, _o2[0]);
1935 : }
1936 : else
1937 : _r2 = _o2[0];
1938 1995 : _o1[1] = _r2;
1939 : }
1940 1995 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1941 1995 : res_op0 = _r1;
1942 : }
1943 1995 : tree _r;
1944 1995 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1945 1995 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 539, __FILE__, __LINE__, true);
1946 1995 : return _r;
1947 : }
1948 : next_after_fail650:;
1949 : }
1950 : }
1951 : return NULL_TREE;
1952 : }
1953 :
1954 : tree
1955 948 : generic_simplify_381 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1956 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1957 : const enum tree_code ARG_UNUSED (op))
1958 : {
1959 948 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1960 1896 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1961 1896 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
1962 : )
1963 : {
1964 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail663;
1965 0 : {
1966 0 : tree res_op0;
1967 0 : res_op0 = captures[0];
1968 0 : tree res_op1;
1969 0 : res_op1 = captures[2];
1970 0 : tree _r;
1971 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1972 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1973 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1974 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 552, __FILE__, __LINE__, true);
1975 0 : return _r;
1976 : }
1977 0 : next_after_fail663:;
1978 : }
1979 : return NULL_TREE;
1980 : }
1981 :
1982 : tree
1983 6 : generic_simplify_386 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1984 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1985 : const enum tree_code ARG_UNUSED (minmax),
1986 : const enum tree_code ARG_UNUSED (cmp))
1987 : {
1988 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1989 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail669;
1990 6 : {
1991 6 : tree _r;
1992 6 : _r = constant_boolean_node (cmp == GE_EXPR || cmp == LE_EXPR, type);
1993 6 : if (TREE_SIDE_EFFECTS (captures[0]))
1994 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1995 6 : if (TREE_SIDE_EFFECTS (captures[1]))
1996 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1997 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 558, __FILE__, __LINE__, true);
1998 : return _r;
1999 : }
2000 0 : next_after_fail669:;
2001 0 : return NULL_TREE;
2002 : }
2003 :
2004 : tree
2005 10115 : generic_simplify_396 (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 10115 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2010 10115 : if (single_use (captures[0])
2011 10115 : && ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2012 10099 : && TYPE_UNSIGNED (TREE_TYPE (captures[1]))
2013 : )
2014 : {
2015 7721 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail711;
2016 7721 : {
2017 7721 : tree res_op0;
2018 7721 : res_op0 = captures[2];
2019 7721 : tree res_op1;
2020 7721 : res_op1 = captures[1];
2021 7721 : tree _r;
2022 7721 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2023 7721 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 583, __FILE__, __LINE__, true);
2024 7721 : return _r;
2025 : }
2026 0 : next_after_fail711:;
2027 : }
2028 : return NULL_TREE;
2029 : }
2030 :
2031 : tree
2032 1475 : generic_simplify_401 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2033 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2034 : const enum tree_code ARG_UNUSED (cmp),
2035 : const enum tree_code ARG_UNUSED (neg_cmp))
2036 : {
2037 1475 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2038 1475 : if (flag_unsafe_math_optimizations
2039 : )
2040 : {
2041 9 : {
2042 9 : tree tem = const_binop (RDIV_EXPR, type, captures[2], captures[1]);
2043 9 : if (tem
2044 27 : && !(REAL_VALUE_ISINF (TREE_REAL_CST (tem))
2045 15 : || (real_zerop (tem) && !real_zerop (captures[1])))
2046 : )
2047 : {
2048 3 : if (real_less (&dconst0, TREE_REAL_CST_PTR (captures[1]))
2049 : )
2050 : {
2051 2 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail716;
2052 2 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail716;
2053 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail716;
2054 2 : {
2055 2 : tree res_op0;
2056 2 : res_op0 = captures[0];
2057 2 : tree res_op1;
2058 2 : res_op1 = tem;
2059 2 : tree _r;
2060 2 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2061 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 588, __FILE__, __LINE__, true);
2062 2 : return _r;
2063 : }
2064 : next_after_fail716:;
2065 : }
2066 : else
2067 : {
2068 1 : if (real_less (TREE_REAL_CST_PTR (captures[1]), &dconst0)
2069 : )
2070 : {
2071 1 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail717;
2072 1 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail717;
2073 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail717;
2074 1 : {
2075 1 : tree res_op0;
2076 1 : res_op0 = captures[0];
2077 1 : tree res_op1;
2078 1 : res_op1 = tem;
2079 1 : tree _r;
2080 1 : _r = fold_build2_loc (loc, neg_cmp, type, res_op0, res_op1);
2081 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 589, __FILE__, __LINE__, true);
2082 1 : return _r;
2083 : }
2084 : next_after_fail717:;
2085 : }
2086 : }
2087 : }
2088 : }
2089 : }
2090 : return NULL_TREE;
2091 : }
2092 :
2093 : tree
2094 0 : generic_simplify_410 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2095 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2096 : const enum tree_code ARG_UNUSED (cmp),
2097 : const enum tree_code ARG_UNUSED (out))
2098 : {
2099 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2100 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[1]))
2101 0 : && types_match (TREE_TYPE (captures[1]), TREE_TYPE (captures[2]))
2102 : )
2103 : {
2104 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail732;
2105 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail732;
2106 0 : {
2107 0 : tree res_op0;
2108 0 : {
2109 0 : tree _o1[1], _r1;
2110 0 : _o1[0] = captures[0];
2111 0 : _r1 = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
2112 0 : res_op0 = _r1;
2113 : }
2114 0 : tree res_op1;
2115 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[1]));
2116 0 : tree _r;
2117 0 : _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
2118 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 586, __FILE__, __LINE__, true);
2119 0 : return _r;
2120 : }
2121 : next_after_fail732:;
2122 : }
2123 : return NULL_TREE;
2124 : }
2125 :
2126 : tree
2127 94 : generic_simplify_415 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2128 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2129 : {
2130 94 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2131 188 : if (INTEGRAL_TYPE_P (type)
2132 93 : && !TYPE_UNSIGNED (type)
2133 93 : && !TYPE_OVERFLOW_TRAPS (type)
2134 93 : && tree_nop_conversion_p (type, TREE_TYPE (captures[2]))
2135 281 : && (expr_not_equal_to (captures[0], wi::to_wide (TYPE_MIN_VALUE (type)))
2136 187 : || expr_not_equal_to (captures[2], wi::minus_one (TYPE_PRECISION
2137 : (TREE_TYPE (captures[2]))),
2138 : gimple_match_ctx (captures[1])))
2139 : )
2140 : {
2141 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail741;
2142 0 : {
2143 0 : tree res_op0;
2144 0 : res_op0 = captures[0];
2145 0 : tree res_op1;
2146 0 : {
2147 0 : tree _o1[1], _r1;
2148 0 : _o1[0] = captures[2];
2149 0 : if (TREE_TYPE (_o1[0]) != type)
2150 : {
2151 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2152 : }
2153 : else
2154 : _r1 = _o1[0];
2155 0 : res_op1 = _r1;
2156 : }
2157 0 : tree _r;
2158 0 : _r = fold_build2_loc (loc, TRUNC_MOD_EXPR, type, res_op0, res_op1);
2159 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 609, __FILE__, __LINE__, true);
2160 0 : return _r;
2161 : }
2162 0 : next_after_fail741:;
2163 : }
2164 : return NULL_TREE;
2165 : }
2166 :
2167 : tree
2168 0 : generic_simplify_422 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2169 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2170 : const enum tree_code ARG_UNUSED (shiftrotate))
2171 : {
2172 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2173 0 : {
2174 0 : tree tem = uniform_vector_p (captures[1]);
2175 0 : if (tem
2176 : )
2177 : {
2178 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail748;
2179 0 : {
2180 0 : tree res_op0;
2181 0 : res_op0 = captures[0];
2182 0 : tree res_op1;
2183 0 : res_op1 = tem;
2184 0 : tree _r;
2185 0 : _r = fold_build2_loc (loc, shiftrotate, type, res_op0, res_op1);
2186 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2187 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2188 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 615, __FILE__, __LINE__, true);
2189 0 : return _r;
2190 : }
2191 0 : next_after_fail748:;
2192 : }
2193 : }
2194 : return NULL_TREE;
2195 : }
2196 :
2197 : tree
2198 3580935 : generic_simplify_429 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2199 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2200 : const enum tree_code ARG_UNUSED (bitop))
2201 : {
2202 3580935 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2203 3580935 : if (0
2204 : && INTEGRAL_TYPE_P (type)
2205 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2206 : && TREE_CODE (captures[3]) != INTEGER_CST
2207 : && tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
2208 : && TYPE_PRECISION (TREE_TYPE (captures[2])) > TYPE_PRECISION (type)
2209 : )
2210 : {
2211 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail762;
2212 : {
2213 : tree res_op0;
2214 : {
2215 : tree _o1[1], _r1;
2216 : _o1[0] = captures[2];
2217 : if (TREE_TYPE (_o1[0]) != type)
2218 : {
2219 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2220 : }
2221 : else
2222 : _r1 = _o1[0];
2223 : res_op0 = _r1;
2224 : }
2225 : tree res_op1;
2226 : {
2227 : tree _o1[1], _r1;
2228 : _o1[0] = captures[3];
2229 : if (TREE_TYPE (_o1[0]) != type)
2230 : {
2231 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2232 : }
2233 : else
2234 : _r1 = _o1[0];
2235 : res_op1 = _r1;
2236 : }
2237 : tree _r;
2238 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
2239 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 628, __FILE__, __LINE__, true);
2240 : return _r;
2241 : }
2242 : next_after_fail762:;
2243 : }
2244 : else
2245 : {
2246 3580935 : if (0
2247 : && INTEGRAL_TYPE_P (type)
2248 : && types_match (type, TREE_TYPE (captures[2]))
2249 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (type)
2250 : )
2251 : {
2252 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail763;
2253 : {
2254 : tree res_op0;
2255 : res_op0 = captures[2];
2256 : tree res_op1;
2257 : {
2258 : tree _o1[1], _r1;
2259 : _o1[0] = captures[3];
2260 : if (TREE_TYPE (_o1[0]) != type)
2261 : {
2262 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2263 : }
2264 : else
2265 : _r1 = _o1[0];
2266 : res_op1 = _r1;
2267 : }
2268 : tree _r;
2269 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
2270 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 629, __FILE__, __LINE__, true);
2271 : return _r;
2272 : }
2273 : next_after_fail763:;
2274 : }
2275 : }
2276 3580935 : return NULL_TREE;
2277 : }
2278 :
2279 : tree
2280 21379718 : generic_simplify_435 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2281 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2282 : const enum tree_code ARG_UNUSED (op))
2283 : {
2284 21379718 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2285 21379718 : if (INTEGRAL_TYPE_P (type)
2286 19945809 : && op != MULT_EXPR
2287 19945809 : && op != RDIV_EXPR
2288 11098177 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2289 11098177 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2290 11098177 : && type_has_mode_precision_p (TREE_TYPE (captures[2]))
2291 11096869 : && type_has_mode_precision_p (TREE_TYPE (captures[4]))
2292 11096869 : && type_has_mode_precision_p (type)
2293 11062714 : && TYPE_PRECISION (TREE_TYPE (captures[1])) > TYPE_PRECISION (TREE_TYPE (captures[2]))
2294 0 : && types_match (captures[2], type)
2295 21379718 : && (types_match (captures[2], captures[4])
2296 0 : || poly_int_tree_p (captures[3]))
2297 : )
2298 : {
2299 0 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))
2300 : )
2301 : {
2302 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail779;
2303 0 : {
2304 0 : tree res_op0;
2305 0 : res_op0 = captures[2];
2306 0 : tree res_op1;
2307 0 : {
2308 0 : tree _o1[1], _r1;
2309 0 : _o1[0] = captures[4];
2310 0 : if (TREE_TYPE (_o1[0]) != type)
2311 : {
2312 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2313 : }
2314 : else
2315 : _r1 = _o1[0];
2316 0 : res_op1 = _r1;
2317 : }
2318 0 : tree _r;
2319 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2320 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 633, __FILE__, __LINE__, true);
2321 0 : return _r;
2322 : }
2323 0 : next_after_fail779:;
2324 : }
2325 : else
2326 : {
2327 0 : {
2328 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
2329 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail780;
2330 0 : {
2331 0 : tree res_op0;
2332 0 : {
2333 0 : tree _o1[2], _r1;
2334 0 : {
2335 0 : tree _o2[1], _r2;
2336 0 : _o2[0] = captures[2];
2337 0 : if (TREE_TYPE (_o2[0]) != utype)
2338 : {
2339 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2340 : }
2341 : else
2342 : _r2 = _o2[0];
2343 0 : _o1[0] = _r2;
2344 : }
2345 0 : {
2346 0 : tree _o2[1], _r2;
2347 0 : _o2[0] = captures[4];
2348 0 : if (TREE_TYPE (_o2[0]) != utype)
2349 : {
2350 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2351 : }
2352 : else
2353 : _r2 = _o2[0];
2354 0 : _o1[1] = _r2;
2355 : }
2356 0 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2357 0 : res_op0 = _r1;
2358 : }
2359 0 : tree _r;
2360 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2361 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 634, __FILE__, __LINE__, true);
2362 0 : return _r;
2363 : }
2364 0 : next_after_fail780:;
2365 : }
2366 : }
2367 : }
2368 : else
2369 : {
2370 21332505 : if (FLOAT_TYPE_P (type)
2371 21426931 : && DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
2372 47213 : == DECIMAL_FLOAT_TYPE_P (type)
2373 : )
2374 : {
2375 47173 : {
2376 47173 : tree arg0 = strip_float_extensions (captures[2]);
2377 47173 : tree arg1 = strip_float_extensions (captures[4]);
2378 47173 : tree itype = TREE_TYPE (captures[0]);
2379 47173 : tree ty1 = TREE_TYPE (arg0);
2380 47173 : tree ty2 = TREE_TYPE (arg1);
2381 47173 : enum tree_code code = TREE_CODE (itype);
2382 0 : if (FLOAT_TYPE_P (ty1)
2383 47173 : && FLOAT_TYPE_P (ty2)
2384 : )
2385 : {
2386 47173 : {
2387 47173 : tree newtype = type;
2388 47173 : if (TYPE_MODE (ty1) == SDmode
2389 46905 : || TYPE_MODE (ty2) == SDmode
2390 94078 : || TYPE_MODE (type) == SDmode)
2391 283 : newtype = dfloat32_type_node;
2392 47173 : if (TYPE_MODE (ty1) == DDmode
2393 47027 : || TYPE_MODE (ty2) == DDmode
2394 94073 : || TYPE_MODE (type) == DDmode)
2395 275 : newtype = dfloat64_type_node;
2396 47173 : if (TYPE_MODE (ty1) == TDmode
2397 47172 : || TYPE_MODE (ty2) == TDmode
2398 94093 : || TYPE_MODE (type) == TDmode)
2399 268 : newtype = dfloat128_type_node;
2400 47173 : if ((newtype == dfloat32_type_node
2401 47169 : || newtype == dfloat64_type_node
2402 47026 : || newtype == dfloat128_type_node)
2403 415 : && newtype == type
2404 47184 : && types_match (newtype, type)
2405 : )
2406 : {
2407 11 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail781;
2408 5 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail781;
2409 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail781;
2410 5 : {
2411 5 : tree res_op0;
2412 5 : {
2413 5 : tree _o1[1], _r1;
2414 5 : _o1[0] = captures[2];
2415 5 : if (TREE_TYPE (_o1[0]) != newtype)
2416 : {
2417 5 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
2418 : }
2419 : else
2420 : _r1 = _o1[0];
2421 5 : res_op0 = _r1;
2422 : }
2423 5 : tree res_op1;
2424 5 : {
2425 5 : tree _o1[1], _r1;
2426 5 : _o1[0] = captures[4];
2427 5 : if (TREE_TYPE (_o1[0]) != newtype)
2428 : {
2429 5 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
2430 : }
2431 : else
2432 : _r1 = _o1[0];
2433 5 : res_op1 = _r1;
2434 : }
2435 5 : tree _r;
2436 5 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2437 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 635, __FILE__, __LINE__, true);
2438 5 : return _r;
2439 : }
2440 : next_after_fail781:;
2441 : }
2442 : else
2443 : {
2444 47162 : {
2445 47162 : if (element_precision (ty1) > element_precision (newtype))
2446 9740 : newtype = ty1;
2447 47162 : if (element_precision (ty2) > element_precision (newtype))
2448 4295 : newtype = ty2;
2449 47162 : if (element_precision (newtype) < element_precision (itype)
2450 12511 : && (!VECTOR_MODE_P (TYPE_MODE (newtype))
2451 0 : || target_supports_op_p (newtype, op, optab_default))
2452 12511 : && (flag_unsafe_math_optimizations
2453 12503 : || (element_precision (newtype) == element_precision (type)
2454 12474 : && real_can_shorten_arithmetic (element_mode (itype),
2455 : element_mode (type))
2456 3555 : && !excess_precision_type (newtype)))
2457 47317 : && !types_match (itype, newtype)
2458 : )
2459 : {
2460 155 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail782;
2461 154 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail782;
2462 136 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail782;
2463 136 : {
2464 136 : tree res_op0;
2465 136 : {
2466 136 : tree _o1[2], _r1;
2467 136 : {
2468 136 : tree _o2[1], _r2;
2469 136 : _o2[0] = captures[2];
2470 136 : if (TREE_TYPE (_o2[0]) != newtype)
2471 : {
2472 136 : _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
2473 : }
2474 : else
2475 : _r2 = _o2[0];
2476 136 : _o1[0] = _r2;
2477 : }
2478 136 : {
2479 136 : tree _o2[1], _r2;
2480 136 : _o2[0] = captures[4];
2481 136 : if (TREE_TYPE (_o2[0]) != newtype)
2482 : {
2483 136 : _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
2484 : }
2485 : else
2486 : _r2 = _o2[0];
2487 136 : _o1[1] = _r2;
2488 : }
2489 136 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2490 136 : res_op0 = _r1;
2491 : }
2492 136 : tree _r;
2493 136 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2494 136 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 636, __FILE__, __LINE__, true);
2495 136 : return _r;
2496 : }
2497 : next_after_fail782:;
2498 : }
2499 : }
2500 : }
2501 : }
2502 : }
2503 : }
2504 : }
2505 : }
2506 : return NULL_TREE;
2507 : }
2508 :
2509 : tree
2510 0 : generic_simplify_467 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2511 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2512 : const enum tree_code ARG_UNUSED (cmp))
2513 : {
2514 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2515 0 : if (fold_before_rtl_expansion_p ()
2516 : )
2517 : {
2518 0 : if (INTEGRAL_TYPE_P (type)
2519 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2520 : )
2521 : {
2522 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail814;
2523 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail814;
2524 0 : {
2525 0 : tree res_op0;
2526 0 : res_op0 = captures[0];
2527 0 : tree res_op1;
2528 0 : res_op1 = captures[3];
2529 0 : tree res_op2;
2530 0 : res_op2 = build_zero_cst (type);
2531 0 : tree _r;
2532 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
2533 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 667, __FILE__, __LINE__, true);
2534 0 : return _r;
2535 : }
2536 : next_after_fail814:;
2537 : }
2538 : }
2539 : return NULL_TREE;
2540 : }
2541 :
2542 : tree
2543 0 : generic_simplify_477 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2544 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2545 : const enum tree_code ARG_UNUSED (eqne))
2546 : {
2547 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2548 0 : if (eqne == EQ_EXPR
2549 : )
2550 : {
2551 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail845;
2552 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail845;
2553 0 : {
2554 0 : tree _r;
2555 0 : _r = constant_boolean_node (false, type);
2556 0 : if (TREE_SIDE_EFFECTS (captures[2]))
2557 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2558 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 671, __FILE__, __LINE__, true);
2559 0 : return _r;
2560 : }
2561 : next_after_fail845:;
2562 : }
2563 : else
2564 : {
2565 0 : if (eqne == NE_EXPR
2566 : )
2567 : {
2568 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail846;
2569 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail846;
2570 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail846;
2571 0 : {
2572 0 : tree _r;
2573 0 : _r = captures[0];
2574 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 672, __FILE__, __LINE__, true);
2575 0 : return _r;
2576 : }
2577 : next_after_fail846:;
2578 : }
2579 : }
2580 : return NULL_TREE;
2581 : }
2582 :
2583 : tree
2584 4 : generic_simplify_485 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2585 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2586 : {
2587 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2588 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail866;
2589 4 : {
2590 4 : tree res_op0;
2591 4 : res_op0 = captures[1];
2592 4 : tree res_op1;
2593 4 : {
2594 4 : tree _o1[2], _r1;
2595 4 : _o1[0] = captures[2];
2596 4 : _o1[1] = captures[3];
2597 4 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2598 4 : if (EXPR_P (_r1))
2599 2 : goto next_after_fail866;
2600 2 : res_op1 = _r1;
2601 : }
2602 2 : tree _r;
2603 2 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
2604 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 690, __FILE__, __LINE__, true);
2605 : return _r;
2606 : }
2607 : next_after_fail866:;
2608 : return NULL_TREE;
2609 : }
2610 :
2611 : tree
2612 234 : generic_simplify_490 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2613 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2614 : const combined_fn ARG_UNUSED (bswap))
2615 : {
2616 234 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2617 234 : if (BITS_PER_UNIT == 8
2618 234 : && tree_fits_uhwi_p (captures[3])
2619 234 : && tree_fits_uhwi_p (captures[4])
2620 : )
2621 : {
2622 234 : {
2623 234 : unsigned HOST_WIDE_INT prec = TYPE_PRECISION (TREE_TYPE (captures[1]));
2624 234 : unsigned HOST_WIDE_INT bits = tree_to_uhwi (captures[3]);
2625 234 : unsigned HOST_WIDE_INT mask = tree_to_uhwi (captures[4]);
2626 234 : unsigned HOST_WIDE_INT lo = bits & 7;
2627 234 : unsigned HOST_WIDE_INT hi = bits - lo;
2628 234 : if (bits < prec
2629 234 : && mask < (256u>>lo)
2630 468 : && bits < TYPE_PRECISION (TREE_TYPE(captures[0]))
2631 : )
2632 : {
2633 234 : {
2634 234 : unsigned HOST_WIDE_INT ns = (prec - (hi + 8)) + lo;
2635 234 : if (ns == 0
2636 : )
2637 : {
2638 1 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail879;
2639 1 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail879;
2640 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail879;
2641 1 : {
2642 1 : tree res_op0;
2643 1 : {
2644 1 : tree _o1[1], _r1;
2645 1 : _o1[0] = captures[2];
2646 1 : if (TREE_TYPE (_o1[0]) != type)
2647 : {
2648 1 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2649 : }
2650 : else
2651 : _r1 = _o1[0];
2652 1 : res_op0 = _r1;
2653 : }
2654 1 : tree res_op1;
2655 1 : res_op1 = captures[4];
2656 1 : tree _r;
2657 1 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2658 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 694, __FILE__, __LINE__, true);
2659 1 : return _r;
2660 : }
2661 : next_after_fail879:;
2662 : }
2663 : else
2664 : {
2665 233 : {
2666 233 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
2667 233 : tree nst = build_int_cst (integer_type_node, ns);
2668 233 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail880;
2669 233 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail880;
2670 233 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail880;
2671 233 : {
2672 233 : tree res_op0;
2673 233 : {
2674 233 : tree _o1[1], _r1;
2675 233 : {
2676 233 : tree _o2[2], _r2;
2677 233 : {
2678 233 : tree _o3[1], _r3;
2679 233 : _o3[0] = captures[2];
2680 233 : if (TREE_TYPE (_o3[0]) != utype)
2681 : {
2682 0 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
2683 : }
2684 : else
2685 : _r3 = _o3[0];
2686 233 : _o2[0] = _r3;
2687 : }
2688 233 : _o2[1] = nst;
2689 233 : _r2 = fold_build2_loc (loc, RSHIFT_EXPR, utype, _o2[0], _o2[1]);
2690 233 : _o1[0] = _r2;
2691 : }
2692 233 : if (TREE_TYPE (_o1[0]) != type)
2693 : {
2694 101 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2695 : }
2696 : else
2697 : _r1 = _o1[0];
2698 233 : res_op0 = _r1;
2699 : }
2700 233 : tree res_op1;
2701 233 : res_op1 = captures[4];
2702 233 : tree _r;
2703 233 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2704 233 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 695, __FILE__, __LINE__, true);
2705 233 : return _r;
2706 : }
2707 : next_after_fail880:;
2708 : }
2709 : }
2710 : }
2711 : }
2712 : }
2713 : }
2714 : return NULL_TREE;
2715 : }
2716 :
2717 : tree
2718 0 : generic_simplify_492 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2719 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2720 : {
2721 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2722 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail882;
2723 0 : {
2724 0 : tree res_op0;
2725 0 : res_op0 = captures[0];
2726 0 : tree res_op1;
2727 0 : res_op1 = captures[1];
2728 0 : tree _r;
2729 0 : _r = fold_build2_loc (loc, LTGT_EXPR, type, res_op0, res_op1);
2730 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 697, __FILE__, __LINE__, true);
2731 : return _r;
2732 : }
2733 0 : next_after_fail882:;
2734 0 : return NULL_TREE;
2735 : }
2736 :
2737 : tree
2738 0 : generic_simplify_493 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2739 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2740 : {
2741 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2742 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail883;
2743 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail883;
2744 0 : {
2745 0 : tree _r;
2746 0 : _r = captures[1];
2747 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 698, __FILE__, __LINE__, true);
2748 : return _r;
2749 : }
2750 : next_after_fail883:;
2751 : return NULL_TREE;
2752 : }
2753 :
2754 : tree
2755 3 : generic_simplify_496 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2756 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2757 : const combined_fn ARG_UNUSED (POPCOUNT),
2758 : const combined_fn ARG_UNUSED (PARITY))
2759 : {
2760 3 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2761 3 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail887;
2762 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail887;
2763 3 : {
2764 3 : tree res_op0;
2765 3 : res_op0 = captures[0];
2766 3 : tree _r;
2767 3 : _r = maybe_build_call_expr_loc (loc, PARITY, type, 1, res_op0);
2768 3 : if (!_r)
2769 0 : goto next_after_fail887;
2770 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 701, __FILE__, __LINE__, true);
2771 : return _r;
2772 : }
2773 : next_after_fail887:;
2774 : return NULL_TREE;
2775 : }
2776 :
2777 : tree
2778 3792 : generic_simplify_501 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2779 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2780 : {
2781 3792 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2782 3792 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[0]))
2783 3792 : || !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
2784 : )
2785 : {
2786 3350 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail892;
2787 3350 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail892;
2788 3350 : {
2789 3350 : tree res_op0;
2790 3350 : {
2791 3350 : tree _o1[1], _r1;
2792 3350 : _o1[0] = captures[0];
2793 3350 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2794 3350 : res_op0 = _r1;
2795 : }
2796 3350 : tree _r;
2797 3350 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2798 3350 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 706, __FILE__, __LINE__, true);
2799 3350 : return _r;
2800 : }
2801 : next_after_fail892:;
2802 : }
2803 : return NULL_TREE;
2804 : }
2805 :
2806 : tree
2807 2 : generic_simplify_509 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2808 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2809 : const enum tree_code ARG_UNUSED (rotate))
2810 : {
2811 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2812 2 : if ((element_precision (TREE_TYPE (captures[2]))
2813 2 : <= element_precision (TREE_TYPE (captures[3]))
2814 0 : || !TYPE_UNSIGNED (TREE_TYPE (captures[3])))
2815 2 : && (element_precision (type) <= element_precision (TREE_TYPE (captures[2]))
2816 0 : || !TYPE_UNSIGNED (TREE_TYPE (captures[2])))
2817 : )
2818 : {
2819 2 : {
2820 2 : tree rotate_type = TREE_TYPE (captures[2]);
2821 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail900;
2822 2 : {
2823 2 : tree res_op0;
2824 2 : {
2825 2 : tree _o1[2], _r1;
2826 2 : {
2827 2 : tree _o2[1], _r2;
2828 2 : _o2[0] = captures[3];
2829 2 : if (TREE_TYPE (_o2[0]) != rotate_type)
2830 : {
2831 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, rotate_type, _o2[0]);
2832 : }
2833 : else
2834 : _r2 = _o2[0];
2835 2 : _o1[0] = _r2;
2836 : }
2837 2 : _o1[1] = captures[4];
2838 2 : _r1 = fold_build2_loc (loc, rotate, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2839 2 : res_op0 = _r1;
2840 : }
2841 2 : tree _r;
2842 2 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2843 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 711, __FILE__, __LINE__, true);
2844 2 : return _r;
2845 : }
2846 0 : next_after_fail900:;
2847 : }
2848 : }
2849 : return NULL_TREE;
2850 : }
2851 :
2852 : tree
2853 2 : generic_simplify_522 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2854 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2855 : {
2856 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2857 2 : if (TREE_CODE (type) != COMPLEX_TYPE
2858 2 : && (! ANY_INTEGRAL_TYPE_P (type)
2859 1 : || TYPE_OVERFLOW_UNDEFINED (type))
2860 : )
2861 : {
2862 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail915;
2863 2 : {
2864 2 : tree res_op0;
2865 2 : {
2866 2 : tree _o1[1], _r1;
2867 2 : _o1[0] = captures[0];
2868 2 : _r1 = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2869 2 : res_op0 = _r1;
2870 : }
2871 2 : tree _r;
2872 2 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
2873 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 726, __FILE__, __LINE__, true);
2874 2 : return _r;
2875 : }
2876 0 : next_after_fail915:;
2877 : }
2878 : return NULL_TREE;
2879 : }
2880 :
2881 : tree
2882 0 : generic_simplify_531 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2883 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2884 : const enum tree_code ARG_UNUSED (minmax),
2885 : const enum tree_code ARG_UNUSED (maxmin))
2886 : {
2887 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2888 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail938;
2889 0 : {
2890 0 : tree res_op0;
2891 0 : {
2892 0 : tree _o1[2], _r1;
2893 0 : _o1[0] = captures[1];
2894 0 : _o1[1] = captures[3];
2895 0 : _r1 = fold_build2_loc (loc, maxmin, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2896 0 : res_op0 = _r1;
2897 : }
2898 0 : tree _r;
2899 0 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
2900 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 737, __FILE__, __LINE__, true);
2901 : return _r;
2902 : }
2903 0 : next_after_fail938:;
2904 0 : return NULL_TREE;
2905 : }
2906 :
2907 : tree
2908 0 : generic_simplify_536 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2909 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2910 : const combined_fn ARG_UNUSED (minmax))
2911 : {
2912 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2913 0 : if (real_isnan (TREE_REAL_CST_PTR (captures[1]))
2914 0 : && (!HONOR_SNANS (captures[1]) || !TREE_REAL_CST (captures[1]).signalling)
2915 0 : && !tree_expr_maybe_signaling_nan_p (captures[0])
2916 : )
2917 : {
2918 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail943;
2919 0 : {
2920 0 : tree _r;
2921 0 : _r = captures[0];
2922 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2923 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2924 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 742, __FILE__, __LINE__, true);
2925 0 : return _r;
2926 : }
2927 0 : next_after_fail943:;
2928 : }
2929 : return NULL_TREE;
2930 : }
2931 :
2932 : tree
2933 0 : generic_simplify_545 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2934 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
2935 : const combined_fn ARG_UNUSED (cond_op))
2936 : {
2937 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2938 0 : {
2939 0 : tree op_type = TREE_TYPE (captures[5]);
2940 0 : if (inverse_conditions_p (captures[0], captures[2])
2941 0 : && element_precision (type) == element_precision (op_type)
2942 : )
2943 : {
2944 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail952;
2945 0 : {
2946 0 : tree res_op0;
2947 0 : {
2948 0 : tree _o1[4], _r1;
2949 0 : _o1[0] = captures[2];
2950 0 : _o1[1] = captures[3];
2951 0 : _o1[2] = captures[4];
2952 0 : {
2953 0 : tree _o2[1], _r2;
2954 0 : _o2[0] = captures[1];
2955 0 : if (TREE_TYPE (_o2[0]) != op_type)
2956 : {
2957 0 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
2958 : }
2959 : else
2960 : _r2 = _o2[0];
2961 0 : _o1[3] = _r2;
2962 : }
2963 0 : _r1 = maybe_build_call_expr_loc (loc, cond_op, TREE_TYPE (_o1[1]), 4, _o1[0], _o1[1], _o1[2], _o1[3]);
2964 0 : if (!_r1)
2965 0 : goto next_after_fail952;
2966 0 : res_op0 = _r1;
2967 : }
2968 0 : tree _r;
2969 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
2970 0 : if (TREE_SIDE_EFFECTS (captures[0]))
2971 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2972 0 : if (TREE_SIDE_EFFECTS (captures[5]))
2973 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
2974 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 746, __FILE__, __LINE__, true);
2975 0 : return _r;
2976 : }
2977 : next_after_fail952:;
2978 : }
2979 : }
2980 : return NULL_TREE;
2981 : }
2982 :
2983 : tree
2984 5786 : generic_simplify_556 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2985 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2986 : {
2987 5786 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2988 11572 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2989 5786 : && TYPE_MAX_VALUE (TREE_TYPE (captures[1]))
2990 5786 : && types_match (TREE_TYPE (captures[1]), TREE_TYPE (TREE_TYPE (captures[0])))
2991 8082 : && int_fits_type_p (captures[2], TREE_TYPE (captures[1]))
2992 : )
2993 : {
2994 1904 : if (TYPE_UNSIGNED (TREE_TYPE (captures[1]))
2995 : )
2996 : {
2997 929 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail964;
2998 929 : {
2999 929 : tree res_op0;
3000 929 : {
3001 929 : tree _o1[2], _r1;
3002 929 : _o1[0] = captures[1];
3003 929 : {
3004 929 : tree _o2[2], _r2;
3005 929 : _o2[0] = TYPE_MAX_VALUE (TREE_TYPE (captures[1]));
3006 929 : _o2[1] = captures[2];
3007 929 : _r2 = fold_build2_loc (loc, TRUNC_DIV_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
3008 929 : if (EXPR_P (_r2))
3009 0 : goto next_after_fail964;
3010 929 : _o1[1] = _r2;
3011 : }
3012 929 : _r1 = fold_build2_loc (loc, GT_EXPR, boolean_type_node, _o1[0], _o1[1]);
3013 929 : res_op0 = _r1;
3014 : }
3015 929 : tree _r;
3016 929 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3017 929 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 758, __FILE__, __LINE__, true);
3018 929 : return _r;
3019 : }
3020 : next_after_fail964:;
3021 : }
3022 : else
3023 : {
3024 975 : if (TYPE_MIN_VALUE (TREE_TYPE (captures[1]))
3025 : )
3026 : {
3027 975 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[2])) && integer_minus_onep (captures[2])
3028 : )
3029 : {
3030 56 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail965;
3031 56 : {
3032 56 : tree res_op0;
3033 56 : {
3034 56 : tree _o1[2], _r1;
3035 56 : _o1[0] = captures[1];
3036 56 : _o1[1] = TYPE_MIN_VALUE (TREE_TYPE (captures[1]));
3037 56 : _r1 = fold_build2_loc (loc, EQ_EXPR, boolean_type_node, _o1[0], _o1[1]);
3038 56 : res_op0 = _r1;
3039 : }
3040 56 : tree _r;
3041 56 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3042 56 : if (TREE_SIDE_EFFECTS (captures[2]))
3043 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
3044 56 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 759, __FILE__, __LINE__, true);
3045 56 : return _r;
3046 : }
3047 0 : next_after_fail965:;
3048 : }
3049 : else
3050 : {
3051 919 : {
3052 919 : tree div = fold_convert (TREE_TYPE (captures[1]), captures[2]);
3053 1838 : tree lo = int_const_binop (TRUNC_DIV_EXPR,
3054 919 : TYPE_MIN_VALUE (TREE_TYPE (captures[1])), div);
3055 1838 : tree hi = int_const_binop (TRUNC_DIV_EXPR,
3056 919 : TYPE_MAX_VALUE (TREE_TYPE (captures[1])), div);
3057 919 : tree etype = range_check_type (TREE_TYPE (captures[1]));
3058 919 : if (etype)
3059 : {
3060 919 : if (wi::neg_p (wi::to_wide (div)))
3061 88 : std::swap (lo, hi);
3062 919 : lo = fold_convert (etype, lo);
3063 919 : hi = fold_convert (etype, hi);
3064 919 : hi = int_const_binop (MINUS_EXPR, hi, lo);
3065 : }
3066 919 : if (etype
3067 : )
3068 : {
3069 919 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail966;
3070 919 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail966;
3071 919 : {
3072 919 : tree res_op0;
3073 919 : {
3074 919 : tree _o1[2], _r1;
3075 919 : {
3076 919 : tree _o2[2], _r2;
3077 919 : {
3078 919 : tree _o3[1], _r3;
3079 919 : _o3[0] = captures[1];
3080 919 : if (TREE_TYPE (_o3[0]) != etype)
3081 : {
3082 919 : _r3 = fold_build1_loc (loc, NOP_EXPR, etype, _o3[0]);
3083 : }
3084 : else
3085 : _r3 = _o3[0];
3086 919 : _o2[0] = _r3;
3087 : }
3088 919 : _o2[1] = lo;
3089 919 : _r2 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
3090 919 : _o1[0] = _r2;
3091 : }
3092 919 : _o1[1] = hi;
3093 919 : _r1 = fold_build2_loc (loc, GT_EXPR, boolean_type_node, _o1[0], _o1[1]);
3094 919 : res_op0 = _r1;
3095 : }
3096 919 : tree _r;
3097 919 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3098 919 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 760, __FILE__, __LINE__, true);
3099 919 : return _r;
3100 : }
3101 : next_after_fail966:;
3102 : }
3103 : }
3104 : }
3105 : }
3106 : }
3107 : }
3108 : return NULL_TREE;
3109 : }
3110 :
3111 : tree
3112 0 : generic_simplify_596 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3113 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures))
3114 : {
3115 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3116 0 : if (canonicalize_math_after_vectorization_p ()
3117 : )
3118 : {
3119 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1006;
3120 : {
3121 : tree res_op0;
3122 : res_op0 = captures[0];
3123 : tree res_op1;
3124 : res_op1 = captures[1];
3125 : tree res_op2;
3126 : res_op2 = captures[2];
3127 : tree _r;
3128 : _r = maybe_build_call_expr_loc (loc, CFN_FMS, type, 3, res_op0, res_op1, res_op2);
3129 : if (!_r)
3130 : goto next_after_fail1006;
3131 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 800, __FILE__, __LINE__, true);
3132 : return _r;
3133 : }
3134 0 : next_after_fail1006:;
3135 : }
3136 0 : return NULL_TREE;
3137 : }
3138 :
3139 : tree
3140 0 : generic_simplify_605 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3141 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree ARG_UNUSED (_p3), tree ARG_UNUSED (_p4), tree *ARG_UNUSED (captures))
3142 : {
3143 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3144 0 : if (canonicalize_math_after_vectorization_p ()
3145 : )
3146 : {
3147 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1015;
3148 : {
3149 : tree res_op0;
3150 : res_op0 = captures[0];
3151 : tree res_op1;
3152 : res_op1 = captures[1];
3153 : tree res_op2;
3154 : res_op2 = captures[2];
3155 : tree res_op3;
3156 : res_op3 = captures[3];
3157 : tree res_op4;
3158 : res_op4 = captures[4];
3159 : tree _r;
3160 : _r = maybe_build_call_expr_loc (loc, CFN_COND_FMA, type, 5, res_op0, res_op1, res_op2, res_op3, res_op4);
3161 : if (!_r)
3162 : goto next_after_fail1015;
3163 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 809, __FILE__, __LINE__, true);
3164 : return _r;
3165 : }
3166 0 : next_after_fail1015:;
3167 : }
3168 0 : return NULL_TREE;
3169 : }
3170 :
3171 : tree
3172 0 : generic_simplify_616 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3173 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3174 : const combined_fn ARG_UNUSED (PARITY))
3175 : {
3176 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3177 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1027;
3178 0 : {
3179 0 : tree res_op0;
3180 0 : res_op0 = captures[0];
3181 0 : tree _r;
3182 0 : _r = maybe_build_call_expr_loc (loc, PARITY, type, 1, res_op0);
3183 0 : if (!_r)
3184 0 : goto next_after_fail1027;
3185 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 816, __FILE__, __LINE__, true);
3186 : return _r;
3187 : }
3188 : next_after_fail1027:;
3189 : return NULL_TREE;
3190 : }
3191 :
3192 : tree
3193 0 : generic_simplify_620 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3194 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3195 : const enum tree_code ARG_UNUSED (rot),
3196 : const combined_fn ARG_UNUSED (parity))
3197 : {
3198 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3199 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3200 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
3201 0 : && (
3202 :
3203 0 : || !TREE_SIDE_EFFECTS (captures[3]))
3204 0 : && TYPE_PRECISION (TREE_TYPE (captures[0]))
3205 0 : >= TYPE_PRECISION (TREE_TYPE (captures[1]))
3206 : )
3207 : {
3208 0 : {
3209 0 : tree type0 = TREE_TYPE (captures[0]);
3210 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1031;
3211 0 : {
3212 0 : tree res_op0;
3213 0 : {
3214 0 : tree _o1[1], _r1;
3215 0 : _o1[0] = captures[2];
3216 0 : if (TREE_TYPE (_o1[0]) != type0)
3217 : {
3218 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type0, _o1[0]);
3219 : }
3220 : else
3221 : _r1 = _o1[0];
3222 0 : res_op0 = _r1;
3223 : }
3224 0 : tree _r;
3225 0 : _r = maybe_build_call_expr_loc (loc, parity, type, 1, res_op0);
3226 0 : if (!_r)
3227 0 : goto next_after_fail1031;
3228 0 : if (TREE_SIDE_EFFECTS (captures[3]))
3229 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
3230 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 818, __FILE__, __LINE__, true);
3231 0 : return _r;
3232 : }
3233 : next_after_fail1031:;
3234 : }
3235 : }
3236 : return NULL_TREE;
3237 : }
3238 :
3239 : tree
3240 470802013 : generic_simplify_VIEW_CONVERT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0)
3241 : {
3242 470802013 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3243 470802013 : {
3244 470802013 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3245 941604026 : if ((
3246 :
3247 : && useless_type_conversion_p (type, TREE_TYPE (captures[0])))
3248 : || (
3249 : 1
3250 470802013 : && type == TREE_TYPE (captures[0]))
3251 : )
3252 : {
3253 208229980 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1092;
3254 208229980 : {
3255 208229980 : tree _r;
3256 208229980 : _r = captures[0];
3257 208229980 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 834, __FILE__, __LINE__, true);
3258 208229980 : return _r;
3259 : }
3260 0 : next_after_fail1092:;
3261 : }
3262 : }
3263 262572033 : switch (TREE_CODE (_p0))
3264 : {
3265 28889136 : case VIEW_CONVERT_EXPR:
3266 28889136 : {
3267 28889136 : tree _q20 = TREE_OPERAND (_p0, 0);
3268 28889136 : {
3269 28889136 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3270 28889136 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1093;
3271 28889136 : {
3272 28889136 : tree res_op0;
3273 28889136 : res_op0 = captures[0];
3274 28889136 : tree _r;
3275 28889136 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3276 28889136 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 868, __FILE__, __LINE__, true);
3277 470802013 : return _r;
3278 : }
3279 0 : next_after_fail1093:;
3280 : }
3281 0 : break;
3282 : }
3283 0 : case BIT_FIELD_REF:
3284 0 : {
3285 0 : tree _q20 = TREE_OPERAND (_p0, 0);
3286 0 : tree _q21 = TREE_OPERAND (_p0, 1);
3287 0 : tree _q22 = TREE_OPERAND (_p0, 2);
3288 0 : {
3289 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
3290 0 : if (is_gimple_reg_type (type)
3291 0 : && (!INTEGRAL_TYPE_P (type)
3292 0 : || type_has_mode_precision_p (type))
3293 0 : && (!INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3294 0 : || type_has_mode_precision_p (TREE_TYPE (captures[0])))
3295 : )
3296 : {
3297 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1094;
3298 0 : {
3299 0 : tree res_op0;
3300 0 : res_op0 = captures[1];
3301 0 : tree res_op1;
3302 0 : res_op1 = captures[2];
3303 0 : tree res_op2;
3304 0 : res_op2 = captures[3];
3305 0 : tree _r;
3306 0 : _r = fold_build3_loc (loc, BIT_FIELD_REF, type, res_op0, res_op1, res_op2);
3307 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 869, __FILE__, __LINE__, true);
3308 0 : return _r;
3309 : }
3310 0 : next_after_fail1094:;
3311 : }
3312 : }
3313 0 : break;
3314 : }
3315 233682897 : default:;
3316 : }
3317 233682897 : {
3318 233682897 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3319 231875954 : if ((INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
3320 3239644 : && (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0])))
3321 236644751 : && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (captures[0]))
3322 : )
3323 : {
3324 2608338 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1095;
3325 2608338 : {
3326 2608338 : tree res_op0;
3327 2608338 : res_op0 = captures[0];
3328 2608338 : tree _r;
3329 2608338 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3330 2608338 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 870, __FILE__, __LINE__, true);
3331 2608338 : return _r;
3332 : }
3333 0 : next_after_fail1095:;
3334 : }
3335 : }
3336 231074559 : switch (TREE_CODE (_p0))
3337 : {
3338 3427 : CASE_CONVERT:
3339 3427 : {
3340 3427 : tree _q20 = TREE_OPERAND (_p0, 0);
3341 3427 : {
3342 3427 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3343 3427 : {
3344 3427 : bool extended_bitint = false;
3345 3427 : if (BITINT_TYPE_P (TREE_TYPE (captures[0])))
3346 : {
3347 0 : struct bitint_info info;
3348 0 : extended_bitint
3349 0 : = targetm.c.bitint_type_info (TYPE_PRECISION (TREE_TYPE (captures[0])),
3350 : &info);
3351 0 : extended_bitint = extended_bitint && info.extended;
3352 : }
3353 6854 : if ((INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0])))
3354 71 : && (INTEGRAL_TYPE_P (TREE_TYPE (captures[1])) || POINTER_TYPE_P (TREE_TYPE (captures[1])))
3355 71 : && !extended_bitint
3356 71 : && TYPE_SIZE (TREE_TYPE (captures[0])) == TYPE_SIZE (TREE_TYPE (captures[1]))
3357 3427 : && (TYPE_PRECISION (TREE_TYPE (captures[0])) == TYPE_PRECISION (TREE_TYPE (captures[1]))
3358 0 : || (TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (TREE_TYPE (captures[1]))
3359 0 : && TYPE_UNSIGNED (TREE_TYPE (captures[1]))))
3360 : )
3361 : {
3362 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1096;
3363 0 : {
3364 0 : tree res_op0;
3365 0 : res_op0 = captures[1];
3366 0 : tree _r;
3367 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3368 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 871, __FILE__, __LINE__, true);
3369 0 : return _r;
3370 : }
3371 0 : next_after_fail1096:;
3372 : }
3373 : }
3374 : }
3375 3427 : break;
3376 : }
3377 83597 : case CONSTRUCTOR:
3378 83597 : {
3379 83597 : {
3380 83597 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3381 83597 : {
3382 83597 : tree ctor = (TREE_CODE (captures[0]) == SSA_NAME
3383 : ? gimple_assign_rhs1 (SSA_NAME_DEF_STMT (captures[0])) : captures[0]);
3384 83597 : if (CONSTRUCTOR_NELTS (ctor) == 0
3385 : )
3386 : {
3387 6 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1097;
3388 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1097;
3389 6 : {
3390 6 : tree _r;
3391 6 : _r = build_zero_cst (type);
3392 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
3393 6 : return _r;
3394 : }
3395 : next_after_fail1097:;
3396 : }
3397 : else
3398 : {
3399 83591 : if (CONSTRUCTOR_NELTS (ctor) == 1
3400 40 : && VECTOR_TYPE_P (TREE_TYPE (ctor))
3401 83626 : && operand_equal_p (TYPE_SIZE (type),
3402 35 : TYPE_SIZE (TREE_TYPE
3403 : (CONSTRUCTOR_ELT (ctor, 0)->value)))
3404 : )
3405 : {
3406 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1098;
3407 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1098;
3408 0 : {
3409 0 : tree res_op0;
3410 0 : res_op0 = CONSTRUCTOR_ELT (ctor, 0)->value;
3411 0 : tree _r;
3412 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3413 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 873, __FILE__, __LINE__, true);
3414 0 : return _r;
3415 : }
3416 : next_after_fail1098:;
3417 : }
3418 : }
3419 : }
3420 : }
3421 : break;
3422 : }
3423 289511 : case VEC_COND_EXPR:
3424 289511 : {
3425 289511 : tree _q20 = TREE_OPERAND (_p0, 0);
3426 289511 : tree _q21 = TREE_OPERAND (_p0, 1);
3427 289511 : tree _q22 = TREE_OPERAND (_p0, 2);
3428 289511 : {
3429 289511 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
3430 289462 : if (VECTOR_TYPE_P (type) && VECTOR_TYPE_P (TREE_TYPE (captures[2]))
3431 289868 : && known_eq (TYPE_VECTOR_SUBPARTS (type),
3432 : TYPE_VECTOR_SUBPARTS (TREE_TYPE (captures[2])))
3433 42087 : && tree_nop_conversion_p (TREE_TYPE (type), TREE_TYPE (TREE_TYPE (captures[2])))
3434 331241 : && (expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
3435 347 : || !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1])))
3436 : )
3437 : {
3438 41730 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1099;
3439 41730 : {
3440 41730 : tree res_op0;
3441 41730 : res_op0 = captures[1];
3442 41730 : tree res_op1;
3443 41730 : {
3444 41730 : tree _o1[1], _r1;
3445 41730 : _o1[0] = captures[2];
3446 41730 : if (TREE_TYPE (_o1[0]) != type)
3447 : {
3448 41730 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
3449 41730 : if (EXPR_P (_r1))
3450 82 : goto next_after_fail1099;
3451 : }
3452 : else
3453 : _r1 = _o1[0];
3454 41648 : res_op1 = _r1;
3455 : }
3456 41648 : tree res_op2;
3457 41648 : {
3458 41648 : tree _o1[1], _r1;
3459 41648 : _o1[0] = captures[3];
3460 41648 : if (TREE_TYPE (_o1[0]) != type)
3461 : {
3462 41648 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
3463 41648 : if (EXPR_P (_r1))
3464 0 : goto next_after_fail1099;
3465 : }
3466 : else
3467 : _r1 = _o1[0];
3468 41648 : res_op2 = _r1;
3469 : }
3470 41648 : tree _r;
3471 41648 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
3472 41648 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 874, __FILE__, __LINE__, true);
3473 41648 : return _r;
3474 : }
3475 247863 : next_after_fail1099:;
3476 : }
3477 : }
3478 247863 : break;
3479 : }
3480 : default:;
3481 : }
3482 : return NULL_TREE;
3483 : }
3484 :
3485 : tree
3486 1567580795 : generic_simplify (location_t loc, enum tree_code code, const tree type ATTRIBUTE_UNUSED, tree _p0)
3487 : {
3488 1567580795 : switch (code)
3489 : {
3490 2141781 : case ABS_EXPR:
3491 2141781 : return generic_simplify_ABS_EXPR (loc, code, type, _p0);
3492 714288288 : CASE_CONVERT:
3493 714288288 : return generic_simplify_CONVERT_EXPR (loc, code, type, _p0);
3494 2770267 : case BIT_NOT_EXPR:
3495 2770267 : return generic_simplify_BIT_NOT_EXPR (loc, code, type, _p0);
3496 942 : case ABSU_EXPR:
3497 942 : return generic_simplify_ABSU_EXPR (loc, code, type, _p0);
3498 4196002 : case NEGATE_EXPR:
3499 4196002 : return generic_simplify_NEGATE_EXPR (loc, code, type, _p0);
3500 470802013 : case VIEW_CONVERT_EXPR:
3501 470802013 : return generic_simplify_VIEW_CONVERT_EXPR (loc, code, type, _p0);
3502 6409896 : case FLOAT_EXPR:
3503 6409896 : return generic_simplify_FLOAT_EXPR (loc, code, type, _p0);
3504 498723 : case FIX_TRUNC_EXPR:
3505 498723 : return generic_simplify_FIX_TRUNC_EXPR (loc, code, type, _p0);
3506 3678 : case PAREN_EXPR:
3507 3678 : return generic_simplify_PAREN_EXPR (loc, code, type, _p0);
3508 1654530 : case REALPART_EXPR:
3509 1654530 : return generic_simplify_REALPART_EXPR (loc, code, type, _p0);
3510 1918374 : case IMAGPART_EXPR:
3511 1918374 : return generic_simplify_IMAGPART_EXPR (loc, code, type, _p0);
3512 1330 : case CONJ_EXPR:
3513 1330 : return generic_simplify_CONJ_EXPR (loc, code, type, _p0);
3514 : default:;
3515 : }
3516 : return NULL_TREE;
3517 : }
3518 :
3519 : tree
3520 49580352 : 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)
3521 : {
3522 49580352 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3523 49580352 : if (integer_zerop (_p1))
3524 : {
3525 2329887 : {
3526 2329887 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3527 2329887 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1256;
3528 2329887 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1256;
3529 2329887 : {
3530 2329887 : tree res_op0;
3531 2329887 : res_op0 = captures[0];
3532 2329887 : tree _r;
3533 2329887 : _r = non_lvalue_loc (loc, res_op0);
3534 2329887 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 886, __FILE__, __LINE__, true);
3535 2329887 : return _r;
3536 : }
3537 : next_after_fail1256:;
3538 : }
3539 : }
3540 47250465 : switch (TREE_CODE (_p0))
3541 : {
3542 3739049 : case POINTER_PLUS_EXPR:
3543 3739049 : {
3544 3739049 : tree _q20 = TREE_OPERAND (_p0, 0);
3545 3739049 : tree _q21 = TREE_OPERAND (_p0, 1);
3546 3739049 : {
3547 3739049 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
3548 3739049 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1257;
3549 3739049 : {
3550 3739049 : tree res_op0;
3551 3739049 : res_op0 = captures[1];
3552 3739049 : tree res_op1;
3553 3739049 : {
3554 3739049 : tree _o1[2], _r1;
3555 3739049 : _o1[0] = captures[2];
3556 3739049 : _o1[1] = captures[3];
3557 3739049 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3558 3739049 : res_op1 = _r1;
3559 : }
3560 3739049 : tree _r;
3561 3739049 : _r = fold_build2_loc (loc, POINTER_PLUS_EXPR, type, res_op0, res_op1);
3562 3739049 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 902, __FILE__, __LINE__, true);
3563 3739049 : return _r;
3564 : }
3565 0 : next_after_fail1257:;
3566 : }
3567 0 : break;
3568 : }
3569 20331370 : CASE_CONVERT:
3570 20331370 : {
3571 20331370 : tree _q20 = TREE_OPERAND (_p0, 0);
3572 20331370 : switch (TREE_CODE (_q20))
3573 : {
3574 27513 : case POINTER_PLUS_EXPR:
3575 27513 : {
3576 27513 : tree _q30 = TREE_OPERAND (_q20, 0);
3577 27513 : tree _q31 = TREE_OPERAND (_q20, 1);
3578 27513 : {
3579 27513 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
3580 27513 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1258;
3581 27513 : {
3582 27513 : tree res_op0;
3583 27513 : {
3584 27513 : tree _o1[1], _r1;
3585 27513 : _o1[0] = captures[2];
3586 27513 : if (TREE_TYPE (_o1[0]) != type)
3587 : {
3588 27405 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3589 : }
3590 : else
3591 : _r1 = _o1[0];
3592 27513 : res_op0 = _r1;
3593 : }
3594 27513 : tree res_op1;
3595 27513 : {
3596 27513 : tree _o1[2], _r1;
3597 27513 : _o1[0] = captures[3];
3598 27513 : _o1[1] = captures[4];
3599 27513 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3600 27513 : res_op1 = _r1;
3601 : }
3602 27513 : tree _r;
3603 27513 : _r = fold_build2_loc (loc, POINTER_PLUS_EXPR, type, res_op0, res_op1);
3604 27513 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 903, __FILE__, __LINE__, true);
3605 27513 : return _r;
3606 : }
3607 0 : next_after_fail1258:;
3608 : }
3609 0 : break;
3610 : }
3611 : default:;
3612 : }
3613 : break;
3614 : }
3615 43483903 : default:;
3616 : }
3617 43483903 : if (integer_zerop (_p0))
3618 : {
3619 646 : {
3620 646 : tree captures[1] ATTRIBUTE_UNUSED = { _p1 };
3621 646 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1259;
3622 646 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1259;
3623 646 : {
3624 646 : tree res_op0;
3625 646 : {
3626 646 : tree _o1[1], _r1;
3627 646 : _o1[0] = captures[0];
3628 646 : if (TREE_TYPE (_o1[0]) != type)
3629 : {
3630 646 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3631 : }
3632 : else
3633 : _r1 = _o1[0];
3634 646 : res_op0 = _r1;
3635 : }
3636 646 : tree _r;
3637 646 : _r = non_lvalue_loc (loc, res_op0);
3638 646 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 904, __FILE__, __LINE__, true);
3639 646 : return _r;
3640 : }
3641 : next_after_fail1259:;
3642 : }
3643 : }
3644 43483257 : switch (TREE_CODE (_p1))
3645 : {
3646 8998061 : CASE_CONVERT:
3647 8998061 : {
3648 8998061 : tree _q30 = TREE_OPERAND (_p1, 0);
3649 8998061 : switch (TREE_CODE (_q30))
3650 : {
3651 197883 : case MINUS_EXPR:
3652 197883 : {
3653 197883 : tree _q40 = TREE_OPERAND (_q30, 0);
3654 197883 : tree _q41 = TREE_OPERAND (_q30, 1);
3655 197883 : switch (TREE_CODE (_q40))
3656 : {
3657 91076 : CASE_CONVERT:
3658 91076 : {
3659 91076 : tree _q50 = TREE_OPERAND (_q40, 0);
3660 91076 : switch (TREE_CODE (_q41))
3661 : {
3662 7031 : CASE_CONVERT:
3663 7031 : {
3664 7031 : tree _q70 = TREE_OPERAND (_q41, 0);
3665 7031 : if ((_q70 == _p0 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _p0, 0) && types_match (_q70, _p0)))
3666 : {
3667 4261 : {
3668 4261 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q50 };
3669 4261 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (TREE_TYPE (captures[2]))
3670 4261 : && ((
3671 :
3672 : && useless_type_conversion_p (type, TREE_TYPE (captures[3])))
3673 : || (
3674 : 1
3675 4261 : && type == TREE_TYPE (captures[3])))
3676 : )
3677 : {
3678 2723 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1260;
3679 2723 : {
3680 2723 : tree _r;
3681 2723 : _r = captures[3];
3682 2723 : if (TREE_SIDE_EFFECTS (captures[0]))
3683 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3684 2723 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 905, __FILE__, __LINE__, true);
3685 2723 : return _r;
3686 : }
3687 0 : next_after_fail1260:;
3688 : }
3689 : }
3690 : }
3691 : break;
3692 : }
3693 : default:;
3694 : }
3695 : break;
3696 : }
3697 : default:;
3698 : }
3699 : break;
3700 : }
3701 568 : case POINTER_DIFF_EXPR:
3702 568 : {
3703 568 : tree _q40 = TREE_OPERAND (_q30, 0);
3704 568 : tree _q41 = TREE_OPERAND (_q30, 1);
3705 568 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _p0, 0))
3706 : {
3707 7 : {
3708 7 : tree captures[5] ATTRIBUTE_UNUSED = { _q41, _p1, _q30, _q40, _p0 };
3709 7 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) >= TYPE_PRECISION (TREE_TYPE (captures[2]))
3710 : )
3711 : {
3712 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1261;
3713 7 : {
3714 7 : tree res_op0;
3715 7 : res_op0 = captures[3];
3716 7 : tree _r;
3717 7 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3718 7 : if (TREE_SIDE_EFFECTS (captures[4]))
3719 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
3720 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
3721 7 : return _r;
3722 : }
3723 0 : next_after_fail1261:;
3724 : }
3725 : }
3726 : }
3727 : break;
3728 : }
3729 : default:;
3730 : }
3731 : break;
3732 : }
3733 28516 : case MINUS_EXPR:
3734 28516 : {
3735 28516 : tree _q30 = TREE_OPERAND (_p1, 0);
3736 28516 : tree _q31 = TREE_OPERAND (_p1, 1);
3737 28516 : switch (TREE_CODE (_q30))
3738 : {
3739 24290 : CASE_CONVERT:
3740 24290 : {
3741 24290 : tree _q40 = TREE_OPERAND (_q30, 0);
3742 24290 : switch (TREE_CODE (_q31))
3743 : {
3744 7504 : CASE_CONVERT:
3745 7504 : {
3746 7504 : tree _q60 = TREE_OPERAND (_q31, 0);
3747 7504 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
3748 : {
3749 20 : {
3750 20 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p1, _p1, _q40 };
3751 20 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (TREE_TYPE (captures[2]))
3752 20 : && ((
3753 :
3754 : && useless_type_conversion_p (type, TREE_TYPE (captures[3])))
3755 : || (
3756 : 1
3757 20 : && type == TREE_TYPE (captures[3])))
3758 : )
3759 : {
3760 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1262;
3761 0 : {
3762 0 : tree _r;
3763 0 : _r = captures[3];
3764 0 : if (TREE_SIDE_EFFECTS (captures[0]))
3765 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3766 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 905, __FILE__, __LINE__, true);
3767 0 : return _r;
3768 : }
3769 0 : next_after_fail1262:;
3770 : }
3771 : }
3772 : }
3773 : break;
3774 : }
3775 : default:;
3776 : }
3777 : break;
3778 : }
3779 977 : case INTEGER_CST:
3780 977 : {
3781 977 : switch (TREE_CODE (_q31))
3782 : {
3783 16 : case BIT_AND_EXPR:
3784 16 : {
3785 16 : tree _q50 = TREE_OPERAND (_q31, 0);
3786 16 : tree _q51 = TREE_OPERAND (_q31, 1);
3787 16 : switch (TREE_CODE (_q50))
3788 : {
3789 16 : CASE_CONVERT:
3790 16 : {
3791 16 : tree _q60 = TREE_OPERAND (_q50, 0);
3792 16 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
3793 : {
3794 0 : switch (TREE_CODE (_q51))
3795 : {
3796 0 : case INTEGER_CST:
3797 0 : {
3798 0 : {
3799 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q51 };
3800 0 : if (tree_int_cst_min_precision (captures[3], UNSIGNED) <= tree_ctz (captures[2])
3801 : )
3802 : {
3803 0 : {
3804 0 : tree algn = wide_int_to_tree (TREE_TYPE (captures[0]), ~wi::to_wide (captures[3]));
3805 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1263;
3806 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1263;
3807 0 : {
3808 0 : tree res_op0;
3809 0 : {
3810 0 : tree _o1[2], _r1;
3811 0 : _o1[0] = captures[0];
3812 0 : _o1[1] = algn;
3813 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3814 0 : res_op0 = _r1;
3815 : }
3816 0 : tree res_op1;
3817 0 : res_op1 = captures[2];
3818 0 : tree _r;
3819 0 : _r = fold_build2_loc (loc, POINTER_PLUS_EXPR, type, res_op0, res_op1);
3820 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 907, __FILE__, __LINE__, true);
3821 0 : return _r;
3822 : }
3823 0 : next_after_fail1263:;
3824 : }
3825 : }
3826 : }
3827 0 : break;
3828 : }
3829 : default:;
3830 : }
3831 : }
3832 16 : switch (TREE_CODE (_q60))
3833 : {
3834 0 : case POINTER_PLUS_EXPR:
3835 0 : {
3836 0 : tree _q70 = TREE_OPERAND (_q60, 0);
3837 0 : tree _q71 = TREE_OPERAND (_q60, 1);
3838 0 : if ((_q70 == _p0 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _p0, 0) && types_match (_q70, _p0)))
3839 : {
3840 0 : switch (TREE_CODE (_q71))
3841 : {
3842 0 : case INTEGER_CST:
3843 0 : {
3844 0 : switch (TREE_CODE (_q51))
3845 : {
3846 0 : case INTEGER_CST:
3847 0 : {
3848 0 : {
3849 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q71, _q51 };
3850 0 : {
3851 0 : auto mask_width = tree_int_cst_min_precision (captures[4], UNSIGNED);
3852 0 : if (mask_width <= tree_ctz (captures[2]) && mask_width <= tree_ctz (captures[3])
3853 : )
3854 : {
3855 0 : {
3856 0 : tree algn = wide_int_to_tree (TREE_TYPE (captures[0]), ~wi::to_wide (captures[4]));
3857 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1264;
3858 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1264;
3859 0 : {
3860 0 : tree res_op0;
3861 0 : {
3862 0 : tree _o1[2], _r1;
3863 0 : _o1[0] = captures[0];
3864 0 : _o1[1] = algn;
3865 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3866 0 : res_op0 = _r1;
3867 : }
3868 0 : tree res_op1;
3869 0 : res_op1 = captures[2];
3870 0 : tree _r;
3871 0 : _r = fold_build2_loc (loc, POINTER_PLUS_EXPR, type, res_op0, res_op1);
3872 0 : if (TREE_SIDE_EFFECTS (captures[3]))
3873 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
3874 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 908, __FILE__, __LINE__, true);
3875 0 : return _r;
3876 : }
3877 0 : next_after_fail1264:;
3878 : }
3879 : }
3880 : }
3881 : }
3882 0 : break;
3883 : }
3884 : default:;
3885 : }
3886 : break;
3887 : }
3888 : default:;
3889 : }
3890 : }
3891 : break;
3892 : }
3893 : default:;
3894 : }
3895 : break;
3896 : }
3897 : default:;
3898 : }
3899 : break;
3900 : }
3901 : default:;
3902 : }
3903 : break;
3904 : }
3905 : default:;
3906 : }
3907 : break;
3908 : }
3909 0 : case POINTER_DIFF_EXPR:
3910 0 : {
3911 0 : tree _q30 = TREE_OPERAND (_p1, 0);
3912 0 : tree _q31 = TREE_OPERAND (_p1, 1);
3913 0 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || operand_equal_p (_q31, _p0, 0))
3914 : {
3915 0 : {
3916 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q31, _p1, _p1, _q30, _p0 };
3917 0 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) >= TYPE_PRECISION (TREE_TYPE (captures[2]))
3918 : )
3919 : {
3920 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1265;
3921 0 : {
3922 0 : tree res_op0;
3923 0 : res_op0 = captures[3];
3924 0 : tree _r;
3925 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3926 0 : if (TREE_SIDE_EFFECTS (captures[4]))
3927 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
3928 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 906, __FILE__, __LINE__, true);
3929 0 : return _r;
3930 : }
3931 0 : next_after_fail1265:;
3932 : }
3933 : }
3934 : }
3935 : break;
3936 : }
3937 343536 : case NEGATE_EXPR:
3938 343536 : {
3939 343536 : tree _q30 = TREE_OPERAND (_p1, 0);
3940 343536 : switch (TREE_CODE (_q30))
3941 : {
3942 22 : case BIT_AND_EXPR:
3943 22 : {
3944 22 : tree _q40 = TREE_OPERAND (_q30, 0);
3945 22 : tree _q41 = TREE_OPERAND (_q30, 1);
3946 22 : switch (TREE_CODE (_q40))
3947 : {
3948 22 : CASE_CONVERT:
3949 22 : {
3950 22 : tree _q50 = TREE_OPERAND (_q40, 0);
3951 22 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
3952 : {
3953 1 : switch (TREE_CODE (_q41))
3954 : {
3955 1 : case INTEGER_CST:
3956 1 : {
3957 1 : {
3958 1 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
3959 1 : {
3960 1 : tree algn = wide_int_to_tree (TREE_TYPE (captures[0]), ~wi::to_wide (captures[1]));
3961 1 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1266;
3962 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1266;
3963 1 : {
3964 1 : tree res_op0;
3965 1 : res_op0 = captures[0];
3966 1 : tree res_op1;
3967 1 : res_op1 = algn;
3968 1 : tree _r;
3969 1 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
3970 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 909, __FILE__, __LINE__, true);
3971 1 : return _r;
3972 : }
3973 0 : next_after_fail1266:;
3974 : }
3975 : }
3976 0 : break;
3977 : }
3978 : default:;
3979 : }
3980 : }
3981 21 : switch (TREE_CODE (_q50))
3982 : {
3983 0 : case POINTER_PLUS_EXPR:
3984 0 : {
3985 0 : tree _q60 = TREE_OPERAND (_q50, 0);
3986 0 : tree _q61 = TREE_OPERAND (_q50, 1);
3987 0 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
3988 : {
3989 0 : switch (TREE_CODE (_q61))
3990 : {
3991 0 : case INTEGER_CST:
3992 0 : {
3993 0 : switch (TREE_CODE (_q41))
3994 : {
3995 0 : case INTEGER_CST:
3996 0 : {
3997 0 : {
3998 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q61, _q41 };
3999 0 : if (tree_int_cst_min_precision (captures[2], UNSIGNED) <= tree_ctz (captures[1])
4000 : )
4001 : {
4002 0 : {
4003 0 : tree algn = wide_int_to_tree (TREE_TYPE (captures[0]), ~wi::to_wide (captures[2]));
4004 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1267;
4005 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1267;
4006 0 : {
4007 0 : tree res_op0;
4008 0 : res_op0 = captures[0];
4009 0 : tree res_op1;
4010 0 : res_op1 = algn;
4011 0 : tree _r;
4012 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
4013 0 : if (TREE_SIDE_EFFECTS (captures[1]))
4014 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4015 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 910, __FILE__, __LINE__, true);
4016 0 : return _r;
4017 : }
4018 0 : next_after_fail1267:;
4019 : }
4020 : }
4021 : }
4022 0 : break;
4023 : }
4024 : default:;
4025 : }
4026 : break;
4027 : }
4028 : default:;
4029 : }
4030 : }
4031 : break;
4032 : }
4033 : default:;
4034 : }
4035 : break;
4036 : }
4037 : default:;
4038 : }
4039 : break;
4040 : }
4041 : default:;
4042 : }
4043 : break;
4044 : }
4045 : default:;
4046 : }
4047 : return NULL_TREE;
4048 : }
4049 :
4050 : tree
4051 36146400 : generic_simplify_NE_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
4052 : {
4053 36146400 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4054 36146400 : switch (TREE_CODE (_p1))
4055 : {
4056 2247 : case NEGATE_EXPR:
4057 2247 : {
4058 2247 : tree _q30 = TREE_OPERAND (_p1, 0);
4059 2247 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
4060 : {
4061 0 : {
4062 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4063 0 : tree res = generic_simplify_203 (loc, type, _p0, _p1, captures, NE_EXPR);
4064 0 : if (res) return res;
4065 : }
4066 : }
4067 : break;
4068 : }
4069 36146400 : default:;
4070 : }
4071 36146400 : switch (TREE_CODE (_p0))
4072 : {
4073 6102 : case NEGATE_EXPR:
4074 6102 : {
4075 6102 : tree _q20 = TREE_OPERAND (_p0, 0);
4076 6102 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4077 : {
4078 88 : {
4079 88 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4080 88 : tree res = generic_simplify_203 (loc, type, _p0, _p1, captures, NE_EXPR);
4081 88 : if (res) return res;
4082 : }
4083 : }
4084 : break;
4085 : }
4086 0 : case CEIL_MOD_EXPR:
4087 0 : {
4088 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4089 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4090 0 : if (integer_pow2p (_q21))
4091 : {
4092 0 : if (integer_zerop (_p1))
4093 : {
4094 0 : {
4095 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4096 0 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR, CEIL_MOD_EXPR);
4097 0 : if (res) return res;
4098 : }
4099 : }
4100 : }
4101 : break;
4102 : }
4103 1623 : case FLOOR_MOD_EXPR:
4104 1623 : {
4105 1623 : tree _q20 = TREE_OPERAND (_p0, 0);
4106 1623 : tree _q21 = TREE_OPERAND (_p0, 1);
4107 1623 : if (integer_pow2p (_q21))
4108 : {
4109 20 : if (integer_zerop (_p1))
4110 : {
4111 20 : {
4112 20 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4113 20 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR, FLOOR_MOD_EXPR);
4114 20 : if (res) return res;
4115 : }
4116 : }
4117 : }
4118 : break;
4119 : }
4120 0 : case ROUND_MOD_EXPR:
4121 0 : {
4122 0 : tree _q20 = TREE_OPERAND (_p0, 0);
4123 0 : tree _q21 = TREE_OPERAND (_p0, 1);
4124 0 : if (integer_pow2p (_q21))
4125 : {
4126 0 : if (integer_zerop (_p1))
4127 : {
4128 0 : {
4129 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4130 0 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR, ROUND_MOD_EXPR);
4131 0 : if (res) return res;
4132 : }
4133 : }
4134 : }
4135 : break;
4136 : }
4137 81134 : case TRUNC_MOD_EXPR:
4138 81134 : {
4139 81134 : tree _q20 = TREE_OPERAND (_p0, 0);
4140 81134 : tree _q21 = TREE_OPERAND (_p0, 1);
4141 81134 : if (integer_pow2p (_q21))
4142 : {
4143 21010 : if (integer_zerop (_p1))
4144 : {
4145 19568 : {
4146 19568 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4147 19568 : tree res = generic_simplify_204 (loc, type, _p0, _p1, captures, NE_EXPR, TRUNC_MOD_EXPR);
4148 19568 : if (res) return res;
4149 : }
4150 : }
4151 : }
4152 : break;
4153 : }
4154 6949957 : CASE_CONVERT:
4155 6949957 : {
4156 6949957 : tree _q20 = TREE_OPERAND (_p0, 0);
4157 6949957 : switch (TREE_CODE (_p1))
4158 : {
4159 69 : case LSHIFT_EXPR:
4160 69 : {
4161 69 : tree _q40 = TREE_OPERAND (_p1, 0);
4162 69 : tree _q41 = TREE_OPERAND (_p1, 1);
4163 69 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
4164 : {
4165 0 : {
4166 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
4167 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4168 0 : if (res) return res;
4169 : }
4170 : }
4171 : break;
4172 : }
4173 6949957 : default:;
4174 : }
4175 6949957 : {
4176 6949957 : tree _p1_pops[1];
4177 6949957 : if (tree_nop_convert (_p1, _p1_pops))
4178 : {
4179 2993184 : tree _q40 = _p1_pops[0];
4180 2993184 : switch (TREE_CODE (_q40))
4181 : {
4182 0 : case LSHIFT_EXPR:
4183 0 : {
4184 0 : tree _q50 = TREE_OPERAND (_q40, 0);
4185 0 : tree _q51 = TREE_OPERAND (_q40, 1);
4186 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4187 : {
4188 0 : {
4189 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q20 };
4190 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4191 0 : if (res) return res;
4192 : }
4193 : }
4194 : break;
4195 : }
4196 : default:;
4197 : }
4198 : }
4199 : }
4200 6949957 : switch (TREE_CODE (_q20))
4201 : {
4202 0 : case EXACT_DIV_EXPR:
4203 0 : {
4204 0 : tree _q30 = TREE_OPERAND (_q20, 0);
4205 0 : tree _q31 = TREE_OPERAND (_q20, 1);
4206 0 : switch (TREE_CODE (_q31))
4207 : {
4208 0 : case INTEGER_CST:
4209 0 : {
4210 0 : switch (TREE_CODE (_p1))
4211 : {
4212 0 : CASE_CONVERT:
4213 0 : {
4214 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4215 0 : switch (TREE_CODE (_q60))
4216 : {
4217 0 : case EXACT_DIV_EXPR:
4218 0 : {
4219 0 : tree _q70 = TREE_OPERAND (_q60, 0);
4220 0 : tree _q71 = TREE_OPERAND (_q60, 1);
4221 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
4222 : {
4223 0 : {
4224 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q70 };
4225 0 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4226 0 : if (res) return res;
4227 : }
4228 : }
4229 : break;
4230 : }
4231 : default:;
4232 : }
4233 : break;
4234 : }
4235 : default:;
4236 : }
4237 : break;
4238 : }
4239 : default:;
4240 : }
4241 : break;
4242 : }
4243 6949957 : default:;
4244 : }
4245 6949957 : switch (TREE_CODE (_p1))
4246 : {
4247 20299 : case PLUS_EXPR:
4248 20299 : {
4249 20299 : tree _q40 = TREE_OPERAND (_p1, 0);
4250 20299 : tree _q41 = TREE_OPERAND (_p1, 1);
4251 20299 : switch (TREE_CODE (_q41))
4252 : {
4253 203 : CASE_CONVERT:
4254 203 : {
4255 203 : tree _q60 = TREE_OPERAND (_q41, 0);
4256 203 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4257 : {
4258 0 : {
4259 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q40, _q20 };
4260 0 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
4261 0 : if (res) return res;
4262 : }
4263 : }
4264 : break;
4265 : }
4266 20299 : default:;
4267 : }
4268 20299 : switch (TREE_CODE (_q40))
4269 : {
4270 800 : CASE_CONVERT:
4271 800 : {
4272 800 : tree _q50 = TREE_OPERAND (_q40, 0);
4273 800 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4274 : {
4275 15 : {
4276 15 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q41, _q20 };
4277 15 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
4278 15 : if (res) return res;
4279 : }
4280 : }
4281 : break;
4282 : }
4283 20292 : default:;
4284 : }
4285 20292 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
4286 : {
4287 0 : {
4288 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q40, _q20 };
4289 0 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
4290 0 : if (res) return res;
4291 : }
4292 : }
4293 20292 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
4294 : {
4295 0 : {
4296 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q41, _q20 };
4297 0 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
4298 0 : if (res) return res;
4299 : }
4300 : }
4301 : break;
4302 : }
4303 6949950 : default:;
4304 : }
4305 6949950 : {
4306 6949950 : tree _p1_pops[1];
4307 6949950 : if (tree_nop_convert (_p1, _p1_pops))
4308 : {
4309 2993184 : tree _q40 = _p1_pops[0];
4310 2993184 : switch (TREE_CODE (_q40))
4311 : {
4312 144 : case PLUS_EXPR:
4313 144 : {
4314 144 : tree _q50 = TREE_OPERAND (_q40, 0);
4315 144 : tree _q51 = TREE_OPERAND (_q40, 1);
4316 144 : switch (TREE_CODE (_q51))
4317 : {
4318 0 : CASE_CONVERT:
4319 0 : {
4320 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4321 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4322 : {
4323 0 : {
4324 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q20 };
4325 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
4326 0 : if (res) return res;
4327 : }
4328 : }
4329 : break;
4330 : }
4331 144 : default:;
4332 : }
4333 144 : switch (TREE_CODE (_q50))
4334 : {
4335 77 : CASE_CONVERT:
4336 77 : {
4337 77 : tree _q60 = TREE_OPERAND (_q50, 0);
4338 77 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4339 : {
4340 0 : {
4341 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q51, _q20 };
4342 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
4343 0 : if (res) return res;
4344 : }
4345 : }
4346 : break;
4347 : }
4348 144 : default:;
4349 : }
4350 144 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4351 : {
4352 0 : {
4353 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q20 };
4354 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
4355 0 : if (res) return res;
4356 : }
4357 : }
4358 144 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4359 : {
4360 0 : {
4361 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q51, _q20 };
4362 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
4363 0 : if (res) return res;
4364 : }
4365 : }
4366 : break;
4367 : }
4368 : default:;
4369 : }
4370 : }
4371 : }
4372 6949950 : break;
4373 : }
4374 36126805 : default:;
4375 : }
4376 36126805 : {
4377 36126805 : tree _p0_pops[1];
4378 36126805 : if (tree_nop_convert (_p0, _p0_pops))
4379 : {
4380 4763531 : tree _q20 = _p0_pops[0];
4381 4763531 : switch (TREE_CODE (_q20))
4382 : {
4383 15 : case LSHIFT_EXPR:
4384 15 : {
4385 15 : tree _q30 = TREE_OPERAND (_q20, 0);
4386 15 : tree _q31 = TREE_OPERAND (_q20, 1);
4387 15 : switch (TREE_CODE (_p1))
4388 : {
4389 1 : CASE_CONVERT:
4390 1 : {
4391 1 : tree _q60 = TREE_OPERAND (_p1, 0);
4392 1 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
4393 : {
4394 0 : {
4395 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
4396 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4397 0 : if (res) return res;
4398 : }
4399 : }
4400 : break;
4401 : }
4402 15 : default:;
4403 : }
4404 15 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
4405 : {
4406 1 : {
4407 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
4408 1 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4409 1 : if (res) return res;
4410 : }
4411 : }
4412 : break;
4413 : }
4414 32397 : case PLUS_EXPR:
4415 32397 : {
4416 32397 : tree _q30 = TREE_OPERAND (_q20, 0);
4417 32397 : tree _q31 = TREE_OPERAND (_q20, 1);
4418 32397 : switch (TREE_CODE (_q31))
4419 : {
4420 37 : CASE_CONVERT:
4421 37 : {
4422 37 : tree _q50 = TREE_OPERAND (_q31, 0);
4423 37 : switch (TREE_CODE (_p1))
4424 : {
4425 0 : CASE_CONVERT:
4426 0 : {
4427 0 : tree _q70 = TREE_OPERAND (_p1, 0);
4428 0 : if ((_q70 == _q50 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q50, 0) && types_match (_q70, _q50)))
4429 : {
4430 0 : {
4431 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50 };
4432 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
4433 0 : if (res) return res;
4434 : }
4435 : }
4436 : break;
4437 : }
4438 : default:;
4439 : }
4440 : break;
4441 : }
4442 32397 : default:;
4443 : }
4444 32397 : switch (TREE_CODE (_q30))
4445 : {
4446 26914 : CASE_CONVERT:
4447 26914 : {
4448 26914 : tree _q40 = TREE_OPERAND (_q30, 0);
4449 26914 : switch (TREE_CODE (_p1))
4450 : {
4451 426 : CASE_CONVERT:
4452 426 : {
4453 426 : tree _q70 = TREE_OPERAND (_p1, 0);
4454 426 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
4455 : {
4456 90 : {
4457 90 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q40 };
4458 90 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
4459 90 : if (res) return res;
4460 : }
4461 : }
4462 : break;
4463 : }
4464 26824 : default:;
4465 : }
4466 26824 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
4467 : {
4468 11 : {
4469 11 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q40 };
4470 11 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
4471 11 : if (res) return res;
4472 : }
4473 : }
4474 : break;
4475 : }
4476 32296 : default:;
4477 : }
4478 32296 : switch (TREE_CODE (_q31))
4479 : {
4480 37 : CASE_CONVERT:
4481 37 : {
4482 37 : tree _q50 = TREE_OPERAND (_q31, 0);
4483 37 : if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
4484 : {
4485 0 : {
4486 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50 };
4487 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
4488 0 : if (res) return res;
4489 : }
4490 : }
4491 : break;
4492 : }
4493 32296 : default:;
4494 : }
4495 32296 : switch (TREE_CODE (_p1))
4496 : {
4497 411 : CASE_CONVERT:
4498 411 : {
4499 411 : tree _q60 = TREE_OPERAND (_p1, 0);
4500 411 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
4501 : {
4502 0 : {
4503 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
4504 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
4505 0 : if (res) return res;
4506 : }
4507 : }
4508 411 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
4509 : {
4510 68 : {
4511 68 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q30 };
4512 68 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
4513 68 : if (res) return res;
4514 : }
4515 : }
4516 : break;
4517 : }
4518 32228 : default:;
4519 : }
4520 32228 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
4521 : {
4522 0 : {
4523 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
4524 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
4525 0 : if (res) return res;
4526 : }
4527 : }
4528 32228 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
4529 : {
4530 0 : {
4531 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q30 };
4532 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
4533 0 : if (res) return res;
4534 : }
4535 : }
4536 : break;
4537 : }
4538 : default:;
4539 : }
4540 : }
4541 : }
4542 36126635 : {
4543 36126635 : tree _p1_pops[1];
4544 36126635 : if (tree_nop_convert (_p1, _p1_pops))
4545 : {
4546 3359580 : tree _q30 = _p1_pops[0];
4547 3359580 : switch (TREE_CODE (_q30))
4548 : {
4549 0 : case LSHIFT_EXPR:
4550 0 : {
4551 0 : tree _q40 = TREE_OPERAND (_q30, 0);
4552 0 : tree _q41 = TREE_OPERAND (_q30, 1);
4553 0 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
4554 : {
4555 0 : {
4556 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _p0 };
4557 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4558 0 : if (res) return res;
4559 : }
4560 : }
4561 : break;
4562 : }
4563 : default:;
4564 : }
4565 : }
4566 : }
4567 36126635 : switch (TREE_CODE (_p0))
4568 : {
4569 5171 : case LSHIFT_EXPR:
4570 5171 : {
4571 5171 : tree _q20 = TREE_OPERAND (_p0, 0);
4572 5171 : tree _q21 = TREE_OPERAND (_p0, 1);
4573 5171 : switch (TREE_CODE (_p1))
4574 : {
4575 35 : CASE_CONVERT:
4576 35 : {
4577 35 : tree _q50 = TREE_OPERAND (_p1, 0);
4578 35 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4579 : {
4580 4 : {
4581 4 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4582 4 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4583 4 : if (res) return res;
4584 : }
4585 : }
4586 : break;
4587 : }
4588 5170 : default:;
4589 : }
4590 5170 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
4591 : {
4592 27 : {
4593 27 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4594 27 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4595 27 : if (res) return res;
4596 : }
4597 : }
4598 5166 : if (tree_zero_one_valued_p (_q20))
4599 : {
4600 476 : switch (TREE_CODE (_q21))
4601 : {
4602 116 : case INTEGER_CST:
4603 116 : {
4604 116 : if (integer_zerop (_p1))
4605 : {
4606 5 : {
4607 5 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4608 5 : if (tree_fits_shwi_p (captures[1])
4609 5 : && tree_to_shwi (captures[1]) > 0
4610 10 : && tree_to_shwi (captures[1]) < TYPE_PRECISION (TREE_TYPE (captures[0]))
4611 : )
4612 : {
4613 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1520;
4614 5 : {
4615 5 : tree res_op0;
4616 5 : res_op0 = captures[0];
4617 5 : tree _r;
4618 5 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4619 5 : if (TREE_SIDE_EFFECTS (captures[1]))
4620 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4621 5 : if (TREE_SIDE_EFFECTS (captures[2]))
4622 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4623 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 987, __FILE__, __LINE__, true);
4624 5 : return _r;
4625 : }
4626 0 : next_after_fail1520:;
4627 : }
4628 : }
4629 : }
4630 : break;
4631 : }
4632 : default:;
4633 : }
4634 : }
4635 : break;
4636 : }
4637 36126625 : default:;
4638 : }
4639 36126625 : switch (TREE_CODE (_p1))
4640 : {
4641 267 : case LSHIFT_EXPR:
4642 267 : {
4643 267 : tree _q30 = TREE_OPERAND (_p1, 0);
4644 267 : tree _q31 = TREE_OPERAND (_p1, 1);
4645 267 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
4646 : {
4647 0 : {
4648 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
4649 0 : tree res = generic_simplify_205 (loc, type, _p0, _p1, captures, NE_EXPR);
4650 0 : if (res) return res;
4651 : }
4652 : }
4653 : break;
4654 : }
4655 36126625 : default:;
4656 : }
4657 36126625 : switch (TREE_CODE (_p0))
4658 : {
4659 155 : case VIEW_CONVERT_EXPR:
4660 155 : {
4661 155 : tree _q20 = TREE_OPERAND (_p0, 0);
4662 155 : if (tree_zero_one_valued_p (_q20))
4663 : {
4664 0 : if (integer_zerop (_p1))
4665 : {
4666 0 : {
4667 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
4668 0 : tree res = generic_simplify_211 (loc, type, _p0, _p1, captures, NE_EXPR);
4669 0 : if (res) return res;
4670 : }
4671 : }
4672 : }
4673 : break;
4674 : }
4675 20461 : case RSHIFT_EXPR:
4676 20461 : {
4677 20461 : tree _q20 = TREE_OPERAND (_p0, 0);
4678 20461 : tree _q21 = TREE_OPERAND (_p0, 1);
4679 20461 : switch (TREE_CODE (_q21))
4680 : {
4681 18143 : case INTEGER_CST:
4682 18143 : {
4683 18143 : switch (TREE_CODE (_p1))
4684 : {
4685 210 : case RSHIFT_EXPR:
4686 210 : {
4687 210 : tree _q50 = TREE_OPERAND (_p1, 0);
4688 210 : tree _q51 = TREE_OPERAND (_p1, 1);
4689 210 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4690 : {
4691 15 : switch (TREE_CODE (_q51))
4692 : {
4693 15 : case INTEGER_CST:
4694 15 : {
4695 15 : {
4696 15 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4697 15 : tree res = generic_simplify_212 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR);
4698 15 : if (res) return res;
4699 : }
4700 3 : break;
4701 : }
4702 : default:;
4703 : }
4704 : }
4705 : break;
4706 : }
4707 18131 : default:;
4708 : }
4709 18131 : if (integer_zerop (_p1))
4710 : {
4711 7623 : {
4712 7623 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
4713 7623 : tree res = generic_simplify_213 (loc, type, _p0, _p1, captures, NE_EXPR, LT_EXPR);
4714 7623 : if (res) return res;
4715 : }
4716 : }
4717 : break;
4718 : }
4719 : default:;
4720 : }
4721 : break;
4722 : }
4723 93753 : case MULT_EXPR:
4724 93753 : {
4725 93753 : tree _q20 = TREE_OPERAND (_p0, 0);
4726 93753 : tree _q21 = TREE_OPERAND (_p0, 1);
4727 93753 : switch (TREE_CODE (_p1))
4728 : {
4729 2857 : case MULT_EXPR:
4730 2857 : {
4731 2857 : tree _q50 = TREE_OPERAND (_p1, 0);
4732 2857 : tree _q51 = TREE_OPERAND (_p1, 1);
4733 2857 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4734 : {
4735 1599 : {
4736 1599 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4737 1599 : tree res = generic_simplify_214 (loc, type, _p0, _p1, captures, NE_EXPR);
4738 1599 : if (res) return res;
4739 : }
4740 : }
4741 2853 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4742 : {
4743 53 : {
4744 53 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
4745 53 : tree res = generic_simplify_214 (loc, type, _p0, _p1, captures, NE_EXPR);
4746 53 : if (res) return res;
4747 : }
4748 : }
4749 2853 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4750 : {
4751 22 : {
4752 22 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
4753 22 : tree res = generic_simplify_214 (loc, type, _p0, _p1, captures, NE_EXPR);
4754 22 : if (res) return res;
4755 : }
4756 : }
4757 2853 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4758 : {
4759 257 : {
4760 257 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
4761 257 : tree res = generic_simplify_214 (loc, type, _p0, _p1, captures, NE_EXPR);
4762 257 : if (res) return res;
4763 : }
4764 : }
4765 : break;
4766 : }
4767 93749 : default:;
4768 : }
4769 93749 : switch (TREE_CODE (_q21))
4770 : {
4771 76280 : case INTEGER_CST:
4772 76280 : {
4773 76280 : switch (TREE_CODE (_p1))
4774 : {
4775 1998 : case MULT_EXPR:
4776 1998 : {
4777 1998 : tree _q50 = TREE_OPERAND (_p1, 0);
4778 1998 : tree _q51 = TREE_OPERAND (_p1, 1);
4779 1998 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4780 : {
4781 1070 : {
4782 1070 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4783 1070 : tree res = generic_simplify_215 (loc, type, _p0, _p1, captures, NE_EXPR);
4784 1070 : if (res) return res;
4785 : }
4786 : }
4787 : break;
4788 : }
4789 : default:;
4790 : }
4791 : break;
4792 : }
4793 : default:;
4794 : }
4795 : break;
4796 : }
4797 2057 : case EXACT_DIV_EXPR:
4798 2057 : {
4799 2057 : tree _q20 = TREE_OPERAND (_p0, 0);
4800 2057 : tree _q21 = TREE_OPERAND (_p0, 1);
4801 2057 : switch (TREE_CODE (_q21))
4802 : {
4803 2057 : case INTEGER_CST:
4804 2057 : {
4805 2057 : switch (TREE_CODE (_p1))
4806 : {
4807 22 : case EXACT_DIV_EXPR:
4808 22 : {
4809 22 : tree _q50 = TREE_OPERAND (_p1, 0);
4810 22 : tree _q51 = TREE_OPERAND (_p1, 1);
4811 22 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4812 : {
4813 12 : {
4814 12 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
4815 12 : tree res = generic_simplify_207 (loc, type, _p0, _p1, captures, NE_EXPR);
4816 12 : if (res) return res;
4817 : }
4818 : }
4819 : break;
4820 : }
4821 : default:;
4822 : }
4823 : break;
4824 : }
4825 : default:;
4826 : }
4827 : break;
4828 : }
4829 11328 : case TRUNC_DIV_EXPR:
4830 11328 : {
4831 11328 : tree _q20 = TREE_OPERAND (_p0, 0);
4832 11328 : tree _q21 = TREE_OPERAND (_p0, 1);
4833 11328 : switch (TREE_CODE (_q21))
4834 : {
4835 8594 : case INTEGER_CST:
4836 8594 : {
4837 8594 : switch (TREE_CODE (_p1))
4838 : {
4839 2440 : case INTEGER_CST:
4840 2440 : {
4841 2440 : {
4842 2440 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
4843 2440 : tree res = generic_simplify_216 (loc, type, _p0, _p1, captures, NE_EXPR);
4844 2440 : if (res) return res;
4845 : }
4846 325 : break;
4847 : }
4848 : default:;
4849 : }
4850 : break;
4851 : }
4852 : default:;
4853 : }
4854 : break;
4855 : }
4856 1518424 : case PLUS_EXPR:
4857 1518424 : {
4858 1518424 : tree _q20 = TREE_OPERAND (_p0, 0);
4859 1518424 : tree _q21 = TREE_OPERAND (_p0, 1);
4860 1518424 : switch (TREE_CODE (_p1))
4861 : {
4862 188833 : case PLUS_EXPR:
4863 188833 : {
4864 188833 : tree _q50 = TREE_OPERAND (_p1, 0);
4865 188833 : tree _q51 = TREE_OPERAND (_p1, 1);
4866 188833 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4867 : {
4868 963 : {
4869 963 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4870 1926 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4871 1895 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
4872 849 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
4873 : )
4874 : {
4875 932 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1521;
4876 932 : {
4877 932 : tree res_op0;
4878 932 : res_op0 = captures[0];
4879 932 : tree res_op1;
4880 932 : res_op1 = captures[2];
4881 932 : tree _r;
4882 932 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
4883 932 : if (TREE_SIDE_EFFECTS (captures[1]))
4884 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4885 932 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 925, __FILE__, __LINE__, true);
4886 932 : return _r;
4887 : }
4888 0 : next_after_fail1521:;
4889 : }
4890 : }
4891 : }
4892 187901 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4893 : {
4894 0 : {
4895 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
4896 0 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4897 0 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
4898 0 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
4899 : )
4900 : {
4901 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1522;
4902 0 : {
4903 0 : tree res_op0;
4904 0 : res_op0 = captures[0];
4905 0 : tree res_op1;
4906 0 : res_op1 = captures[2];
4907 0 : tree _r;
4908 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
4909 0 : if (TREE_SIDE_EFFECTS (captures[1]))
4910 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4911 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 925, __FILE__, __LINE__, true);
4912 0 : return _r;
4913 : }
4914 0 : next_after_fail1522:;
4915 : }
4916 : }
4917 : }
4918 187901 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4919 : {
4920 94 : {
4921 94 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
4922 188 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4923 188 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
4924 94 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
4925 : )
4926 : {
4927 94 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1523;
4928 94 : {
4929 94 : tree res_op0;
4930 94 : res_op0 = captures[0];
4931 94 : tree res_op1;
4932 94 : res_op1 = captures[2];
4933 94 : tree _r;
4934 94 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
4935 94 : if (TREE_SIDE_EFFECTS (captures[1]))
4936 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4937 94 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 925, __FILE__, __LINE__, true);
4938 94 : return _r;
4939 : }
4940 0 : next_after_fail1523:;
4941 : }
4942 : }
4943 : }
4944 187807 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4945 : {
4946 107264 : {
4947 107264 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
4948 214528 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4949 214505 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
4950 107241 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
4951 : )
4952 : {
4953 107241 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1524;
4954 107241 : {
4955 107241 : tree res_op0;
4956 107241 : res_op0 = captures[0];
4957 107241 : tree res_op1;
4958 107241 : res_op1 = captures[2];
4959 107241 : tree _r;
4960 107241 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
4961 107241 : if (TREE_SIDE_EFFECTS (captures[1]))
4962 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4963 107241 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 925, __FILE__, __LINE__, true);
4964 107241 : return _r;
4965 : }
4966 0 : next_after_fail1524:;
4967 : }
4968 : }
4969 : }
4970 : break;
4971 : }
4972 1410157 : default:;
4973 : }
4974 1410157 : switch (TREE_CODE (_q21))
4975 : {
4976 749 : CASE_CONVERT:
4977 749 : {
4978 749 : tree _q40 = TREE_OPERAND (_q21, 0);
4979 749 : switch (TREE_CODE (_p1))
4980 : {
4981 88 : CASE_CONVERT:
4982 88 : {
4983 88 : tree _q60 = TREE_OPERAND (_p1, 0);
4984 88 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
4985 : {
4986 0 : {
4987 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40 };
4988 0 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
4989 0 : if (res) return res;
4990 : }
4991 : }
4992 : break;
4993 : }
4994 : default:;
4995 : }
4996 : break;
4997 : }
4998 1410157 : default:;
4999 : }
5000 1410157 : switch (TREE_CODE (_q20))
5001 : {
5002 142475 : CASE_CONVERT:
5003 142475 : {
5004 142475 : tree _q30 = TREE_OPERAND (_q20, 0);
5005 142475 : switch (TREE_CODE (_p1))
5006 : {
5007 3862 : CASE_CONVERT:
5008 3862 : {
5009 3862 : tree _q60 = TREE_OPERAND (_p1, 0);
5010 3862 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
5011 : {
5012 398 : {
5013 398 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q30 };
5014 398 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
5015 398 : if (res) return res;
5016 : }
5017 : }
5018 : break;
5019 : }
5020 142077 : default:;
5021 : }
5022 142077 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
5023 : {
5024 0 : {
5025 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q30 };
5026 0 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
5027 0 : if (res) return res;
5028 : }
5029 : }
5030 : break;
5031 : }
5032 1409759 : default:;
5033 : }
5034 1409759 : switch (TREE_CODE (_q21))
5035 : {
5036 749 : CASE_CONVERT:
5037 749 : {
5038 749 : tree _q40 = TREE_OPERAND (_q21, 0);
5039 749 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
5040 : {
5041 0 : {
5042 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40 };
5043 0 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
5044 0 : if (res) return res;
5045 : }
5046 : }
5047 : break;
5048 : }
5049 1409759 : default:;
5050 : }
5051 1409759 : switch (TREE_CODE (_p1))
5052 : {
5053 43700 : CASE_CONVERT:
5054 43700 : {
5055 43700 : tree _q50 = TREE_OPERAND (_p1, 0);
5056 43700 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5057 : {
5058 0 : {
5059 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
5060 0 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
5061 0 : if (res) return res;
5062 : }
5063 : }
5064 43700 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5065 : {
5066 0 : {
5067 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q20 };
5068 0 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
5069 0 : if (res) return res;
5070 : }
5071 : }
5072 : break;
5073 : }
5074 1409759 : default:;
5075 : }
5076 1409759 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5077 : {
5078 76054 : {
5079 76054 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
5080 76054 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
5081 76054 : if (res) return res;
5082 : }
5083 : }
5084 1334409 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5085 : {
5086 19217 : {
5087 19217 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q20 };
5088 19217 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
5089 19217 : if (res) return res;
5090 : }
5091 : }
5092 : break;
5093 : }
5094 517446 : case POINTER_PLUS_EXPR:
5095 517446 : {
5096 517446 : tree _q20 = TREE_OPERAND (_p0, 0);
5097 517446 : tree _q21 = TREE_OPERAND (_p0, 1);
5098 517446 : switch (TREE_CODE (_p1))
5099 : {
5100 33034 : case POINTER_PLUS_EXPR:
5101 33034 : {
5102 33034 : tree _q50 = TREE_OPERAND (_p1, 0);
5103 33034 : tree _q51 = TREE_OPERAND (_p1, 1);
5104 33034 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5105 : {
5106 7397 : {
5107 7397 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5108 7397 : tree res = generic_simplify_217 (loc, type, _p0, _p1, captures, NE_EXPR);
5109 7397 : if (res) return res;
5110 : }
5111 : }
5112 : break;
5113 : }
5114 510049 : default:;
5115 : }
5116 510049 : switch (TREE_CODE (_q20))
5117 : {
5118 72918 : CASE_CONVERT:
5119 72918 : {
5120 72918 : tree _q30 = TREE_OPERAND (_q20, 0);
5121 72918 : switch (TREE_CODE (_p1))
5122 : {
5123 192 : CASE_CONVERT:
5124 192 : {
5125 192 : tree _q60 = TREE_OPERAND (_p1, 0);
5126 192 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
5127 : {
5128 0 : {
5129 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q30, _q21 };
5130 0 : tree res = generic_simplify_218 (loc, type, _p0, _p1, captures, NE_EXPR);
5131 0 : if (res) return res;
5132 : }
5133 : }
5134 : break;
5135 : }
5136 72918 : default:;
5137 : }
5138 72918 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
5139 : {
5140 55 : {
5141 55 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q30, _q21 };
5142 55 : tree res = generic_simplify_218 (loc, type, _p0, _p1, captures, NE_EXPR);
5143 55 : if (res) return res;
5144 : }
5145 : }
5146 : break;
5147 : }
5148 509994 : default:;
5149 : }
5150 509994 : switch (TREE_CODE (_p1))
5151 : {
5152 3207 : CASE_CONVERT:
5153 3207 : {
5154 3207 : tree _q50 = TREE_OPERAND (_p1, 0);
5155 3207 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5156 : {
5157 0 : {
5158 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
5159 0 : tree res = generic_simplify_218 (loc, type, _p0, _p1, captures, NE_EXPR);
5160 0 : if (res) return res;
5161 : }
5162 : }
5163 : break;
5164 : }
5165 509994 : default:;
5166 : }
5167 509994 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5168 : {
5169 10079 : {
5170 10079 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
5171 10079 : tree res = generic_simplify_218 (loc, type, _p0, _p1, captures, NE_EXPR);
5172 10079 : if (res) return res;
5173 : }
5174 : }
5175 : break;
5176 : }
5177 105967 : case MINUS_EXPR:
5178 105967 : {
5179 105967 : tree _q20 = TREE_OPERAND (_p0, 0);
5180 105967 : tree _q21 = TREE_OPERAND (_p0, 1);
5181 105967 : switch (TREE_CODE (_p1))
5182 : {
5183 5878 : case MINUS_EXPR:
5184 5878 : {
5185 5878 : tree _q50 = TREE_OPERAND (_p1, 0);
5186 5878 : tree _q51 = TREE_OPERAND (_p1, 1);
5187 5878 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5188 : {
5189 170 : {
5190 170 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5191 340 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
5192 173 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5193 0 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
5194 : )
5195 : {
5196 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1525;
5197 3 : {
5198 3 : tree res_op0;
5199 3 : res_op0 = captures[0];
5200 3 : tree res_op1;
5201 3 : res_op1 = captures[2];
5202 3 : tree _r;
5203 3 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
5204 3 : if (TREE_SIDE_EFFECTS (captures[1]))
5205 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5206 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 926, __FILE__, __LINE__, true);
5207 3 : return _r;
5208 : }
5209 0 : next_after_fail1525:;
5210 : }
5211 : }
5212 : }
5213 5875 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5214 : {
5215 166 : {
5216 166 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5217 332 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
5218 166 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
5219 0 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1])))
5220 : )
5221 : {
5222 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1526;
5223 0 : {
5224 0 : tree res_op0;
5225 0 : res_op0 = captures[2];
5226 0 : tree res_op1;
5227 0 : res_op1 = captures[1];
5228 0 : tree _r;
5229 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
5230 0 : if (TREE_SIDE_EFFECTS (captures[0]))
5231 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
5232 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
5233 0 : return _r;
5234 : }
5235 0 : next_after_fail1526:;
5236 : }
5237 : }
5238 : }
5239 : break;
5240 : }
5241 105964 : default:;
5242 : }
5243 105964 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5244 : {
5245 1752 : {
5246 1752 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
5247 1752 : tree res = generic_simplify_219 (loc, type, _p0, _p1, captures, NE_EXPR);
5248 1752 : if (res) return res;
5249 : }
5250 : }
5251 : break;
5252 : }
5253 25233 : case POINTER_DIFF_EXPR:
5254 25233 : {
5255 25233 : tree _q20 = TREE_OPERAND (_p0, 0);
5256 25233 : tree _q21 = TREE_OPERAND (_p0, 1);
5257 25233 : switch (TREE_CODE (_p1))
5258 : {
5259 2263 : case POINTER_DIFF_EXPR:
5260 2263 : {
5261 2263 : tree _q50 = TREE_OPERAND (_p1, 0);
5262 2263 : tree _q51 = TREE_OPERAND (_p1, 1);
5263 2263 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5264 : {
5265 0 : {
5266 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
5267 0 : tree res = generic_simplify_220 (loc, type, _p0, _p1, captures, NE_EXPR);
5268 0 : if (res) return res;
5269 : }
5270 : }
5271 2263 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5272 : {
5273 0 : {
5274 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
5275 0 : tree res = generic_simplify_221 (loc, type, _p0, _p1, captures, NE_EXPR);
5276 0 : if (res) return res;
5277 : }
5278 : }
5279 : break;
5280 : }
5281 : default:;
5282 : }
5283 : break;
5284 : }
5285 35901836 : default:;
5286 : }
5287 35901836 : {
5288 35901836 : tree _p0_pops[1];
5289 35901836 : if (tree_logical_inverted_value (_p0, _p0_pops))
5290 : {
5291 537078 : tree _q20 = _p0_pops[0];
5292 537078 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5293 : {
5294 24 : if (tree_truth_valued_p (_p1))
5295 : {
5296 0 : {
5297 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
5298 0 : tree res = generic_simplify_209 (loc, type, _p0, _p1, captures, NE_EXPR);
5299 0 : if (res) return res;
5300 : }
5301 : }
5302 : }
5303 : }
5304 : }
5305 35901836 : if (tree_truth_valued_p (_p0))
5306 : {
5307 5378022 : {
5308 5378022 : tree _p1_pops[1];
5309 5378022 : if (tree_logical_inverted_value (_p1, _p1_pops))
5310 : {
5311 1129 : tree _q30 = _p1_pops[0];
5312 1129 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5313 : {
5314 0 : {
5315 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
5316 0 : tree res = generic_simplify_209 (loc, type, _p0, _p1, captures, NE_EXPR);
5317 0 : if (res) return res;
5318 : }
5319 : }
5320 : }
5321 : }
5322 : }
5323 35901836 : switch (TREE_CODE (_p1))
5324 : {
5325 121369 : case PLUS_EXPR:
5326 121369 : {
5327 121369 : tree _q30 = TREE_OPERAND (_p1, 0);
5328 121369 : tree _q31 = TREE_OPERAND (_p1, 1);
5329 121369 : switch (TREE_CODE (_q31))
5330 : {
5331 342 : CASE_CONVERT:
5332 342 : {
5333 342 : tree _q50 = TREE_OPERAND (_q31, 0);
5334 342 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
5335 : {
5336 0 : {
5337 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0 };
5338 0 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
5339 0 : if (res) return res;
5340 : }
5341 : }
5342 : break;
5343 : }
5344 121369 : default:;
5345 : }
5346 121369 : switch (TREE_CODE (_q30))
5347 : {
5348 5537 : CASE_CONVERT:
5349 5537 : {
5350 5537 : tree _q40 = TREE_OPERAND (_q30, 0);
5351 5537 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
5352 : {
5353 0 : {
5354 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q31, _p0 };
5355 0 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
5356 0 : if (res) return res;
5357 : }
5358 : }
5359 : break;
5360 : }
5361 121369 : default:;
5362 : }
5363 121369 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5364 : {
5365 0 : {
5366 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0 };
5367 0 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
5368 0 : if (res) return res;
5369 : }
5370 : }
5371 121369 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5372 : {
5373 8 : {
5374 8 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q31, _p0 };
5375 8 : tree res = generic_simplify_208 (loc, type, _p0, _p1, captures, NE_EXPR);
5376 8 : if (res) return res;
5377 : }
5378 : }
5379 : break;
5380 : }
5381 35901828 : default:;
5382 : }
5383 35901828 : {
5384 35901828 : tree _p1_pops[1];
5385 35901828 : if (tree_nop_convert (_p1, _p1_pops))
5386 : {
5387 3359180 : tree _q30 = _p1_pops[0];
5388 3359180 : switch (TREE_CODE (_q30))
5389 : {
5390 1663 : case PLUS_EXPR:
5391 1663 : {
5392 1663 : tree _q40 = TREE_OPERAND (_q30, 0);
5393 1663 : tree _q41 = TREE_OPERAND (_q30, 1);
5394 1663 : switch (TREE_CODE (_q41))
5395 : {
5396 3 : CASE_CONVERT:
5397 3 : {
5398 3 : tree _q60 = TREE_OPERAND (_q41, 0);
5399 3 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
5400 : {
5401 0 : {
5402 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0 };
5403 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
5404 0 : if (res) return res;
5405 : }
5406 : }
5407 : break;
5408 : }
5409 1663 : default:;
5410 : }
5411 1663 : switch (TREE_CODE (_q40))
5412 : {
5413 1107 : CASE_CONVERT:
5414 1107 : {
5415 1107 : tree _q50 = TREE_OPERAND (_q40, 0);
5416 1107 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
5417 : {
5418 0 : {
5419 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q41, _p0 };
5420 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
5421 0 : if (res) return res;
5422 : }
5423 : }
5424 : break;
5425 : }
5426 1663 : default:;
5427 : }
5428 1663 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
5429 : {
5430 0 : {
5431 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0 };
5432 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
5433 0 : if (res) return res;
5434 : }
5435 : }
5436 1663 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
5437 : {
5438 0 : {
5439 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q41, _p0 };
5440 0 : tree res = generic_simplify_206 (loc, type, _p0, _p1, captures, NE_EXPR);
5441 0 : if (res) return res;
5442 : }
5443 : }
5444 : break;
5445 : }
5446 : default:;
5447 : }
5448 : }
5449 : }
5450 35901828 : switch (TREE_CODE (_p0))
5451 : {
5452 6949772 : CASE_CONVERT:
5453 6949772 : {
5454 6949772 : tree _q20 = TREE_OPERAND (_p0, 0);
5455 6949772 : switch (TREE_CODE (_p1))
5456 : {
5457 173 : case POINTER_PLUS_EXPR:
5458 173 : {
5459 173 : tree _q40 = TREE_OPERAND (_p1, 0);
5460 173 : tree _q41 = TREE_OPERAND (_p1, 1);
5461 173 : switch (TREE_CODE (_q40))
5462 : {
5463 48 : CASE_CONVERT:
5464 48 : {
5465 48 : tree _q50 = TREE_OPERAND (_q40, 0);
5466 48 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5467 : {
5468 0 : {
5469 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q20, _q41 };
5470 0 : tree res = generic_simplify_218 (loc, type, _p0, _p1, captures, NE_EXPR);
5471 0 : if (res) return res;
5472 : }
5473 : }
5474 : break;
5475 : }
5476 173 : default:;
5477 : }
5478 173 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
5479 : {
5480 0 : {
5481 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q20, _q41 };
5482 0 : tree res = generic_simplify_218 (loc, type, _p0, _p1, captures, NE_EXPR);
5483 0 : if (res) return res;
5484 : }
5485 : }
5486 : break;
5487 : }
5488 6949772 : default:;
5489 : }
5490 6949772 : {
5491 6949772 : tree _p1_pops[1];
5492 6949772 : if (tree_nop_convert (_p1, _p1_pops))
5493 : {
5494 2993026 : tree _q40 = _p1_pops[0];
5495 2993026 : switch (TREE_CODE (_q40))
5496 : {
5497 48 : case POINTER_PLUS_EXPR:
5498 48 : {
5499 48 : tree _q50 = TREE_OPERAND (_q40, 0);
5500 48 : tree _q51 = TREE_OPERAND (_q40, 1);
5501 48 : switch (TREE_CODE (_q50))
5502 : {
5503 8 : CASE_CONVERT:
5504 8 : {
5505 8 : tree _q60 = TREE_OPERAND (_q50, 0);
5506 8 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
5507 : {
5508 0 : {
5509 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q20, _q51 };
5510 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, NE_EXPR);
5511 0 : if (res) return res;
5512 : }
5513 : }
5514 : break;
5515 : }
5516 48 : default:;
5517 : }
5518 48 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5519 : {
5520 0 : {
5521 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q20, _q51 };
5522 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, NE_EXPR);
5523 0 : if (res) return res;
5524 : }
5525 : }
5526 : break;
5527 : }
5528 : default:;
5529 : }
5530 : }
5531 : }
5532 6949772 : break;
5533 : }
5534 35901828 : default:;
5535 : }
5536 35901828 : {
5537 35901828 : tree _p0_pops[1];
5538 35901828 : if (tree_nop_convert (_p0, _p0_pops))
5539 : {
5540 4763361 : tree _q20 = _p0_pops[0];
5541 4763361 : switch (TREE_CODE (_q20))
5542 : {
5543 185 : case POINTER_PLUS_EXPR:
5544 185 : {
5545 185 : tree _q30 = TREE_OPERAND (_q20, 0);
5546 185 : tree _q31 = TREE_OPERAND (_q20, 1);
5547 185 : switch (TREE_CODE (_q30))
5548 : {
5549 24 : CASE_CONVERT:
5550 24 : {
5551 24 : tree _q40 = TREE_OPERAND (_q30, 0);
5552 24 : switch (TREE_CODE (_p1))
5553 : {
5554 8 : CASE_CONVERT:
5555 8 : {
5556 8 : tree _q70 = TREE_OPERAND (_p1, 0);
5557 8 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
5558 : {
5559 0 : {
5560 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31 };
5561 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, NE_EXPR);
5562 0 : if (res) return res;
5563 : }
5564 : }
5565 : break;
5566 : }
5567 24 : default:;
5568 : }
5569 24 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
5570 : {
5571 0 : {
5572 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31 };
5573 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, NE_EXPR);
5574 0 : if (res) return res;
5575 : }
5576 : }
5577 : break;
5578 : }
5579 185 : default:;
5580 : }
5581 185 : switch (TREE_CODE (_p1))
5582 : {
5583 50 : CASE_CONVERT:
5584 50 : {
5585 50 : tree _q60 = TREE_OPERAND (_p1, 0);
5586 50 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
5587 : {
5588 0 : {
5589 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
5590 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, NE_EXPR);
5591 0 : if (res) return res;
5592 : }
5593 : }
5594 : break;
5595 : }
5596 185 : default:;
5597 : }
5598 185 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
5599 : {
5600 0 : {
5601 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
5602 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, NE_EXPR);
5603 0 : if (res) return res;
5604 : }
5605 : }
5606 : break;
5607 : }
5608 : default:;
5609 : }
5610 : }
5611 : }
5612 35901828 : switch (TREE_CODE (_p1))
5613 : {
5614 29626 : case POINTER_PLUS_EXPR:
5615 29626 : {
5616 29626 : tree _q30 = TREE_OPERAND (_p1, 0);
5617 29626 : tree _q31 = TREE_OPERAND (_p1, 1);
5618 29626 : switch (TREE_CODE (_q30))
5619 : {
5620 2754 : CASE_CONVERT:
5621 2754 : {
5622 2754 : tree _q40 = TREE_OPERAND (_q30, 0);
5623 2754 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
5624 : {
5625 0 : {
5626 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _p0, _q31 };
5627 0 : tree res = generic_simplify_218 (loc, type, _p0, _p1, captures, NE_EXPR);
5628 0 : if (res) return res;
5629 : }
5630 : }
5631 : break;
5632 : }
5633 29626 : default:;
5634 : }
5635 29626 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5636 : {
5637 0 : {
5638 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _p0, _q31 };
5639 0 : tree res = generic_simplify_218 (loc, type, _p0, _p1, captures, NE_EXPR);
5640 0 : if (res) return res;
5641 : }
5642 : }
5643 : break;
5644 : }
5645 35901828 : default:;
5646 : }
5647 35901828 : {
5648 35901828 : tree _p1_pops[1];
5649 35901828 : if (tree_nop_convert (_p1, _p1_pops))
5650 : {
5651 3359180 : tree _q30 = _p1_pops[0];
5652 3359180 : switch (TREE_CODE (_q30))
5653 : {
5654 387 : case POINTER_PLUS_EXPR:
5655 387 : {
5656 387 : tree _q40 = TREE_OPERAND (_q30, 0);
5657 387 : tree _q41 = TREE_OPERAND (_q30, 1);
5658 387 : switch (TREE_CODE (_q40))
5659 : {
5660 8 : CASE_CONVERT:
5661 8 : {
5662 8 : tree _q50 = TREE_OPERAND (_q40, 0);
5663 8 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
5664 : {
5665 0 : {
5666 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _p0, _q41 };
5667 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, NE_EXPR);
5668 0 : if (res) return res;
5669 : }
5670 : }
5671 : break;
5672 : }
5673 387 : default:;
5674 : }
5675 387 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
5676 : {
5677 0 : {
5678 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _p0, _q41 };
5679 0 : tree res = generic_simplify_222 (loc, type, _p0, _p1, captures, NE_EXPR);
5680 0 : if (res) return res;
5681 : }
5682 : }
5683 : break;
5684 : }
5685 : default:;
5686 : }
5687 : }
5688 : }
5689 35901828 : switch (TREE_CODE (_p0))
5690 : {
5691 499915 : case POINTER_PLUS_EXPR:
5692 499915 : {
5693 499915 : tree _q20 = TREE_OPERAND (_p0, 0);
5694 499915 : tree _q21 = TREE_OPERAND (_p0, 1);
5695 499915 : switch (TREE_CODE (_p1))
5696 : {
5697 47935 : case ADDR_EXPR:
5698 47935 : {
5699 47935 : {
5700 47935 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5701 47935 : tree res = generic_simplify_223 (loc, type, _p0, _p1, captures, NE_EXPR);
5702 47935 : if (res) return res;
5703 : }
5704 32895 : break;
5705 : }
5706 484875 : default:;
5707 : }
5708 484875 : switch (TREE_CODE (_q20))
5709 : {
5710 4916 : case ADDR_EXPR:
5711 4916 : {
5712 4916 : switch (TREE_CODE (_p1))
5713 : {
5714 269 : case POINTER_PLUS_EXPR:
5715 269 : {
5716 269 : tree _q50 = TREE_OPERAND (_p1, 0);
5717 269 : tree _q51 = TREE_OPERAND (_p1, 1);
5718 269 : switch (TREE_CODE (_q50))
5719 : {
5720 0 : case ADDR_EXPR:
5721 0 : {
5722 0 : {
5723 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51 };
5724 0 : tree res = generic_simplify_224 (loc, type, _p0, _p1, captures, NE_EXPR);
5725 0 : if (res) return res;
5726 : }
5727 0 : break;
5728 : }
5729 : default:;
5730 : }
5731 : break;
5732 : }
5733 : default:;
5734 : }
5735 : break;
5736 : }
5737 : default:;
5738 : }
5739 : break;
5740 : }
5741 196121 : case ADDR_EXPR:
5742 196121 : {
5743 196121 : switch (TREE_CODE (_p1))
5744 : {
5745 0 : case POINTER_PLUS_EXPR:
5746 0 : {
5747 0 : tree _q30 = TREE_OPERAND (_p1, 0);
5748 0 : tree _q31 = TREE_OPERAND (_p1, 1);
5749 0 : {
5750 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
5751 0 : tree res = generic_simplify_223 (loc, type, _p0, _p1, captures, NE_EXPR);
5752 0 : if (res) return res;
5753 : }
5754 0 : break;
5755 : }
5756 : default:;
5757 : }
5758 : break;
5759 : }
5760 35886788 : default:;
5761 : }
5762 35886788 : switch (TREE_CODE (_p1))
5763 : {
5764 30243 : case MINUS_EXPR:
5765 30243 : {
5766 30243 : tree _q30 = TREE_OPERAND (_p1, 0);
5767 30243 : tree _q31 = TREE_OPERAND (_p1, 1);
5768 30243 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5769 : {
5770 0 : {
5771 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
5772 0 : tree res = generic_simplify_219 (loc, type, _p0, _p1, captures, NE_EXPR);
5773 0 : if (res) return res;
5774 : }
5775 : }
5776 : break;
5777 : }
5778 35886788 : default:;
5779 : }
5780 35886788 : switch (TREE_CODE (_p0))
5781 : {
5782 9213 : case TRUNC_DIV_EXPR:
5783 9213 : {
5784 9213 : tree _q20 = TREE_OPERAND (_p0, 0);
5785 9213 : tree _q21 = TREE_OPERAND (_p0, 1);
5786 9213 : if (integer_zerop (_p1))
5787 : {
5788 1035 : {
5789 1035 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5790 1035 : tree res = generic_simplify_225 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR);
5791 1035 : if (res) return res;
5792 : }
5793 : }
5794 : break;
5795 : }
5796 6949772 : CASE_CONVERT:
5797 6949772 : {
5798 6949772 : tree _q20 = TREE_OPERAND (_p0, 0);
5799 6949772 : switch (TREE_CODE (_p1))
5800 : {
5801 3132607 : CASE_CONVERT:
5802 3132607 : {
5803 3132607 : tree _q40 = TREE_OPERAND (_p1, 0);
5804 3132607 : switch (TREE_CODE (_q40))
5805 : {
5806 0 : case MINUS_EXPR:
5807 0 : {
5808 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5809 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5810 0 : switch (TREE_CODE (_q50))
5811 : {
5812 0 : case INTEGER_CST:
5813 0 : {
5814 0 : switch (TREE_CODE (_q51))
5815 : {
5816 0 : CASE_CONVERT:
5817 0 : {
5818 0 : tree _q70 = TREE_OPERAND (_q51, 0);
5819 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
5820 : {
5821 0 : {
5822 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
5823 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
5824 0 : if (res) return res;
5825 : }
5826 : }
5827 : break;
5828 : }
5829 : default:;
5830 : }
5831 : break;
5832 : }
5833 : default:;
5834 : }
5835 : break;
5836 : }
5837 : default:;
5838 : }
5839 : break;
5840 : }
5841 6949772 : default:;
5842 : }
5843 6949772 : switch (TREE_CODE (_q20))
5844 : {
5845 99 : case MINUS_EXPR:
5846 99 : {
5847 99 : tree _q30 = TREE_OPERAND (_q20, 0);
5848 99 : tree _q31 = TREE_OPERAND (_q20, 1);
5849 99 : switch (TREE_CODE (_q30))
5850 : {
5851 49 : case INTEGER_CST:
5852 49 : {
5853 49 : switch (TREE_CODE (_q31))
5854 : {
5855 0 : CASE_CONVERT:
5856 0 : {
5857 0 : tree _q50 = TREE_OPERAND (_q31, 0);
5858 0 : switch (TREE_CODE (_p1))
5859 : {
5860 0 : CASE_CONVERT:
5861 0 : {
5862 0 : tree _q70 = TREE_OPERAND (_p1, 0);
5863 0 : if ((_q70 == _q50 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q50, 0) && types_match (_q70, _q50)))
5864 : {
5865 0 : {
5866 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
5867 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
5868 0 : if (res) return res;
5869 : }
5870 : }
5871 : break;
5872 : }
5873 0 : default:;
5874 : }
5875 0 : if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
5876 : {
5877 0 : {
5878 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
5879 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
5880 0 : if (res) return res;
5881 : }
5882 : }
5883 : break;
5884 : }
5885 49 : default:;
5886 : }
5887 49 : switch (TREE_CODE (_p1))
5888 : {
5889 0 : CASE_CONVERT:
5890 0 : {
5891 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5892 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
5893 : {
5894 0 : {
5895 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q30 };
5896 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
5897 0 : if (res) return res;
5898 : }
5899 : }
5900 : break;
5901 : }
5902 49 : default:;
5903 : }
5904 49 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
5905 : {
5906 0 : {
5907 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q30 };
5908 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
5909 0 : if (res) return res;
5910 : }
5911 : }
5912 : break;
5913 : }
5914 : default:;
5915 : }
5916 : break;
5917 : }
5918 6949772 : default:;
5919 : }
5920 6949772 : switch (TREE_CODE (_p1))
5921 : {
5922 3132607 : CASE_CONVERT:
5923 3132607 : {
5924 3132607 : tree _q40 = TREE_OPERAND (_p1, 0);
5925 3132607 : switch (TREE_CODE (_q40))
5926 : {
5927 0 : case MINUS_EXPR:
5928 0 : {
5929 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5930 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5931 0 : switch (TREE_CODE (_q50))
5932 : {
5933 0 : case INTEGER_CST:
5934 0 : {
5935 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5936 : {
5937 0 : {
5938 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
5939 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
5940 0 : if (res) return res;
5941 : }
5942 : }
5943 : break;
5944 : }
5945 : default:;
5946 : }
5947 : break;
5948 : }
5949 : default:;
5950 : }
5951 : break;
5952 : }
5953 21676 : case MINUS_EXPR:
5954 21676 : {
5955 21676 : tree _q40 = TREE_OPERAND (_p1, 0);
5956 21676 : tree _q41 = TREE_OPERAND (_p1, 1);
5957 21676 : switch (TREE_CODE (_q40))
5958 : {
5959 401 : case INTEGER_CST:
5960 401 : {
5961 401 : switch (TREE_CODE (_q41))
5962 : {
5963 20 : CASE_CONVERT:
5964 20 : {
5965 20 : tree _q60 = TREE_OPERAND (_q41, 0);
5966 20 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
5967 : {
5968 0 : {
5969 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
5970 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
5971 0 : if (res) return res;
5972 : }
5973 : }
5974 : break;
5975 : }
5976 401 : default:;
5977 : }
5978 401 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
5979 : {
5980 0 : {
5981 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
5982 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
5983 0 : if (res) return res;
5984 : }
5985 : }
5986 : break;
5987 : }
5988 : default:;
5989 : }
5990 : break;
5991 : }
5992 : default:;
5993 : }
5994 : break;
5995 : }
5996 104252 : case MINUS_EXPR:
5997 104252 : {
5998 104252 : tree _q20 = TREE_OPERAND (_p0, 0);
5999 104252 : tree _q21 = TREE_OPERAND (_p0, 1);
6000 104252 : switch (TREE_CODE (_q20))
6001 : {
6002 2082 : case INTEGER_CST:
6003 2082 : {
6004 2082 : switch (TREE_CODE (_q21))
6005 : {
6006 182 : CASE_CONVERT:
6007 182 : {
6008 182 : tree _q40 = TREE_OPERAND (_q21, 0);
6009 182 : switch (TREE_CODE (_p1))
6010 : {
6011 0 : CASE_CONVERT:
6012 0 : {
6013 0 : tree _q60 = TREE_OPERAND (_p1, 0);
6014 0 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
6015 : {
6016 0 : {
6017 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
6018 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
6019 0 : if (res) return res;
6020 : }
6021 : }
6022 : break;
6023 : }
6024 182 : default:;
6025 : }
6026 182 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
6027 : {
6028 0 : {
6029 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
6030 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
6031 0 : if (res) return res;
6032 : }
6033 : }
6034 : break;
6035 : }
6036 2082 : default:;
6037 : }
6038 2082 : switch (TREE_CODE (_p1))
6039 : {
6040 306 : CASE_CONVERT:
6041 306 : {
6042 306 : tree _q50 = TREE_OPERAND (_p1, 0);
6043 306 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6044 : {
6045 0 : {
6046 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6047 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
6048 0 : if (res) return res;
6049 : }
6050 : }
6051 : break;
6052 : }
6053 2082 : default:;
6054 : }
6055 2082 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
6056 : {
6057 19 : {
6058 19 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6059 19 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
6060 19 : if (res) return res;
6061 : }
6062 : }
6063 : break;
6064 : }
6065 : default:;
6066 : }
6067 : break;
6068 : }
6069 35886672 : default:;
6070 : }
6071 35886672 : switch (TREE_CODE (_p1))
6072 : {
6073 3526174 : CASE_CONVERT:
6074 3526174 : {
6075 3526174 : tree _q30 = TREE_OPERAND (_p1, 0);
6076 3526174 : switch (TREE_CODE (_q30))
6077 : {
6078 556 : case MINUS_EXPR:
6079 556 : {
6080 556 : tree _q40 = TREE_OPERAND (_q30, 0);
6081 556 : tree _q41 = TREE_OPERAND (_q30, 1);
6082 556 : switch (TREE_CODE (_q40))
6083 : {
6084 17 : case INTEGER_CST:
6085 17 : {
6086 17 : switch (TREE_CODE (_q41))
6087 : {
6088 0 : CASE_CONVERT:
6089 0 : {
6090 0 : tree _q60 = TREE_OPERAND (_q41, 0);
6091 0 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
6092 : {
6093 0 : {
6094 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
6095 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
6096 0 : if (res) return res;
6097 : }
6098 : }
6099 : break;
6100 : }
6101 17 : default:;
6102 : }
6103 17 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
6104 : {
6105 0 : {
6106 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
6107 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
6108 0 : if (res) return res;
6109 : }
6110 : }
6111 : break;
6112 : }
6113 : default:;
6114 : }
6115 : break;
6116 : }
6117 : default:;
6118 : }
6119 : break;
6120 : }
6121 30243 : case MINUS_EXPR:
6122 30243 : {
6123 30243 : tree _q30 = TREE_OPERAND (_p1, 0);
6124 30243 : tree _q31 = TREE_OPERAND (_p1, 1);
6125 30243 : switch (TREE_CODE (_q30))
6126 : {
6127 612 : case INTEGER_CST:
6128 612 : {
6129 612 : switch (TREE_CODE (_q31))
6130 : {
6131 32 : CASE_CONVERT:
6132 32 : {
6133 32 : tree _q50 = TREE_OPERAND (_q31, 0);
6134 32 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
6135 : {
6136 0 : {
6137 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
6138 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
6139 0 : if (res) return res;
6140 : }
6141 : }
6142 : break;
6143 : }
6144 612 : default:;
6145 : }
6146 612 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6147 : {
6148 0 : {
6149 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
6150 0 : tree res = generic_simplify_226 (loc, type, _p0, _p1, captures, NE_EXPR);
6151 0 : if (res) return res;
6152 : }
6153 : }
6154 : break;
6155 : }
6156 : default:;
6157 : }
6158 : break;
6159 : }
6160 35886672 : default:;
6161 : }
6162 35886672 : switch (TREE_CODE (_p0))
6163 : {
6164 18225 : case LT_EXPR:
6165 18225 : {
6166 18225 : tree _q20 = TREE_OPERAND (_p0, 0);
6167 18225 : tree _q21 = TREE_OPERAND (_p0, 1);
6168 18225 : switch (TREE_CODE (_p1))
6169 : {
6170 18 : case GT_EXPR:
6171 18 : {
6172 18 : tree _q50 = TREE_OPERAND (_p1, 0);
6173 18 : tree _q51 = TREE_OPERAND (_p1, 1);
6174 18 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6175 : {
6176 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6177 : {
6178 0 : {
6179 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6180 0 : const enum tree_code cmp1 = LT_EXPR;
6181 0 : const enum tree_code cmp2 = GT_EXPR;
6182 0 : const enum tree_code rcmp = NE_EXPR;
6183 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6184 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6185 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6186 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6187 : )
6188 : {
6189 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1527;
6190 0 : {
6191 0 : tree res_op0;
6192 0 : res_op0 = captures[0];
6193 0 : tree res_op1;
6194 0 : res_op1 = captures[1];
6195 0 : tree _r;
6196 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6197 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6198 0 : return _r;
6199 : }
6200 0 : next_after_fail1527:;
6201 : }
6202 : }
6203 : }
6204 : }
6205 : break;
6206 : }
6207 23 : case EQ_EXPR:
6208 23 : {
6209 23 : tree _q50 = TREE_OPERAND (_p1, 0);
6210 23 : tree _q51 = TREE_OPERAND (_p1, 1);
6211 23 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6212 : {
6213 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6214 : {
6215 0 : {
6216 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6217 0 : const enum tree_code cmp1 = LT_EXPR;
6218 0 : const enum tree_code cmp2 = EQ_EXPR;
6219 0 : const enum tree_code rcmp = LE_EXPR;
6220 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6221 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6222 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6223 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6224 : )
6225 : {
6226 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1528;
6227 0 : {
6228 0 : tree res_op0;
6229 0 : res_op0 = captures[0];
6230 0 : tree res_op1;
6231 0 : res_op1 = captures[1];
6232 0 : tree _r;
6233 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6234 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6235 0 : return _r;
6236 : }
6237 0 : next_after_fail1528:;
6238 : }
6239 : }
6240 : }
6241 : }
6242 : break;
6243 : }
6244 23 : case NE_EXPR:
6245 23 : {
6246 23 : tree _q50 = TREE_OPERAND (_p1, 0);
6247 23 : tree _q51 = TREE_OPERAND (_p1, 1);
6248 23 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6249 : {
6250 9 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6251 : {
6252 0 : {
6253 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6254 0 : const enum tree_code cmp1 = LT_EXPR;
6255 0 : const enum tree_code cmp2 = NE_EXPR;
6256 0 : const enum tree_code rcmp = GT_EXPR;
6257 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6258 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6259 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6260 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6261 : )
6262 : {
6263 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1529;
6264 0 : {
6265 0 : tree res_op0;
6266 0 : res_op0 = captures[0];
6267 0 : tree res_op1;
6268 0 : res_op1 = captures[1];
6269 0 : tree _r;
6270 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6271 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6272 0 : return _r;
6273 : }
6274 0 : next_after_fail1529:;
6275 : }
6276 : }
6277 : }
6278 : }
6279 : break;
6280 : }
6281 : default:;
6282 : }
6283 : break;
6284 : }
6285 11965 : case LE_EXPR:
6286 11965 : {
6287 11965 : tree _q20 = TREE_OPERAND (_p0, 0);
6288 11965 : tree _q21 = TREE_OPERAND (_p0, 1);
6289 11965 : switch (TREE_CODE (_p1))
6290 : {
6291 25 : case GE_EXPR:
6292 25 : {
6293 25 : tree _q50 = TREE_OPERAND (_p1, 0);
6294 25 : tree _q51 = TREE_OPERAND (_p1, 1);
6295 25 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6296 : {
6297 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6298 : {
6299 0 : {
6300 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6301 0 : const enum tree_code cmp1 = LE_EXPR;
6302 0 : const enum tree_code cmp2 = GE_EXPR;
6303 0 : const enum tree_code rcmp = NE_EXPR;
6304 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6305 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6306 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6307 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6308 : )
6309 : {
6310 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1530;
6311 0 : {
6312 0 : tree res_op0;
6313 0 : res_op0 = captures[0];
6314 0 : tree res_op1;
6315 0 : res_op1 = captures[1];
6316 0 : tree _r;
6317 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6318 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6319 0 : return _r;
6320 : }
6321 0 : next_after_fail1530:;
6322 : }
6323 : }
6324 : }
6325 : }
6326 : break;
6327 : }
6328 41 : case EQ_EXPR:
6329 41 : {
6330 41 : tree _q50 = TREE_OPERAND (_p1, 0);
6331 41 : tree _q51 = TREE_OPERAND (_p1, 1);
6332 41 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6333 : {
6334 9 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6335 : {
6336 0 : {
6337 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6338 0 : const enum tree_code cmp1 = LE_EXPR;
6339 0 : const enum tree_code cmp2 = EQ_EXPR;
6340 0 : const enum tree_code rcmp = LT_EXPR;
6341 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6342 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6343 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6344 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6345 : )
6346 : {
6347 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1531;
6348 0 : {
6349 0 : tree res_op0;
6350 0 : res_op0 = captures[0];
6351 0 : tree res_op1;
6352 0 : res_op1 = captures[1];
6353 0 : tree _r;
6354 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6355 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6356 0 : return _r;
6357 : }
6358 0 : next_after_fail1531:;
6359 : }
6360 : }
6361 : }
6362 : }
6363 : break;
6364 : }
6365 13 : case NE_EXPR:
6366 13 : {
6367 13 : tree _q50 = TREE_OPERAND (_p1, 0);
6368 13 : tree _q51 = TREE_OPERAND (_p1, 1);
6369 13 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6370 : {
6371 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6372 : {
6373 0 : {
6374 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6375 0 : const enum tree_code cmp1 = LE_EXPR;
6376 0 : const enum tree_code cmp2 = NE_EXPR;
6377 0 : const enum tree_code rcmp = GE_EXPR;
6378 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6379 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6380 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6381 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6382 : )
6383 : {
6384 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1532;
6385 0 : {
6386 0 : tree res_op0;
6387 0 : res_op0 = captures[0];
6388 0 : tree res_op1;
6389 0 : res_op1 = captures[1];
6390 0 : tree _r;
6391 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6392 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6393 0 : return _r;
6394 : }
6395 0 : next_after_fail1532:;
6396 : }
6397 : }
6398 : }
6399 : }
6400 : break;
6401 : }
6402 : default:;
6403 : }
6404 : break;
6405 : }
6406 35577 : case GT_EXPR:
6407 35577 : {
6408 35577 : tree _q20 = TREE_OPERAND (_p0, 0);
6409 35577 : tree _q21 = TREE_OPERAND (_p0, 1);
6410 35577 : switch (TREE_CODE (_p1))
6411 : {
6412 77 : case GT_EXPR:
6413 77 : {
6414 77 : tree _q50 = TREE_OPERAND (_p1, 0);
6415 77 : tree _q51 = TREE_OPERAND (_p1, 1);
6416 77 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6417 : {
6418 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6419 : {
6420 0 : {
6421 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6422 0 : const enum tree_code cmp1 = LT_EXPR;
6423 0 : const enum tree_code cmp2 = GT_EXPR;
6424 0 : const enum tree_code rcmp = NE_EXPR;
6425 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6426 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6427 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6428 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6429 : )
6430 : {
6431 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1533;
6432 0 : {
6433 0 : tree res_op0;
6434 0 : res_op0 = captures[0];
6435 0 : tree res_op1;
6436 0 : res_op1 = captures[1];
6437 0 : tree _r;
6438 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6439 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6440 0 : return _r;
6441 : }
6442 0 : next_after_fail1533:;
6443 : }
6444 : }
6445 0 : {
6446 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6447 0 : const enum tree_code cmp1 = LT_EXPR;
6448 0 : const enum tree_code cmp2 = GT_EXPR;
6449 0 : const enum tree_code rcmp = NE_EXPR;
6450 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6451 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6452 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6453 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6454 : )
6455 : {
6456 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1534;
6457 0 : {
6458 0 : tree res_op0;
6459 0 : res_op0 = captures[0];
6460 0 : tree res_op1;
6461 0 : res_op1 = captures[1];
6462 0 : tree _r;
6463 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6464 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6465 0 : return _r;
6466 : }
6467 0 : next_after_fail1534:;
6468 : }
6469 : }
6470 : }
6471 : }
6472 : break;
6473 : }
6474 29 : case EQ_EXPR:
6475 29 : {
6476 29 : tree _q50 = TREE_OPERAND (_p1, 0);
6477 29 : tree _q51 = TREE_OPERAND (_p1, 1);
6478 29 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6479 : {
6480 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6481 : {
6482 0 : {
6483 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6484 0 : const enum tree_code cmp1 = LT_EXPR;
6485 0 : const enum tree_code cmp2 = EQ_EXPR;
6486 0 : const enum tree_code rcmp = LE_EXPR;
6487 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6488 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6489 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6490 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6491 : )
6492 : {
6493 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1535;
6494 0 : {
6495 0 : tree res_op0;
6496 0 : res_op0 = captures[0];
6497 0 : tree res_op1;
6498 0 : res_op1 = captures[1];
6499 0 : tree _r;
6500 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6501 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6502 0 : return _r;
6503 : }
6504 0 : next_after_fail1535:;
6505 : }
6506 : }
6507 : }
6508 : }
6509 : break;
6510 : }
6511 53 : case NE_EXPR:
6512 53 : {
6513 53 : tree _q50 = TREE_OPERAND (_p1, 0);
6514 53 : tree _q51 = TREE_OPERAND (_p1, 1);
6515 53 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6516 : {
6517 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6518 : {
6519 0 : {
6520 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6521 0 : const enum tree_code cmp1 = LT_EXPR;
6522 0 : const enum tree_code cmp2 = NE_EXPR;
6523 0 : const enum tree_code rcmp = GT_EXPR;
6524 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6525 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6526 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6527 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6528 : )
6529 : {
6530 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1536;
6531 0 : {
6532 0 : tree res_op0;
6533 0 : res_op0 = captures[0];
6534 0 : tree res_op1;
6535 0 : res_op1 = captures[1];
6536 0 : tree _r;
6537 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6538 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6539 0 : return _r;
6540 : }
6541 0 : next_after_fail1536:;
6542 : }
6543 : }
6544 : }
6545 : }
6546 : break;
6547 : }
6548 32 : case LT_EXPR:
6549 32 : {
6550 32 : tree _q50 = TREE_OPERAND (_p1, 0);
6551 32 : tree _q51 = TREE_OPERAND (_p1, 1);
6552 32 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6553 : {
6554 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6555 : {
6556 0 : {
6557 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6558 0 : const enum tree_code cmp1 = LT_EXPR;
6559 0 : const enum tree_code cmp2 = GT_EXPR;
6560 0 : const enum tree_code rcmp = NE_EXPR;
6561 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6562 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6563 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6564 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6565 : )
6566 : {
6567 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1537;
6568 0 : {
6569 0 : tree res_op0;
6570 0 : res_op0 = captures[0];
6571 0 : tree res_op1;
6572 0 : res_op1 = captures[1];
6573 0 : tree _r;
6574 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6575 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6576 0 : return _r;
6577 : }
6578 0 : next_after_fail1537:;
6579 : }
6580 : }
6581 : }
6582 : }
6583 : break;
6584 : }
6585 : default:;
6586 : }
6587 : break;
6588 : }
6589 6117 : case GE_EXPR:
6590 6117 : {
6591 6117 : tree _q20 = TREE_OPERAND (_p0, 0);
6592 6117 : tree _q21 = TREE_OPERAND (_p0, 1);
6593 6117 : switch (TREE_CODE (_p1))
6594 : {
6595 76 : case GE_EXPR:
6596 76 : {
6597 76 : tree _q50 = TREE_OPERAND (_p1, 0);
6598 76 : tree _q51 = TREE_OPERAND (_p1, 1);
6599 76 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6600 : {
6601 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6602 : {
6603 0 : {
6604 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6605 0 : const enum tree_code cmp1 = LE_EXPR;
6606 0 : const enum tree_code cmp2 = GE_EXPR;
6607 0 : const enum tree_code rcmp = NE_EXPR;
6608 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6609 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6610 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6611 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6612 : )
6613 : {
6614 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1538;
6615 0 : {
6616 0 : tree res_op0;
6617 0 : res_op0 = captures[0];
6618 0 : tree res_op1;
6619 0 : res_op1 = captures[1];
6620 0 : tree _r;
6621 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6622 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6623 0 : return _r;
6624 : }
6625 0 : next_after_fail1538:;
6626 : }
6627 : }
6628 0 : {
6629 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6630 0 : const enum tree_code cmp1 = LE_EXPR;
6631 0 : const enum tree_code cmp2 = GE_EXPR;
6632 0 : const enum tree_code rcmp = NE_EXPR;
6633 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6634 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6635 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6636 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6637 : )
6638 : {
6639 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1539;
6640 0 : {
6641 0 : tree res_op0;
6642 0 : res_op0 = captures[0];
6643 0 : tree res_op1;
6644 0 : res_op1 = captures[1];
6645 0 : tree _r;
6646 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6647 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6648 0 : return _r;
6649 : }
6650 0 : next_after_fail1539:;
6651 : }
6652 : }
6653 : }
6654 : }
6655 : break;
6656 : }
6657 52 : case EQ_EXPR:
6658 52 : {
6659 52 : tree _q50 = TREE_OPERAND (_p1, 0);
6660 52 : tree _q51 = TREE_OPERAND (_p1, 1);
6661 52 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6662 : {
6663 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6664 : {
6665 0 : {
6666 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6667 0 : const enum tree_code cmp1 = LE_EXPR;
6668 0 : const enum tree_code cmp2 = EQ_EXPR;
6669 0 : const enum tree_code rcmp = LT_EXPR;
6670 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6671 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6672 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6673 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6674 : )
6675 : {
6676 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1540;
6677 0 : {
6678 0 : tree res_op0;
6679 0 : res_op0 = captures[0];
6680 0 : tree res_op1;
6681 0 : res_op1 = captures[1];
6682 0 : tree _r;
6683 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6684 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6685 0 : return _r;
6686 : }
6687 0 : next_after_fail1540:;
6688 : }
6689 : }
6690 : }
6691 : }
6692 : break;
6693 : }
6694 11 : case NE_EXPR:
6695 11 : {
6696 11 : tree _q50 = TREE_OPERAND (_p1, 0);
6697 11 : tree _q51 = TREE_OPERAND (_p1, 1);
6698 11 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6699 : {
6700 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6701 : {
6702 0 : {
6703 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6704 0 : const enum tree_code cmp1 = LE_EXPR;
6705 0 : const enum tree_code cmp2 = NE_EXPR;
6706 0 : const enum tree_code rcmp = GE_EXPR;
6707 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6708 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6709 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6710 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6711 : )
6712 : {
6713 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1541;
6714 0 : {
6715 0 : tree res_op0;
6716 0 : res_op0 = captures[0];
6717 0 : tree res_op1;
6718 0 : res_op1 = captures[1];
6719 0 : tree _r;
6720 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6721 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6722 0 : return _r;
6723 : }
6724 0 : next_after_fail1541:;
6725 : }
6726 : }
6727 : }
6728 : }
6729 : break;
6730 : }
6731 16 : case LE_EXPR:
6732 16 : {
6733 16 : tree _q50 = TREE_OPERAND (_p1, 0);
6734 16 : tree _q51 = TREE_OPERAND (_p1, 1);
6735 16 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6736 : {
6737 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6738 : {
6739 0 : {
6740 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6741 0 : const enum tree_code cmp1 = LE_EXPR;
6742 0 : const enum tree_code cmp2 = GE_EXPR;
6743 0 : const enum tree_code rcmp = NE_EXPR;
6744 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6745 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6746 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6747 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6748 : )
6749 : {
6750 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1542;
6751 0 : {
6752 0 : tree res_op0;
6753 0 : res_op0 = captures[0];
6754 0 : tree res_op1;
6755 0 : res_op1 = captures[1];
6756 0 : tree _r;
6757 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6758 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6759 0 : return _r;
6760 : }
6761 0 : next_after_fail1542:;
6762 : }
6763 : }
6764 : }
6765 : }
6766 : break;
6767 : }
6768 : default:;
6769 : }
6770 : break;
6771 : }
6772 63639 : case EQ_EXPR:
6773 63639 : {
6774 63639 : tree _q20 = TREE_OPERAND (_p0, 0);
6775 63639 : tree _q21 = TREE_OPERAND (_p0, 1);
6776 63639 : switch (TREE_CODE (_p1))
6777 : {
6778 5 : case LT_EXPR:
6779 5 : {
6780 5 : tree _q50 = TREE_OPERAND (_p1, 0);
6781 5 : tree _q51 = TREE_OPERAND (_p1, 1);
6782 5 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6783 : {
6784 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6785 : {
6786 0 : {
6787 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6788 0 : const enum tree_code cmp1 = LT_EXPR;
6789 0 : const enum tree_code cmp2 = EQ_EXPR;
6790 0 : const enum tree_code rcmp = LE_EXPR;
6791 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6792 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6793 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6794 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6795 : )
6796 : {
6797 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1543;
6798 0 : {
6799 0 : tree res_op0;
6800 0 : res_op0 = captures[0];
6801 0 : tree res_op1;
6802 0 : res_op1 = captures[1];
6803 0 : tree _r;
6804 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6805 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6806 0 : return _r;
6807 : }
6808 0 : next_after_fail1543:;
6809 : }
6810 : }
6811 : }
6812 : }
6813 : break;
6814 : }
6815 42 : case LE_EXPR:
6816 42 : {
6817 42 : tree _q50 = TREE_OPERAND (_p1, 0);
6818 42 : tree _q51 = TREE_OPERAND (_p1, 1);
6819 42 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6820 : {
6821 7 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6822 : {
6823 0 : {
6824 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6825 0 : const enum tree_code cmp1 = LE_EXPR;
6826 0 : const enum tree_code cmp2 = EQ_EXPR;
6827 0 : const enum tree_code rcmp = LT_EXPR;
6828 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6829 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6830 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6831 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6832 : )
6833 : {
6834 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1544;
6835 0 : {
6836 0 : tree res_op0;
6837 0 : res_op0 = captures[0];
6838 0 : tree res_op1;
6839 0 : res_op1 = captures[1];
6840 0 : tree _r;
6841 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6842 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6843 0 : return _r;
6844 : }
6845 0 : next_after_fail1544:;
6846 : }
6847 : }
6848 : }
6849 : }
6850 : break;
6851 : }
6852 7 : case GT_EXPR:
6853 7 : {
6854 7 : tree _q50 = TREE_OPERAND (_p1, 0);
6855 7 : tree _q51 = TREE_OPERAND (_p1, 1);
6856 7 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6857 : {
6858 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6859 : {
6860 0 : {
6861 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6862 0 : const enum tree_code cmp1 = LT_EXPR;
6863 0 : const enum tree_code cmp2 = EQ_EXPR;
6864 0 : const enum tree_code rcmp = LE_EXPR;
6865 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6866 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6867 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6868 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6869 : )
6870 : {
6871 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1545;
6872 0 : {
6873 0 : tree res_op0;
6874 0 : res_op0 = captures[0];
6875 0 : tree res_op1;
6876 0 : res_op1 = captures[1];
6877 0 : tree _r;
6878 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6879 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6880 0 : return _r;
6881 : }
6882 0 : next_after_fail1545:;
6883 : }
6884 : }
6885 : }
6886 : }
6887 : break;
6888 : }
6889 14 : case GE_EXPR:
6890 14 : {
6891 14 : tree _q50 = TREE_OPERAND (_p1, 0);
6892 14 : tree _q51 = TREE_OPERAND (_p1, 1);
6893 14 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6894 : {
6895 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6896 : {
6897 0 : {
6898 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6899 0 : const enum tree_code cmp1 = LE_EXPR;
6900 0 : const enum tree_code cmp2 = EQ_EXPR;
6901 0 : const enum tree_code rcmp = LT_EXPR;
6902 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6903 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6904 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6905 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6906 : )
6907 : {
6908 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1546;
6909 0 : {
6910 0 : tree res_op0;
6911 0 : res_op0 = captures[0];
6912 0 : tree res_op1;
6913 0 : res_op1 = captures[1];
6914 0 : tree _r;
6915 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6916 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6917 0 : return _r;
6918 : }
6919 0 : next_after_fail1546:;
6920 : }
6921 : }
6922 : }
6923 : }
6924 : break;
6925 : }
6926 : default:;
6927 : }
6928 : break;
6929 : }
6930 69135 : case NE_EXPR:
6931 69135 : {
6932 69135 : tree _q20 = TREE_OPERAND (_p0, 0);
6933 69135 : tree _q21 = TREE_OPERAND (_p0, 1);
6934 69135 : switch (TREE_CODE (_p1))
6935 : {
6936 7 : case LT_EXPR:
6937 7 : {
6938 7 : tree _q50 = TREE_OPERAND (_p1, 0);
6939 7 : tree _q51 = TREE_OPERAND (_p1, 1);
6940 7 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6941 : {
6942 7 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6943 : {
6944 0 : {
6945 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6946 0 : const enum tree_code cmp1 = LT_EXPR;
6947 0 : const enum tree_code cmp2 = NE_EXPR;
6948 0 : const enum tree_code rcmp = GT_EXPR;
6949 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6950 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6951 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6952 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6953 : )
6954 : {
6955 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1547;
6956 0 : {
6957 0 : tree res_op0;
6958 0 : res_op0 = captures[0];
6959 0 : tree res_op1;
6960 0 : res_op1 = captures[1];
6961 0 : tree _r;
6962 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
6963 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
6964 0 : return _r;
6965 : }
6966 0 : next_after_fail1547:;
6967 : }
6968 : }
6969 : }
6970 : }
6971 : break;
6972 : }
6973 302 : case LE_EXPR:
6974 302 : {
6975 302 : tree _q50 = TREE_OPERAND (_p1, 0);
6976 302 : tree _q51 = TREE_OPERAND (_p1, 1);
6977 302 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6978 : {
6979 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6980 : {
6981 0 : {
6982 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6983 0 : const enum tree_code cmp1 = LE_EXPR;
6984 0 : const enum tree_code cmp2 = NE_EXPR;
6985 0 : const enum tree_code rcmp = GE_EXPR;
6986 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6987 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
6988 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
6989 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
6990 : )
6991 : {
6992 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1548;
6993 0 : {
6994 0 : tree res_op0;
6995 0 : res_op0 = captures[0];
6996 0 : tree res_op1;
6997 0 : res_op1 = captures[1];
6998 0 : tree _r;
6999 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
7000 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
7001 0 : return _r;
7002 : }
7003 0 : next_after_fail1548:;
7004 : }
7005 : }
7006 : }
7007 : }
7008 : break;
7009 : }
7010 323 : case GT_EXPR:
7011 323 : {
7012 323 : tree _q50 = TREE_OPERAND (_p1, 0);
7013 323 : tree _q51 = TREE_OPERAND (_p1, 1);
7014 323 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7015 : {
7016 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7017 : {
7018 0 : {
7019 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7020 0 : const enum tree_code cmp1 = LT_EXPR;
7021 0 : const enum tree_code cmp2 = NE_EXPR;
7022 0 : const enum tree_code rcmp = GT_EXPR;
7023 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
7024 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
7025 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
7026 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
7027 : )
7028 : {
7029 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1549;
7030 0 : {
7031 0 : tree res_op0;
7032 0 : res_op0 = captures[0];
7033 0 : tree res_op1;
7034 0 : res_op1 = captures[1];
7035 0 : tree _r;
7036 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
7037 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
7038 0 : return _r;
7039 : }
7040 0 : next_after_fail1549:;
7041 : }
7042 : }
7043 : }
7044 : }
7045 : break;
7046 : }
7047 2 : case GE_EXPR:
7048 2 : {
7049 2 : tree _q50 = TREE_OPERAND (_p1, 0);
7050 2 : tree _q51 = TREE_OPERAND (_p1, 1);
7051 2 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7052 : {
7053 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7054 : {
7055 0 : {
7056 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7057 0 : const enum tree_code cmp1 = LE_EXPR;
7058 0 : const enum tree_code cmp2 = NE_EXPR;
7059 0 : const enum tree_code rcmp = GE_EXPR;
7060 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
7061 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
7062 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
7063 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
7064 : )
7065 : {
7066 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1550;
7067 0 : {
7068 0 : tree res_op0;
7069 0 : res_op0 = captures[0];
7070 0 : tree res_op1;
7071 0 : res_op1 = captures[1];
7072 0 : tree _r;
7073 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
7074 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
7075 0 : return _r;
7076 : }
7077 0 : next_after_fail1550:;
7078 : }
7079 : }
7080 : }
7081 : }
7082 : break;
7083 : }
7084 : default:;
7085 : }
7086 : break;
7087 : }
7088 8276 : case MIN_EXPR:
7089 8276 : {
7090 8276 : tree _q20 = TREE_OPERAND (_p0, 0);
7091 8276 : tree _q21 = TREE_OPERAND (_p0, 1);
7092 8276 : switch (TREE_CODE (_p1))
7093 : {
7094 0 : case MAX_EXPR:
7095 0 : {
7096 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7097 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7098 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7099 : {
7100 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7101 : {
7102 0 : {
7103 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7104 0 : if (!HONOR_NANS (captures[0])
7105 : )
7106 : {
7107 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1551;
7108 0 : {
7109 0 : tree res_op0;
7110 0 : res_op0 = captures[0];
7111 0 : tree res_op1;
7112 0 : res_op1 = captures[1];
7113 0 : tree _r;
7114 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
7115 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
7116 0 : return _r;
7117 : }
7118 0 : next_after_fail1551:;
7119 : }
7120 : }
7121 : }
7122 : }
7123 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7124 : {
7125 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7126 : {
7127 0 : {
7128 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
7129 0 : if (!HONOR_NANS (captures[0])
7130 : )
7131 : {
7132 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1552;
7133 0 : {
7134 0 : tree res_op0;
7135 0 : res_op0 = captures[0];
7136 0 : tree res_op1;
7137 0 : res_op1 = captures[1];
7138 0 : tree _r;
7139 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
7140 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
7141 0 : return _r;
7142 : }
7143 0 : next_after_fail1552:;
7144 : }
7145 : }
7146 : }
7147 : }
7148 : break;
7149 : }
7150 8276 : default:;
7151 : }
7152 8276 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
7153 : {
7154 0 : {
7155 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7156 0 : tree res = generic_simplify_229 (loc, type, _p0, _p1, captures, MIN_EXPR, NE_EXPR, GT_EXPR);
7157 0 : if (res) return res;
7158 : }
7159 : }
7160 8276 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
7161 : {
7162 616 : {
7163 616 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
7164 616 : tree res = generic_simplify_229 (loc, type, _p0, _p1, captures, MIN_EXPR, NE_EXPR, GT_EXPR);
7165 616 : if (res) return res;
7166 : }
7167 : }
7168 : break;
7169 : }
7170 7895 : case MAX_EXPR:
7171 7895 : {
7172 7895 : tree _q20 = TREE_OPERAND (_p0, 0);
7173 7895 : tree _q21 = TREE_OPERAND (_p0, 1);
7174 7895 : switch (TREE_CODE (_p1))
7175 : {
7176 0 : case MIN_EXPR:
7177 0 : {
7178 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7179 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7180 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7181 : {
7182 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7183 : {
7184 0 : {
7185 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7186 0 : if (!HONOR_NANS (captures[0])
7187 : )
7188 : {
7189 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1553;
7190 0 : {
7191 0 : tree res_op0;
7192 0 : res_op0 = captures[0];
7193 0 : tree res_op1;
7194 0 : res_op1 = captures[1];
7195 0 : tree _r;
7196 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
7197 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
7198 0 : return _r;
7199 : }
7200 0 : next_after_fail1553:;
7201 : }
7202 : }
7203 : }
7204 : }
7205 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7206 : {
7207 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7208 : {
7209 0 : {
7210 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7211 0 : if (!HONOR_NANS (captures[0])
7212 : )
7213 : {
7214 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1554;
7215 0 : {
7216 0 : tree res_op0;
7217 0 : res_op0 = captures[0];
7218 0 : tree res_op1;
7219 0 : res_op1 = captures[1];
7220 0 : tree _r;
7221 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
7222 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
7223 0 : return _r;
7224 : }
7225 0 : next_after_fail1554:;
7226 : }
7227 : }
7228 : }
7229 : }
7230 : break;
7231 : }
7232 7895 : default:;
7233 : }
7234 7895 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
7235 : {
7236 0 : {
7237 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7238 0 : tree res = generic_simplify_229 (loc, type, _p0, _p1, captures, MAX_EXPR, NE_EXPR, LT_EXPR);
7239 0 : if (res) return res;
7240 : }
7241 : }
7242 7895 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
7243 : {
7244 425 : {
7245 425 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
7246 425 : tree res = generic_simplify_229 (loc, type, _p0, _p1, captures, MAX_EXPR, NE_EXPR, LT_EXPR);
7247 425 : if (res) return res;
7248 : }
7249 : }
7250 : break;
7251 : }
7252 35886543 : default:;
7253 : }
7254 35886543 : if (tree_with_possible_nonzero_bits (_p0))
7255 : {
7256 15450715 : if (tree_with_known_nonzero_bits (_p1))
7257 : {
7258 13988057 : {
7259 13988057 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
7260 13988057 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, NE_EXPR);
7261 13988057 : if (res) return res;
7262 : }
7263 : }
7264 : }
7265 35826838 : if (tree_with_known_nonzero_bits (_p0))
7266 : {
7267 11354378 : if (tree_with_possible_nonzero_bits (_p1))
7268 : {
7269 11303766 : {
7270 11303766 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _p0 };
7271 11303766 : tree res = generic_simplify_227 (loc, type, _p0, _p1, captures, NE_EXPR);
7272 11303766 : if (res) return res;
7273 : }
7274 : }
7275 : }
7276 35825424 : switch (TREE_CODE (_p1))
7277 : {
7278 146 : case MIN_EXPR:
7279 146 : {
7280 146 : tree _q30 = TREE_OPERAND (_p1, 0);
7281 146 : tree _q31 = TREE_OPERAND (_p1, 1);
7282 146 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
7283 : {
7284 0 : {
7285 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
7286 0 : tree res = generic_simplify_229 (loc, type, _p0, _p1, captures, MIN_EXPR, NE_EXPR, GT_EXPR);
7287 0 : if (res) return res;
7288 : }
7289 : }
7290 146 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
7291 : {
7292 0 : {
7293 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
7294 0 : tree res = generic_simplify_229 (loc, type, _p0, _p1, captures, MIN_EXPR, NE_EXPR, GT_EXPR);
7295 0 : if (res) return res;
7296 : }
7297 : }
7298 : break;
7299 : }
7300 1584 : case MAX_EXPR:
7301 1584 : {
7302 1584 : tree _q30 = TREE_OPERAND (_p1, 0);
7303 1584 : tree _q31 = TREE_OPERAND (_p1, 1);
7304 1584 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
7305 : {
7306 0 : {
7307 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
7308 0 : tree res = generic_simplify_229 (loc, type, _p0, _p1, captures, MAX_EXPR, NE_EXPR, LT_EXPR);
7309 0 : if (res) return res;
7310 : }
7311 : }
7312 1584 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
7313 : {
7314 0 : {
7315 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
7316 0 : tree res = generic_simplify_229 (loc, type, _p0, _p1, captures, MAX_EXPR, NE_EXPR, LT_EXPR);
7317 0 : if (res) return res;
7318 : }
7319 : }
7320 : break;
7321 : }
7322 35825424 : default:;
7323 : }
7324 35825424 : switch (TREE_CODE (_p0))
7325 : {
7326 8276 : case MIN_EXPR:
7327 8276 : {
7328 8276 : tree _q20 = TREE_OPERAND (_p0, 0);
7329 8276 : tree _q21 = TREE_OPERAND (_p0, 1);
7330 8276 : switch (TREE_CODE (_q21))
7331 : {
7332 680 : case INTEGER_CST:
7333 680 : {
7334 680 : switch (TREE_CODE (_p1))
7335 : {
7336 0 : case INTEGER_CST:
7337 0 : {
7338 0 : {
7339 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7340 0 : tree res = generic_simplify_230 (loc, type, _p0, _p1, captures, NE_EXPR);
7341 0 : if (res) return res;
7342 : }
7343 0 : break;
7344 : }
7345 : default:;
7346 : }
7347 : break;
7348 : }
7349 : default:;
7350 : }
7351 : break;
7352 : }
7353 7766 : case MAX_EXPR:
7354 7766 : {
7355 7766 : tree _q20 = TREE_OPERAND (_p0, 0);
7356 7766 : tree _q21 = TREE_OPERAND (_p0, 1);
7357 7766 : switch (TREE_CODE (_q21))
7358 : {
7359 6716 : case INTEGER_CST:
7360 6716 : {
7361 6716 : switch (TREE_CODE (_p1))
7362 : {
7363 684 : case INTEGER_CST:
7364 684 : {
7365 684 : {
7366 684 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7367 684 : tree res = generic_simplify_231 (loc, type, _p0, _p1, captures, NE_EXPR);
7368 684 : if (res) return res;
7369 : }
7370 0 : break;
7371 : }
7372 : default:;
7373 : }
7374 : break;
7375 : }
7376 7082 : default:;
7377 : }
7378 7082 : if (integer_zerop (_p1))
7379 : {
7380 34 : {
7381 34 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7382 34 : tree res = generic_simplify_232 (loc, type, _p0, _p1, captures, NE_EXPR);
7383 34 : if (res) return res;
7384 : }
7385 : }
7386 : break;
7387 : }
7388 1263277 : case BIT_AND_EXPR:
7389 1263277 : {
7390 1263277 : tree _q20 = TREE_OPERAND (_p0, 0);
7391 1263277 : tree _q21 = TREE_OPERAND (_p0, 1);
7392 1263277 : switch (TREE_CODE (_q20))
7393 : {
7394 3603 : case LSHIFT_EXPR:
7395 3603 : {
7396 3603 : tree _q30 = TREE_OPERAND (_q20, 0);
7397 3603 : tree _q31 = TREE_OPERAND (_q20, 1);
7398 3603 : if (integer_pow2p (_q30))
7399 : {
7400 3583 : if (integer_pow2p (_q21))
7401 : {
7402 5 : if (integer_zerop (_p1))
7403 : {
7404 5 : {
7405 5 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q21 };
7406 5 : tree res = generic_simplify_233 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
7407 5 : if (res) return res;
7408 : }
7409 : }
7410 : }
7411 : }
7412 3598 : switch (TREE_CODE (_q31))
7413 : {
7414 13 : case INTEGER_CST:
7415 13 : {
7416 13 : switch (TREE_CODE (_q21))
7417 : {
7418 13 : case INTEGER_CST:
7419 13 : {
7420 13 : switch (TREE_CODE (_p1))
7421 : {
7422 13 : case INTEGER_CST:
7423 13 : {
7424 13 : {
7425 13 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1 };
7426 13 : tree res = generic_simplify_234 (loc, type, _p0, _p1, captures, NE_EXPR);
7427 13 : if (res) return res;
7428 : }
7429 0 : break;
7430 : }
7431 : default:;
7432 : }
7433 : break;
7434 : }
7435 : default:;
7436 : }
7437 : break;
7438 : }
7439 3585 : default:;
7440 : }
7441 3585 : if (integer_onep (_q30))
7442 : {
7443 3577 : if (integer_pow2p (_q21))
7444 : {
7445 0 : if (integer_zerop (_p1))
7446 : {
7447 0 : {
7448 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q21 };
7449 0 : tree res = generic_simplify_235 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
7450 0 : if (res) return res;
7451 : }
7452 : }
7453 : }
7454 : }
7455 : break;
7456 : }
7457 4784 : case RSHIFT_EXPR:
7458 4784 : {
7459 4784 : tree _q30 = TREE_OPERAND (_q20, 0);
7460 4784 : tree _q31 = TREE_OPERAND (_q20, 1);
7461 4784 : if (integer_pow2p (_q30))
7462 : {
7463 33 : if (integer_pow2p (_q21))
7464 : {
7465 1 : if (integer_zerop (_p1))
7466 : {
7467 1 : {
7468 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q21 };
7469 1 : tree res = generic_simplify_236 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
7470 1 : if (res) return res;
7471 : }
7472 : }
7473 : }
7474 : }
7475 4783 : switch (TREE_CODE (_q31))
7476 : {
7477 329 : case INTEGER_CST:
7478 329 : {
7479 329 : switch (TREE_CODE (_q21))
7480 : {
7481 305 : case INTEGER_CST:
7482 305 : {
7483 305 : switch (TREE_CODE (_p1))
7484 : {
7485 280 : case INTEGER_CST:
7486 280 : {
7487 280 : {
7488 280 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1 };
7489 280 : tree res = generic_simplify_237 (loc, type, _p0, _p1, captures, NE_EXPR);
7490 280 : if (res) return res;
7491 : }
7492 14 : break;
7493 : }
7494 : default:;
7495 : }
7496 : break;
7497 : }
7498 : default:;
7499 : }
7500 : break;
7501 : }
7502 : default:;
7503 : }
7504 : break;
7505 : }
7506 1262992 : default:;
7507 : }
7508 1262992 : {
7509 1262992 : tree _q20_pops[1];
7510 1262992 : if (tree_nop_convert (_q20, _q20_pops))
7511 : {
7512 138798 : tree _q30 = _q20_pops[0];
7513 138798 : switch (TREE_CODE (_q30))
7514 : {
7515 37188 : case LSHIFT_EXPR:
7516 37188 : {
7517 37188 : tree _q40 = TREE_OPERAND (_q30, 0);
7518 37188 : tree _q41 = TREE_OPERAND (_q30, 1);
7519 37188 : if (integer_onep (_q40))
7520 : {
7521 37188 : if (integer_pow2p (_q21))
7522 : {
7523 0 : if (integer_zerop (_p1))
7524 : {
7525 0 : {
7526 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q41, _q21 };
7527 0 : tree res = generic_simplify_235 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
7528 0 : if (res) return res;
7529 : }
7530 : }
7531 : }
7532 : }
7533 : break;
7534 : }
7535 : default:;
7536 : }
7537 : }
7538 : }
7539 1262992 : break;
7540 : }
7541 5161 : case LSHIFT_EXPR:
7542 5161 : {
7543 5161 : tree _q20 = TREE_OPERAND (_p0, 0);
7544 5161 : tree _q21 = TREE_OPERAND (_p0, 1);
7545 5161 : switch (TREE_CODE (_q20))
7546 : {
7547 534 : case INTEGER_CST:
7548 534 : {
7549 534 : switch (TREE_CODE (_p1))
7550 : {
7551 159 : case INTEGER_CST:
7552 159 : {
7553 159 : {
7554 159 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7555 159 : tree res = generic_simplify_238 (loc, type, _p0, _p1, captures, NE_EXPR);
7556 159 : if (res) return res;
7557 : }
7558 88 : break;
7559 : }
7560 : default:;
7561 : }
7562 : break;
7563 : }
7564 : default:;
7565 : }
7566 : break;
7567 : }
7568 397 : case LROTATE_EXPR:
7569 397 : {
7570 397 : tree _q20 = TREE_OPERAND (_p0, 0);
7571 397 : tree _q21 = TREE_OPERAND (_p0, 1);
7572 397 : switch (TREE_CODE (_p1))
7573 : {
7574 0 : case LROTATE_EXPR:
7575 0 : {
7576 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7577 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7578 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7579 : {
7580 0 : {
7581 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
7582 0 : tree res = generic_simplify_239 (loc, type, _p0, _p1, captures, LROTATE_EXPR, RROTATE_EXPR, NE_EXPR);
7583 0 : if (res) return res;
7584 : }
7585 : }
7586 : break;
7587 : }
7588 397 : default:;
7589 : }
7590 397 : switch (TREE_CODE (_q21))
7591 : {
7592 112 : case INTEGER_CST:
7593 112 : {
7594 112 : switch (TREE_CODE (_p1))
7595 : {
7596 112 : case INTEGER_CST:
7597 112 : {
7598 112 : {
7599 112 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7600 112 : tree res = generic_simplify_240 (loc, type, _p0, _p1, captures, LROTATE_EXPR, RROTATE_EXPR, NE_EXPR);
7601 112 : if (res) return res;
7602 : }
7603 0 : break;
7604 : }
7605 : default:;
7606 : }
7607 : break;
7608 : }
7609 285 : default:;
7610 : }
7611 285 : switch (TREE_CODE (_p1))
7612 : {
7613 197 : case INTEGER_CST:
7614 197 : {
7615 197 : {
7616 197 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7617 197 : tree res = generic_simplify_241 (loc, type, _p0, _p1, captures, LROTATE_EXPR, RROTATE_EXPR, NE_EXPR);
7618 197 : if (res) return res;
7619 : }
7620 197 : break;
7621 : }
7622 : default:;
7623 : }
7624 : break;
7625 : }
7626 443 : case RROTATE_EXPR:
7627 443 : {
7628 443 : tree _q20 = TREE_OPERAND (_p0, 0);
7629 443 : tree _q21 = TREE_OPERAND (_p0, 1);
7630 443 : switch (TREE_CODE (_p1))
7631 : {
7632 0 : case RROTATE_EXPR:
7633 0 : {
7634 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7635 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7636 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7637 : {
7638 0 : {
7639 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
7640 0 : tree res = generic_simplify_239 (loc, type, _p0, _p1, captures, RROTATE_EXPR, LROTATE_EXPR, NE_EXPR);
7641 0 : if (res) return res;
7642 : }
7643 : }
7644 : break;
7645 : }
7646 443 : default:;
7647 : }
7648 443 : switch (TREE_CODE (_q21))
7649 : {
7650 233 : case INTEGER_CST:
7651 233 : {
7652 233 : switch (TREE_CODE (_p1))
7653 : {
7654 12 : case INTEGER_CST:
7655 12 : {
7656 12 : {
7657 12 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7658 12 : tree res = generic_simplify_240 (loc, type, _p0, _p1, captures, RROTATE_EXPR, LROTATE_EXPR, NE_EXPR);
7659 12 : if (res) return res;
7660 : }
7661 0 : break;
7662 : }
7663 : default:;
7664 : }
7665 : break;
7666 : }
7667 431 : default:;
7668 : }
7669 431 : switch (TREE_CODE (_p1))
7670 : {
7671 194 : case INTEGER_CST:
7672 194 : {
7673 194 : {
7674 194 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7675 194 : tree res = generic_simplify_241 (loc, type, _p0, _p1, captures, RROTATE_EXPR, LROTATE_EXPR, NE_EXPR);
7676 194 : if (res) return res;
7677 : }
7678 194 : break;
7679 : }
7680 : default:;
7681 : }
7682 : break;
7683 : }
7684 268 : case VEC_COND_EXPR:
7685 268 : {
7686 268 : tree _q20 = TREE_OPERAND (_p0, 0);
7687 268 : tree _q21 = TREE_OPERAND (_p0, 1);
7688 268 : tree _q22 = TREE_OPERAND (_p0, 2);
7689 268 : switch (TREE_CODE (_p1))
7690 : {
7691 8 : case VEC_COND_EXPR:
7692 8 : {
7693 8 : tree _q60 = TREE_OPERAND (_p1, 0);
7694 8 : tree _q61 = TREE_OPERAND (_p1, 1);
7695 8 : tree _q62 = TREE_OPERAND (_p1, 2);
7696 8 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7697 : {
7698 0 : {
7699 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
7700 0 : if (VECTOR_TYPE_P (type)
7701 0 : && (TREE_CODE_CLASS (NE_EXPR) != tcc_comparison
7702 0 : || types_match (type, TREE_TYPE (captures[2]))
7703 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
7704 : || (optimize_vectors_before_lowering_p ()
7705 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
7706 : )
7707 : {
7708 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1555;
7709 0 : {
7710 0 : tree res_op0;
7711 0 : res_op0 = captures[1];
7712 0 : tree res_op1;
7713 0 : {
7714 0 : tree _o1[2], _r1;
7715 0 : _o1[0] = captures[2];
7716 0 : _o1[1] = captures[5];
7717 0 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7718 0 : if (EXPR_P (_r1))
7719 0 : goto next_after_fail1555;
7720 0 : res_op1 = _r1;
7721 : }
7722 0 : tree res_op2;
7723 0 : {
7724 0 : tree _o1[2], _r1;
7725 0 : _o1[0] = captures[3];
7726 0 : _o1[1] = captures[6];
7727 0 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7728 0 : if (EXPR_P (_r1))
7729 0 : goto next_after_fail1555;
7730 0 : res_op2 = _r1;
7731 : }
7732 0 : tree _r;
7733 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7734 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
7735 0 : return _r;
7736 : }
7737 0 : next_after_fail1555:;
7738 : }
7739 : }
7740 : }
7741 : break;
7742 : }
7743 268 : default:;
7744 : }
7745 268 : {
7746 268 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
7747 268 : if (VECTOR_TYPE_P (type)
7748 268 : && (TREE_CODE_CLASS (NE_EXPR) != tcc_comparison
7749 266 : || types_match (type, TREE_TYPE (captures[2]))
7750 266 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
7751 : || (optimize_vectors_before_lowering_p ()
7752 27 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
7753 : )
7754 : {
7755 266 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1556;
7756 266 : {
7757 266 : if (! tree_invariant_p (captures[4])) goto next_after_fail1556;
7758 80 : tree res_op0;
7759 80 : res_op0 = captures[1];
7760 80 : tree res_op1;
7761 80 : {
7762 80 : tree _o1[2], _r1;
7763 80 : _o1[0] = captures[2];
7764 80 : _o1[1] = unshare_expr (captures[4]);
7765 80 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7766 80 : if (EXPR_P (_r1))
7767 8 : goto next_after_fail1556;
7768 72 : res_op1 = _r1;
7769 : }
7770 72 : tree res_op2;
7771 72 : {
7772 72 : tree _o1[2], _r1;
7773 72 : _o1[0] = captures[3];
7774 72 : _o1[1] = captures[4];
7775 72 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
7776 72 : if (EXPR_P (_r1))
7777 0 : goto next_after_fail1556;
7778 72 : res_op2 = _r1;
7779 : }
7780 72 : tree _r;
7781 72 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7782 72 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 895, __FILE__, __LINE__, true);
7783 72 : return _r;
7784 : }
7785 196 : next_after_fail1556:;
7786 : }
7787 : }
7788 196 : break;
7789 : }
7790 2317413 : case CALL_EXPR:
7791 2317413 : switch (get_call_combined_fn (_p0))
7792 : {
7793 0 : case CFN_BUILT_IN_BITREVERSE128:
7794 0 : if (call_expr_nargs (_p0) == 1)
7795 : {
7796 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7797 0 : switch (TREE_CODE (_p1))
7798 : {
7799 0 : case INTEGER_CST:
7800 0 : {
7801 0 : {
7802 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7803 0 : tree res = generic_simplify_244 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE128);
7804 0 : if (res) return res;
7805 : }
7806 0 : break;
7807 : }
7808 0 : case CALL_EXPR:
7809 0 : switch (get_call_combined_fn (_p1))
7810 : {
7811 0 : case CFN_BUILT_IN_BITREVERSE128:
7812 0 : if (call_expr_nargs (_p1) == 1)
7813 : {
7814 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7815 0 : {
7816 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7817 0 : tree res = generic_simplify_243 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE128);
7818 0 : if (res) return res;
7819 : }
7820 : }
7821 : break;
7822 : default:;
7823 : }
7824 : break;
7825 : default:;
7826 : }
7827 : }
7828 : break;
7829 0 : case CFN_BUILT_IN_BITREVERSE16:
7830 0 : if (call_expr_nargs (_p0) == 1)
7831 : {
7832 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7833 0 : switch (TREE_CODE (_p1))
7834 : {
7835 0 : case INTEGER_CST:
7836 0 : {
7837 0 : {
7838 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7839 0 : tree res = generic_simplify_244 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE16);
7840 0 : if (res) return res;
7841 : }
7842 0 : break;
7843 : }
7844 0 : case CALL_EXPR:
7845 0 : switch (get_call_combined_fn (_p1))
7846 : {
7847 0 : case CFN_BUILT_IN_BITREVERSE16:
7848 0 : if (call_expr_nargs (_p1) == 1)
7849 : {
7850 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7851 0 : {
7852 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7853 0 : tree res = generic_simplify_243 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE16);
7854 0 : if (res) return res;
7855 : }
7856 : }
7857 : break;
7858 : default:;
7859 : }
7860 : break;
7861 : default:;
7862 : }
7863 : }
7864 : break;
7865 0 : case CFN_BUILT_IN_BITREVERSE32:
7866 0 : if (call_expr_nargs (_p0) == 1)
7867 : {
7868 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7869 0 : switch (TREE_CODE (_p1))
7870 : {
7871 0 : case INTEGER_CST:
7872 0 : {
7873 0 : {
7874 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7875 0 : tree res = generic_simplify_244 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE32);
7876 0 : if (res) return res;
7877 : }
7878 0 : break;
7879 : }
7880 0 : case CALL_EXPR:
7881 0 : switch (get_call_combined_fn (_p1))
7882 : {
7883 0 : case CFN_BUILT_IN_BITREVERSE32:
7884 0 : if (call_expr_nargs (_p1) == 1)
7885 : {
7886 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7887 0 : {
7888 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7889 0 : tree res = generic_simplify_243 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE32);
7890 0 : if (res) return res;
7891 : }
7892 : }
7893 : break;
7894 : default:;
7895 : }
7896 : break;
7897 : default:;
7898 : }
7899 : }
7900 : break;
7901 0 : case CFN_BUILT_IN_BITREVERSE64:
7902 0 : if (call_expr_nargs (_p0) == 1)
7903 : {
7904 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7905 0 : switch (TREE_CODE (_p1))
7906 : {
7907 0 : case INTEGER_CST:
7908 0 : {
7909 0 : {
7910 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7911 0 : tree res = generic_simplify_244 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE64);
7912 0 : if (res) return res;
7913 : }
7914 0 : break;
7915 : }
7916 0 : case CALL_EXPR:
7917 0 : switch (get_call_combined_fn (_p1))
7918 : {
7919 0 : case CFN_BUILT_IN_BITREVERSE64:
7920 0 : if (call_expr_nargs (_p1) == 1)
7921 : {
7922 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7923 0 : {
7924 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7925 0 : tree res = generic_simplify_243 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE64);
7926 0 : if (res) return res;
7927 : }
7928 : }
7929 : break;
7930 : default:;
7931 : }
7932 : break;
7933 : default:;
7934 : }
7935 : }
7936 : break;
7937 2 : case CFN_BUILT_IN_BSWAP128:
7938 2 : if (call_expr_nargs (_p0) == 1)
7939 : {
7940 2 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7941 2 : switch (TREE_CODE (_p1))
7942 : {
7943 0 : case INTEGER_CST:
7944 0 : {
7945 0 : {
7946 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7947 0 : tree res = generic_simplify_244 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP128);
7948 0 : if (res) return res;
7949 : }
7950 0 : break;
7951 : }
7952 1 : case CALL_EXPR:
7953 1 : switch (get_call_combined_fn (_p1))
7954 : {
7955 0 : case CFN_BUILT_IN_BSWAP128:
7956 0 : if (call_expr_nargs (_p1) == 1)
7957 : {
7958 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7959 0 : {
7960 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7961 0 : tree res = generic_simplify_243 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP128);
7962 0 : if (res) return res;
7963 : }
7964 : }
7965 : break;
7966 : default:;
7967 : }
7968 : break;
7969 : default:;
7970 : }
7971 : }
7972 : break;
7973 0 : case CFN_BUILT_IN_BITREVERSE8:
7974 0 : if (call_expr_nargs (_p0) == 1)
7975 : {
7976 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
7977 0 : switch (TREE_CODE (_p1))
7978 : {
7979 0 : case INTEGER_CST:
7980 0 : {
7981 0 : {
7982 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
7983 0 : tree res = generic_simplify_244 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE8);
7984 0 : if (res) return res;
7985 : }
7986 0 : break;
7987 : }
7988 0 : case CALL_EXPR:
7989 0 : switch (get_call_combined_fn (_p1))
7990 : {
7991 0 : case CFN_BUILT_IN_BITREVERSE8:
7992 0 : if (call_expr_nargs (_p1) == 1)
7993 : {
7994 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
7995 0 : {
7996 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
7997 0 : tree res = generic_simplify_243 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BITREVERSE8);
7998 0 : if (res) return res;
7999 : }
8000 : }
8001 : break;
8002 : default:;
8003 : }
8004 : break;
8005 : default:;
8006 : }
8007 : }
8008 : break;
8009 11 : case CFN_BUILT_IN_BSWAP16:
8010 11 : if (call_expr_nargs (_p0) == 1)
8011 : {
8012 11 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8013 11 : switch (TREE_CODE (_p1))
8014 : {
8015 9 : case INTEGER_CST:
8016 9 : {
8017 9 : {
8018 9 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
8019 9 : tree res = generic_simplify_244 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP16);
8020 9 : if (res) return res;
8021 : }
8022 9 : break;
8023 : }
8024 1 : case CALL_EXPR:
8025 1 : switch (get_call_combined_fn (_p1))
8026 : {
8027 1 : case CFN_BUILT_IN_BSWAP16:
8028 1 : if (call_expr_nargs (_p1) == 1)
8029 : {
8030 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8031 1 : {
8032 1 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
8033 1 : tree res = generic_simplify_243 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP16);
8034 1 : if (res) return res;
8035 : }
8036 : }
8037 : break;
8038 : default:;
8039 : }
8040 : break;
8041 : default:;
8042 : }
8043 : }
8044 : break;
8045 7 : case CFN_BUILT_IN_BSWAP32:
8046 7 : if (call_expr_nargs (_p0) == 1)
8047 : {
8048 7 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8049 7 : switch (TREE_CODE (_p1))
8050 : {
8051 3 : case INTEGER_CST:
8052 3 : {
8053 3 : {
8054 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
8055 3 : tree res = generic_simplify_244 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP32);
8056 3 : if (res) return res;
8057 : }
8058 3 : break;
8059 : }
8060 3 : case CALL_EXPR:
8061 3 : switch (get_call_combined_fn (_p1))
8062 : {
8063 3 : case CFN_BUILT_IN_BSWAP32:
8064 3 : if (call_expr_nargs (_p1) == 1)
8065 : {
8066 3 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8067 3 : {
8068 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
8069 3 : tree res = generic_simplify_243 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP32);
8070 3 : if (res) return res;
8071 : }
8072 : }
8073 : break;
8074 : default:;
8075 : }
8076 : break;
8077 : default:;
8078 : }
8079 : }
8080 : break;
8081 7 : case CFN_BUILT_IN_BSWAP64:
8082 7 : if (call_expr_nargs (_p0) == 1)
8083 : {
8084 7 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8085 7 : switch (TREE_CODE (_p1))
8086 : {
8087 3 : case INTEGER_CST:
8088 3 : {
8089 3 : {
8090 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
8091 3 : tree res = generic_simplify_244 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP64);
8092 3 : if (res) return res;
8093 : }
8094 3 : break;
8095 : }
8096 3 : case CALL_EXPR:
8097 3 : switch (get_call_combined_fn (_p1))
8098 : {
8099 3 : case CFN_BUILT_IN_BSWAP64:
8100 3 : if (call_expr_nargs (_p1) == 1)
8101 : {
8102 3 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8103 3 : {
8104 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
8105 3 : tree res = generic_simplify_243 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_BSWAP64);
8106 3 : if (res) return res;
8107 : }
8108 : }
8109 : break;
8110 : default:;
8111 : }
8112 : break;
8113 : default:;
8114 : }
8115 : }
8116 : break;
8117 : default:;
8118 : }
8119 : break;
8120 35824181 : default:;
8121 : }
8122 35824181 : switch (TREE_CODE (_p1))
8123 : {
8124 24 : case VEC_COND_EXPR:
8125 24 : {
8126 24 : tree _q30 = TREE_OPERAND (_p1, 0);
8127 24 : tree _q31 = TREE_OPERAND (_p1, 1);
8128 24 : tree _q32 = TREE_OPERAND (_p1, 2);
8129 24 : {
8130 24 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
8131 24 : if (VECTOR_TYPE_P (type)
8132 24 : && (TREE_CODE_CLASS (NE_EXPR) != tcc_comparison
8133 24 : || types_match (type, TREE_TYPE (captures[3]))
8134 24 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
8135 : || (optimize_vectors_before_lowering_p ()
8136 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
8137 : )
8138 : {
8139 24 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1557;
8140 24 : {
8141 24 : if (! tree_invariant_p (captures[0])) goto next_after_fail1557;
8142 0 : tree res_op0;
8143 0 : res_op0 = captures[2];
8144 0 : tree res_op1;
8145 0 : {
8146 0 : tree _o1[2], _r1;
8147 0 : _o1[0] = unshare_expr (captures[0]);
8148 0 : _o1[1] = captures[3];
8149 0 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
8150 0 : if (EXPR_P (_r1))
8151 0 : goto next_after_fail1557;
8152 0 : res_op1 = _r1;
8153 : }
8154 0 : tree res_op2;
8155 0 : {
8156 0 : tree _o1[2], _r1;
8157 0 : _o1[0] = captures[0];
8158 0 : _o1[1] = captures[4];
8159 0 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
8160 0 : if (EXPR_P (_r1))
8161 0 : goto next_after_fail1557;
8162 0 : res_op2 = _r1;
8163 : }
8164 0 : tree _r;
8165 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8166 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
8167 0 : return _r;
8168 : }
8169 24 : next_after_fail1557:;
8170 : }
8171 : }
8172 24 : break;
8173 : }
8174 35824181 : default:;
8175 : }
8176 35824181 : switch (TREE_CODE (_p0))
8177 : {
8178 97012 : case COND_EXPR:
8179 97012 : {
8180 97012 : tree _q20 = TREE_OPERAND (_p0, 0);
8181 97012 : tree _q21 = TREE_OPERAND (_p0, 1);
8182 97012 : tree _q22 = TREE_OPERAND (_p0, 2);
8183 97012 : switch (TREE_CODE (_p1))
8184 : {
8185 276 : case COND_EXPR:
8186 276 : {
8187 276 : tree _q60 = TREE_OPERAND (_p1, 0);
8188 276 : tree _q61 = TREE_OPERAND (_p1, 1);
8189 276 : tree _q62 = TREE_OPERAND (_p1, 2);
8190 276 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
8191 : {
8192 72 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
8193 : {
8194 72 : {
8195 72 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
8196 72 : const enum tree_code eqne = NE_EXPR;
8197 72 : if (!HONOR_NANS (captures[1])
8198 56 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
8199 49 : && types_match (type, TREE_TYPE (captures[0]))
8200 49 : && expr_no_side_effects_p (captures[1])
8201 114 : && expr_no_side_effects_p (captures[2])
8202 : )
8203 : {
8204 42 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1558;
8205 42 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1558;
8206 42 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1558;
8207 42 : {
8208 42 : tree res_op0;
8209 42 : {
8210 42 : tree _o1[2], _r1;
8211 42 : {
8212 42 : tree _o2[2], _r2;
8213 42 : _o2[0] = captures[0];
8214 42 : _o2[1] = captures[3];
8215 42 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8216 42 : _o1[0] = _r2;
8217 : }
8218 42 : {
8219 42 : tree _o2[2], _r2;
8220 42 : _o2[0] = captures[1];
8221 42 : _o2[1] = captures[2];
8222 42 : _r2 = fold_build2_loc (loc, NE_EXPR, type, _o2[0], _o2[1]);
8223 42 : _o1[1] = _r2;
8224 : }
8225 42 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8226 42 : res_op0 = _r1;
8227 : }
8228 42 : tree res_op1;
8229 42 : res_op1 = constant_boolean_node (eqne == NE_EXPR, type);
8230 42 : tree res_op2;
8231 42 : res_op2 = constant_boolean_node (eqne != NE_EXPR, type);
8232 42 : tree _r;
8233 42 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
8234 42 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 981, __FILE__, __LINE__, true);
8235 42 : return _r;
8236 : }
8237 30 : next_after_fail1558:;
8238 : }
8239 : }
8240 : }
8241 : }
8242 234 : if ((_q61 == _q22 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q22, 0) && types_match (_q61, _q22)))
8243 : {
8244 0 : if ((_q62 == _q21 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q21, 0) && types_match (_q62, _q21)))
8245 : {
8246 0 : {
8247 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
8248 0 : const enum tree_code eqne = NE_EXPR;
8249 0 : if (!HONOR_NANS (captures[1])
8250 0 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
8251 0 : && types_match (type, TREE_TYPE (captures[0]))
8252 0 : && expr_no_side_effects_p (captures[1])
8253 0 : && expr_no_side_effects_p (captures[2])
8254 : )
8255 : {
8256 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1559;
8257 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1559;
8258 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1559;
8259 0 : {
8260 0 : tree res_op0;
8261 0 : {
8262 0 : tree _o1[2], _r1;
8263 0 : {
8264 0 : tree _o2[2], _r2;
8265 0 : _o2[0] = captures[0];
8266 0 : _o2[1] = captures[3];
8267 0 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8268 0 : _o1[0] = _r2;
8269 : }
8270 0 : {
8271 0 : tree _o2[2], _r2;
8272 0 : _o2[0] = captures[1];
8273 0 : _o2[1] = captures[2];
8274 0 : _r2 = fold_build2_loc (loc, EQ_EXPR, type, _o2[0], _o2[1]);
8275 0 : _o1[1] = _r2;
8276 : }
8277 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8278 0 : res_op0 = _r1;
8279 : }
8280 0 : tree res_op1;
8281 0 : res_op1 = constant_boolean_node (eqne != NE_EXPR, type);
8282 0 : tree res_op2;
8283 0 : res_op2 = constant_boolean_node (eqne == NE_EXPR, type);
8284 0 : tree _r;
8285 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
8286 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 982, __FILE__, __LINE__, true);
8287 0 : return _r;
8288 : }
8289 0 : next_after_fail1559:;
8290 : }
8291 : }
8292 : }
8293 : }
8294 : break;
8295 : }
8296 : default:;
8297 : }
8298 : break;
8299 : }
8300 196 : case VEC_COND_EXPR:
8301 196 : {
8302 196 : tree _q20 = TREE_OPERAND (_p0, 0);
8303 196 : tree _q21 = TREE_OPERAND (_p0, 1);
8304 196 : tree _q22 = TREE_OPERAND (_p0, 2);
8305 196 : switch (TREE_CODE (_p1))
8306 : {
8307 8 : case VEC_COND_EXPR:
8308 8 : {
8309 8 : tree _q60 = TREE_OPERAND (_p1, 0);
8310 8 : tree _q61 = TREE_OPERAND (_p1, 1);
8311 8 : tree _q62 = TREE_OPERAND (_p1, 2);
8312 8 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
8313 : {
8314 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
8315 : {
8316 0 : {
8317 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
8318 0 : const enum tree_code eqne = NE_EXPR;
8319 0 : if (!HONOR_NANS (captures[1])
8320 0 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
8321 0 : && types_match (type, TREE_TYPE (captures[0]))
8322 0 : && expr_no_side_effects_p (captures[1])
8323 0 : && expr_no_side_effects_p (captures[2])
8324 : )
8325 : {
8326 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1560;
8327 0 : {
8328 0 : tree res_op0;
8329 0 : {
8330 0 : tree _o1[2], _r1;
8331 0 : {
8332 0 : tree _o2[2], _r2;
8333 0 : _o2[0] = captures[0];
8334 0 : _o2[1] = captures[3];
8335 0 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8336 0 : _o1[0] = _r2;
8337 : }
8338 0 : {
8339 0 : tree _o2[2], _r2;
8340 0 : _o2[0] = captures[1];
8341 0 : _o2[1] = captures[2];
8342 0 : _r2 = fold_build2_loc (loc, NE_EXPR, type, _o2[0], _o2[1]);
8343 0 : _o1[1] = _r2;
8344 : }
8345 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8346 0 : res_op0 = _r1;
8347 : }
8348 0 : tree res_op1;
8349 0 : res_op1 = constant_boolean_node (eqne == NE_EXPR, type);
8350 0 : tree res_op2;
8351 0 : res_op2 = constant_boolean_node (eqne != NE_EXPR, type);
8352 0 : tree _r;
8353 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8354 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 981, __FILE__, __LINE__, true);
8355 0 : return _r;
8356 : }
8357 0 : next_after_fail1560:;
8358 : }
8359 : }
8360 : }
8361 : }
8362 8 : if ((_q61 == _q22 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q22, 0) && types_match (_q61, _q22)))
8363 : {
8364 8 : if ((_q62 == _q21 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q21, 0) && types_match (_q62, _q21)))
8365 : {
8366 8 : {
8367 8 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
8368 8 : const enum tree_code eqne = NE_EXPR;
8369 8 : if (!HONOR_NANS (captures[1])
8370 0 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
8371 0 : && types_match (type, TREE_TYPE (captures[0]))
8372 0 : && expr_no_side_effects_p (captures[1])
8373 8 : && expr_no_side_effects_p (captures[2])
8374 : )
8375 : {
8376 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1561;
8377 0 : {
8378 0 : tree res_op0;
8379 0 : {
8380 0 : tree _o1[2], _r1;
8381 0 : {
8382 0 : tree _o2[2], _r2;
8383 0 : _o2[0] = captures[0];
8384 0 : _o2[1] = captures[3];
8385 0 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8386 0 : _o1[0] = _r2;
8387 : }
8388 0 : {
8389 0 : tree _o2[2], _r2;
8390 0 : _o2[0] = captures[1];
8391 0 : _o2[1] = captures[2];
8392 0 : _r2 = fold_build2_loc (loc, EQ_EXPR, type, _o2[0], _o2[1]);
8393 0 : _o1[1] = _r2;
8394 : }
8395 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8396 0 : res_op0 = _r1;
8397 : }
8398 0 : tree res_op1;
8399 0 : res_op1 = constant_boolean_node (eqne != NE_EXPR, type);
8400 0 : tree res_op2;
8401 0 : res_op2 = constant_boolean_node (eqne == NE_EXPR, type);
8402 0 : tree _r;
8403 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
8404 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 982, __FILE__, __LINE__, true);
8405 0 : return _r;
8406 : }
8407 0 : next_after_fail1561:;
8408 : }
8409 : }
8410 : }
8411 : }
8412 : break;
8413 : }
8414 : default:;
8415 : }
8416 : break;
8417 : }
8418 18225 : case LT_EXPR:
8419 18225 : {
8420 18225 : tree _q20 = TREE_OPERAND (_p0, 0);
8421 18225 : tree _q21 = TREE_OPERAND (_p0, 1);
8422 18225 : if (integer_zerop (_p1))
8423 : {
8424 16717 : {
8425 16717 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8426 16717 : tree res = generic_simplify_300 (loc, type, _p0, _p1, captures, LT_EXPR, GE_EXPR, UNGE_EXPR);
8427 16717 : if (res) return res;
8428 : }
8429 : }
8430 15291 : if (integer_truep (_p1))
8431 : {
8432 559 : {
8433 559 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8434 559 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, LT_EXPR, GE_EXPR, UNGE_EXPR);
8435 559 : if (res) return res;
8436 : }
8437 : }
8438 : break;
8439 : }
8440 11965 : case LE_EXPR:
8441 11965 : {
8442 11965 : tree _q20 = TREE_OPERAND (_p0, 0);
8443 11965 : tree _q21 = TREE_OPERAND (_p0, 1);
8444 11965 : if (integer_zerop (_p1))
8445 : {
8446 9405 : {
8447 9405 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8448 9405 : tree res = generic_simplify_300 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR, UNGT_EXPR);
8449 9405 : if (res) return res;
8450 : }
8451 : }
8452 11173 : if (integer_truep (_p1))
8453 : {
8454 461 : {
8455 461 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8456 461 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR, UNGT_EXPR);
8457 461 : if (res) return res;
8458 : }
8459 : }
8460 : break;
8461 : }
8462 63639 : case EQ_EXPR:
8463 63639 : {
8464 63639 : tree _q20 = TREE_OPERAND (_p0, 0);
8465 63639 : tree _q21 = TREE_OPERAND (_p0, 1);
8466 63639 : if (integer_zerop (_p1))
8467 : {
8468 36008 : {
8469 36008 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8470 36008 : tree res = generic_simplify_300 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR, NE_EXPR);
8471 36008 : if (res) return res;
8472 : }
8473 : }
8474 62518 : if (integer_truep (_p1))
8475 : {
8476 21941 : {
8477 21941 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8478 21941 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR, NE_EXPR);
8479 21941 : if (res) return res;
8480 : }
8481 : }
8482 : break;
8483 : }
8484 69135 : case NE_EXPR:
8485 69135 : {
8486 69135 : tree _q20 = TREE_OPERAND (_p0, 0);
8487 69135 : tree _q21 = TREE_OPERAND (_p0, 1);
8488 69135 : if (integer_zerop (_p1))
8489 : {
8490 57297 : {
8491 57297 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8492 57297 : tree res = generic_simplify_300 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR, EQ_EXPR);
8493 57297 : if (res) return res;
8494 : }
8495 : }
8496 34589 : if (integer_truep (_p1))
8497 : {
8498 141 : {
8499 141 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8500 141 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR, EQ_EXPR);
8501 141 : if (res) return res;
8502 : }
8503 : }
8504 : break;
8505 : }
8506 6117 : case GE_EXPR:
8507 6117 : {
8508 6117 : tree _q20 = TREE_OPERAND (_p0, 0);
8509 6117 : tree _q21 = TREE_OPERAND (_p0, 1);
8510 6117 : if (integer_zerop (_p1))
8511 : {
8512 4176 : {
8513 4176 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8514 4176 : tree res = generic_simplify_300 (loc, type, _p0, _p1, captures, GE_EXPR, LT_EXPR, UNLT_EXPR);
8515 4176 : if (res) return res;
8516 : }
8517 : }
8518 5459 : if (integer_truep (_p1))
8519 : {
8520 477 : {
8521 477 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8522 477 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, GE_EXPR, LT_EXPR, UNLT_EXPR);
8523 477 : if (res) return res;
8524 : }
8525 : }
8526 : break;
8527 : }
8528 35577 : case GT_EXPR:
8529 35577 : {
8530 35577 : tree _q20 = TREE_OPERAND (_p0, 0);
8531 35577 : tree _q21 = TREE_OPERAND (_p0, 1);
8532 35577 : if (integer_zerop (_p1))
8533 : {
8534 33518 : {
8535 33518 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8536 33518 : tree res = generic_simplify_300 (loc, type, _p0, _p1, captures, GT_EXPR, LE_EXPR, UNLE_EXPR);
8537 33518 : if (res) return res;
8538 : }
8539 : }
8540 29567 : if (integer_truep (_p1))
8541 : {
8542 320 : {
8543 320 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8544 320 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, GT_EXPR, LE_EXPR, UNLE_EXPR);
8545 320 : if (res) return res;
8546 : }
8547 : }
8548 : break;
8549 : }
8550 129789 : case UNORDERED_EXPR:
8551 129789 : {
8552 129789 : tree _q20 = TREE_OPERAND (_p0, 0);
8553 129789 : tree _q21 = TREE_OPERAND (_p0, 1);
8554 129789 : if (integer_zerop (_p1))
8555 : {
8556 127641 : {
8557 127641 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8558 127641 : tree res = generic_simplify_300 (loc, type, _p0, _p1, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR);
8559 127641 : if (res) return res;
8560 : }
8561 : }
8562 129399 : if (integer_truep (_p1))
8563 : {
8564 42 : {
8565 42 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8566 42 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR);
8567 42 : if (res) return res;
8568 : }
8569 : }
8570 : break;
8571 : }
8572 113 : case ORDERED_EXPR:
8573 113 : {
8574 113 : tree _q20 = TREE_OPERAND (_p0, 0);
8575 113 : tree _q21 = TREE_OPERAND (_p0, 1);
8576 113 : if (integer_zerop (_p1))
8577 : {
8578 42 : {
8579 42 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8580 42 : tree res = generic_simplify_300 (loc, type, _p0, _p1, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR);
8581 42 : if (res) return res;
8582 : }
8583 : }
8584 71 : if (integer_truep (_p1))
8585 : {
8586 0 : {
8587 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8588 0 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR);
8589 0 : if (res) return res;
8590 : }
8591 : }
8592 : break;
8593 : }
8594 213 : case UNLT_EXPR:
8595 213 : {
8596 213 : tree _q20 = TREE_OPERAND (_p0, 0);
8597 213 : tree _q21 = TREE_OPERAND (_p0, 1);
8598 213 : if (integer_zerop (_p1))
8599 : {
8600 28 : {
8601 28 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8602 28 : tree res = generic_simplify_300 (loc, type, _p0, _p1, captures, UNLT_EXPR, GE_EXPR, GE_EXPR);
8603 28 : if (res) return res;
8604 : }
8605 : }
8606 185 : if (integer_truep (_p1))
8607 : {
8608 161 : {
8609 161 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8610 161 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, UNLT_EXPR, GE_EXPR, GE_EXPR);
8611 161 : if (res) return res;
8612 : }
8613 : }
8614 : break;
8615 : }
8616 1442 : case UNLE_EXPR:
8617 1442 : {
8618 1442 : tree _q20 = TREE_OPERAND (_p0, 0);
8619 1442 : tree _q21 = TREE_OPERAND (_p0, 1);
8620 1442 : if (integer_zerop (_p1))
8621 : {
8622 104 : {
8623 104 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8624 104 : tree res = generic_simplify_300 (loc, type, _p0, _p1, captures, UNLE_EXPR, GT_EXPR, GT_EXPR);
8625 104 : if (res) return res;
8626 : }
8627 : }
8628 1338 : if (integer_truep (_p1))
8629 : {
8630 1314 : {
8631 1314 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8632 1314 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, UNLE_EXPR, GT_EXPR, GT_EXPR);
8633 1314 : if (res) return res;
8634 : }
8635 : }
8636 : break;
8637 : }
8638 2009 : case UNGT_EXPR:
8639 2009 : {
8640 2009 : tree _q20 = TREE_OPERAND (_p0, 0);
8641 2009 : tree _q21 = TREE_OPERAND (_p0, 1);
8642 2009 : if (integer_zerop (_p1))
8643 : {
8644 96 : {
8645 96 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8646 96 : tree res = generic_simplify_300 (loc, type, _p0, _p1, captures, UNGT_EXPR, LE_EXPR, LE_EXPR);
8647 96 : if (res) return res;
8648 : }
8649 : }
8650 1913 : if (integer_truep (_p1))
8651 : {
8652 1778 : {
8653 1778 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8654 1778 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, UNGT_EXPR, LE_EXPR, LE_EXPR);
8655 1778 : if (res) return res;
8656 : }
8657 : }
8658 : break;
8659 : }
8660 391 : case UNGE_EXPR:
8661 391 : {
8662 391 : tree _q20 = TREE_OPERAND (_p0, 0);
8663 391 : tree _q21 = TREE_OPERAND (_p0, 1);
8664 391 : if (integer_zerop (_p1))
8665 : {
8666 16 : {
8667 16 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8668 16 : tree res = generic_simplify_300 (loc, type, _p0, _p1, captures, UNGE_EXPR, LT_EXPR, LT_EXPR);
8669 16 : if (res) return res;
8670 : }
8671 : }
8672 375 : if (integer_truep (_p1))
8673 : {
8674 211 : {
8675 211 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8676 211 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, UNGE_EXPR, LT_EXPR, LT_EXPR);
8677 211 : if (res) return res;
8678 : }
8679 : }
8680 : break;
8681 : }
8682 161 : case UNEQ_EXPR:
8683 161 : {
8684 161 : tree _q20 = TREE_OPERAND (_p0, 0);
8685 161 : tree _q21 = TREE_OPERAND (_p0, 1);
8686 161 : if (integer_zerop (_p1))
8687 : {
8688 0 : {
8689 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8690 0 : tree res = generic_simplify_300 (loc, type, _p0, _p1, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR);
8691 0 : if (res) return res;
8692 : }
8693 : }
8694 161 : if (integer_truep (_p1))
8695 : {
8696 124 : {
8697 124 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8698 124 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR);
8699 124 : if (res) return res;
8700 : }
8701 : }
8702 : break;
8703 : }
8704 24 : case LTGT_EXPR:
8705 24 : {
8706 24 : tree _q20 = TREE_OPERAND (_p0, 0);
8707 24 : tree _q21 = TREE_OPERAND (_p0, 1);
8708 24 : if (integer_zerop (_p1))
8709 : {
8710 6 : {
8711 6 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8712 6 : tree res = generic_simplify_300 (loc, type, _p0, _p1, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR);
8713 6 : if (res) return res;
8714 : }
8715 : }
8716 24 : if (integer_truep (_p1))
8717 : {
8718 0 : {
8719 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8720 0 : tree res = generic_simplify_301 (loc, type, _p0, _p1, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR);
8721 0 : if (res) return res;
8722 : }
8723 : }
8724 : break;
8725 : }
8726 104251 : case MINUS_EXPR:
8727 104251 : {
8728 104251 : tree _q20 = TREE_OPERAND (_p0, 0);
8729 104251 : tree _q21 = TREE_OPERAND (_p0, 1);
8730 104251 : if (integer_zerop (_p1))
8731 : {
8732 35741 : {
8733 35741 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8734 35741 : tree res = generic_simplify_247 (loc, type, _p0, _p1, captures, NE_EXPR);
8735 35741 : if (res) return res;
8736 : }
8737 : }
8738 : break;
8739 : }
8740 25233 : case POINTER_DIFF_EXPR:
8741 25233 : {
8742 25233 : tree _q20 = TREE_OPERAND (_p0, 0);
8743 25233 : tree _q21 = TREE_OPERAND (_p0, 1);
8744 25233 : if (integer_zerop (_p1))
8745 : {
8746 12788 : {
8747 12788 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8748 12788 : tree res = generic_simplify_248 (loc, type, _p0, _p1, captures, NE_EXPR);
8749 12788 : if (res) return res;
8750 : }
8751 : }
8752 : break;
8753 : }
8754 93739 : case MULT_EXPR:
8755 93739 : {
8756 93739 : tree _q20 = TREE_OPERAND (_p0, 0);
8757 93739 : tree _q21 = TREE_OPERAND (_p0, 1);
8758 93739 : switch (TREE_CODE (_q21))
8759 : {
8760 76270 : case INTEGER_CST:
8761 76270 : {
8762 76270 : switch (TREE_CODE (_p1))
8763 : {
8764 50267 : case INTEGER_CST:
8765 50267 : {
8766 50267 : {
8767 50267 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
8768 50267 : tree res = generic_simplify_250 (loc, type, _p0, _p1, captures, NE_EXPR);
8769 50267 : if (res) return res;
8770 : }
8771 33726 : break;
8772 : }
8773 59729 : default:;
8774 : }
8775 59729 : if (integer_zerop (_p1))
8776 : {
8777 10623 : {
8778 10623 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
8779 10623 : tree res = generic_simplify_249 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
8780 10623 : if (res) return res;
8781 : }
8782 : }
8783 : break;
8784 : }
8785 : default:;
8786 : }
8787 : break;
8788 : }
8789 35690296 : default:;
8790 : }
8791 35690296 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
8792 : {
8793 106675 : {
8794 106675 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8795 106675 : tree res = generic_simplify_302 (loc, type, _p0, _p1, captures, NE_EXPR);
8796 106675 : if (res) return res;
8797 : }
8798 : }
8799 35590334 : switch (TREE_CODE (_p0))
8800 : {
8801 6869847 : CASE_CONVERT:
8802 6869847 : {
8803 6869847 : tree _q20 = TREE_OPERAND (_p0, 0);
8804 6869847 : switch (TREE_CODE (_p1))
8805 : {
8806 3052743 : CASE_CONVERT:
8807 3052743 : {
8808 3052743 : tree _q40 = TREE_OPERAND (_p1, 0);
8809 3052743 : {
8810 3052743 : tree _q40_pops[1];
8811 3052743 : if (tree_maybe_bit_not (_q40, _q40_pops))
8812 : {
8813 0 : tree _q50 = _q40_pops[0];
8814 0 : {
8815 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
8816 0 : tree res = generic_simplify_252 (loc, type, _p0, _p1, captures, NE_EXPR);
8817 0 : if (res) return res;
8818 : }
8819 : }
8820 : }
8821 3052743 : break;
8822 : }
8823 6869847 : default:;
8824 : }
8825 6869847 : {
8826 6869847 : tree _q20_pops[1];
8827 6869847 : if (tree_maybe_bit_not (_q20, _q20_pops))
8828 : {
8829 12921 : tree _q30 = _q20_pops[0];
8830 12921 : switch (TREE_CODE (_p1))
8831 : {
8832 0 : CASE_CONVERT:
8833 0 : {
8834 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8835 0 : {
8836 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
8837 0 : tree res = generic_simplify_252 (loc, type, _p0, _p1, captures, NE_EXPR);
8838 0 : if (res) return res;
8839 : }
8840 0 : break;
8841 : }
8842 : default:;
8843 : }
8844 : }
8845 : }
8846 6869847 : break;
8847 : }
8848 35590334 : default:;
8849 : }
8850 35590334 : {
8851 35590334 : tree _p1_pops[1];
8852 35590334 : if (tree_maybe_bit_not (_p1, _p1_pops))
8853 : {
8854 25847306 : tree _q30 = _p1_pops[0];
8855 25847306 : {
8856 25847306 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
8857 25847306 : tree res = generic_simplify_252 (loc, type, _p0, _p1, captures, NE_EXPR);
8858 25847306 : if (res) return res;
8859 : }
8860 : }
8861 : }
8862 35590334 : switch (TREE_CODE (_p0))
8863 : {
8864 13398 : case BIT_NOT_EXPR:
8865 13398 : {
8866 13398 : tree _q20 = TREE_OPERAND (_p0, 0);
8867 13398 : switch (TREE_CODE (_p1))
8868 : {
8869 1 : case BIT_NOT_EXPR:
8870 1 : {
8871 1 : tree _q40 = TREE_OPERAND (_p1, 0);
8872 1 : {
8873 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _p1, _q40 };
8874 1 : tree res = generic_simplify_255 (loc, type, _p0, _p1, captures, NE_EXPR);
8875 1 : if (res) return res;
8876 : }
8877 0 : break;
8878 : }
8879 13397 : default:;
8880 : }
8881 13397 : {
8882 13397 : tree _p1_pops[1];
8883 13397 : if (tree_nop_convert (_p1, _p1_pops))
8884 : {
8885 80 : tree _q40 = _p1_pops[0];
8886 80 : switch (TREE_CODE (_q40))
8887 : {
8888 0 : case BIT_NOT_EXPR:
8889 0 : {
8890 0 : tree _q50 = TREE_OPERAND (_q40, 0);
8891 0 : {
8892 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40, _q50 };
8893 0 : tree res = generic_simplify_255 (loc, type, _p0, _p1, captures, NE_EXPR);
8894 0 : if (res) return res;
8895 : }
8896 0 : break;
8897 : }
8898 : default:;
8899 : }
8900 : }
8901 : }
8902 13397 : if (CONSTANT_CLASS_P (_p1))
8903 : {
8904 12231 : {
8905 12231 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
8906 12231 : tree res = generic_simplify_254 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
8907 12231 : if (res) return res;
8908 : }
8909 : }
8910 : break;
8911 : }
8912 35578102 : default:;
8913 : }
8914 35578102 : {
8915 35578102 : tree _p0_pops[1];
8916 35578102 : if (tree_maybe_bit_not (_p0, _p0_pops))
8917 : {
8918 285415 : tree _q20 = _p0_pops[0];
8919 285415 : {
8920 285415 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _q20 };
8921 285415 : tree res = generic_simplify_252 (loc, type, _p0, _p1, captures, NE_EXPR);
8922 285415 : if (res) return res;
8923 : }
8924 : }
8925 : }
8926 35578100 : {
8927 35578100 : tree _p0_pops[1];
8928 35578100 : if (tree_nop_convert (_p0, _p0_pops))
8929 : {
8930 4683494 : tree _q20 = _p0_pops[0];
8931 4683494 : switch (TREE_CODE (_q20))
8932 : {
8933 1 : case BIT_NOT_EXPR:
8934 1 : {
8935 1 : tree _q30 = TREE_OPERAND (_q20, 0);
8936 1 : switch (TREE_CODE (_p1))
8937 : {
8938 0 : case BIT_NOT_EXPR:
8939 0 : {
8940 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8941 0 : {
8942 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _p1, _q50 };
8943 0 : tree res = generic_simplify_253 (loc, type, _p0, _p1, captures, NE_EXPR);
8944 0 : if (res) return res;
8945 : }
8946 0 : break;
8947 : }
8948 1 : default:;
8949 : }
8950 1 : {
8951 1 : tree _p1_pops[1];
8952 1 : if (tree_nop_convert (_p1, _p1_pops))
8953 : {
8954 0 : tree _q50 = _p1_pops[0];
8955 0 : switch (TREE_CODE (_q50))
8956 : {
8957 0 : case BIT_NOT_EXPR:
8958 0 : {
8959 0 : tree _q60 = TREE_OPERAND (_q50, 0);
8960 0 : {
8961 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50, _q60 };
8962 0 : tree res = generic_simplify_253 (loc, type, _p0, _p1, captures, NE_EXPR);
8963 0 : if (res) return res;
8964 : }
8965 0 : break;
8966 : }
8967 : default:;
8968 : }
8969 : }
8970 : }
8971 1 : if (CONSTANT_CLASS_P (_p1))
8972 : {
8973 1 : {
8974 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
8975 1 : tree res = generic_simplify_254 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
8976 1 : if (res) return res;
8977 : }
8978 : }
8979 : break;
8980 : }
8981 : default:;
8982 : }
8983 : }
8984 : }
8985 35578099 : switch (TREE_CODE (_p1))
8986 : {
8987 698317 : case REAL_CST:
8988 698317 : {
8989 698317 : {
8990 698317 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8991 698317 : tree res = generic_simplify_256 (loc, type, _p0, _p1, captures, NE_EXPR);
8992 698317 : if (res) return res;
8993 : }
8994 630219 : break;
8995 : }
8996 35510001 : default:;
8997 : }
8998 35510001 : switch (TREE_CODE (_p0))
8999 : {
9000 1315195 : case PLUS_EXPR:
9001 1315195 : {
9002 1315195 : tree _q20 = TREE_OPERAND (_p0, 0);
9003 1315195 : tree _q21 = TREE_OPERAND (_p0, 1);
9004 1315195 : switch (TREE_CODE (_q21))
9005 : {
9006 3843 : case REAL_CST:
9007 3843 : {
9008 3843 : switch (TREE_CODE (_p1))
9009 : {
9010 3067 : case REAL_CST:
9011 3067 : {
9012 3067 : {
9013 3067 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
9014 3067 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, PLUS_EXPR, NE_EXPR);
9015 3067 : if (res) return res;
9016 : }
9017 3067 : break;
9018 : }
9019 : default:;
9020 : }
9021 : break;
9022 : }
9023 : default:;
9024 : }
9025 : break;
9026 : }
9027 68506 : case MINUS_EXPR:
9028 68506 : {
9029 68506 : tree _q20 = TREE_OPERAND (_p0, 0);
9030 68506 : tree _q21 = TREE_OPERAND (_p0, 1);
9031 68506 : switch (TREE_CODE (_q21))
9032 : {
9033 3215 : case REAL_CST:
9034 3215 : {
9035 3215 : switch (TREE_CODE (_p1))
9036 : {
9037 2849 : case REAL_CST:
9038 2849 : {
9039 2849 : {
9040 2849 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
9041 2849 : tree res = generic_simplify_257 (loc, type, _p0, _p1, captures, MINUS_EXPR, NE_EXPR);
9042 2849 : if (res) return res;
9043 : }
9044 2849 : break;
9045 : }
9046 : default:;
9047 : }
9048 : break;
9049 : }
9050 68506 : default:;
9051 : }
9052 68506 : switch (TREE_CODE (_q20))
9053 : {
9054 87 : case REAL_CST:
9055 87 : {
9056 87 : switch (TREE_CODE (_p1))
9057 : {
9058 44 : case REAL_CST:
9059 44 : {
9060 44 : {
9061 44 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
9062 44 : tree res = generic_simplify_258 (loc, type, _p0, _p1, captures, NE_EXPR);
9063 44 : if (res) return res;
9064 : }
9065 44 : break;
9066 : }
9067 : default:;
9068 : }
9069 : break;
9070 : }
9071 : default:;
9072 : }
9073 : break;
9074 : }
9075 9957 : case FLOAT_EXPR:
9076 9957 : {
9077 9957 : tree _q20 = TREE_OPERAND (_p0, 0);
9078 9957 : switch (TREE_CODE (_p1))
9079 : {
9080 1115 : case FLOAT_EXPR:
9081 1115 : {
9082 1115 : tree _q40 = TREE_OPERAND (_p1, 0);
9083 1115 : {
9084 1115 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
9085 1115 : tree res = generic_simplify_261 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
9086 1115 : if (res) return res;
9087 : }
9088 971 : break;
9089 : }
9090 1808 : case REAL_CST:
9091 1808 : {
9092 1808 : {
9093 1808 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9094 1808 : tree res = generic_simplify_262 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
9095 1808 : if (res) return res;
9096 : }
9097 1687 : break;
9098 : }
9099 : default:;
9100 : }
9101 : break;
9102 : }
9103 2045 : case EXACT_DIV_EXPR:
9104 2045 : {
9105 2045 : tree _q20 = TREE_OPERAND (_p0, 0);
9106 2045 : tree _q21 = TREE_OPERAND (_p0, 1);
9107 2045 : switch (TREE_CODE (_p1))
9108 : {
9109 36 : case INTEGER_CST:
9110 36 : {
9111 36 : {
9112 36 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
9113 36 : tree res = generic_simplify_263 (loc, type, _p0, _p1, captures, NE_EXPR);
9114 36 : if (res) return res;
9115 : }
9116 0 : break;
9117 : }
9118 : default:;
9119 : }
9120 : break;
9121 : }
9122 6102 : case NEGATE_EXPR:
9123 6102 : {
9124 6102 : tree _q20 = TREE_OPERAND (_p0, 0);
9125 6102 : switch (TREE_CODE (_p1))
9126 : {
9127 4 : case NEGATE_EXPR:
9128 4 : {
9129 4 : tree _q40 = TREE_OPERAND (_p1, 0);
9130 4 : {
9131 4 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9132 4 : tree res = generic_simplify_264 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
9133 4 : if (res) return res;
9134 : }
9135 0 : break;
9136 : }
9137 6098 : default:;
9138 : }
9139 6098 : if (CONSTANT_CLASS_P (_p1))
9140 : {
9141 577 : {
9142 577 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9143 577 : tree res = generic_simplify_265 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
9144 577 : if (res) return res;
9145 : }
9146 : }
9147 : break;
9148 : }
9149 1940 : case ABS_EXPR:
9150 1940 : {
9151 1940 : tree _q20 = TREE_OPERAND (_p0, 0);
9152 1940 : if (zerop (_p1))
9153 : {
9154 72 : {
9155 72 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9156 72 : const enum tree_code eqne = NE_EXPR;
9157 72 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1562;
9158 72 : {
9159 72 : tree res_op0;
9160 72 : res_op0 = captures[0];
9161 72 : tree res_op1;
9162 72 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
9163 72 : tree _r;
9164 72 : _r = fold_build2_loc (loc, eqne, type, res_op0, res_op1);
9165 72 : if (TREE_SIDE_EFFECTS (captures[1]))
9166 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
9167 72 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 983, __FILE__, __LINE__, true);
9168 72 : return _r;
9169 : }
9170 0 : next_after_fail1562:;
9171 : }
9172 : }
9173 : break;
9174 : }
9175 1698 : case ABSU_EXPR:
9176 1698 : {
9177 1698 : tree _q20 = TREE_OPERAND (_p0, 0);
9178 1698 : if (zerop (_p1))
9179 : {
9180 65 : {
9181 65 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9182 65 : const enum tree_code eqne = NE_EXPR;
9183 65 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1563;
9184 65 : {
9185 65 : tree res_op0;
9186 65 : res_op0 = captures[0];
9187 65 : tree res_op1;
9188 65 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
9189 65 : tree _r;
9190 65 : _r = fold_build2_loc (loc, eqne, type, res_op0, res_op1);
9191 65 : if (TREE_SIDE_EFFECTS (captures[1]))
9192 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
9193 65 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 983, __FILE__, __LINE__, true);
9194 65 : return _r;
9195 : }
9196 0 : next_after_fail1563:;
9197 : }
9198 : }
9199 : break;
9200 : }
9201 6869767 : CASE_CONVERT:
9202 6869767 : {
9203 6869767 : tree _q20 = TREE_OPERAND (_p0, 0);
9204 6869767 : switch (TREE_CODE (_p1))
9205 : {
9206 3052743 : CASE_CONVERT:
9207 3052743 : {
9208 3052743 : tree _q40 = TREE_OPERAND (_p1, 0);
9209 3052743 : {
9210 3052743 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
9211 3052743 : tree res = generic_simplify_266 (loc, type, _p0, _p1, captures, NE_EXPR);
9212 3052743 : if (res) return res;
9213 : }
9214 2850199 : break;
9215 : }
9216 6667223 : default:;
9217 : }
9218 6667223 : {
9219 6667223 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
9220 6667223 : tree res = generic_simplify_267 (loc, type, _p0, _p1, captures, NE_EXPR);
9221 6667223 : if (res) return res;
9222 : }
9223 4579918 : switch (TREE_CODE (_q20))
9224 : {
9225 12 : case BIT_IOR_EXPR:
9226 12 : {
9227 12 : tree _q30 = TREE_OPERAND (_q20, 0);
9228 12 : tree _q31 = TREE_OPERAND (_q20, 1);
9229 12 : switch (TREE_CODE (_q31))
9230 : {
9231 0 : case INTEGER_CST:
9232 0 : {
9233 0 : switch (TREE_CODE (_p1))
9234 : {
9235 0 : case INTEGER_CST:
9236 0 : {
9237 0 : {
9238 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _p1 };
9239 0 : tree res = generic_simplify_268 (loc, type, _p0, _p1, captures, NE_EXPR);
9240 0 : if (res) return res;
9241 : }
9242 0 : break;
9243 : }
9244 : default:;
9245 : }
9246 : break;
9247 : }
9248 : default:;
9249 : }
9250 : break;
9251 : }
9252 : default:;
9253 : }
9254 : break;
9255 : }
9256 14775940 : case SSA_NAME:
9257 14775940 : {
9258 14775940 : switch (TREE_CODE (_p1))
9259 : {
9260 301769 : case ADDR_EXPR:
9261 301769 : {
9262 301769 : {
9263 301769 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9264 301769 : tree res = generic_simplify_269 (loc, type, _p0, _p1, captures, NE_EXPR);
9265 301769 : if (res) return res;
9266 : }
9267 301767 : break;
9268 : }
9269 : default:;
9270 : }
9271 : break;
9272 : }
9273 239463 : case BIT_IOR_EXPR:
9274 239463 : {
9275 239463 : tree _q20 = TREE_OPERAND (_p0, 0);
9276 239463 : tree _q21 = TREE_OPERAND (_p0, 1);
9277 239463 : switch (TREE_CODE (_q21))
9278 : {
9279 970 : case INTEGER_CST:
9280 970 : {
9281 970 : switch (TREE_CODE (_p1))
9282 : {
9283 233 : case INTEGER_CST:
9284 233 : {
9285 233 : {
9286 233 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
9287 233 : tree res = generic_simplify_268 (loc, type, _p0, _p1, captures, NE_EXPR);
9288 233 : if (res) return res;
9289 : }
9290 233 : break;
9291 : }
9292 : default:;
9293 : }
9294 : break;
9295 : }
9296 : default:;
9297 : }
9298 : break;
9299 : }
9300 29776 : case BIT_XOR_EXPR:
9301 29776 : {
9302 29776 : tree _q20 = TREE_OPERAND (_p0, 0);
9303 29776 : tree _q21 = TREE_OPERAND (_p0, 1);
9304 29776 : if (integer_zerop (_p1))
9305 : {
9306 25444 : {
9307 25444 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9308 25444 : tree res = generic_simplify_270 (loc, type, _p0, _p1, captures, NE_EXPR);
9309 25444 : if (res) return res;
9310 : }
9311 : }
9312 4332 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9313 : {
9314 1 : {
9315 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9316 1 : tree res = generic_simplify_271 (loc, type, _p0, _p1, captures, NE_EXPR);
9317 1 : if (res) return res;
9318 : }
9319 : }
9320 4331 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
9321 : {
9322 2 : {
9323 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9324 2 : tree res = generic_simplify_271 (loc, type, _p0, _p1, captures, NE_EXPR);
9325 2 : if (res) return res;
9326 : }
9327 : }
9328 : break;
9329 : }
9330 2311321 : case CALL_EXPR:
9331 2311321 : switch (get_call_combined_fn (_p0))
9332 : {
9333 42 : case CFN_BUILT_IN_SQRTF:
9334 42 : if (call_expr_nargs (_p0) == 1)
9335 : {
9336 42 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9337 42 : switch (TREE_CODE (_p1))
9338 : {
9339 0 : case REAL_CST:
9340 0 : {
9341 0 : {
9342 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9343 0 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, NE_EXPR);
9344 0 : if (res) return res;
9345 : }
9346 0 : break;
9347 : }
9348 42 : case CALL_EXPR:
9349 42 : switch (get_call_combined_fn (_p1))
9350 : {
9351 0 : case CFN_BUILT_IN_SQRTF:
9352 0 : if (call_expr_nargs (_p1) == 1)
9353 : {
9354 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9355 0 : {
9356 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9357 0 : tree res = generic_simplify_260 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTF, NE_EXPR);
9358 0 : if (res) return res;
9359 : }
9360 : }
9361 : break;
9362 : default:;
9363 : }
9364 : break;
9365 : default:;
9366 : }
9367 : }
9368 : break;
9369 42 : case CFN_BUILT_IN_SQRTL:
9370 42 : if (call_expr_nargs (_p0) == 1)
9371 : {
9372 42 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9373 42 : switch (TREE_CODE (_p1))
9374 : {
9375 0 : case REAL_CST:
9376 0 : {
9377 0 : {
9378 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9379 0 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, NE_EXPR);
9380 0 : if (res) return res;
9381 : }
9382 0 : break;
9383 : }
9384 42 : case CALL_EXPR:
9385 42 : switch (get_call_combined_fn (_p1))
9386 : {
9387 0 : case CFN_BUILT_IN_SQRTL:
9388 0 : if (call_expr_nargs (_p1) == 1)
9389 : {
9390 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9391 0 : {
9392 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9393 0 : tree res = generic_simplify_260 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRTL, NE_EXPR);
9394 0 : if (res) return res;
9395 : }
9396 : }
9397 : break;
9398 : default:;
9399 : }
9400 : break;
9401 : default:;
9402 : }
9403 : }
9404 : break;
9405 46 : case CFN_BUILT_IN_SQRT:
9406 46 : if (call_expr_nargs (_p0) == 1)
9407 : {
9408 46 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9409 46 : switch (TREE_CODE (_p1))
9410 : {
9411 2 : case REAL_CST:
9412 2 : {
9413 2 : {
9414 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9415 2 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, NE_EXPR);
9416 2 : if (res) return res;
9417 : }
9418 2 : break;
9419 : }
9420 43 : case CALL_EXPR:
9421 43 : switch (get_call_combined_fn (_p1))
9422 : {
9423 0 : case CFN_BUILT_IN_SQRT:
9424 0 : if (call_expr_nargs (_p1) == 1)
9425 : {
9426 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9427 0 : {
9428 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9429 0 : tree res = generic_simplify_260 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_SQRT, NE_EXPR);
9430 0 : if (res) return res;
9431 : }
9432 : }
9433 : break;
9434 : default:;
9435 : }
9436 : break;
9437 : default:;
9438 : }
9439 : }
9440 : break;
9441 0 : case CFN_SQRT:
9442 0 : if (call_expr_nargs (_p0) == 1)
9443 : {
9444 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9445 0 : switch (TREE_CODE (_p1))
9446 : {
9447 0 : case REAL_CST:
9448 0 : {
9449 0 : {
9450 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
9451 0 : tree res = generic_simplify_259 (loc, type, _p0, _p1, captures, CFN_SQRT, NE_EXPR);
9452 0 : if (res) return res;
9453 : }
9454 0 : break;
9455 : }
9456 0 : case CALL_EXPR:
9457 0 : switch (get_call_combined_fn (_p1))
9458 : {
9459 0 : case CFN_SQRT:
9460 0 : if (call_expr_nargs (_p1) == 1)
9461 : {
9462 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9463 0 : {
9464 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
9465 0 : tree res = generic_simplify_260 (loc, type, _p0, _p1, captures, CFN_SQRT, NE_EXPR);
9466 0 : if (res) return res;
9467 : }
9468 : }
9469 : break;
9470 : default:;
9471 : }
9472 : break;
9473 : default:;
9474 : }
9475 : }
9476 : break;
9477 : default:;
9478 : }
9479 : break;
9480 33193702 : default:;
9481 : }
9482 33193702 : switch (TREE_CODE (_p1))
9483 : {
9484 840 : case BIT_XOR_EXPR:
9485 840 : {
9486 840 : tree _q30 = TREE_OPERAND (_p1, 0);
9487 840 : tree _q31 = TREE_OPERAND (_p1, 1);
9488 840 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9489 : {
9490 0 : {
9491 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
9492 0 : tree res = generic_simplify_271 (loc, type, _p0, _p1, captures, NE_EXPR);
9493 0 : if (res) return res;
9494 : }
9495 : }
9496 840 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
9497 : {
9498 0 : {
9499 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
9500 0 : tree res = generic_simplify_271 (loc, type, _p0, _p1, captures, NE_EXPR);
9501 0 : if (res) return res;
9502 : }
9503 : }
9504 : break;
9505 : }
9506 33193702 : default:;
9507 : }
9508 33193702 : switch (TREE_CODE (_p0))
9509 : {
9510 1262980 : case BIT_AND_EXPR:
9511 1262980 : {
9512 1262980 : tree _q20 = TREE_OPERAND (_p0, 0);
9513 1262980 : tree _q21 = TREE_OPERAND (_p0, 1);
9514 1262980 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9515 : {
9516 179 : {
9517 179 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9518 179 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, NE_EXPR);
9519 179 : if (res) return res;
9520 : }
9521 : }
9522 1262952 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
9523 : {
9524 4466 : {
9525 4466 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9526 4466 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, NE_EXPR);
9527 4466 : if (res) return res;
9528 : }
9529 : }
9530 : break;
9531 : }
9532 33193674 : default:;
9533 : }
9534 33193674 : switch (TREE_CODE (_p1))
9535 : {
9536 15935 : case BIT_AND_EXPR:
9537 15935 : {
9538 15935 : tree _q30 = TREE_OPERAND (_p1, 0);
9539 15935 : tree _q31 = TREE_OPERAND (_p1, 1);
9540 15935 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9541 : {
9542 0 : {
9543 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
9544 0 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, NE_EXPR);
9545 0 : if (res) return res;
9546 : }
9547 : }
9548 15935 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
9549 : {
9550 0 : {
9551 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
9552 0 : tree res = generic_simplify_272 (loc, type, _p0, _p1, captures, NE_EXPR);
9553 0 : if (res) return res;
9554 : }
9555 : }
9556 : break;
9557 : }
9558 33193674 : default:;
9559 : }
9560 33193674 : switch (TREE_CODE (_p0))
9561 : {
9562 4579918 : CASE_CONVERT:
9563 4579918 : {
9564 4579918 : tree _q20 = TREE_OPERAND (_p0, 0);
9565 4579918 : switch (TREE_CODE (_q20))
9566 : {
9567 0 : case BIT_AND_EXPR:
9568 0 : {
9569 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9570 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9571 0 : switch (TREE_CODE (_q30))
9572 : {
9573 0 : CASE_CONVERT:
9574 0 : {
9575 0 : tree _q40 = TREE_OPERAND (_q30, 0);
9576 0 : switch (TREE_CODE (_q31))
9577 : {
9578 0 : case INTEGER_CST:
9579 0 : {
9580 0 : switch (TREE_CODE (_p1))
9581 : {
9582 0 : CASE_CONVERT:
9583 0 : {
9584 0 : tree _q70 = TREE_OPERAND (_p1, 0);
9585 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
9586 : {
9587 0 : {
9588 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q40, _q31 };
9589 0 : tree res = generic_simplify_273 (loc, type, _p0, _p1, captures, NE_EXPR);
9590 0 : if (res) return res;
9591 : }
9592 : }
9593 : break;
9594 : }
9595 : default:;
9596 : }
9597 : break;
9598 : }
9599 : default:;
9600 : }
9601 : break;
9602 : }
9603 : default:;
9604 : }
9605 : break;
9606 : }
9607 4579918 : default:;
9608 : }
9609 4579918 : switch (TREE_CODE (_p1))
9610 : {
9611 2850199 : CASE_CONVERT:
9612 2850199 : {
9613 2850199 : tree _q40 = TREE_OPERAND (_p1, 0);
9614 2850199 : switch (TREE_CODE (_q40))
9615 : {
9616 0 : case BIT_AND_EXPR:
9617 0 : {
9618 0 : tree _q50 = TREE_OPERAND (_q40, 0);
9619 0 : tree _q51 = TREE_OPERAND (_q40, 1);
9620 0 : switch (TREE_CODE (_q50))
9621 : {
9622 0 : CASE_CONVERT:
9623 0 : {
9624 0 : tree _q60 = TREE_OPERAND (_q50, 0);
9625 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9626 : {
9627 0 : switch (TREE_CODE (_q51))
9628 : {
9629 0 : case INTEGER_CST:
9630 0 : {
9631 0 : {
9632 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q50, _q20, _q51 };
9633 0 : tree res = generic_simplify_273 (loc, type, _p0, _p1, captures, NE_EXPR);
9634 0 : if (res) return res;
9635 : }
9636 0 : break;
9637 : }
9638 : default:;
9639 : }
9640 : }
9641 : break;
9642 : }
9643 : default:;
9644 : }
9645 : break;
9646 : }
9647 : default:;
9648 : }
9649 : break;
9650 : }
9651 : default:;
9652 : }
9653 : break;
9654 : }
9655 239463 : case BIT_IOR_EXPR:
9656 239463 : {
9657 239463 : tree _q20 = TREE_OPERAND (_p0, 0);
9658 239463 : tree _q21 = TREE_OPERAND (_p0, 1);
9659 239463 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
9660 : {
9661 128 : {
9662 128 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9663 128 : tree res = generic_simplify_274 (loc, type, _p0, _p1, captures, NE_EXPR);
9664 128 : if (res) return res;
9665 : }
9666 : }
9667 239455 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9668 : {
9669 253 : {
9670 253 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9671 253 : tree res = generic_simplify_274 (loc, type, _p0, _p1, captures, NE_EXPR);
9672 253 : if (res) return res;
9673 : }
9674 : }
9675 : break;
9676 : }
9677 33193666 : default:;
9678 : }
9679 33193666 : switch (TREE_CODE (_p1))
9680 : {
9681 564 : case BIT_IOR_EXPR:
9682 564 : {
9683 564 : tree _q30 = TREE_OPERAND (_p1, 0);
9684 564 : tree _q31 = TREE_OPERAND (_p1, 1);
9685 564 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
9686 : {
9687 0 : {
9688 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
9689 0 : tree res = generic_simplify_274 (loc, type, _p0, _p1, captures, NE_EXPR);
9690 0 : if (res) return res;
9691 : }
9692 : }
9693 564 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9694 : {
9695 0 : {
9696 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _p0 };
9697 0 : tree res = generic_simplify_274 (loc, type, _p0, _p1, captures, NE_EXPR);
9698 0 : if (res) return res;
9699 : }
9700 : }
9701 : break;
9702 : }
9703 33193666 : default:;
9704 : }
9705 33193666 : switch (TREE_CODE (_p0))
9706 : {
9707 4579918 : CASE_CONVERT:
9708 4579918 : {
9709 4579918 : tree _q20 = TREE_OPERAND (_p0, 0);
9710 4579918 : switch (TREE_CODE (_q20))
9711 : {
9712 661 : case BIT_XOR_EXPR:
9713 661 : {
9714 661 : tree _q30 = TREE_OPERAND (_q20, 0);
9715 661 : tree _q31 = TREE_OPERAND (_q20, 1);
9716 661 : switch (TREE_CODE (_q31))
9717 : {
9718 0 : case INTEGER_CST:
9719 0 : {
9720 0 : switch (TREE_CODE (_p1))
9721 : {
9722 0 : case INTEGER_CST:
9723 0 : {
9724 0 : {
9725 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _p1 };
9726 0 : tree res = generic_simplify_275 (loc, type, _p0, _p1, captures, NE_EXPR);
9727 0 : if (res) return res;
9728 : }
9729 0 : break;
9730 : }
9731 : default:;
9732 : }
9733 : break;
9734 : }
9735 : default:;
9736 : }
9737 : break;
9738 : }
9739 : default:;
9740 : }
9741 : break;
9742 : }
9743 4329 : case BIT_XOR_EXPR:
9744 4329 : {
9745 4329 : tree _q20 = TREE_OPERAND (_p0, 0);
9746 4329 : tree _q21 = TREE_OPERAND (_p0, 1);
9747 4329 : switch (TREE_CODE (_q21))
9748 : {
9749 884 : case INTEGER_CST:
9750 884 : {
9751 884 : switch (TREE_CODE (_p1))
9752 : {
9753 10 : case INTEGER_CST:
9754 10 : {
9755 10 : {
9756 10 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
9757 10 : tree res = generic_simplify_275 (loc, type, _p0, _p1, captures, NE_EXPR);
9758 10 : if (res) return res;
9759 : }
9760 0 : break;
9761 : }
9762 : default:;
9763 : }
9764 : break;
9765 : }
9766 : default:;
9767 : }
9768 : break;
9769 : }
9770 33193656 : default:;
9771 : }
9772 33193656 : {
9773 33193656 : tree _p0_pops[1];
9774 33193656 : if (tree_nop_convert (_p0, _p0_pops))
9775 : {
9776 3869167 : tree _q20 = _p0_pops[0];
9777 3869167 : if (integer_zerop (_p1))
9778 : {
9779 924900 : {
9780 924900 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9781 924900 : tree res = generic_simplify_276 (loc, type, _p0, _p1, captures, NE_EXPR);
9782 924900 : if (res) return res;
9783 : }
9784 : }
9785 : }
9786 : }
9787 32622473 : if (integer_zerop (_p1))
9788 : {
9789 18157959 : {
9790 18157959 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
9791 18157959 : tree res = generic_simplify_276 (loc, type, _p0, _p1, captures, NE_EXPR);
9792 18157959 : if (res) return res;
9793 : }
9794 : }
9795 32447386 : switch (TREE_CODE (_p0))
9796 : {
9797 1262952 : case BIT_AND_EXPR:
9798 1262952 : {
9799 1262952 : tree _q20 = TREE_OPERAND (_p0, 0);
9800 1262952 : tree _q21 = TREE_OPERAND (_p0, 1);
9801 1262952 : switch (TREE_CODE (_p1))
9802 : {
9803 14506 : case BIT_AND_EXPR:
9804 14506 : {
9805 14506 : tree _q50 = TREE_OPERAND (_p1, 0);
9806 14506 : tree _q51 = TREE_OPERAND (_p1, 1);
9807 14506 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9808 : {
9809 14261 : {
9810 14261 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
9811 14261 : tree res = generic_simplify_277 (loc, type, _p0, _p1, captures, NE_EXPR);
9812 14261 : if (res) return res;
9813 : }
9814 : }
9815 245 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9816 : {
9817 2 : {
9818 2 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
9819 2 : tree res = generic_simplify_277 (loc, type, _p0, _p1, captures, NE_EXPR);
9820 2 : if (res) return res;
9821 : }
9822 : }
9823 243 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9824 : {
9825 1 : {
9826 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q50 };
9827 1 : tree res = generic_simplify_277 (loc, type, _p0, _p1, captures, NE_EXPR);
9828 1 : if (res) return res;
9829 : }
9830 : }
9831 242 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9832 : {
9833 7 : {
9834 7 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q51 };
9835 7 : tree res = generic_simplify_277 (loc, type, _p0, _p1, captures, NE_EXPR);
9836 7 : if (res) return res;
9837 : }
9838 : }
9839 : break;
9840 : }
9841 1248681 : default:;
9842 : }
9843 1248681 : if (integer_pow2p (_q21))
9844 : {
9845 644845 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
9846 : {
9847 579 : {
9848 579 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
9849 579 : tree res = generic_simplify_278 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR);
9850 579 : if (res) return res;
9851 : }
9852 : }
9853 : }
9854 1248106 : switch (TREE_CODE (_q20))
9855 : {
9856 194044 : CASE_CONVERT:
9857 194044 : {
9858 194044 : tree _q30 = TREE_OPERAND (_q20, 0);
9859 194044 : if (integer_pow2p (_q21))
9860 : {
9861 96184 : if (integer_zerop (_p1))
9862 : {
9863 96089 : {
9864 96089 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q21 };
9865 96089 : tree res = generic_simplify_279 (loc, type, _p0, _p1, captures, NE_EXPR, LT_EXPR);
9866 96089 : if (res) return res;
9867 : }
9868 : }
9869 : }
9870 : break;
9871 : }
9872 1244156 : default:;
9873 : }
9874 1244156 : if (integer_pow2p (_q21))
9875 : {
9876 640320 : if (integer_zerop (_p1))
9877 : {
9878 636895 : {
9879 636895 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q20, _q21 };
9880 636895 : tree res = generic_simplify_280 (loc, type, _p0, _p1, captures, NE_EXPR, LT_EXPR);
9881 636895 : if (res) return res;
9882 : }
9883 : }
9884 : }
9885 : break;
9886 : }
9887 5406 : case GE_EXPR:
9888 5406 : {
9889 5406 : tree _q20 = TREE_OPERAND (_p0, 0);
9890 5406 : tree _q21 = TREE_OPERAND (_p0, 1);
9891 5406 : if (integer_zerop (_q21))
9892 : {
9893 963 : switch (TREE_CODE (_p1))
9894 : {
9895 1 : case GE_EXPR:
9896 1 : {
9897 1 : tree _q50 = TREE_OPERAND (_p1, 0);
9898 1 : tree _q51 = TREE_OPERAND (_p1, 1);
9899 1 : if (integer_zerop (_q51))
9900 : {
9901 1 : {
9902 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
9903 1 : tree res = generic_simplify_281 (loc, type, _p0, _p1, captures, GE_EXPR, NE_EXPR, LT_EXPR);
9904 1 : if (res) return res;
9905 : }
9906 : }
9907 : break;
9908 : }
9909 3 : case LT_EXPR:
9910 3 : {
9911 3 : tree _q50 = TREE_OPERAND (_p1, 0);
9912 3 : tree _q51 = TREE_OPERAND (_p1, 1);
9913 3 : if (integer_zerop (_q51))
9914 : {
9915 3 : {
9916 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
9917 3 : tree res = generic_simplify_282 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR);
9918 3 : if (res) return res;
9919 : }
9920 : }
9921 : break;
9922 : }
9923 : default:;
9924 : }
9925 : }
9926 : break;
9927 : }
9928 15235 : case LT_EXPR:
9929 15235 : {
9930 15235 : tree _q20 = TREE_OPERAND (_p0, 0);
9931 15235 : tree _q21 = TREE_OPERAND (_p0, 1);
9932 15235 : if (integer_zerop (_q21))
9933 : {
9934 8595 : switch (TREE_CODE (_p1))
9935 : {
9936 69 : case LT_EXPR:
9937 69 : {
9938 69 : tree _q50 = TREE_OPERAND (_p1, 0);
9939 69 : tree _q51 = TREE_OPERAND (_p1, 1);
9940 69 : if (integer_zerop (_q51))
9941 : {
9942 69 : {
9943 69 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
9944 69 : tree res = generic_simplify_281 (loc, type, _p0, _p1, captures, LT_EXPR, NE_EXPR, LT_EXPR);
9945 69 : if (res) return res;
9946 : }
9947 : }
9948 : break;
9949 : }
9950 17 : case GE_EXPR:
9951 17 : {
9952 17 : tree _q50 = TREE_OPERAND (_p1, 0);
9953 17 : tree _q51 = TREE_OPERAND (_p1, 1);
9954 17 : if (integer_zerop (_q51))
9955 : {
9956 17 : {
9957 17 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
9958 17 : tree res = generic_simplify_283 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR);
9959 17 : if (res) return res;
9960 : }
9961 : }
9962 : break;
9963 : }
9964 : default:;
9965 : }
9966 : }
9967 : break;
9968 : }
9969 239455 : case BIT_IOR_EXPR:
9970 239455 : {
9971 239455 : tree _q20 = TREE_OPERAND (_p0, 0);
9972 239455 : tree _q21 = TREE_OPERAND (_p0, 1);
9973 239455 : switch (TREE_CODE (_q21))
9974 : {
9975 261 : CASE_CONVERT:
9976 261 : {
9977 261 : tree _q40 = TREE_OPERAND (_q21, 0);
9978 261 : switch (TREE_CODE (_q40))
9979 : {
9980 0 : case NE_EXPR:
9981 0 : {
9982 0 : tree _q50 = TREE_OPERAND (_q40, 0);
9983 0 : tree _q51 = TREE_OPERAND (_q40, 1);
9984 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9985 : {
9986 0 : if (integer_zerop (_q51))
9987 : {
9988 0 : if (integer_zerop (_p1))
9989 : {
9990 0 : {
9991 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9992 0 : tree res = generic_simplify_284 (loc, type, _p0, _p1, captures, NE_EXPR);
9993 0 : if (res) return res;
9994 : }
9995 : }
9996 : }
9997 : }
9998 : break;
9999 : }
10000 : default:;
10001 : }
10002 : break;
10003 : }
10004 239455 : default:;
10005 : }
10006 239455 : switch (TREE_CODE (_q20))
10007 : {
10008 800 : CASE_CONVERT:
10009 800 : {
10010 800 : tree _q30 = TREE_OPERAND (_q20, 0);
10011 800 : switch (TREE_CODE (_q30))
10012 : {
10013 0 : case NE_EXPR:
10014 0 : {
10015 0 : tree _q40 = TREE_OPERAND (_q30, 0);
10016 0 : tree _q41 = TREE_OPERAND (_q30, 1);
10017 0 : if (integer_zerop (_q41))
10018 : {
10019 0 : if ((_q21 == _q40 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q40, 0) && types_match (_q21, _q40)))
10020 : {
10021 0 : if (integer_zerop (_p1))
10022 : {
10023 0 : {
10024 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q40 };
10025 0 : tree res = generic_simplify_284 (loc, type, _p0, _p1, captures, NE_EXPR);
10026 0 : if (res) return res;
10027 : }
10028 : }
10029 : }
10030 : }
10031 : break;
10032 : }
10033 : default:;
10034 : }
10035 : break;
10036 : }
10037 239455 : default:;
10038 : }
10039 239455 : switch (TREE_CODE (_q21))
10040 : {
10041 24 : case NE_EXPR:
10042 24 : {
10043 24 : tree _q40 = TREE_OPERAND (_q21, 0);
10044 24 : tree _q41 = TREE_OPERAND (_q21, 1);
10045 24 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
10046 : {
10047 0 : if (integer_zerop (_q41))
10048 : {
10049 0 : if (integer_zerop (_p1))
10050 : {
10051 0 : {
10052 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10053 0 : tree res = generic_simplify_284 (loc, type, _p0, _p1, captures, NE_EXPR);
10054 0 : if (res) return res;
10055 : }
10056 : }
10057 : }
10058 : }
10059 : break;
10060 : }
10061 239455 : default:;
10062 : }
10063 239455 : switch (TREE_CODE (_q20))
10064 : {
10065 2 : case NE_EXPR:
10066 2 : {
10067 2 : tree _q30 = TREE_OPERAND (_q20, 0);
10068 2 : tree _q31 = TREE_OPERAND (_q20, 1);
10069 2 : if (integer_zerop (_q31))
10070 : {
10071 1 : if ((_q21 == _q30 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q30, 0) && types_match (_q21, _q30)))
10072 : {
10073 0 : if (integer_zerop (_p1))
10074 : {
10075 0 : {
10076 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
10077 0 : tree res = generic_simplify_284 (loc, type, _p0, _p1, captures, NE_EXPR);
10078 0 : if (res) return res;
10079 : }
10080 : }
10081 : }
10082 : }
10083 : break;
10084 : }
10085 : default:;
10086 : }
10087 : break;
10088 : }
10089 4008735 : CASE_CONVERT:
10090 4008735 : {
10091 4008735 : tree _q20 = TREE_OPERAND (_p0, 0);
10092 4008735 : switch (TREE_CODE (_q20))
10093 : {
10094 2755301 : case ADDR_EXPR:
10095 2755301 : {
10096 2755301 : switch (TREE_CODE (_p1))
10097 : {
10098 2725952 : CASE_CONVERT:
10099 2725952 : {
10100 2725952 : tree _q40 = TREE_OPERAND (_p1, 0);
10101 2725952 : switch (TREE_CODE (_q40))
10102 : {
10103 2725952 : case ADDR_EXPR:
10104 2725952 : {
10105 2725952 : {
10106 2725952 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
10107 2725952 : tree res = generic_simplify_285 (loc, type, _p0, _p1, captures, NE_EXPR);
10108 2725952 : if (res) return res;
10109 : }
10110 33 : break;
10111 : }
10112 : default:;
10113 : }
10114 : break;
10115 : }
10116 21277 : case ADDR_EXPR:
10117 21277 : {
10118 21277 : {
10119 21277 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10120 21277 : tree res = generic_simplify_285 (loc, type, _p0, _p1, captures, NE_EXPR);
10121 21277 : if (res) return res;
10122 : }
10123 7935 : break;
10124 : }
10125 : default:;
10126 : }
10127 : break;
10128 : }
10129 : default:;
10130 : }
10131 : break;
10132 : }
10133 60242 : case ADDR_EXPR:
10134 60242 : {
10135 60242 : switch (TREE_CODE (_p1))
10136 : {
10137 205 : CASE_CONVERT:
10138 205 : {
10139 205 : tree _q30 = TREE_OPERAND (_p1, 0);
10140 205 : switch (TREE_CODE (_q30))
10141 : {
10142 205 : case ADDR_EXPR:
10143 205 : {
10144 205 : {
10145 205 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q30 };
10146 205 : tree res = generic_simplify_286 (loc, type, _p0, _p1, captures, NE_EXPR);
10147 205 : if (res) return res;
10148 : }
10149 143 : break;
10150 : }
10151 : default:;
10152 : }
10153 : break;
10154 : }
10155 51876 : case ADDR_EXPR:
10156 51876 : {
10157 51876 : {
10158 51876 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
10159 51876 : tree res = generic_simplify_286 (loc, type, _p0, _p1, captures, NE_EXPR);
10160 51876 : if (res) return res;
10161 : }
10162 4079 : break;
10163 : }
10164 : default:;
10165 : }
10166 : break;
10167 : }
10168 29628719 : default:;
10169 : }
10170 29628719 : {
10171 29628719 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
10172 29628719 : tree res = generic_simplify_287 (loc, type, _p0, _p1, captures, NE_EXPR);
10173 29628719 : if (res) return res;
10174 : }
10175 29619901 : switch (TREE_CODE (_p0))
10176 : {
10177 1269474 : CASE_CONVERT:
10178 1269474 : {
10179 1269474 : tree _q20 = TREE_OPERAND (_p0, 0);
10180 1269474 : switch (TREE_CODE (_p1))
10181 : {
10182 816208 : case INTEGER_CST:
10183 816208 : {
10184 816208 : {
10185 816208 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
10186 816208 : tree res = generic_simplify_288 (loc, type, _p0, _p1, captures, NE_EXPR);
10187 816208 : if (res) return res;
10188 : }
10189 807696 : break;
10190 : }
10191 1260962 : default:;
10192 : }
10193 1260962 : switch (TREE_CODE (_q20))
10194 : {
10195 8 : case NE_EXPR:
10196 8 : {
10197 8 : tree _q30 = TREE_OPERAND (_q20, 0);
10198 8 : tree _q31 = TREE_OPERAND (_q20, 1);
10199 8 : switch (TREE_CODE (_q31))
10200 : {
10201 8 : case INTEGER_CST:
10202 8 : {
10203 8 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
10204 : {
10205 0 : {
10206 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
10207 0 : tree res = generic_simplify_289 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
10208 0 : if (res) return res;
10209 : }
10210 : }
10211 : break;
10212 : }
10213 : default:;
10214 : }
10215 : break;
10216 : }
10217 0 : case EQ_EXPR:
10218 0 : {
10219 0 : tree _q30 = TREE_OPERAND (_q20, 0);
10220 0 : tree _q31 = TREE_OPERAND (_q20, 1);
10221 0 : switch (TREE_CODE (_q31))
10222 : {
10223 0 : case INTEGER_CST:
10224 0 : {
10225 0 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
10226 : {
10227 0 : {
10228 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
10229 0 : tree res = generic_simplify_289 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR);
10230 0 : if (res) return res;
10231 : }
10232 : }
10233 : break;
10234 : }
10235 : default:;
10236 : }
10237 : break;
10238 : }
10239 : default:;
10240 : }
10241 : break;
10242 : }
10243 29611389 : default:;
10244 : }
10245 29611389 : switch (TREE_CODE (_p1))
10246 : {
10247 517785 : CASE_CONVERT:
10248 517785 : {
10249 517785 : tree _q30 = TREE_OPERAND (_p1, 0);
10250 517785 : switch (TREE_CODE (_q30))
10251 : {
10252 0 : case NE_EXPR:
10253 0 : {
10254 0 : tree _q40 = TREE_OPERAND (_q30, 0);
10255 0 : tree _q41 = TREE_OPERAND (_q30, 1);
10256 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
10257 : {
10258 0 : switch (TREE_CODE (_q41))
10259 : {
10260 0 : case INTEGER_CST:
10261 0 : {
10262 0 : {
10263 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
10264 0 : tree res = generic_simplify_289 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
10265 0 : if (res) return res;
10266 : }
10267 0 : break;
10268 : }
10269 : default:;
10270 : }
10271 : }
10272 : break;
10273 : }
10274 0 : case EQ_EXPR:
10275 0 : {
10276 0 : tree _q40 = TREE_OPERAND (_q30, 0);
10277 0 : tree _q41 = TREE_OPERAND (_q30, 1);
10278 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
10279 : {
10280 0 : switch (TREE_CODE (_q41))
10281 : {
10282 0 : case INTEGER_CST:
10283 0 : {
10284 0 : {
10285 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
10286 0 : tree res = generic_simplify_289 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR);
10287 0 : if (res) return res;
10288 : }
10289 0 : break;
10290 : }
10291 : default:;
10292 : }
10293 : }
10294 : break;
10295 : }
10296 : default:;
10297 : }
10298 : break;
10299 : }
10300 29611389 : default:;
10301 : }
10302 29611389 : if (integer_zerop (_p1))
10303 : {
10304 17957389 : {
10305 17957389 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10306 17957389 : if (TREE_CODE (TREE_TYPE (captures[0])) == BOOLEAN_TYPE
10307 17957389 : && types_match (type, TREE_TYPE (captures[0]))
10308 : )
10309 : {
10310 3337097 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1564;
10311 3337097 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1564;
10312 3337097 : {
10313 3337097 : tree res_op0;
10314 3337097 : res_op0 = captures[0];
10315 3337097 : tree _r;
10316 3337097 : _r = non_lvalue_loc (loc, res_op0);
10317 3337097 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 988, __FILE__, __LINE__, true);
10318 3337097 : return _r;
10319 : }
10320 : next_after_fail1564:;
10321 : }
10322 : }
10323 : }
10324 26274292 : switch (TREE_CODE (_p0))
10325 : {
10326 962491 : case BIT_AND_EXPR:
10327 962491 : {
10328 962491 : tree _q20 = TREE_OPERAND (_p0, 0);
10329 962491 : tree _q21 = TREE_OPERAND (_p0, 1);
10330 962491 : switch (TREE_CODE (_q21))
10331 : {
10332 2054 : case VECTOR_CST:
10333 2054 : {
10334 2054 : if (integer_zerop (_p1))
10335 : {
10336 2054 : {
10337 2054 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
10338 2054 : const enum tree_code cmp = NE_EXPR;
10339 2054 : const enum tree_code icmp = GT_EXPR;
10340 2054 : {
10341 2054 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
10342 2054 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
10343 : )
10344 : {
10345 13 : {
10346 13 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
10347 13 : ? optab_vector : optab_default;
10348 13 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
10349 13 : if (target_supports_op_p (utype, icmp, optab)
10350 13 : || (optimize_vectors_before_lowering_p ()
10351 7 : && (!target_supports_op_p (type, cmp, optab)
10352 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
10353 : )
10354 : {
10355 7 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
10356 : )
10357 : {
10358 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1565;
10359 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1565;
10360 0 : {
10361 0 : tree res_op0;
10362 0 : res_op0 = captures[1];
10363 0 : tree res_op1;
10364 0 : res_op1 = csts;
10365 0 : tree _r;
10366 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10367 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10368 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10369 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 985, __FILE__, __LINE__, true);
10370 0 : return _r;
10371 : }
10372 2047 : next_after_fail1565:;
10373 : }
10374 : else
10375 : {
10376 7 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1566;
10377 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1566;
10378 7 : {
10379 7 : tree res_op0;
10380 7 : {
10381 7 : tree _o1[1], _r1;
10382 7 : _o1[0] = captures[1];
10383 7 : if (TREE_TYPE (_o1[0]) != utype)
10384 : {
10385 7 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, utype, _o1[0]);
10386 : }
10387 : else
10388 : _r1 = _o1[0];
10389 7 : res_op0 = _r1;
10390 : }
10391 7 : tree res_op1;
10392 7 : res_op1 = csts;
10393 7 : tree _r;
10394 7 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10395 7 : if (TREE_SIDE_EFFECTS (captures[2]))
10396 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10397 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 986, __FILE__, __LINE__, true);
10398 7 : return _r;
10399 : }
10400 2047 : next_after_fail1566:;
10401 : }
10402 : }
10403 : }
10404 : }
10405 : }
10406 : }
10407 : }
10408 : break;
10409 : }
10410 766797 : case INTEGER_CST:
10411 766797 : {
10412 766797 : if (integer_zerop (_p1))
10413 : {
10414 731331 : {
10415 731331 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
10416 731331 : const enum tree_code cmp = NE_EXPR;
10417 731331 : const enum tree_code icmp = GT_EXPR;
10418 731331 : {
10419 731331 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
10420 731331 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
10421 : )
10422 : {
10423 1261 : {
10424 1261 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
10425 1261 : ? optab_vector : optab_default;
10426 1261 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
10427 1261 : if (target_supports_op_p (utype, icmp, optab)
10428 1261 : || (optimize_vectors_before_lowering_p ()
10429 1092 : && (!target_supports_op_p (type, cmp, optab)
10430 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
10431 : )
10432 : {
10433 1092 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
10434 : )
10435 : {
10436 989 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1567;
10437 989 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1567;
10438 989 : {
10439 989 : tree res_op0;
10440 989 : res_op0 = captures[1];
10441 989 : tree res_op1;
10442 989 : res_op1 = csts;
10443 989 : tree _r;
10444 989 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10445 989 : if (TREE_SIDE_EFFECTS (captures[2]))
10446 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10447 989 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 985, __FILE__, __LINE__, true);
10448 989 : return _r;
10449 : }
10450 730239 : next_after_fail1567:;
10451 : }
10452 : else
10453 : {
10454 103 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1568;
10455 103 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1568;
10456 103 : {
10457 103 : tree res_op0;
10458 103 : {
10459 103 : tree _o1[1], _r1;
10460 103 : _o1[0] = captures[1];
10461 103 : if (TREE_TYPE (_o1[0]) != utype)
10462 : {
10463 103 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, utype, _o1[0]);
10464 : }
10465 : else
10466 : _r1 = _o1[0];
10467 103 : res_op0 = _r1;
10468 : }
10469 103 : tree res_op1;
10470 103 : res_op1 = csts;
10471 103 : tree _r;
10472 103 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10473 103 : if (TREE_SIDE_EFFECTS (captures[2]))
10474 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10475 103 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 986, __FILE__, __LINE__, true);
10476 103 : return _r;
10477 : }
10478 730239 : next_after_fail1568:;
10479 : }
10480 : }
10481 : }
10482 : }
10483 : }
10484 : }
10485 : }
10486 : break;
10487 : }
10488 961392 : default:;
10489 : }
10490 961392 : switch (TREE_CODE (_q20))
10491 : {
10492 0 : case VECTOR_CST:
10493 0 : {
10494 0 : if (integer_zerop (_p1))
10495 : {
10496 0 : {
10497 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
10498 0 : const enum tree_code cmp = NE_EXPR;
10499 0 : const enum tree_code icmp = GT_EXPR;
10500 0 : {
10501 0 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
10502 0 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
10503 : )
10504 : {
10505 0 : {
10506 0 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
10507 0 : ? optab_vector : optab_default;
10508 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
10509 0 : if (target_supports_op_p (utype, icmp, optab)
10510 0 : || (optimize_vectors_before_lowering_p ()
10511 0 : && (!target_supports_op_p (type, cmp, optab)
10512 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
10513 : )
10514 : {
10515 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
10516 : )
10517 : {
10518 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1569;
10519 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1569;
10520 0 : {
10521 0 : tree res_op0;
10522 0 : res_op0 = captures[1];
10523 0 : tree res_op1;
10524 0 : res_op1 = csts;
10525 0 : tree _r;
10526 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10527 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10528 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10529 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 985, __FILE__, __LINE__, true);
10530 0 : return _r;
10531 : }
10532 0 : next_after_fail1569:;
10533 : }
10534 : else
10535 : {
10536 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1570;
10537 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1570;
10538 0 : {
10539 0 : tree res_op0;
10540 0 : {
10541 0 : tree _o1[1], _r1;
10542 0 : _o1[0] = captures[1];
10543 0 : if (TREE_TYPE (_o1[0]) != utype)
10544 : {
10545 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, utype, _o1[0]);
10546 : }
10547 : else
10548 : _r1 = _o1[0];
10549 0 : res_op0 = _r1;
10550 : }
10551 0 : tree res_op1;
10552 0 : res_op1 = csts;
10553 0 : tree _r;
10554 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10555 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10556 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10557 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 986, __FILE__, __LINE__, true);
10558 0 : return _r;
10559 : }
10560 0 : next_after_fail1570:;
10561 : }
10562 : }
10563 : }
10564 : }
10565 : }
10566 : }
10567 : }
10568 : break;
10569 : }
10570 0 : case INTEGER_CST:
10571 0 : {
10572 0 : if (integer_zerop (_p1))
10573 : {
10574 0 : {
10575 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
10576 0 : const enum tree_code cmp = NE_EXPR;
10577 0 : const enum tree_code icmp = GT_EXPR;
10578 0 : {
10579 0 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
10580 0 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
10581 : )
10582 : {
10583 0 : {
10584 0 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
10585 0 : ? optab_vector : optab_default;
10586 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
10587 0 : if (target_supports_op_p (utype, icmp, optab)
10588 0 : || (optimize_vectors_before_lowering_p ()
10589 0 : && (!target_supports_op_p (type, cmp, optab)
10590 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
10591 : )
10592 : {
10593 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
10594 : )
10595 : {
10596 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1571;
10597 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1571;
10598 0 : {
10599 0 : tree res_op0;
10600 0 : res_op0 = captures[1];
10601 0 : tree res_op1;
10602 0 : res_op1 = csts;
10603 0 : tree _r;
10604 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10605 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10606 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10607 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 985, __FILE__, __LINE__, true);
10608 0 : return _r;
10609 : }
10610 0 : next_after_fail1571:;
10611 : }
10612 : else
10613 : {
10614 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1572;
10615 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1572;
10616 0 : {
10617 0 : tree res_op0;
10618 0 : {
10619 0 : tree _o1[1], _r1;
10620 0 : _o1[0] = captures[1];
10621 0 : if (TREE_TYPE (_o1[0]) != utype)
10622 : {
10623 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, utype, _o1[0]);
10624 : }
10625 : else
10626 : _r1 = _o1[0];
10627 0 : res_op0 = _r1;
10628 : }
10629 0 : tree res_op1;
10630 0 : res_op1 = csts;
10631 0 : tree _r;
10632 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
10633 0 : if (TREE_SIDE_EFFECTS (captures[2]))
10634 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
10635 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 986, __FILE__, __LINE__, true);
10636 0 : return _r;
10637 : }
10638 0 : next_after_fail1572:;
10639 : }
10640 : }
10641 : }
10642 : }
10643 : }
10644 : }
10645 : }
10646 : break;
10647 : }
10648 : default:;
10649 : }
10650 : break;
10651 : }
10652 20270 : case RSHIFT_EXPR:
10653 20270 : {
10654 20270 : tree _q20 = TREE_OPERAND (_p0, 0);
10655 20270 : tree _q21 = TREE_OPERAND (_p0, 1);
10656 20270 : switch (TREE_CODE (_q20))
10657 : {
10658 1 : case MULT_EXPR:
10659 1 : {
10660 1 : tree _q30 = TREE_OPERAND (_q20, 0);
10661 1 : tree _q31 = TREE_OPERAND (_q20, 1);
10662 1 : switch (TREE_CODE (_q30))
10663 : {
10664 1 : CASE_CONVERT:
10665 1 : {
10666 1 : tree _q40 = TREE_OPERAND (_q30, 0);
10667 1 : switch (TREE_CODE (_q31))
10668 : {
10669 1 : CASE_CONVERT:
10670 1 : {
10671 1 : tree _q60 = TREE_OPERAND (_q31, 0);
10672 1 : switch (TREE_CODE (_q21))
10673 : {
10674 1 : case INTEGER_CST:
10675 1 : {
10676 1 : if (integer_zerop (_p1))
10677 : {
10678 1 : {
10679 1 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q30, _q40, _q60, _q21 };
10680 1 : tree res = generic_simplify_290 (loc, type, _p0, _p1, captures, NE_EXPR);
10681 1 : if (res) return res;
10682 : }
10683 : }
10684 : break;
10685 : }
10686 : default:;
10687 : }
10688 : break;
10689 : }
10690 : default:;
10691 : }
10692 : break;
10693 : }
10694 : default:;
10695 : }
10696 : break;
10697 : }
10698 : default:;
10699 : }
10700 : break;
10701 : }
10702 1315142 : case PLUS_EXPR:
10703 1315142 : {
10704 1315142 : tree _q20 = TREE_OPERAND (_p0, 0);
10705 1315142 : tree _q21 = TREE_OPERAND (_p0, 1);
10706 1315142 : switch (TREE_CODE (_q21))
10707 : {
10708 1192405 : case INTEGER_CST:
10709 1192405 : {
10710 1192405 : switch (TREE_CODE (_p1))
10711 : {
10712 705702 : case INTEGER_CST:
10713 705702 : {
10714 705702 : {
10715 705702 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
10716 705702 : tree res = generic_simplify_291 (loc, type, _p0, _p1, captures, PLUS_EXPR, MINUS_EXPR, NE_EXPR);
10717 705702 : if (res) return res;
10718 : }
10719 355 : break;
10720 : }
10721 : default:;
10722 : }
10723 : break;
10724 : }
10725 : default:;
10726 : }
10727 : break;
10728 : }
10729 68506 : case MINUS_EXPR:
10730 68506 : {
10731 68506 : tree _q20 = TREE_OPERAND (_p0, 0);
10732 68506 : tree _q21 = TREE_OPERAND (_p0, 1);
10733 68506 : switch (TREE_CODE (_q21))
10734 : {
10735 193 : case INTEGER_CST:
10736 193 : {
10737 193 : switch (TREE_CODE (_p1))
10738 : {
10739 72 : case INTEGER_CST:
10740 72 : {
10741 72 : {
10742 72 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
10743 72 : tree res = generic_simplify_291 (loc, type, _p0, _p1, captures, MINUS_EXPR, PLUS_EXPR, NE_EXPR);
10744 72 : if (res) return res;
10745 : }
10746 72 : break;
10747 : }
10748 : default:;
10749 : }
10750 : break;
10751 : }
10752 68506 : default:;
10753 : }
10754 68506 : switch (TREE_CODE (_q20))
10755 : {
10756 1717 : case INTEGER_CST:
10757 1717 : {
10758 1717 : switch (TREE_CODE (_p1))
10759 : {
10760 61 : case INTEGER_CST:
10761 61 : {
10762 61 : {
10763 61 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
10764 61 : tree res = generic_simplify_292 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR);
10765 61 : if (res) return res;
10766 : }
10767 0 : break;
10768 : }
10769 : default:;
10770 : }
10771 : break;
10772 : }
10773 : default:;
10774 : }
10775 : break;
10776 : }
10777 2309117 : case CALL_EXPR:
10778 2309117 : switch (get_call_combined_fn (_p0))
10779 : {
10780 224 : case CFN_BUILT_IN_CLZ:
10781 224 : if (call_expr_nargs (_p0) == 1)
10782 : {
10783 224 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10784 224 : switch (TREE_CODE (_p1))
10785 : {
10786 210 : case INTEGER_CST:
10787 210 : {
10788 210 : {
10789 210 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10790 210 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZ);
10791 210 : if (res) return res;
10792 : }
10793 135 : break;
10794 : }
10795 : default:;
10796 : }
10797 : }
10798 : break;
10799 246 : case CFN_BUILT_IN_CTZ:
10800 246 : if (call_expr_nargs (_p0) == 1)
10801 : {
10802 246 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10803 246 : switch (TREE_CODE (_p1))
10804 : {
10805 200 : case INTEGER_CST:
10806 200 : {
10807 200 : {
10808 200 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10809 200 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_CTZ);
10810 200 : if (res) return res;
10811 : }
10812 0 : break;
10813 : }
10814 : default:;
10815 : }
10816 : }
10817 : break;
10818 31 : case CFN_BUILT_IN_FFS:
10819 31 : if (call_expr_nargs (_p0) == 1)
10820 : {
10821 31 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10822 31 : switch (TREE_CODE (_p1))
10823 : {
10824 11 : case INTEGER_CST:
10825 11 : {
10826 11 : {
10827 11 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10828 11 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_FFS);
10829 11 : if (res) return res;
10830 : }
10831 0 : break;
10832 : }
10833 : default:;
10834 : }
10835 : }
10836 : break;
10837 0 : case CFN_REDUC_IOR:
10838 0 : if (call_expr_nargs (_p0) == 1)
10839 : {
10840 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10841 0 : if (integer_zerop (_p1))
10842 : {
10843 0 : {
10844 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10845 0 : tree res = generic_simplify_299 (loc, type, _p0, _p1, captures, NE_EXPR);
10846 0 : if (res) return res;
10847 : }
10848 : }
10849 : }
10850 : break;
10851 0 : case CFN_BUILT_IN_FFSIMAX:
10852 0 : if (call_expr_nargs (_p0) == 1)
10853 : {
10854 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10855 0 : switch (TREE_CODE (_p1))
10856 : {
10857 0 : case INTEGER_CST:
10858 0 : {
10859 0 : {
10860 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10861 0 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_FFSIMAX);
10862 0 : if (res) return res;
10863 : }
10864 0 : break;
10865 : }
10866 : default:;
10867 : }
10868 : }
10869 : break;
10870 13 : case CFN_BUILT_IN_POPCOUNT:
10871 13 : if (call_expr_nargs (_p0) == 1)
10872 : {
10873 13 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10874 13 : if (integer_zerop (_p1))
10875 : {
10876 1 : {
10877 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10878 1 : tree res = generic_simplify_297 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNT);
10879 1 : if (res) return res;
10880 : }
10881 : }
10882 : }
10883 : break;
10884 87 : case CFN_BUILT_IN_CLZL:
10885 87 : if (call_expr_nargs (_p0) == 1)
10886 : {
10887 87 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10888 87 : switch (TREE_CODE (_p1))
10889 : {
10890 79 : case INTEGER_CST:
10891 79 : {
10892 79 : {
10893 79 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10894 79 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZL);
10895 79 : if (res) return res;
10896 : }
10897 43 : break;
10898 : }
10899 : default:;
10900 : }
10901 : }
10902 : break;
10903 85 : case CFN_BUILT_IN_CTZL:
10904 85 : if (call_expr_nargs (_p0) == 1)
10905 : {
10906 85 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10907 85 : switch (TREE_CODE (_p1))
10908 : {
10909 77 : case INTEGER_CST:
10910 77 : {
10911 77 : {
10912 77 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10913 77 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_CTZL);
10914 77 : if (res) return res;
10915 : }
10916 16 : break;
10917 : }
10918 : default:;
10919 : }
10920 : }
10921 : break;
10922 8 : case CFN_BUILT_IN_FFSL:
10923 8 : if (call_expr_nargs (_p0) == 1)
10924 : {
10925 8 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10926 8 : switch (TREE_CODE (_p1))
10927 : {
10928 0 : case INTEGER_CST:
10929 0 : {
10930 0 : {
10931 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10932 0 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_FFSL);
10933 0 : if (res) return res;
10934 : }
10935 0 : break;
10936 : }
10937 : default:;
10938 : }
10939 : }
10940 : break;
10941 11 : case CFN_BUILT_IN_POPCOUNTLL:
10942 11 : if (call_expr_nargs (_p0) == 1)
10943 : {
10944 11 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10945 11 : if (integer_zerop (_p1))
10946 : {
10947 1 : {
10948 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10949 1 : tree res = generic_simplify_297 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNTLL);
10950 1 : if (res) return res;
10951 : }
10952 : }
10953 : }
10954 : break;
10955 0 : case CFN_BUILT_IN_CTZIMAX:
10956 0 : if (call_expr_nargs (_p0) == 1)
10957 : {
10958 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10959 0 : switch (TREE_CODE (_p1))
10960 : {
10961 0 : case INTEGER_CST:
10962 0 : {
10963 0 : {
10964 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10965 0 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_CTZIMAX);
10966 0 : if (res) return res;
10967 : }
10968 0 : break;
10969 : }
10970 : default:;
10971 : }
10972 : }
10973 : break;
10974 0 : case CFN_POPCOUNT:
10975 0 : if (call_expr_nargs (_p0) == 1)
10976 : {
10977 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10978 0 : if (integer_zerop (_p1))
10979 : {
10980 0 : {
10981 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10982 0 : tree res = generic_simplify_297 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_POPCOUNT);
10983 0 : if (res) return res;
10984 : }
10985 : }
10986 : }
10987 : break;
10988 0 : case CFN_CLZ:
10989 0 : if (call_expr_nargs (_p0) == 1)
10990 : {
10991 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10992 0 : switch (TREE_CODE (_p1))
10993 : {
10994 0 : case INTEGER_CST:
10995 0 : {
10996 0 : {
10997 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
10998 0 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_CLZ);
10999 0 : if (res) return res;
11000 : }
11001 0 : break;
11002 : }
11003 : default:;
11004 : }
11005 : }
11006 0 : if (call_expr_nargs (_p0) == 2)
11007 : {
11008 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11009 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
11010 0 : switch (TREE_CODE (_p1))
11011 : {
11012 0 : case INTEGER_CST:
11013 0 : {
11014 0 : {
11015 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
11016 0 : tree res = generic_simplify_294 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR);
11017 0 : if (res) return res;
11018 : }
11019 0 : break;
11020 : }
11021 : default:;
11022 : }
11023 : }
11024 : break;
11025 0 : case CFN_CTZ:
11026 0 : if (call_expr_nargs (_p0) == 1)
11027 : {
11028 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11029 0 : switch (TREE_CODE (_p1))
11030 : {
11031 0 : case INTEGER_CST:
11032 0 : {
11033 0 : {
11034 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11035 0 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_CTZ);
11036 0 : if (res) return res;
11037 : }
11038 0 : break;
11039 : }
11040 : default:;
11041 : }
11042 : }
11043 0 : if (call_expr_nargs (_p0) == 2)
11044 : {
11045 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11046 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
11047 0 : switch (TREE_CODE (_p1))
11048 : {
11049 0 : case INTEGER_CST:
11050 0 : {
11051 0 : {
11052 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
11053 0 : tree res = generic_simplify_296 (loc, type, _p0, _p1, captures, NE_EXPR);
11054 0 : if (res) return res;
11055 : }
11056 0 : break;
11057 : }
11058 : default:;
11059 : }
11060 : }
11061 : break;
11062 0 : case CFN_FFS:
11063 0 : if (call_expr_nargs (_p0) == 1)
11064 : {
11065 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11066 0 : switch (TREE_CODE (_p1))
11067 : {
11068 0 : case INTEGER_CST:
11069 0 : {
11070 0 : {
11071 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11072 0 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_FFS);
11073 0 : if (res) return res;
11074 : }
11075 0 : break;
11076 : }
11077 : default:;
11078 : }
11079 : }
11080 : break;
11081 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
11082 0 : if (call_expr_nargs (_p0) == 1)
11083 : {
11084 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11085 0 : if (integer_zerop (_p1))
11086 : {
11087 0 : {
11088 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
11089 0 : tree res = generic_simplify_297 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
11090 0 : if (res) return res;
11091 : }
11092 : }
11093 : }
11094 : break;
11095 0 : case CFN_BUILT_IN_CLZIMAX:
11096 0 : if (call_expr_nargs (_p0) == 1)
11097 : {
11098 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11099 0 : switch (TREE_CODE (_p1))
11100 : {
11101 0 : case INTEGER_CST:
11102 0 : {
11103 0 : {
11104 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11105 0 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZIMAX);
11106 0 : if (res) return res;
11107 : }
11108 0 : break;
11109 : }
11110 : default:;
11111 : }
11112 : }
11113 : break;
11114 12 : case CFN_BUILT_IN_POPCOUNTL:
11115 12 : if (call_expr_nargs (_p0) == 1)
11116 : {
11117 12 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11118 12 : if (integer_zerop (_p1))
11119 : {
11120 1 : {
11121 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
11122 1 : tree res = generic_simplify_297 (loc, type, _p0, _p1, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNTL);
11123 1 : if (res) return res;
11124 : }
11125 : }
11126 : }
11127 : break;
11128 52 : case CFN_BUILT_IN_CLZLL:
11129 52 : if (call_expr_nargs (_p0) == 1)
11130 : {
11131 52 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11132 52 : switch (TREE_CODE (_p1))
11133 : {
11134 42 : case INTEGER_CST:
11135 42 : {
11136 42 : {
11137 42 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11138 42 : tree res = generic_simplify_293 (loc, type, _p0, _p1, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZLL);
11139 42 : if (res) return res;
11140 : }
11141 18 : break;
11142 : }
11143 : default:;
11144 : }
11145 : }
11146 : break;
11147 74 : case CFN_BUILT_IN_CTZLL:
11148 74 : if (call_expr_nargs (_p0) == 1)
11149 : {
11150 74 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11151 74 : switch (TREE_CODE (_p1))
11152 : {
11153 64 : case INTEGER_CST:
11154 64 : {
11155 64 : {
11156 64 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11157 64 : tree res = generic_simplify_295 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_CTZLL);
11158 64 : if (res) return res;
11159 : }
11160 16 : break;
11161 : }
11162 : default:;
11163 : }
11164 : }
11165 : break;
11166 11 : case CFN_BUILT_IN_FFSLL:
11167 11 : if (call_expr_nargs (_p0) == 1)
11168 : {
11169 11 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11170 11 : switch (TREE_CODE (_p1))
11171 : {
11172 1 : case INTEGER_CST:
11173 1 : {
11174 1 : {
11175 1 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
11176 1 : tree res = generic_simplify_298 (loc, type, _p0, _p1, captures, NE_EXPR, CFN_BUILT_IN_FFSLL);
11177 1 : if (res) return res;
11178 : }
11179 0 : break;
11180 : }
11181 : default:;
11182 : }
11183 : }
11184 : break;
11185 : default:;
11186 : }
11187 : break;
11188 : default:;
11189 : }
11190 : return NULL_TREE;
11191 : }
11192 :
11193 : tree
11194 14844 : generic_simplify_BIT_INSERT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1, tree _p2)
11195 : {
11196 14844 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
11197 14844 : switch (TREE_CODE (_p1))
11198 : {
11199 0 : case BIT_FIELD_REF:
11200 0 : {
11201 0 : tree _q30 = TREE_OPERAND (_p1, 0);
11202 0 : tree _q31 = TREE_OPERAND (_p1, 1);
11203 0 : tree _q32 = TREE_OPERAND (_p1, 2);
11204 0 : {
11205 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32, _p2 };
11206 0 : if (VECTOR_TYPE_P (type)
11207 0 : && (VECTOR_MODE_P (TYPE_MODE (type))
11208 : || optimize_vectors_before_lowering_p ())
11209 0 : && operand_equal_p (TYPE_SIZE (TREE_TYPE (captures[0])),
11210 0 : TYPE_SIZE (TREE_TYPE (captures[2])), 0)
11211 0 : && types_match (TREE_TYPE (TREE_TYPE (captures[0])), TREE_TYPE (captures[1]))
11212 0 : && TYPE_VECTOR_SUBPARTS (type).is_constant ()
11213 0 : && multiple_p (wi::to_poly_offset (captures[4]),
11214 0 : wi::to_poly_offset (TYPE_SIZE (TREE_TYPE (type))))
11215 : )
11216 : {
11217 0 : {
11218 0 : unsigned HOST_WIDE_INT elsz
11219 0 : = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0]))));
11220 0 : poly_uint64 relt = exact_div (tree_to_poly_uint64 (captures[4]), elsz);
11221 0 : poly_uint64 ielt = exact_div (tree_to_poly_uint64 (captures[5]), elsz);
11222 0 : unsigned nunits = TYPE_VECTOR_SUBPARTS (type).to_constant ();
11223 0 : vec_perm_builder builder;
11224 0 : builder.new_vector (nunits, nunits, 1);
11225 0 : for (unsigned i = 0; i < nunits; ++i)
11226 0 : builder.quick_push (known_eq (ielt, i) ? nunits + relt : i);
11227 0 : vec_perm_indices sel (builder, 2, nunits);
11228 0 : if (!VECTOR_MODE_P (TYPE_MODE (type))
11229 0 : || can_vec_perm_const_p (TYPE_MODE (type),
11230 0 : TYPE_MODE (type), sel, false)
11231 : )
11232 : {
11233 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1970;
11234 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1970;
11235 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1970;
11236 0 : {
11237 0 : tree res_op0;
11238 0 : res_op0 = captures[0];
11239 0 : tree res_op1;
11240 0 : {
11241 0 : tree _o1[1], _r1;
11242 0 : _o1[0] = captures[2];
11243 0 : if (TREE_TYPE (_o1[0]) != type)
11244 : {
11245 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
11246 : }
11247 : else
11248 : _r1 = _o1[0];
11249 0 : res_op1 = _r1;
11250 : }
11251 0 : tree res_op2;
11252 0 : res_op2 = vec_perm_indices_to_tree (build_vector_type (ssizetype, nunits),
11253 : sel);
11254 0 : tree _r;
11255 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
11256 0 : if (TREE_SIDE_EFFECTS (captures[3]))
11257 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
11258 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1099, __FILE__, __LINE__, true);
11259 0 : return _r;
11260 : }
11261 0 : next_after_fail1970:;
11262 : }
11263 0 : }
11264 : }
11265 : }
11266 0 : break;
11267 : }
11268 : default:;
11269 : }
11270 : return NULL_TREE;
11271 : }
11272 :
11273 : tree
11274 773506 : generic_simplify_VEC_PERM_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1, tree _p2)
11275 : {
11276 773506 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
11277 773506 : switch (TREE_CODE (_p0))
11278 : {
11279 0 : case PLUS_EXPR:
11280 0 : {
11281 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11282 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11283 0 : switch (TREE_CODE (_p1))
11284 : {
11285 0 : case MINUS_EXPR:
11286 0 : {
11287 0 : tree _q50 = TREE_OPERAND (_p1, 0);
11288 0 : tree _q51 = TREE_OPERAND (_p1, 1);
11289 0 : switch (TREE_CODE (_p2))
11290 : {
11291 0 : case VECTOR_CST:
11292 0 : {
11293 0 : {
11294 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51, _p2 };
11295 0 : tree res = generic_simplify_623 (loc, type, _p0, _p1, _p2, captures, PLUS_EXPR, MINUS_EXPR);
11296 0 : if (res) return res;
11297 : }
11298 0 : break;
11299 : }
11300 : default:;
11301 : }
11302 : break;
11303 : }
11304 : default:;
11305 : }
11306 : break;
11307 : }
11308 0 : case MINUS_EXPR:
11309 0 : {
11310 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11311 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11312 0 : switch (TREE_CODE (_p1))
11313 : {
11314 0 : case PLUS_EXPR:
11315 0 : {
11316 0 : tree _q50 = TREE_OPERAND (_p1, 0);
11317 0 : tree _q51 = TREE_OPERAND (_p1, 1);
11318 0 : switch (TREE_CODE (_p2))
11319 : {
11320 0 : case VECTOR_CST:
11321 0 : {
11322 0 : {
11323 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51, _p2 };
11324 0 : tree res = generic_simplify_623 (loc, type, _p0, _p1, _p2, captures, MINUS_EXPR, PLUS_EXPR);
11325 0 : if (res) return res;
11326 : }
11327 0 : break;
11328 : }
11329 : default:;
11330 : }
11331 : break;
11332 : }
11333 : default:;
11334 : }
11335 : break;
11336 : }
11337 773506 : default:;
11338 : }
11339 773506 : switch (TREE_CODE (_p2))
11340 : {
11341 762038 : case VECTOR_CST:
11342 762038 : {
11343 762038 : {
11344 762038 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _p2 };
11345 762038 : {
11346 762038 : tree op0 = captures[0], op1 = captures[1], op2 = captures[2];
11347 762038 : machine_mode result_mode = TYPE_MODE (type);
11348 762038 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (op0));
11349 762038 : vec_perm_builder builder;
11350 762038 : if (tree_to_vec_perm_builder (&builder, op2)
11351 : )
11352 : {
11353 762026 : {
11354 762026 : poly_uint64 nelts = TYPE_VECTOR_SUBPARTS (type);
11355 762026 : poly_uint64 nelts_in = TYPE_VECTOR_SUBPARTS (TREE_TYPE (op0));
11356 762026 : bool single_arg = (op0 == op1);
11357 1328348 : vec_perm_indices sel (builder, single_arg ? 1 : 2, nelts_in);
11358 762026 : if (known_eq (nelts, nelts_in) && sel.series_p (0, 1, 0, 1)
11359 : )
11360 : {
11361 8426 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1971;
11362 8426 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1971;
11363 8426 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1971;
11364 8426 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1971;
11365 8426 : {
11366 8426 : tree res_op0;
11367 8426 : res_op0 = captures[0];
11368 8426 : tree _r;
11369 8426 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11370 8426 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1100, __FILE__, __LINE__, true);
11371 8426 : return _r;
11372 : }
11373 736134 : next_after_fail1971:;
11374 : }
11375 : else
11376 : {
11377 753600 : if (known_eq (nelts, nelts_in) && sel.series_p (0, 1, nelts_in, 1)
11378 : )
11379 : {
11380 13 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1972;
11381 13 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1972;
11382 13 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1972;
11383 13 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1972;
11384 13 : {
11385 13 : tree res_op0;
11386 13 : res_op0 = captures[1];
11387 13 : tree _r;
11388 13 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11389 13 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1101, __FILE__, __LINE__, true);
11390 13 : return _r;
11391 : }
11392 736134 : next_after_fail1972:;
11393 : }
11394 : else
11395 : {
11396 753587 : {
11397 753587 : if (!single_arg)
11398 : {
11399 558559 : if (sel.all_from_input_p (0))
11400 : op1 = op0;
11401 551536 : else if (sel.all_from_input_p (1))
11402 : {
11403 32 : op0 = op1;
11404 32 : sel.rotate_inputs (1);
11405 : }
11406 551504 : else if (known_ge (poly_uint64 (sel[0]), nelts_in))
11407 : {
11408 153 : std::swap (op0, op1);
11409 153 : sel.rotate_inputs (1);
11410 : }
11411 : }
11412 753587 : gassign *def;
11413 753587 : tree cop0 = op0, cop1 = op1;
11414 753587 : if (TREE_CODE (op0) == SSA_NAME
11415 720590 : && (def = dyn_cast <gassign *> (SSA_NAME_DEF_STMT (op0)))
11416 1439857 : && gimple_assign_rhs_code (def) == CONSTRUCTOR)
11417 6861 : cop0 = gimple_assign_rhs1 (def);
11418 753587 : if (TREE_CODE (op1) == SSA_NAME
11419 707033 : && (def = dyn_cast <gassign *> (SSA_NAME_DEF_STMT (op1)))
11420 1427529 : && gimple_assign_rhs_code (def) == CONSTRUCTOR)
11421 13483 : cop1 = gimple_assign_rhs1 (def);
11422 753587 : tree t;
11423 753587 : if ((TREE_CODE (cop0) == VECTOR_CST
11424 724080 : || TREE_CODE (cop0) == CONSTRUCTOR)
11425 37215 : && (TREE_CODE (cop1) == VECTOR_CST
11426 18418 : || TREE_CODE (cop1) == CONSTRUCTOR)
11427 778396 : && (t = fold_vec_perm (type, cop0, cop1, sel))
11428 : )
11429 : {
11430 15021 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1973;
11431 15021 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1973;
11432 15021 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1973;
11433 15021 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1973;
11434 15021 : {
11435 15021 : tree _r;
11436 15021 : _r = t;
11437 15021 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1102, __FILE__, __LINE__, true);
11438 15021 : return _r;
11439 : }
11440 736134 : next_after_fail1973:;
11441 : }
11442 : else
11443 : {
11444 738566 : {
11445 738566 : bool changed = (op0 == op1 && !single_arg);
11446 738566 : tree ins = NULL_TREE;
11447 738566 : unsigned at = 0;
11448 738566 : if (op_mode != BLKmode
11449 729561 : && known_eq (nelts, nelts_in)
11450 1467974 : && (TREE_CODE (cop0) == VECTOR_CST
11451 713999 : || TREE_CODE (cop0) == CONSTRUCTOR
11452 709558 : || TREE_CODE (cop1) == VECTOR_CST
11453 685219 : || TREE_CODE (cop1) == CONSTRUCTOR))
11454 : {
11455 51920 : bool insert_first_p = sel.series_p (1, 1, nelts + 1, 1);
11456 51920 : if (insert_first_p)
11457 : {
11458 778 : at = 0;
11459 778 : if ((ins = fold_read_from_vector (cop0, sel[0])))
11460 115 : op0 = op1;
11461 : }
11462 778 : if (!insert_first_p || (!ins && maybe_eq (nelts, 2u)))
11463 : {
11464 51606 : unsigned int encoded_nelts = sel.encoding ().encoded_nelts ();
11465 105748 : for (at = 0; at < encoded_nelts; ++at)
11466 105622 : if (maybe_ne (sel[at], at))
11467 : break;
11468 51606 : if (at < encoded_nelts
11469 51606 : && (known_eq (at + 1, nelts)
11470 50400 : || sel.series_p (at + 1, 1, at + 1, 1)))
11471 : {
11472 1787 : if (known_lt (poly_uint64 (sel[at]), nelts))
11473 0 : ins = fold_read_from_vector (cop0, sel[at]);
11474 : else
11475 1787 : ins = fold_read_from_vector (cop1, sel[at] - nelts);
11476 : }
11477 : }
11478 : }
11479 738566 : if (!ins && sel.encoding () != builder)
11480 : {
11481 1128 : tree oldop2 = op2;
11482 1128 : if (sel.ninputs () == 2
11483 1128 : || can_vec_perm_const_p (result_mode, op_mode, sel, false))
11484 689 : op2 = vec_perm_indices_to_tree (TREE_TYPE (op2), sel);
11485 : else
11486 : {
11487 439 : vec_perm_indices sel2 (builder, 2, nelts);
11488 439 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false))
11489 164 : op2 = vec_perm_indices_to_tree (TREE_TYPE (op2), sel2);
11490 : else
11491 275 : op2 = vec_perm_indices_to_tree (TREE_TYPE (op2), sel);
11492 439 : }
11493 1128 : if (!operand_equal_p (op2, oldop2, 0))
11494 964 : changed = true;
11495 : }
11496 738566 : if (ins
11497 : )
11498 : {
11499 1467 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1974;
11500 1467 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1974;
11501 1467 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1974;
11502 1467 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1974;
11503 1467 : {
11504 1467 : tree res_op0;
11505 1467 : res_op0 = op0;
11506 1467 : tree res_op1;
11507 1467 : res_op1 = ins;
11508 1467 : tree res_op2;
11509 1467 : res_op2 = bitsize_int (at * vector_element_bits (type));
11510 1467 : tree _r;
11511 1467 : _r = fold_build3_loc (loc, BIT_INSERT_EXPR, type, res_op0, res_op1, res_op2);
11512 1467 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1103, __FILE__, __LINE__, true);
11513 25892 : return _r;
11514 : }
11515 : next_after_fail1974:;
11516 : }
11517 : else
11518 : {
11519 737099 : if (changed
11520 : )
11521 : {
11522 965 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1975;
11523 965 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1975;
11524 965 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1975;
11525 965 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1975;
11526 965 : {
11527 965 : tree res_op0;
11528 965 : res_op0 = op0;
11529 965 : tree res_op1;
11530 965 : res_op1 = op1;
11531 965 : tree res_op2;
11532 965 : res_op2 = op2;
11533 965 : tree _r;
11534 965 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
11535 965 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1104, __FILE__, __LINE__, true);
11536 965 : return _r;
11537 : }
11538 : next_after_fail1975:;
11539 : }
11540 : }
11541 : }
11542 : }
11543 : }
11544 : }
11545 : }
11546 762026 : }
11547 : }
11548 25892 : }
11549 : }
11550 736146 : break;
11551 : }
11552 747614 : default:;
11553 : }
11554 747614 : switch (TREE_CODE (_p0))
11555 : {
11556 0 : case VIEW_CONVERT_EXPR:
11557 0 : {
11558 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11559 0 : switch (TREE_CODE (_q20))
11560 : {
11561 0 : case VEC_PERM_EXPR:
11562 0 : {
11563 0 : tree _q30 = TREE_OPERAND (_q20, 0);
11564 0 : tree _q31 = TREE_OPERAND (_q20, 1);
11565 0 : tree _q32 = TREE_OPERAND (_q20, 2);
11566 0 : switch (TREE_CODE (_q32))
11567 : {
11568 0 : case VECTOR_CST:
11569 0 : {
11570 0 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
11571 : {
11572 0 : switch (TREE_CODE (_p2))
11573 : {
11574 0 : case VECTOR_CST:
11575 0 : {
11576 0 : {
11577 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q32, _p2 };
11578 0 : if (TYPE_VECTOR_SUBPARTS (type).is_constant ()
11579 : )
11580 : {
11581 0 : {
11582 0 : machine_mode result_mode = TYPE_MODE (type);
11583 0 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (captures[2]));
11584 0 : int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
11585 0 : vec_perm_builder builder0;
11586 0 : vec_perm_builder builder1;
11587 0 : vec_perm_builder builder2 (nelts, nelts, 1);
11588 0 : if (tree_to_vec_perm_builder (&builder0, captures[4])
11589 0 : && tree_to_vec_perm_builder (&builder1, captures[5])
11590 0 : && TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0])))
11591 0 : == TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[1])))
11592 : )
11593 : {
11594 0 : {
11595 0 : vec_perm_indices sel0 (builder0, 2, nelts);
11596 0 : vec_perm_indices sel1 (builder1, 2, nelts);
11597 0 : for (int i = 0; i < nelts; i++)
11598 0 : builder2.quick_push (sel0[sel1[i].to_constant ()]);
11599 0 : vec_perm_indices sel2 (builder2, 2, nelts);
11600 0 : tree op0 = NULL_TREE;
11601 0 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false)
11602 0 : || (single_use (captures[0])
11603 0 : ? (!can_vec_perm_const_p (result_mode, op_mode, sel0, false)
11604 0 : || !can_vec_perm_const_p (result_mode, op_mode, sel1, false))
11605 : : !can_vec_perm_const_p (result_mode, op_mode, sel1, false)))
11606 0 : op0 = vec_perm_indices_to_tree (TREE_TYPE (captures[5]), sel2);
11607 0 : if (op0
11608 : )
11609 : {
11610 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1976;
11611 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1976;
11612 0 : {
11613 0 : tree res_op0;
11614 0 : {
11615 0 : tree _o1[3], _r1;
11616 0 : _o1[0] = captures[2];
11617 0 : _o1[1] = captures[3];
11618 0 : _o1[2] = op0;
11619 0 : _r1 = fold_build3_loc (loc, VEC_PERM_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1], _o1[2]);
11620 0 : res_op0 = _r1;
11621 : }
11622 0 : tree _r;
11623 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11624 0 : if (TREE_SIDE_EFFECTS (captures[4]))
11625 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
11626 0 : if (TREE_SIDE_EFFECTS (captures[5]))
11627 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
11628 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1105, __FILE__, __LINE__, true);
11629 0 : return _r;
11630 : }
11631 0 : next_after_fail1976:;
11632 : }
11633 0 : }
11634 : }
11635 0 : }
11636 : }
11637 : }
11638 0 : break;
11639 : }
11640 : default:;
11641 : }
11642 : }
11643 : break;
11644 : }
11645 : default:;
11646 : }
11647 : break;
11648 : }
11649 : default:;
11650 : }
11651 : break;
11652 : }
11653 0 : case VEC_PERM_EXPR:
11654 0 : {
11655 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11656 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11657 0 : tree _q22 = TREE_OPERAND (_p0, 2);
11658 0 : switch (TREE_CODE (_q22))
11659 : {
11660 0 : case VECTOR_CST:
11661 0 : {
11662 0 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
11663 : {
11664 0 : switch (TREE_CODE (_p2))
11665 : {
11666 0 : case VECTOR_CST:
11667 0 : {
11668 0 : {
11669 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _q22, _p2 };
11670 0 : if (TYPE_VECTOR_SUBPARTS (type).is_constant ()
11671 : )
11672 : {
11673 0 : {
11674 0 : machine_mode result_mode = TYPE_MODE (type);
11675 0 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (captures[2]));
11676 0 : int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
11677 0 : vec_perm_builder builder0;
11678 0 : vec_perm_builder builder1;
11679 0 : vec_perm_builder builder2 (nelts, nelts, 1);
11680 0 : if (tree_to_vec_perm_builder (&builder0, captures[4])
11681 0 : && tree_to_vec_perm_builder (&builder1, captures[5])
11682 0 : && TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0])))
11683 0 : == TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[1])))
11684 : )
11685 : {
11686 0 : {
11687 0 : vec_perm_indices sel0 (builder0, 2, nelts);
11688 0 : vec_perm_indices sel1 (builder1, 2, nelts);
11689 0 : for (int i = 0; i < nelts; i++)
11690 0 : builder2.quick_push (sel0[sel1[i].to_constant ()]);
11691 0 : vec_perm_indices sel2 (builder2, 2, nelts);
11692 0 : tree op0 = NULL_TREE;
11693 0 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false)
11694 0 : || (single_use (captures[0])
11695 0 : ? (!can_vec_perm_const_p (result_mode, op_mode, sel0, false)
11696 0 : || !can_vec_perm_const_p (result_mode, op_mode, sel1, false))
11697 : : !can_vec_perm_const_p (result_mode, op_mode, sel1, false)))
11698 0 : op0 = vec_perm_indices_to_tree (TREE_TYPE (captures[5]), sel2);
11699 0 : if (op0
11700 : )
11701 : {
11702 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1977;
11703 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1977;
11704 0 : {
11705 0 : tree res_op0;
11706 0 : {
11707 0 : tree _o1[3], _r1;
11708 0 : _o1[0] = captures[2];
11709 0 : _o1[1] = captures[3];
11710 0 : _o1[2] = op0;
11711 0 : _r1 = fold_build3_loc (loc, VEC_PERM_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1], _o1[2]);
11712 0 : res_op0 = _r1;
11713 : }
11714 0 : tree _r;
11715 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11716 0 : if (TREE_SIDE_EFFECTS (captures[4]))
11717 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
11718 0 : if (TREE_SIDE_EFFECTS (captures[5]))
11719 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
11720 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1105, __FILE__, __LINE__, true);
11721 0 : return _r;
11722 : }
11723 0 : next_after_fail1977:;
11724 : }
11725 0 : }
11726 : }
11727 0 : }
11728 : }
11729 : }
11730 0 : break;
11731 : }
11732 : default:;
11733 : }
11734 : }
11735 : break;
11736 : }
11737 : default:;
11738 : }
11739 : break;
11740 : }
11741 747614 : default:;
11742 : }
11743 747614 : if (tree_vec_same_elem_p (_p0))
11744 : {
11745 13913 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
11746 : {
11747 0 : {
11748 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p2 };
11749 0 : if (types_match (type, TREE_TYPE (captures[0]))
11750 : )
11751 : {
11752 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1978;
11753 0 : {
11754 0 : tree _r;
11755 0 : _r = captures[0];
11756 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11757 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11758 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1106, __FILE__, __LINE__, true);
11759 0 : return _r;
11760 : }
11761 0 : next_after_fail1978:;
11762 : }
11763 : else
11764 : {
11765 0 : {
11766 0 : tree elem = uniform_vector_p (captures[0]);
11767 0 : if (elem
11768 : )
11769 : {
11770 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1979;
11771 0 : {
11772 0 : tree _r;
11773 0 : _r = build_vector_from_val (type, elem);
11774 0 : if (TREE_SIDE_EFFECTS (captures[0]))
11775 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
11776 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11777 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11778 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1107, __FILE__, __LINE__, true);
11779 0 : return _r;
11780 : }
11781 0 : next_after_fail1979:;
11782 : }
11783 : }
11784 : }
11785 : }
11786 : }
11787 : }
11788 747614 : switch (TREE_CODE (_p1))
11789 : {
11790 0 : case VEC_PERM_EXPR:
11791 0 : {
11792 0 : tree _q30 = TREE_OPERAND (_p1, 0);
11793 0 : tree _q31 = TREE_OPERAND (_p1, 1);
11794 0 : tree _q32 = TREE_OPERAND (_p1, 2);
11795 0 : switch (TREE_CODE (_q32))
11796 : {
11797 0 : case VECTOR_CST:
11798 0 : {
11799 0 : switch (TREE_CODE (_p2))
11800 : {
11801 0 : case VECTOR_CST:
11802 0 : {
11803 0 : {
11804 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32, _p2 };
11805 0 : if (TYPE_VECTOR_SUBPARTS (type).is_constant ()
11806 : )
11807 : {
11808 0 : {
11809 0 : machine_mode result_mode = TYPE_MODE (type);
11810 0 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (captures[2]));
11811 0 : int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
11812 0 : vec_perm_builder builder0;
11813 0 : vec_perm_builder builder1;
11814 0 : vec_perm_builder builder2 (nelts, nelts, 2);
11815 0 : if (tree_to_vec_perm_builder (&builder0, captures[4])
11816 0 : && tree_to_vec_perm_builder (&builder1, captures[5])
11817 : )
11818 : {
11819 0 : {
11820 0 : vec_perm_indices sel0 (builder0, 2, nelts);
11821 0 : vec_perm_indices sel1 (builder1, 2, nelts);
11822 0 : bool use_1 = false, use_2 = false;
11823 0 : for (int i = 0; i < nelts; i++)
11824 : {
11825 0 : if (known_lt ((poly_uint64)sel1[i], sel1.nelts_per_input ()))
11826 0 : builder2.quick_push (sel1[i]);
11827 : else
11828 : {
11829 0 : poly_uint64 j = sel0[(sel1[i] - sel1.nelts_per_input ())
11830 0 : .to_constant ()];
11831 0 : if (known_lt (j, sel0.nelts_per_input ()))
11832 : use_1 = true;
11833 : else
11834 : {
11835 0 : use_2 = true;
11836 0 : j -= sel0.nelts_per_input ();
11837 : }
11838 0 : builder2.quick_push (j + sel1.nelts_per_input ());
11839 : }
11840 : }
11841 0 : if (use_1 ^ use_2
11842 : )
11843 : {
11844 0 : {
11845 0 : vec_perm_indices sel2 (builder2, 2, nelts);
11846 0 : tree op0 = NULL_TREE;
11847 0 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false)
11848 0 : || (single_use (captures[1])
11849 0 : ? (!can_vec_perm_const_p (result_mode, op_mode, sel0, false)
11850 0 : || !can_vec_perm_const_p (result_mode, op_mode, sel1, false))
11851 : : !can_vec_perm_const_p (result_mode, op_mode, sel1, false)))
11852 0 : op0 = vec_perm_indices_to_tree (TREE_TYPE (captures[5]), sel2);
11853 0 : if (op0
11854 : )
11855 : {
11856 0 : if (use_1
11857 : )
11858 : {
11859 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1980;
11860 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1980;
11861 0 : {
11862 0 : tree res_op0;
11863 0 : res_op0 = captures[0];
11864 0 : tree res_op1;
11865 0 : res_op1 = captures[2];
11866 0 : tree res_op2;
11867 0 : res_op2 = op0;
11868 0 : tree _r;
11869 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
11870 0 : if (TREE_SIDE_EFFECTS (captures[3]))
11871 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
11872 0 : if (TREE_SIDE_EFFECTS (captures[4]))
11873 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
11874 0 : if (TREE_SIDE_EFFECTS (captures[5]))
11875 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
11876 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1108, __FILE__, __LINE__, true);
11877 0 : return _r;
11878 : }
11879 0 : next_after_fail1980:;
11880 : }
11881 : else
11882 : {
11883 0 : if (use_2
11884 : )
11885 : {
11886 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1981;
11887 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1981;
11888 0 : {
11889 0 : tree res_op0;
11890 0 : res_op0 = captures[0];
11891 0 : tree res_op1;
11892 0 : res_op1 = captures[3];
11893 0 : tree res_op2;
11894 0 : res_op2 = op0;
11895 0 : tree _r;
11896 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
11897 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11898 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11899 0 : if (TREE_SIDE_EFFECTS (captures[4]))
11900 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
11901 0 : if (TREE_SIDE_EFFECTS (captures[5]))
11902 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
11903 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1109, __FILE__, __LINE__, true);
11904 0 : return _r;
11905 : }
11906 0 : next_after_fail1981:;
11907 : }
11908 : }
11909 : }
11910 0 : }
11911 : }
11912 0 : }
11913 : }
11914 0 : }
11915 : }
11916 : }
11917 0 : break;
11918 : }
11919 : default:;
11920 : }
11921 : break;
11922 : }
11923 : default:;
11924 : }
11925 : break;
11926 : }
11927 747614 : default:;
11928 : }
11929 747614 : switch (TREE_CODE (_p0))
11930 : {
11931 0 : case VEC_PERM_EXPR:
11932 0 : {
11933 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11934 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11935 0 : tree _q22 = TREE_OPERAND (_p0, 2);
11936 0 : switch (TREE_CODE (_q22))
11937 : {
11938 0 : case VECTOR_CST:
11939 0 : {
11940 0 : switch (TREE_CODE (_p2))
11941 : {
11942 0 : case VECTOR_CST:
11943 0 : {
11944 0 : {
11945 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _p2 };
11946 0 : if (TYPE_VECTOR_SUBPARTS (type).is_constant ()
11947 : )
11948 : {
11949 0 : {
11950 0 : machine_mode result_mode = TYPE_MODE (type);
11951 0 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (captures[1]));
11952 0 : int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
11953 0 : vec_perm_builder builder0;
11954 0 : vec_perm_builder builder1;
11955 0 : vec_perm_builder builder2 (nelts, nelts, 2);
11956 0 : if (tree_to_vec_perm_builder (&builder0, captures[3])
11957 0 : && tree_to_vec_perm_builder (&builder1, captures[5])
11958 : )
11959 : {
11960 0 : {
11961 0 : vec_perm_indices sel0 (builder0, 2, nelts);
11962 0 : vec_perm_indices sel1 (builder1, 2, nelts);
11963 0 : bool use_1 = false, use_2 = false;
11964 0 : for (int i = 0; i < nelts; i++)
11965 : {
11966 0 : if (known_ge ((poly_uint64)sel1[i], sel1.nelts_per_input ()))
11967 0 : builder2.quick_push (sel1[i]);
11968 : else
11969 : {
11970 0 : poly_uint64 j = sel0[sel1[i].to_constant ()];
11971 0 : if (known_lt (j, sel0.nelts_per_input ()))
11972 : use_1 = true;
11973 : else
11974 : {
11975 0 : use_2 = true;
11976 0 : j -= sel0.nelts_per_input ();
11977 : }
11978 0 : builder2.quick_push (j);
11979 : }
11980 : }
11981 0 : if (use_1 ^ use_2
11982 : )
11983 : {
11984 0 : {
11985 0 : vec_perm_indices sel2 (builder2, 2, nelts);
11986 0 : tree op0 = NULL_TREE;
11987 0 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false)
11988 0 : || (single_use (captures[0])
11989 0 : ? (!can_vec_perm_const_p (result_mode, op_mode, sel0, false)
11990 0 : || !can_vec_perm_const_p (result_mode, op_mode, sel1, false))
11991 : : !can_vec_perm_const_p (result_mode, op_mode, sel1, false)))
11992 0 : op0 = vec_perm_indices_to_tree (TREE_TYPE (captures[5]), sel2);
11993 0 : if (op0
11994 : )
11995 : {
11996 0 : if (use_1
11997 : )
11998 : {
11999 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1982;
12000 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1982;
12001 0 : {
12002 0 : tree res_op0;
12003 0 : res_op0 = captures[1];
12004 0 : tree res_op1;
12005 0 : res_op1 = captures[4];
12006 0 : tree res_op2;
12007 0 : res_op2 = op0;
12008 0 : tree _r;
12009 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
12010 0 : if (TREE_SIDE_EFFECTS (captures[2]))
12011 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
12012 0 : if (TREE_SIDE_EFFECTS (captures[3]))
12013 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
12014 0 : if (TREE_SIDE_EFFECTS (captures[5]))
12015 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
12016 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1110, __FILE__, __LINE__, true);
12017 0 : return _r;
12018 : }
12019 0 : next_after_fail1982:;
12020 : }
12021 : else
12022 : {
12023 0 : if (use_2
12024 : )
12025 : {
12026 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1983;
12027 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1983;
12028 0 : {
12029 0 : tree res_op0;
12030 0 : res_op0 = captures[2];
12031 0 : tree res_op1;
12032 0 : res_op1 = captures[4];
12033 0 : tree res_op2;
12034 0 : res_op2 = op0;
12035 0 : tree _r;
12036 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
12037 0 : if (TREE_SIDE_EFFECTS (captures[1]))
12038 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
12039 0 : if (TREE_SIDE_EFFECTS (captures[3]))
12040 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
12041 0 : if (TREE_SIDE_EFFECTS (captures[5]))
12042 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
12043 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1111, __FILE__, __LINE__, true);
12044 0 : return _r;
12045 : }
12046 0 : next_after_fail1983:;
12047 : }
12048 : }
12049 : }
12050 0 : }
12051 : }
12052 0 : }
12053 : }
12054 0 : }
12055 : }
12056 : }
12057 0 : break;
12058 : }
12059 0 : default:;
12060 : }
12061 0 : switch (TREE_CODE (_p1))
12062 : {
12063 0 : case VEC_PERM_EXPR:
12064 0 : {
12065 0 : tree _q60 = TREE_OPERAND (_p1, 0);
12066 0 : tree _q61 = TREE_OPERAND (_p1, 1);
12067 0 : tree _q62 = TREE_OPERAND (_p1, 2);
12068 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
12069 : {
12070 0 : switch (TREE_CODE (_q62))
12071 : {
12072 0 : case VECTOR_CST:
12073 0 : {
12074 0 : switch (TREE_CODE (_p2))
12075 : {
12076 0 : case VECTOR_CST:
12077 0 : {
12078 0 : {
12079 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60, _q61, _p2 };
12080 0 : tree res = generic_simplify_624 (loc, type, _p0, _p1, _p2, captures);
12081 0 : if (res) return res;
12082 : }
12083 0 : break;
12084 : }
12085 : default:;
12086 : }
12087 : break;
12088 : }
12089 : default:;
12090 : }
12091 : }
12092 : break;
12093 : }
12094 : default:;
12095 : }
12096 : break;
12097 : }
12098 : default:;
12099 : }
12100 : break;
12101 : }
12102 0 : case VIEW_CONVERT_EXPR:
12103 0 : {
12104 0 : tree _q20 = TREE_OPERAND (_p0, 0);
12105 0 : switch (TREE_CODE (_q20))
12106 : {
12107 0 : case VEC_PERM_EXPR:
12108 0 : {
12109 0 : tree _q30 = TREE_OPERAND (_q20, 0);
12110 0 : tree _q31 = TREE_OPERAND (_q20, 1);
12111 0 : tree _q32 = TREE_OPERAND (_q20, 2);
12112 0 : switch (TREE_CODE (_q32))
12113 : {
12114 0 : case VECTOR_CST:
12115 0 : {
12116 0 : switch (TREE_CODE (_p1))
12117 : {
12118 0 : case VIEW_CONVERT_EXPR:
12119 0 : {
12120 0 : tree _q70 = TREE_OPERAND (_p1, 0);
12121 0 : switch (TREE_CODE (_q70))
12122 : {
12123 0 : case VEC_PERM_EXPR:
12124 0 : {
12125 0 : tree _q80 = TREE_OPERAND (_q70, 0);
12126 0 : tree _q81 = TREE_OPERAND (_q70, 1);
12127 0 : tree _q82 = TREE_OPERAND (_q70, 2);
12128 0 : if ((_q82 == _q32 && ! TREE_SIDE_EFFECTS (_q82)) || (operand_equal_p (_q82, _q32, 0) && types_match (_q82, _q32)))
12129 : {
12130 0 : switch (TREE_CODE (_q82))
12131 : {
12132 0 : case VECTOR_CST:
12133 0 : {
12134 0 : switch (TREE_CODE (_p2))
12135 : {
12136 0 : case VECTOR_CST:
12137 0 : {
12138 0 : {
12139 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q30, _q31, _q32, _q80, _q81, _p2 };
12140 0 : tree res = generic_simplify_624 (loc, type, _p0, _p1, _p2, captures);
12141 0 : if (res) return res;
12142 : }
12143 0 : break;
12144 : }
12145 : default:;
12146 : }
12147 : break;
12148 : }
12149 : default:;
12150 : }
12151 : }
12152 : break;
12153 : }
12154 : default:;
12155 : }
12156 : break;
12157 : }
12158 : default:;
12159 : }
12160 : break;
12161 : }
12162 : default:;
12163 : }
12164 : break;
12165 : }
12166 : default:;
12167 : }
12168 : break;
12169 : }
12170 : default:;
12171 : }
12172 : return NULL_TREE;
12173 : }
12174 : #pragma GCC diagnostic pop
|
