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 1102532559 : tree_nop_convert (tree t, tree *res_ops)
11 : {
12 1102532559 : const tree type = TREE_TYPE (t);
13 1102532559 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 1102532559 : if (TREE_SIDE_EFFECTS (t)) return false;
15 1057944568 : switch (TREE_CODE (t))
16 : {
17 214170334 : CASE_CONVERT:
18 214170334 : {
19 214170334 : tree _p0 = TREE_OPERAND (t, 0);
20 214170334 : {
21 214170334 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
22 214170334 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
23 : )
24 : {
25 172681997 : {
26 172681997 : res_ops[0] = captures[0];
27 172681997 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 0, __FILE__, __LINE__, false);
28 172681997 : return true;
29 : }
30 : }
31 : }
32 : break;
33 : }
34 4500074 : case VIEW_CONVERT_EXPR:
35 4500074 : {
36 4500074 : tree _p0 = TREE_OPERAND (t, 0);
37 4500074 : {
38 4500074 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
39 3208993 : if (VECTOR_TYPE_P (type) && VECTOR_TYPE_P (TREE_TYPE (captures[0]))
40 3208975 : && known_eq (TYPE_VECTOR_SUBPARTS (type),
41 : TYPE_VECTOR_SUBPARTS (TREE_TYPE (captures[0])))
42 6717616 : && tree_nop_conversion_p (TREE_TYPE (type), TREE_TYPE (TREE_TYPE (captures[0])))
43 : )
44 : {
45 2217536 : {
46 2217536 : res_ops[0] = captures[0];
47 2217536 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1, __FILE__, __LINE__, false);
48 2217536 : return true;
49 : }
50 : }
51 : }
52 2282538 : break;
53 : }
54 : default:;
55 : }
56 : return false;
57 : }
58 :
59 : bool
60 87109926 : tree_with_known_nonzero_bits (tree t)
61 : {
62 87109926 : const tree type = TREE_TYPE (t);
63 87109926 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
64 87109926 : if (TREE_SIDE_EFFECTS (t)) return false;
65 82113410 : switch (TREE_CODE (t))
66 : {
67 271956 : case BIT_IOR_EXPR:
68 271956 : {
69 271956 : tree _p0 = TREE_OPERAND (t, 0);
70 271956 : tree _p1 = TREE_OPERAND (t, 1);
71 271956 : if (tree_with_known_nonzero_bits_1 (_p0))
72 : {
73 264442 : {
74 264442 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
75 264442 : {
76 264442 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 39, __FILE__, __LINE__, false);
77 264442 : return true;
78 : }
79 : }
80 : }
81 7514 : if (tree_with_known_nonzero_bits_1 (_p1))
82 : {
83 186 : {
84 186 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _p0 };
85 186 : {
86 186 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 39, __FILE__, __LINE__, false);
87 186 : return true;
88 : }
89 : }
90 : }
91 : break;
92 : }
93 81848782 : default:;
94 : }
95 81848782 : if (tree_with_known_nonzero_bits_1 (t))
96 : {
97 39271434 : {
98 39271434 : tree captures[1] ATTRIBUTE_UNUSED = { t };
99 39271434 : {
100 39271434 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 40, __FILE__, __LINE__, false);
101 39271434 : return true;
102 : }
103 : }
104 : }
105 : return false;
106 : }
107 :
108 : tree
109 15 : generic_simplify_4 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
110 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
111 : const enum tree_code ARG_UNUSED (op))
112 : {
113 15 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
114 15 : if (INTEGRAL_TYPE_P (type)
115 : )
116 : {
117 15 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail75;
118 15 : {
119 15 : tree res_op0;
120 15 : {
121 15 : tree _o1[2], _r1;
122 15 : _o1[0] = captures[1];
123 15 : _o1[1] = captures[4];
124 15 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
125 15 : res_op0 = _r1;
126 : }
127 15 : tree res_op1;
128 15 : res_op1 = captures[2];
129 15 : tree _r;
130 15 : _r = fold_build2_loc (loc, RSHIFT_EXPR, type, res_op0, res_op1);
131 15 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 52, __FILE__, __LINE__, true);
132 15 : return _r;
133 : }
134 0 : next_after_fail75:;
135 : }
136 : return NULL_TREE;
137 : }
138 :
139 : tree
140 589 : generic_simplify_12 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
141 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
142 : {
143 589 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
144 589 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail87;
145 589 : {
146 589 : if (! tree_invariant_p (captures[3])) goto next_after_fail87;
147 1 : tree res_op0;
148 1 : {
149 1 : tree _o1[2], _r1;
150 1 : _o1[0] = captures[2];
151 1 : _o1[1] = unshare_expr (captures[3]);
152 1 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
153 1 : res_op0 = _r1;
154 : }
155 1 : tree res_op1;
156 1 : {
157 1 : tree _o1[2], _r1;
158 1 : {
159 1 : tree _o2[1], _r2;
160 1 : _o2[0] = captures[4];
161 1 : _r2 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
162 1 : if (EXPR_P (_r2))
163 0 : goto next_after_fail87;
164 1 : _o1[0] = _r2;
165 : }
166 1 : _o1[1] = captures[3];
167 1 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
168 1 : if (EXPR_P (_r1))
169 0 : goto next_after_fail87;
170 1 : res_op1 = _r1;
171 : }
172 1 : tree _r;
173 1 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
174 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 60, __FILE__, __LINE__, true);
175 : return _r;
176 : }
177 : next_after_fail87:;
178 : return NULL_TREE;
179 : }
180 :
181 : tree
182 10 : generic_simplify_25 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
183 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
184 : {
185 10 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
186 10 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[0]))
187 10 : && element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
188 : )
189 : {
190 10 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail100;
191 10 : {
192 10 : tree res_op0;
193 10 : {
194 10 : tree _o1[1], _r1;
195 10 : _o1[0] = captures[0];
196 10 : if (TREE_TYPE (_o1[0]) != type)
197 : {
198 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
199 : }
200 : else
201 : _r1 = _o1[0];
202 10 : res_op0 = _r1;
203 : }
204 10 : tree res_op1;
205 10 : {
206 10 : tree _o1[1], _r1;
207 10 : _o1[0] = captures[1];
208 10 : if (TREE_TYPE (_o1[0]) != type)
209 : {
210 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
211 : }
212 : else
213 : _r1 = _o1[0];
214 10 : res_op1 = _r1;
215 : }
216 10 : tree _r;
217 10 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
218 10 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 73, __FILE__, __LINE__, true);
219 10 : return _r;
220 : }
221 0 : next_after_fail100:;
222 : }
223 : return NULL_TREE;
224 : }
225 :
226 : tree
227 0 : generic_simplify_35 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
228 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
229 : const enum tree_code ARG_UNUSED (op),
230 : const enum tree_code ARG_UNUSED (cmp),
231 : const enum tree_code ARG_UNUSED (icmp))
232 : {
233 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
234 0 : if (INTEGRAL_TYPE_P (type)
235 0 : && invert_tree_comparison (cmp, HONOR_NANS (captures[1])) == icmp
236 0 : && canonicalize_math_after_vectorization_p ()
237 : )
238 : {
239 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail112;
240 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail112;
241 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail112;
242 : {
243 : tree res_op0;
244 : res_op0 = captures[0];
245 : tree res_op1;
246 : res_op1 = captures[3];
247 : tree res_op2;
248 : res_op2 = captures[5];
249 : tree _r;
250 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
251 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 84, __FILE__, __LINE__, true);
252 : return _r;
253 : }
254 0 : next_after_fail112:;
255 : }
256 0 : return NULL_TREE;
257 : }
258 :
259 : tree
260 0 : generic_simplify_43 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
261 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
262 : const enum tree_code ARG_UNUSED (op))
263 : {
264 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
265 0 : if (INTEGRAL_TYPE_P (type)
266 0 : && tree_int_cst_sgn (captures[5]) > 0
267 0 : && (tree_nonzero_bits (captures[0]) & tree_nonzero_bits (captures[4])) == 0
268 : )
269 : {
270 0 : {
271 0 : tree t = type;
272 0 : if (!TYPE_OVERFLOW_WRAPS (t))
273 0 : t = unsigned_type_for (t);
274 0 : wide_int wone = wi::one (TYPE_PRECISION (type));
275 0 : wide_int c = wi::add (wi::to_wide (captures[3]),
276 0 : wi::lshift (wone, wi::to_wide (captures[5])));
277 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail121;
278 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail121;
279 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail121;
280 0 : {
281 0 : tree res_op0;
282 0 : {
283 0 : tree _o1[2], _r1;
284 0 : {
285 0 : tree _o2[1], _r2;
286 0 : _o2[0] = captures[2];
287 0 : if (TREE_TYPE (_o2[0]) != t)
288 : {
289 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, t, _o2[0]);
290 : }
291 : else
292 : _r2 = _o2[0];
293 0 : _o1[0] = _r2;
294 : }
295 0 : _o1[1] = wide_int_to_tree (t, c);
296 0 : _r1 = fold_build2_loc (loc, MULT_EXPR, t, _o1[0], _o1[1]);
297 0 : res_op0 = _r1;
298 : }
299 0 : tree _r;
300 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
301 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 87, __FILE__, __LINE__, true);
302 0 : return _r;
303 : }
304 0 : next_after_fail121:;
305 0 : }
306 : }
307 : return NULL_TREE;
308 : }
309 :
310 : tree
311 312 : generic_simplify_53 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
312 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
313 : const enum tree_code ARG_UNUSED (outer_op),
314 : const enum tree_code ARG_UNUSED (inner_op))
315 : {
316 312 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
317 312 : if (real_zerop (captures[2])
318 34 : && real_zerop (captures[3])
319 346 : && !HONOR_SIGN_DEPENDENT_ROUNDING (type)
320 : )
321 : {
322 10 : {
323 10 : bool inner_plus = ((inner_op == PLUS_EXPR)
324 10 : ^ REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (captures[2])));
325 10 : bool outer_plus
326 10 : = ((outer_op == PLUS_EXPR)
327 10 : ^ REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (captures[3])));
328 10 : if (outer_plus && !inner_plus
329 : )
330 : {
331 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail133;
332 2 : {
333 2 : tree res_op0;
334 2 : res_op0 = captures[1];
335 2 : tree res_op1;
336 2 : res_op1 = captures[3];
337 2 : tree _r;
338 2 : _r = fold_build2_loc (loc, outer_op, type, res_op0, res_op1);
339 2 : if (TREE_SIDE_EFFECTS (captures[2]))
340 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
341 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 101, __FILE__, __LINE__, true);
342 2 : return _r;
343 : }
344 0 : next_after_fail133:;
345 : }
346 : else
347 : {
348 8 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail134;
349 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail134;
350 8 : {
351 8 : tree _r;
352 8 : _r = captures[0];
353 8 : if (TREE_SIDE_EFFECTS (captures[3]))
354 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
355 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 102, __FILE__, __LINE__, true);
356 8 : return _r;
357 : }
358 : next_after_fail134:;
359 : }
360 : }
361 : }
362 : return NULL_TREE;
363 : }
364 :
365 : tree
366 539 : generic_simplify_67 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
367 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
368 : {
369 539 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
370 539 : if (!TYPE_SATURATING (type)
371 : )
372 : {
373 539 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
374 1078 : && !FIXED_POINT_TYPE_P (type)
375 : )
376 : {
377 539 : if (!TYPE_OVERFLOW_TRAPS (type)
378 : )
379 : {
380 539 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail156;
381 539 : {
382 539 : tree res_op0;
383 539 : res_op0 = build_all_ones_cst (TREE_TYPE (captures[0]));
384 539 : tree _r;
385 539 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
386 539 : if (TREE_SIDE_EFFECTS (captures[0]))
387 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
388 539 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 124, __FILE__, __LINE__, true);
389 539 : return _r;
390 : }
391 0 : next_after_fail156:;
392 : }
393 : }
394 : }
395 : return NULL_TREE;
396 : }
397 :
398 : tree
399 2 : generic_simplify_74 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
400 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
401 : const enum tree_code ARG_UNUSED (div),
402 : const enum tree_code ARG_UNUSED (mod))
403 : {
404 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
405 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail164;
406 2 : {
407 2 : tree _r;
408 2 : _r = captures[0];
409 2 : if (TREE_SIDE_EFFECTS (captures[1]))
410 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
411 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 132, __FILE__, __LINE__, true);
412 : return _r;
413 : }
414 0 : next_after_fail164:;
415 0 : return NULL_TREE;
416 : }
417 :
418 : tree
419 18804 : generic_simplify_77 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
420 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
421 : const enum tree_code ARG_UNUSED (op))
422 : {
423 18804 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
424 18804 : if (flag_unsafe_math_optimizations
425 : )
426 : {
427 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail168;
428 12 : {
429 12 : tree res_op0;
430 12 : {
431 12 : tree _o1[2], _r1;
432 12 : _o1[0] = captures[0];
433 12 : _o1[1] = captures[2];
434 12 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
435 12 : res_op0 = _r1;
436 : }
437 12 : tree res_op1;
438 12 : res_op1 = captures[1];
439 12 : tree _r;
440 12 : _r = fold_build2_loc (loc, RDIV_EXPR, type, res_op0, res_op1);
441 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 136, __FILE__, __LINE__, true);
442 12 : return _r;
443 : }
444 0 : next_after_fail168:;
445 : }
446 : return NULL_TREE;
447 : }
448 :
449 : tree
450 0 : generic_simplify_83 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
451 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
452 : const enum tree_code ARG_UNUSED (op))
453 : {
454 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
455 0 : if (VECTOR_FLOAT_TYPE_P (type)
456 0 : && TYPE_VECTOR_SUBPARTS (type).is_constant ()
457 : )
458 : {
459 0 : {
460 0 : tree perm_cst = captures[1];
461 0 : vec_perm_builder builder;
462 0 : bool full_perm_p = false;
463 0 : if (tree_to_vec_perm_builder (&builder, perm_cst))
464 : {
465 0 : unsigned HOST_WIDE_INT nelts;
466 0 : nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
467 0 : vec_perm_indices sel (builder, 1, nelts);
468 0 : if (sel.encoding ().encoded_full_vector_p ())
469 : {
470 0 : auto_sbitmap seen (nelts);
471 0 : bitmap_clear (seen);
472 0 : unsigned HOST_WIDE_INT count = 0, i;
473 0 : for (i = 0; i < nelts; i++)
474 : {
475 0 : if (!bitmap_set_bit (seen, sel[i].to_constant ()))
476 : break;
477 0 : count++;
478 : }
479 0 : full_perm_p = count == nelts;
480 0 : }
481 0 : }
482 0 : if (full_perm_p
483 : )
484 : {
485 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail174;
486 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail174;
487 0 : {
488 0 : tree res_op0;
489 0 : {
490 0 : tree _o1[2], _r1;
491 0 : _o1[0] = captures[0];
492 0 : _o1[1] = captures[2];
493 0 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
494 0 : captures[3] = _r1;
495 : }
496 0 : res_op0 = unshare_expr (captures[3]);
497 0 : tree res_op1;
498 0 : res_op1 = captures[3];
499 0 : tree res_op2;
500 0 : res_op2 = captures[1];
501 0 : tree _r;
502 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
503 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 142, __FILE__, __LINE__, true);
504 0 : return _r;
505 : }
506 0 : next_after_fail174:;
507 : }
508 0 : }
509 : }
510 : return NULL_TREE;
511 : }
512 :
513 : tree
514 39730 : generic_simplify_96 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
515 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
516 : {
517 39730 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
518 39730 : if (!TYPE_SATURATING (type)
519 : )
520 : {
521 39730 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
522 79460 : && !FIXED_POINT_TYPE_P (type)
523 : )
524 : {
525 0 : if (!ANY_INTEGRAL_TYPE_P (type)
526 39730 : || TYPE_OVERFLOW_WRAPS (type)
527 : )
528 : {
529 35968 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail188;
530 35968 : {
531 35968 : tree res_op0;
532 35968 : {
533 35968 : tree _o1[1], _r1;
534 35968 : _o1[0] = captures[1];
535 35968 : if (TREE_TYPE (_o1[0]) != type)
536 : {
537 192 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
538 : }
539 : else
540 : _r1 = _o1[0];
541 35968 : res_op0 = _r1;
542 : }
543 35968 : tree _r;
544 35968 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
545 35968 : if (TREE_SIDE_EFFECTS (captures[0]))
546 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
547 35968 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 155, __FILE__, __LINE__, true);
548 35968 : return _r;
549 : }
550 0 : next_after_fail188:;
551 : }
552 : else
553 : {
554 3762 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail189;
555 3762 : {
556 3762 : tree res_op0;
557 3762 : {
558 3762 : tree _o1[1], _r1;
559 3762 : _o1[0] = captures[1];
560 3762 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
561 3762 : res_op0 = _r1;
562 : }
563 3762 : tree _r;
564 3762 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
565 3762 : if (TREE_SIDE_EFFECTS (captures[0]))
566 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
567 3762 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 156, __FILE__, __LINE__, true);
568 3762 : return _r;
569 : }
570 0 : next_after_fail189:;
571 : }
572 : }
573 : }
574 : return NULL_TREE;
575 : }
576 :
577 : tree
578 36 : generic_simplify_109 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
579 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
580 : const enum tree_code ARG_UNUSED (bitop),
581 : const enum tree_code ARG_UNUSED (cmp))
582 : {
583 36 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
584 72 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
585 36 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
586 72 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == TYPE_PRECISION (TREE_TYPE (captures[2]))
587 : )
588 : {
589 36 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail206;
590 36 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail206;
591 36 : {
592 36 : tree res_op0;
593 36 : {
594 36 : tree _o1[2], _r1;
595 36 : _o1[0] = captures[0];
596 36 : {
597 36 : tree _o2[1], _r2;
598 36 : _o2[0] = captures[2];
599 36 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
600 : {
601 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
602 : }
603 : else
604 : _r2 = _o2[0];
605 36 : _o1[1] = _r2;
606 : }
607 36 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
608 36 : res_op0 = _r1;
609 : }
610 36 : tree res_op1;
611 36 : res_op1 = captures[1];
612 36 : tree _r;
613 36 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
614 36 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 173, __FILE__, __LINE__, true);
615 36 : return _r;
616 : }
617 : next_after_fail206:;
618 : }
619 : return NULL_TREE;
620 : }
621 :
622 : tree
623 0 : generic_simplify_118 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
624 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
625 : const enum tree_code ARG_UNUSED (op))
626 : {
627 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
628 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail215;
629 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail215;
630 0 : {
631 0 : tree _r;
632 0 : _r = captures[0];
633 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 181, __FILE__, __LINE__, true);
634 : return _r;
635 : }
636 : next_after_fail215:;
637 : return NULL_TREE;
638 : }
639 :
640 : tree
641 0 : generic_simplify_125 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
642 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
643 : {
644 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
645 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
646 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
647 : )
648 : {
649 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail222;
650 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail222;
651 0 : {
652 0 : tree _r;
653 0 : _r = captures[2];
654 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 183, __FILE__, __LINE__, true);
655 0 : return _r;
656 : }
657 : next_after_fail222:;
658 : }
659 : return NULL_TREE;
660 : }
661 :
662 : tree
663 0 : generic_simplify_136 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
664 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
665 : const enum tree_code ARG_UNUSED (op))
666 : {
667 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
668 0 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[3]))
669 0 : && tree_nop_conversion_p (type, TREE_TYPE (captures[6]))
670 : )
671 : {
672 0 : if (single_use (captures[4]) && single_use (captures[5])
673 : )
674 : {
675 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail234;
676 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail234;
677 0 : {
678 0 : tree res_op0;
679 0 : res_op0 = captures[0];
680 0 : tree res_op1;
681 0 : {
682 0 : tree _o1[1], _r1;
683 0 : _o1[0] = captures[6];
684 0 : if (TREE_TYPE (_o1[0]) != type)
685 : {
686 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
687 : }
688 : else
689 : _r1 = _o1[0];
690 0 : res_op1 = _r1;
691 : }
692 0 : tree _r;
693 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
694 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 192, __FILE__, __LINE__, true);
695 0 : return _r;
696 : }
697 : next_after_fail234:;
698 : }
699 : else
700 : {
701 : if (single_use (captures[0]) && single_use (captures[1])
702 : )
703 : {
704 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail235;
705 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail235;
706 : {
707 : tree res_op0;
708 : {
709 : tree _o1[1], _r1;
710 : _o1[0] = captures[3];
711 : if (TREE_TYPE (_o1[0]) != type)
712 : {
713 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
714 : }
715 : else
716 : _r1 = _o1[0];
717 : res_op0 = _r1;
718 : }
719 : tree res_op1;
720 : res_op1 = captures[4];
721 : tree _r;
722 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
723 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 193, __FILE__, __LINE__, true);
724 : return _r;
725 : }
726 : next_after_fail235:;
727 : }
728 : }
729 : }
730 : return NULL_TREE;
731 : }
732 :
733 : tree
734 0 : generic_simplify_150 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
735 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
736 : const enum tree_code ARG_UNUSED (cmp),
737 : const enum tree_code ARG_UNUSED (icmp))
738 : {
739 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
740 0 : if (INTEGRAL_TYPE_P (type)
741 0 : && invert_tree_comparison (cmp, HONOR_NANS (captures[1])) == icmp
742 0 : && canonicalize_math_after_vectorization_p ()
743 : )
744 : {
745 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail252;
746 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail252;
747 : {
748 : tree res_op0;
749 : {
750 : tree _o1[3], _r1;
751 : _o1[0] = captures[0];
752 : _o1[1] = captures[3];
753 : _o1[2] = captures[5];
754 : _r1 = fold_build3_loc (loc, COND_EXPR, TREE_TYPE (_o1[1]), _o1[0], _o1[1], _o1[2]);
755 : res_op0 = _r1;
756 : }
757 : tree res_op1;
758 : res_op1 = build_one_cst (type);
759 : tree _r;
760 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
761 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 201, __FILE__, __LINE__, true);
762 : return _r;
763 : }
764 0 : next_after_fail252:;
765 : }
766 0 : return NULL_TREE;
767 : }
768 :
769 : tree
770 0 : generic_simplify_162 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
771 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
772 : {
773 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
774 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail285;
775 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail285;
776 0 : {
777 0 : tree _r;
778 0 : _r = constant_boolean_node (true, type);
779 0 : if (TREE_SIDE_EFFECTS (captures[1]))
780 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
781 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 226, __FILE__, __LINE__, true);
782 : return _r;
783 : }
784 : next_after_fail285:;
785 : return NULL_TREE;
786 : }
787 :
788 : tree
789 417 : generic_simplify_166 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
790 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
791 : const enum tree_code ARG_UNUSED (code2),
792 : const enum tree_code ARG_UNUSED (code1))
793 : {
794 417 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
795 417 : if ((TREE_CODE (captures[2]) == INTEGER_CST
796 393 : && TREE_CODE (captures[5]) == INTEGER_CST)
797 417 : || ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
798 1 : || (VECTOR_TYPE_P (TREE_TYPE (captures[2])))
799 0 : || POINTER_TYPE_P (TREE_TYPE (captures[2])))
800 24 : && bitwise_equal_p (captures[2], captures[5]))
801 : )
802 : {
803 393 : {
804 393 : bool one_before = false;
805 393 : bool one_after = false;
806 393 : int cmp = 0;
807 393 : bool allbits = true;
808 393 : if (TREE_CODE (captures[2]) == INTEGER_CST
809 393 : && TREE_CODE (captures[5]) == INTEGER_CST)
810 : {
811 393 : allbits = TYPE_PRECISION (TREE_TYPE (captures[2])) <= TYPE_PRECISION (TREE_TYPE (captures[5]));
812 393 : auto t1 = wi::to_wide (fold_convert (TREE_TYPE (captures[5]), captures[2]));
813 393 : auto t2 = wi::to_wide (captures[5]);
814 393 : cmp = wi::cmp (t1, t2, TYPE_SIGN (TREE_TYPE (captures[5])));
815 393 : if (cmp < 0
816 393 : && t1 == t2 - 1)
817 : one_before = true;
818 393 : if (cmp > 0
819 393 : && t1 == t2 + 1)
820 : one_after = true;
821 : }
822 393 : bool val;
823 393 : switch (code2)
824 : {
825 384 : case EQ_EXPR: val = (cmp == 0); break;
826 0 : case NE_EXPR: val = (cmp != 0); break;
827 0 : case LT_EXPR: val = (cmp < 0); break;
828 9 : case GT_EXPR: val = (cmp > 0); break;
829 0 : case LE_EXPR: val = (cmp <= 0); break;
830 0 : case GE_EXPR: val = (cmp >= 0); break;
831 0 : default: gcc_unreachable ();
832 : }
833 393 : if (code1 == EQ_EXPR && val
834 : )
835 : {
836 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail296;
837 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail296;
838 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail296;
839 0 : {
840 0 : tree _r;
841 0 : _r = captures[3];
842 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 210, __FILE__, __LINE__, true);
843 0 : return _r;
844 : }
845 : next_after_fail296:;
846 : }
847 : else
848 : {
849 393 : if (code1 == NE_EXPR && val && allbits
850 : )
851 : {
852 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail297;
853 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail297;
854 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail297;
855 0 : {
856 0 : tree _r;
857 0 : _r = constant_boolean_node (true, type);
858 0 : if (TREE_SIDE_EFFECTS (captures[4]))
859 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
860 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 211, __FILE__, __LINE__, true);
861 0 : return _r;
862 : }
863 : next_after_fail297:;
864 : }
865 : else
866 : {
867 393 : if (code1 == NE_EXPR && !val && allbits
868 : )
869 : {
870 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail298;
871 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail298;
872 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail298;
873 0 : {
874 0 : tree _r;
875 0 : _r = captures[0];
876 0 : if (TREE_SIDE_EFFECTS (captures[4]))
877 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
878 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 212, __FILE__, __LINE__, true);
879 0 : return _r;
880 : }
881 : next_after_fail298:;
882 : }
883 : else
884 : {
885 393 : if (code1 == EQ_EXPR
886 393 : && code2 == GT_EXPR
887 9 : && cmp == 0
888 9 : && allbits
889 393 : && ((VECTOR_BOOLEAN_TYPE_P (type)
890 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GE_EXPR))
891 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
892 : )
893 : {
894 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail299;
895 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail299;
896 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail299;
897 0 : {
898 0 : tree res_op0;
899 0 : res_op0 = captures[4];
900 0 : tree res_op1;
901 0 : res_op1 = captures[5];
902 0 : tree _r;
903 0 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
904 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 213, __FILE__, __LINE__, true);
905 0 : return _r;
906 : }
907 : next_after_fail299:;
908 : }
909 : else
910 : {
911 393 : if (code1 == EQ_EXPR
912 393 : && code2 == LT_EXPR
913 0 : && cmp == 0
914 0 : && allbits
915 393 : && ((VECTOR_BOOLEAN_TYPE_P (type)
916 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LE_EXPR))
917 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
918 : )
919 : {
920 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail300;
921 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail300;
922 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail300;
923 0 : {
924 0 : tree res_op0;
925 0 : res_op0 = captures[4];
926 0 : tree res_op1;
927 0 : res_op1 = captures[5];
928 0 : tree _r;
929 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
930 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 214, __FILE__, __LINE__, true);
931 0 : return _r;
932 : }
933 : next_after_fail300:;
934 : }
935 : else
936 : {
937 393 : if (code1 == EQ_EXPR
938 393 : && code2 == GE_EXPR
939 : && one_before
940 0 : && allbits
941 393 : && ((VECTOR_BOOLEAN_TYPE_P (type)
942 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GE_EXPR))
943 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
944 : )
945 : {
946 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail301;
947 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail301;
948 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail301;
949 0 : {
950 0 : tree res_op0;
951 0 : res_op0 = captures[4];
952 0 : tree res_op1;
953 0 : {
954 0 : tree _o1[1], _r1;
955 0 : _o1[0] = captures[2];
956 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
957 : {
958 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
959 : }
960 : else
961 : _r1 = _o1[0];
962 0 : res_op1 = _r1;
963 : }
964 0 : tree _r;
965 0 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
966 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 215, __FILE__, __LINE__, true);
967 0 : return _r;
968 : }
969 : next_after_fail301:;
970 : }
971 : else
972 : {
973 393 : if (code1 == EQ_EXPR
974 393 : && code2 == LE_EXPR
975 : && one_after
976 0 : && allbits
977 393 : && ((VECTOR_BOOLEAN_TYPE_P (type)
978 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LE_EXPR))
979 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
980 : )
981 : {
982 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail302;
983 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail302;
984 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail302;
985 0 : {
986 0 : tree res_op0;
987 0 : res_op0 = captures[4];
988 0 : tree res_op1;
989 0 : {
990 0 : tree _o1[1], _r1;
991 0 : _o1[0] = captures[2];
992 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
993 : {
994 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
995 : }
996 : else
997 : _r1 = _o1[0];
998 0 : res_op1 = _r1;
999 : }
1000 0 : tree _r;
1001 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1002 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 216, __FILE__, __LINE__, true);
1003 0 : return _r;
1004 : }
1005 : next_after_fail302:;
1006 : }
1007 : }
1008 : }
1009 : }
1010 : }
1011 : }
1012 : }
1013 : }
1014 : }
1015 : return NULL_TREE;
1016 : }
1017 :
1018 : tree
1019 29 : generic_simplify_211 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1020 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1021 : const enum tree_code ARG_UNUSED (cmp),
1022 : const enum tree_code ARG_UNUSED (icmp))
1023 : {
1024 29 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1025 58 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1026 29 : && TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1027 13 : && type_has_mode_precision_p (TREE_TYPE (captures[0]))
1028 13 : && types_match (captures[0], captures[2])
1029 13 : && tree_fits_shwi_p (captures[1])
1030 13 : && tree_to_shwi (captures[1]) > 0
1031 42 : && tree_to_shwi (captures[1]) < TYPE_PRECISION (TREE_TYPE (captures[0]))
1032 : )
1033 : {
1034 13 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail354;
1035 13 : {
1036 13 : tree res_op0;
1037 13 : {
1038 13 : tree _o1[2], _r1;
1039 13 : _o1[0] = captures[0];
1040 13 : _o1[1] = captures[2];
1041 13 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1042 13 : res_op0 = _r1;
1043 : }
1044 13 : tree res_op1;
1045 13 : {
1046 13 : tree _o1[2], _r1;
1047 13 : _o1[0] = build_one_cst (TREE_TYPE (captures[0]));
1048 13 : _o1[1] = captures[1];
1049 13 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1050 13 : res_op1 = _r1;
1051 : }
1052 13 : tree _r;
1053 13 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
1054 13 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 268, __FILE__, __LINE__, true);
1055 13 : return _r;
1056 : }
1057 0 : next_after_fail354:;
1058 : }
1059 : return NULL_TREE;
1060 : }
1061 :
1062 : tree
1063 43 : generic_simplify_219 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1064 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1065 : const enum tree_code ARG_UNUSED (op))
1066 : {
1067 43 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1068 43 : if (!TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[2]))
1069 : )
1070 : {
1071 43 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail375;
1072 43 : {
1073 43 : tree res_op0;
1074 43 : res_op0 = captures[1];
1075 43 : tree res_op1;
1076 43 : res_op1 = captures[3];
1077 43 : tree _r;
1078 43 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1079 43 : if (TREE_SIDE_EFFECTS (captures[2]))
1080 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1081 43 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 289, __FILE__, __LINE__, true);
1082 43 : return _r;
1083 : }
1084 0 : next_after_fail375:;
1085 : }
1086 : return NULL_TREE;
1087 : }
1088 :
1089 : tree
1090 0 : generic_simplify_227 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1091 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1092 : const enum tree_code ARG_UNUSED (cmp1),
1093 : const enum tree_code ARG_UNUSED (cmp2),
1094 : const enum tree_code ARG_UNUSED (rcmp))
1095 : {
1096 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1097 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1098 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
1099 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[0]))
1100 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
1101 : )
1102 : {
1103 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail383;
1104 0 : {
1105 0 : tree res_op0;
1106 0 : res_op0 = captures[0];
1107 0 : tree res_op1;
1108 0 : res_op1 = captures[1];
1109 0 : tree _r;
1110 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
1111 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 296, __FILE__, __LINE__, true);
1112 0 : return _r;
1113 : }
1114 0 : next_after_fail383:;
1115 : }
1116 : return NULL_TREE;
1117 : }
1118 :
1119 : tree
1120 2 : generic_simplify_235 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1121 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1122 : const enum tree_code ARG_UNUSED (cmp),
1123 : const enum tree_code ARG_UNUSED (icmp))
1124 : {
1125 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1126 2 : if (tree_int_cst_sgn (captures[0]) > 0
1127 : )
1128 : {
1129 2 : {
1130 2 : int c1 = wi::clz (wi::to_wide (captures[0]));
1131 2 : int c2 = wi::clz (wi::to_wide (captures[2]));
1132 2 : if (c1 > c2
1133 : )
1134 : {
1135 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail395;
1136 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail395;
1137 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail395;
1138 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail395;
1139 0 : {
1140 0 : tree _r;
1141 0 : _r = constant_boolean_node (cmp == NE_EXPR ? false : true, type);
1142 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1143 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1144 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 308, __FILE__, __LINE__, true);
1145 0 : return _r;
1146 : }
1147 : next_after_fail395:;
1148 : }
1149 : else
1150 : {
1151 2 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail396;
1152 2 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail396;
1153 2 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail396;
1154 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail396;
1155 2 : {
1156 2 : tree res_op0;
1157 2 : res_op0 = captures[1];
1158 2 : tree res_op1;
1159 2 : res_op1 = build_int_cst (TREE_TYPE (captures[1]), c2 - c1);
1160 2 : tree _r;
1161 2 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
1162 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 309, __FILE__, __LINE__, true);
1163 2 : return _r;
1164 : }
1165 : next_after_fail396:;
1166 : }
1167 : }
1168 : }
1169 : return NULL_TREE;
1170 : }
1171 :
1172 : tree
1173 179 : generic_simplify_244 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1174 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1175 : const enum tree_code ARG_UNUSED (cmp),
1176 : const enum tree_code ARG_UNUSED (icmp),
1177 : const enum tree_code ARG_UNUSED (ncmp))
1178 : {
1179 179 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1180 179 : if (types_match (type, TREE_TYPE (captures[0]))
1181 : )
1182 : {
1183 125 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail412;
1184 125 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail412;
1185 125 : {
1186 125 : tree res_op0;
1187 125 : res_op0 = captures[1];
1188 125 : tree res_op1;
1189 125 : res_op1 = captures[2];
1190 125 : tree _r;
1191 125 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1192 125 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 325, __FILE__, __LINE__, true);
1193 125 : return _r;
1194 : }
1195 : next_after_fail412:;
1196 : }
1197 : return NULL_TREE;
1198 : }
1199 :
1200 : tree
1201 45029480 : generic_simplify_251 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1202 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1203 : const enum tree_code ARG_UNUSED (cmp))
1204 : {
1205 45029480 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1206 45029480 : {
1207 45029480 : bool wascmp;
1208 45029480 : if (types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
1209 45029480 : && bitwise_inverted_equal_p (captures[0], captures[1], wascmp)
1210 : )
1211 : {
1212 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail425;
1213 5 : {
1214 5 : tree _r;
1215 5 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1216 5 : if (TREE_SIDE_EFFECTS (captures[0]))
1217 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1218 5 : if (TREE_SIDE_EFFECTS (captures[1]))
1219 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1220 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 337, __FILE__, __LINE__, true);
1221 5 : return _r;
1222 : }
1223 0 : next_after_fail425:;
1224 : }
1225 : }
1226 45029475 : return NULL_TREE;
1227 : }
1228 :
1229 : tree
1230 8847 : generic_simplify_256 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1231 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1232 : const enum tree_code ARG_UNUSED (op),
1233 : const enum tree_code ARG_UNUSED (cmp))
1234 : {
1235 8847 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1236 8847 : if (flag_unsafe_math_optimizations
1237 : )
1238 : {
1239 5 : {
1240 8 : tree tem = const_binop (op == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR,
1241 5 : TREE_TYPE (captures[1]), captures[2], captures[1]);
1242 5 : if (tem && !TREE_OVERFLOW (tem)
1243 : )
1244 : {
1245 4 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail444;
1246 4 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail444;
1247 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail444;
1248 4 : {
1249 4 : tree res_op0;
1250 4 : res_op0 = captures[0];
1251 4 : tree res_op1;
1252 4 : res_op1 = tem;
1253 4 : tree _r;
1254 4 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1255 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 355, __FILE__, __LINE__, true);
1256 4 : return _r;
1257 : }
1258 : next_after_fail444:;
1259 : }
1260 : }
1261 : }
1262 : return NULL_TREE;
1263 : }
1264 :
1265 : tree
1266 69 : generic_simplify_262 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1267 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1268 : const enum tree_code ARG_UNUSED (cmp))
1269 : {
1270 69 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1271 69 : if (!integer_zerop (captures[1])
1272 : )
1273 : {
1274 69 : if (wi::to_wide (captures[2]) == 0
1275 : )
1276 : {
1277 22 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail475;
1278 22 : {
1279 22 : tree res_op0;
1280 22 : res_op0 = captures[0];
1281 22 : tree res_op1;
1282 22 : res_op1 = captures[2];
1283 22 : tree _r;
1284 22 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1285 22 : if (TREE_SIDE_EFFECTS (captures[1]))
1286 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1287 22 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 386, __FILE__, __LINE__, true);
1288 22 : return _r;
1289 : }
1290 0 : next_after_fail475:;
1291 : }
1292 : else
1293 : {
1294 47 : if (TREE_CODE (captures[1]) == INTEGER_CST
1295 : )
1296 : {
1297 47 : {
1298 47 : wi::overflow_type ovf;
1299 47 : wide_int prod = wi::mul (wi::to_wide (captures[2]), wi::to_wide (captures[1]),
1300 94 : TYPE_SIGN (TREE_TYPE (captures[1])), &ovf);
1301 47 : if (ovf
1302 : )
1303 : {
1304 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail476;
1305 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail476;
1306 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail476;
1307 0 : {
1308 0 : tree _r;
1309 0 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1310 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1311 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1312 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 387, __FILE__, __LINE__, true);
1313 0 : return _r;
1314 : }
1315 0 : next_after_fail476:;
1316 : }
1317 : else
1318 : {
1319 47 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail477;
1320 47 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail477;
1321 47 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail477;
1322 47 : {
1323 47 : tree res_op0;
1324 47 : res_op0 = captures[0];
1325 47 : tree res_op1;
1326 47 : res_op1 = wide_int_to_tree (TREE_TYPE (captures[0]), prod);
1327 47 : tree _r;
1328 47 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1329 47 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 388, __FILE__, __LINE__, true);
1330 47 : return _r;
1331 : }
1332 0 : next_after_fail477:;
1333 : }
1334 47 : }
1335 : }
1336 : }
1337 : }
1338 : return NULL_TREE;
1339 : }
1340 :
1341 : tree
1342 25296 : generic_simplify_269 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1343 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1344 : const enum tree_code ARG_UNUSED (cmp))
1345 : {
1346 25296 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1347 25296 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail499;
1348 25296 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail499;
1349 25296 : {
1350 25296 : tree res_op0;
1351 25296 : res_op0 = captures[0];
1352 25296 : tree res_op1;
1353 25296 : res_op1 = captures[1];
1354 25296 : tree _r;
1355 25296 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1356 25296 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 403, __FILE__, __LINE__, true);
1357 : return _r;
1358 : }
1359 : next_after_fail499:;
1360 : return NULL_TREE;
1361 : }
1362 :
1363 : tree
1364 145541 : generic_simplify_271 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1365 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1366 : const enum tree_code ARG_UNUSED (cmp))
1367 : {
1368 145541 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1369 145541 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail501;
1370 145541 : {
1371 145541 : tree res_op0;
1372 145541 : {
1373 145541 : tree _o1[2], _r1;
1374 145541 : _o1[0] = captures[0];
1375 145541 : {
1376 145541 : tree _o2[1], _r2;
1377 145541 : _o2[0] = captures[1];
1378 145541 : _r2 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
1379 145541 : if (EXPR_P (_r2))
1380 145512 : goto next_after_fail501;
1381 29 : _o1[1] = _r2;
1382 : }
1383 29 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1384 29 : res_op0 = _r1;
1385 : }
1386 29 : tree res_op1;
1387 29 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
1388 29 : tree _r;
1389 29 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1390 29 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 405, __FILE__, __LINE__, true);
1391 : return _r;
1392 : }
1393 : next_after_fail501:;
1394 : return NULL_TREE;
1395 : }
1396 :
1397 : tree
1398 29129137 : generic_simplify_275 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1399 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1400 : const enum tree_code ARG_UNUSED (cmp))
1401 : {
1402 29129137 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1403 29129137 : if (tree_expr_nonzero_p (captures[0])
1404 : )
1405 : {
1406 1286829 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail505;
1407 1286829 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail505;
1408 1286829 : {
1409 1286829 : tree _r;
1410 1286829 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1411 1286829 : if (TREE_SIDE_EFFECTS (captures[0]))
1412 7786 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1413 1286829 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 409, __FILE__, __LINE__, true);
1414 1286829 : return _r;
1415 : }
1416 : next_after_fail505:;
1417 : }
1418 : return NULL_TREE;
1419 : }
1420 :
1421 : tree
1422 81 : generic_simplify_280 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1423 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1424 : const enum tree_code ARG_UNUSED (sgncmp),
1425 : const enum tree_code ARG_UNUSED (cmp),
1426 : const enum tree_code ARG_UNUSED (ncmp))
1427 : {
1428 81 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1429 162 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1430 81 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1431 162 : && types_match (captures[0], captures[2])
1432 : )
1433 : {
1434 81 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail510;
1435 81 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail510;
1436 81 : {
1437 81 : tree res_op0;
1438 81 : {
1439 81 : tree _o1[2], _r1;
1440 81 : _o1[0] = captures[0];
1441 81 : _o1[1] = captures[2];
1442 81 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1443 81 : res_op0 = _r1;
1444 : }
1445 81 : tree res_op1;
1446 81 : res_op1 = captures[1];
1447 81 : tree _r;
1448 81 : _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
1449 81 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 413, __FILE__, __LINE__, true);
1450 81 : return _r;
1451 : }
1452 : next_after_fail510:;
1453 : }
1454 : return NULL_TREE;
1455 : }
1456 :
1457 : tree
1458 52262800 : generic_simplify_286 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1459 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1460 : const enum tree_code ARG_UNUSED (neeq))
1461 : {
1462 52262800 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1463 93185056 : if (POINTER_TYPE_P (TREE_TYPE (captures[0]))
1464 52273166 : && ptrs_compare_unequal (captures[0], captures[1])
1465 : )
1466 : {
1467 12773 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail530;
1468 12773 : {
1469 12773 : tree _r;
1470 12773 : _r = constant_boolean_node (neeq != EQ_EXPR, type);
1471 12773 : if (TREE_SIDE_EFFECTS (captures[0]))
1472 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1473 12773 : if (TREE_SIDE_EFFECTS (captures[1]))
1474 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1475 12773 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 424, __FILE__, __LINE__, true);
1476 12773 : return _r;
1477 : }
1478 0 : next_after_fail530:;
1479 : }
1480 : return NULL_TREE;
1481 : }
1482 :
1483 : tree
1484 1049460 : generic_simplify_290 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1485 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1486 : const enum tree_code ARG_UNUSED (op),
1487 : const enum tree_code ARG_UNUSED (rop),
1488 : const enum tree_code ARG_UNUSED (cmp))
1489 : {
1490 1049460 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1491 2098920 : if (!TREE_OVERFLOW (captures[2]) && !TREE_OVERFLOW (captures[3])
1492 1049460 : && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[1]))
1493 1049147 : && !TYPE_OVERFLOW_TRAPS (TREE_TYPE (captures[1]))
1494 2098463 : && !TYPE_SATURATING (TREE_TYPE (captures[1]))
1495 : )
1496 : {
1497 1049003 : {
1498 1049003 : tree res = int_const_binop (rop, captures[3], captures[2]);
1499 1049003 : if (TREE_OVERFLOW (res)
1500 1049003 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
1501 : )
1502 : {
1503 7583 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail538;
1504 7583 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail538;
1505 7583 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail538;
1506 7583 : {
1507 7583 : tree _r;
1508 7583 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1509 7583 : if (TREE_SIDE_EFFECTS (captures[1]))
1510 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1511 7583 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 432, __FILE__, __LINE__, true);
1512 7583 : return _r;
1513 : }
1514 : next_after_fail538:;
1515 : }
1516 : else
1517 : {
1518 1041420 : if (single_use (captures[0]) || wi::to_wide (res) == 0
1519 : )
1520 : {
1521 1041420 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail539;
1522 1041420 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail539;
1523 1041420 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail539;
1524 1041420 : {
1525 1041420 : tree res_op0;
1526 1041420 : res_op0 = captures[1];
1527 1041420 : tree res_op1;
1528 1041420 : res_op1 = TREE_OVERFLOW (res)
1529 1041420 : ? drop_tree_overflow (res) : res;
1530 1041420 : tree _r;
1531 1041420 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1532 1041420 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 433, __FILE__, __LINE__, true);
1533 1041420 : return _r;
1534 : }
1535 : next_after_fail539:;
1536 : }
1537 : }
1538 : }
1539 : }
1540 : return NULL_TREE;
1541 : }
1542 :
1543 : tree
1544 0 : generic_simplify_293 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1545 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1546 : const enum tree_code ARG_UNUSED (op),
1547 : const enum tree_code ARG_UNUSED (cmp))
1548 : {
1549 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1550 0 : if (integer_zerop (captures[3]) && single_use (captures[0])
1551 : )
1552 : {
1553 0 : {
1554 0 : tree type0 = TREE_TYPE (captures[1]);
1555 0 : tree stype = signed_type_for (TREE_TYPE (captures[1]));
1556 0 : if (integer_zerop (captures[2]))
1557 : stype = NULL_TREE;
1558 0 : if (stype
1559 : )
1560 : {
1561 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail551;
1562 0 : {
1563 0 : tree res_op0;
1564 0 : {
1565 0 : tree _o1[1], _r1;
1566 0 : _o1[0] = captures[1];
1567 0 : if (TREE_TYPE (_o1[0]) != stype)
1568 : {
1569 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
1570 : }
1571 : else
1572 : _r1 = _o1[0];
1573 0 : res_op0 = _r1;
1574 : }
1575 0 : tree res_op1;
1576 0 : res_op1 = build_zero_cst (stype);
1577 0 : tree _r;
1578 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1579 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1580 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1581 0 : if (TREE_SIDE_EFFECTS (captures[3]))
1582 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
1583 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 445, __FILE__, __LINE__, true);
1584 0 : return _r;
1585 : }
1586 0 : next_after_fail551:;
1587 : }
1588 : }
1589 : }
1590 : else
1591 : {
1592 0 : {
1593 0 : bool ok = true;
1594 0 : tree type0 = TREE_TYPE (captures[1]);
1595 0 : if (wi::to_widest (captures[2]) == TYPE_PRECISION (type0) - 1)
1596 : ok = false;
1597 0 : if (ok && wi::to_wide (captures[3]) == (TYPE_PRECISION (type0) - 1)
1598 : )
1599 : {
1600 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail552;
1601 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail552;
1602 0 : {
1603 0 : tree res_op0;
1604 0 : res_op0 = captures[1];
1605 0 : tree res_op1;
1606 0 : res_op1 = build_one_cst (type0);
1607 0 : tree _r;
1608 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1609 0 : if (TREE_SIDE_EFFECTS (captures[3]))
1610 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
1611 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 446, __FILE__, __LINE__, true);
1612 0 : return _r;
1613 : }
1614 : next_after_fail552:;
1615 : }
1616 : }
1617 : }
1618 : return NULL_TREE;
1619 : }
1620 :
1621 : tree
1622 0 : generic_simplify_302 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1623 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1624 : const combined_fn ARG_UNUSED (COPYSIGN_ALL))
1625 : {
1626 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1627 0 : if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (captures[0]))
1628 : )
1629 : {
1630 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail566;
1631 0 : {
1632 0 : tree res_op0;
1633 0 : {
1634 0 : tree _o1[1], _r1;
1635 0 : _o1[0] = captures[0];
1636 0 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
1637 0 : res_op0 = _r1;
1638 : }
1639 0 : tree res_op1;
1640 0 : res_op1 = captures[1];
1641 0 : tree _r;
1642 0 : _r = maybe_build_call_expr_loc (loc, COPYSIGN_ALL, type, 2, res_op0, res_op1);
1643 0 : if (!_r)
1644 0 : goto next_after_fail566;
1645 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 460, __FILE__, __LINE__, true);
1646 0 : return _r;
1647 : }
1648 : next_after_fail566:;
1649 : }
1650 : return NULL_TREE;
1651 : }
1652 :
1653 : tree
1654 23 : generic_simplify_309 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1655 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1656 : const enum tree_code ARG_UNUSED (div))
1657 : {
1658 23 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1659 30 : if ((TYPE_UNSIGNED (type) || tree_expr_nonnegative_p (captures[0]))
1660 16 : && (!VECTOR_TYPE_P (type)
1661 0 : || target_supports_op_p (type, RSHIFT_EXPR, optab_vector)
1662 0 : || target_supports_op_p (type, RSHIFT_EXPR, optab_scalar))
1663 39 : && (useless_type_conversion_p (type, TREE_TYPE (captures[2]))
1664 7 : || (element_precision (type) >= element_precision (TREE_TYPE (captures[2]))
1665 7 : && (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
1666 14 : || (element_precision (type)
1667 7 : == element_precision (TREE_TYPE (captures[2])))
1668 7 : || (INTEGRAL_TYPE_P (type)
1669 14 : && (tree_nonzero_bits (captures[0])
1670 44 : & wi::mask (element_precision (TREE_TYPE (captures[2])) - 1,
1671 : true,
1672 37 : element_precision (type))) == 0))))
1673 : )
1674 : {
1675 9 : if (!VECTOR_TYPE_P (type)
1676 9 : && useless_type_conversion_p (TREE_TYPE (captures[1]), TREE_TYPE (captures[2]))
1677 18 : && element_precision (TREE_TYPE (captures[1])) < element_precision (type)
1678 : )
1679 : {
1680 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail574;
1681 0 : {
1682 0 : tree res_op0;
1683 0 : {
1684 0 : tree _o1[2], _r1;
1685 0 : _o1[0] = captures[1];
1686 0 : _o1[1] = captures[3];
1687 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1688 0 : res_op0 = _r1;
1689 : }
1690 0 : tree _r;
1691 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1692 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1693 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1694 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 466, __FILE__, __LINE__, true);
1695 0 : return _r;
1696 : }
1697 0 : next_after_fail574:;
1698 : }
1699 : else
1700 : {
1701 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail575;
1702 9 : {
1703 9 : tree res_op0;
1704 9 : res_op0 = captures[0];
1705 9 : tree res_op1;
1706 9 : res_op1 = captures[3];
1707 9 : tree _r;
1708 9 : _r = fold_build2_loc (loc, RSHIFT_EXPR, type, res_op0, res_op1);
1709 9 : if (TREE_SIDE_EFFECTS (captures[2]))
1710 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1711 9 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 467, __FILE__, __LINE__, true);
1712 9 : return _r;
1713 : }
1714 0 : next_after_fail575:;
1715 : }
1716 : }
1717 : return NULL_TREE;
1718 : }
1719 :
1720 : tree
1721 7188 : generic_simplify_327 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1722 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1723 : const enum tree_code ARG_UNUSED (mod))
1724 : {
1725 7188 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1726 0 : if (ANY_INTEGRAL_TYPE_P (type)
1727 7188 : && TYPE_OVERFLOW_UNDEFINED (type)
1728 14376 : && wi::multiple_of_p (wi::to_wide (captures[1]), wi::to_wide (captures[2]),
1729 195 : TYPE_SIGN (type))
1730 : )
1731 : {
1732 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail594;
1733 0 : {
1734 0 : tree _r;
1735 0 : _r = build_zero_cst (type);
1736 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1737 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1738 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1739 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1740 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1741 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1742 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 486, __FILE__, __LINE__, true);
1743 0 : return _r;
1744 : }
1745 0 : next_after_fail594:;
1746 : }
1747 : return NULL_TREE;
1748 : }
1749 :
1750 : tree
1751 24 : generic_simplify_339 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1752 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1753 : const combined_fn ARG_UNUSED (POW))
1754 : {
1755 24 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1756 24 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1757 : )
1758 : {
1759 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail608;
1760 6 : {
1761 6 : tree res_op0;
1762 6 : res_op0 = captures[0];
1763 6 : tree res_op1;
1764 6 : {
1765 6 : tree _o1[2], _r1;
1766 6 : _o1[0] = captures[2];
1767 6 : {
1768 6 : tree _o2[1], _r2;
1769 6 : _o2[0] = captures[3];
1770 6 : _r2 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
1771 6 : _o1[1] = _r2;
1772 : }
1773 6 : _r1 = maybe_build_call_expr_loc (loc, POW, TREE_TYPE (_o1[0]), 2, _o1[0], _o1[1]);
1774 6 : if (!_r1)
1775 0 : goto next_after_fail608;
1776 6 : res_op1 = _r1;
1777 : }
1778 6 : tree _r;
1779 6 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
1780 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 500, __FILE__, __LINE__, true);
1781 6 : return _r;
1782 : }
1783 : next_after_fail608:;
1784 : }
1785 : return NULL_TREE;
1786 : }
1787 :
1788 : tree
1789 0 : generic_simplify_348 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1790 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1791 : const enum tree_code ARG_UNUSED (cmp))
1792 : {
1793 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1794 0 : if (INTEGRAL_TYPE_P (type)
1795 : )
1796 : {
1797 0 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail623;
1798 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail623;
1799 0 : {
1800 0 : tree _r;
1801 0 : _r = captures[2];
1802 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1803 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1804 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 515, __FILE__, __LINE__, true);
1805 0 : return _r;
1806 : }
1807 : next_after_fail623:;
1808 : }
1809 : return NULL_TREE;
1810 : }
1811 :
1812 : tree
1813 0 : generic_simplify_351 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1814 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1815 : const enum tree_code ARG_UNUSED (op))
1816 : {
1817 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1818 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail626;
1819 0 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail626;
1820 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail626;
1821 0 : {
1822 0 : tree _r;
1823 0 : _r = captures[2];
1824 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 518, __FILE__, __LINE__, true);
1825 : return _r;
1826 : }
1827 : next_after_fail626:;
1828 : return NULL_TREE;
1829 : }
1830 :
1831 : tree
1832 0 : generic_simplify_355 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1833 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1834 : const enum tree_code ARG_UNUSED (op))
1835 : {
1836 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1837 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail630;
1838 0 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail630;
1839 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail630;
1840 0 : {
1841 0 : tree _r;
1842 0 : _r = captures[2];
1843 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 522, __FILE__, __LINE__, true);
1844 : return _r;
1845 : }
1846 : next_after_fail630:;
1847 : return NULL_TREE;
1848 : }
1849 :
1850 : tree
1851 0 : generic_simplify_362 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1852 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures))
1853 : {
1854 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1855 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail637;
1856 0 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail637;
1857 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail637;
1858 0 : {
1859 0 : tree _r;
1860 0 : _r = captures[2];
1861 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 529, __FILE__, __LINE__, true);
1862 : return _r;
1863 : }
1864 : next_after_fail637:;
1865 : return NULL_TREE;
1866 : }
1867 :
1868 : tree
1869 3 : generic_simplify_369 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1870 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1871 : const combined_fn ARG_UNUSED (func))
1872 : {
1873 3 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1874 3 : if (wi::to_widest (captures[4]) == TYPE_PRECISION (TREE_TYPE (captures[3])) - 1
1875 : )
1876 : {
1877 3 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail645;
1878 3 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail645;
1879 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail645;
1880 3 : {
1881 3 : tree _r;
1882 3 : _r = captures[2];
1883 3 : if (TREE_SIDE_EFFECTS (captures[1]))
1884 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1885 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 536, __FILE__, __LINE__, true);
1886 3 : return _r;
1887 : }
1888 : next_after_fail645:;
1889 : }
1890 : return NULL_TREE;
1891 : }
1892 :
1893 : tree
1894 161404 : generic_simplify_377 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1895 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1896 : const enum tree_code ARG_UNUSED (op))
1897 : {
1898 161404 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1899 322808 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1900 322808 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
1901 : )
1902 : {
1903 67722 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail657;
1904 67722 : {
1905 67722 : tree res_op0;
1906 67722 : res_op0 = captures[0];
1907 67722 : tree res_op1;
1908 67722 : res_op1 = captures[2];
1909 67722 : tree _r;
1910 67722 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1911 67722 : if (TREE_SIDE_EFFECTS (captures[1]))
1912 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1913 67722 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 547, __FILE__, __LINE__, true);
1914 67722 : return _r;
1915 : }
1916 0 : next_after_fail657:;
1917 : }
1918 : return NULL_TREE;
1919 : }
1920 :
1921 : tree
1922 3936 : generic_simplify_382 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1923 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1924 : const enum tree_code ARG_UNUSED (cmp),
1925 : const enum tree_code ARG_UNUSED (bitop))
1926 : {
1927 3936 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1928 3936 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1929 : )
1930 : {
1931 3936 : if (bitop == BIT_AND_EXPR || tree_expr_nonnegative_p (captures[1])
1932 : )
1933 : {
1934 3936 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail662;
1935 3936 : {
1936 3936 : tree _r;
1937 3936 : _r = constant_boolean_node (cmp == GE_EXPR || cmp == LE_EXPR, type);
1938 3936 : if (TREE_SIDE_EFFECTS (captures[0]))
1939 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1940 3936 : if (TREE_SIDE_EFFECTS (captures[1]))
1941 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1942 3936 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 552, __FILE__, __LINE__, true);
1943 3936 : return _r;
1944 : }
1945 0 : next_after_fail662:;
1946 : }
1947 : else
1948 : {
1949 0 : if (TREE_CODE (captures[1]) == INTEGER_CST && wi::neg_p (wi::to_wide (captures[1]))
1950 : )
1951 : {
1952 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail663;
1953 0 : {
1954 0 : tree _r;
1955 0 : _r = constant_boolean_node (cmp == LT_EXPR, type);
1956 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1957 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1958 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1959 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1960 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 553, __FILE__, __LINE__, true);
1961 0 : return _r;
1962 : }
1963 0 : next_after_fail663:;
1964 : }
1965 : }
1966 : }
1967 : return NULL_TREE;
1968 : }
1969 :
1970 : tree
1971 2 : generic_simplify_396 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1972 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1973 : const enum tree_code ARG_UNUSED (cmp))
1974 : {
1975 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1976 4 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1977 4 : && TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1978 : )
1979 : {
1980 2 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail709;
1981 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail709;
1982 2 : {
1983 2 : tree res_op0;
1984 2 : res_op0 = captures[1];
1985 2 : tree res_op1;
1986 2 : res_op1 = captures[0];
1987 2 : tree _r;
1988 2 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1989 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 582, __FILE__, __LINE__, true);
1990 2 : return _r;
1991 : }
1992 : next_after_fail709:;
1993 : }
1994 : return NULL_TREE;
1995 : }
1996 :
1997 : tree
1998 2462187 : generic_simplify_401 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1999 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2000 : const enum tree_code ARG_UNUSED (op),
2001 : const enum tree_code ARG_UNUSED (rop),
2002 : const enum tree_code ARG_UNUSED (cmp),
2003 : const enum tree_code ARG_UNUSED (rcmp))
2004 : {
2005 2462187 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2006 4924360 : if (!TREE_OVERFLOW (captures[2]) && !TREE_OVERFLOW (captures[3])
2007 4924348 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
2008 : )
2009 : {
2010 878632 : {
2011 878632 : tree res = int_const_binop (rop, captures[3], captures[2]);
2012 878632 : if (TREE_OVERFLOW (res)
2013 : )
2014 : {
2015 12964 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail715;
2016 12964 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail715;
2017 12964 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail715;
2018 12964 : {
2019 12964 : tree _r;
2020 12964 : bool less = cmp == LE_EXPR || cmp == LT_EXPR;
2021 12964 : bool ovf_high = wi::lt_p (wi::to_wide (captures[2]), 0,
2022 12964 : TYPE_SIGN (TREE_TYPE (captures[2])))
2023 12964 : != (op == MINUS_EXPR); _r =
2024 12964 : constant_boolean_node (less == ovf_high, type);
2025 12964 : if (TREE_SIDE_EFFECTS (captures[1]))
2026 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2027 12964 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 588, __FILE__, __LINE__, true);
2028 12964 : return _r;
2029 : }
2030 : next_after_fail715:;
2031 : }
2032 : else
2033 : {
2034 865668 : if (single_use (captures[0])
2035 : )
2036 : {
2037 865668 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail716;
2038 865668 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail716;
2039 865668 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail716;
2040 865668 : {
2041 865668 : tree res_op0;
2042 865668 : res_op0 = captures[1];
2043 865668 : tree res_op1;
2044 865668 : res_op1 = res;
2045 865668 : tree _r;
2046 865668 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2047 865668 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 589, __FILE__, __LINE__, true);
2048 865668 : return _r;
2049 : }
2050 : next_after_fail716:;
2051 : }
2052 : }
2053 : }
2054 : }
2055 : else
2056 : {
2057 1583555 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))
2058 : )
2059 : {
2060 1583432 : {
2061 1583432 : wide_int max = wi::max_value (TREE_TYPE (captures[1]));
2062 1583432 : wide_int min = wi::min_value (TREE_TYPE (captures[1]));
2063 1583432 : wide_int c2 = rop == PLUS_EXPR
2064 1583432 : ? wi::add (wi::to_wide (captures[3]), wi::to_wide (captures[2]))
2065 1583432 : : wi::sub (wi::to_wide (captures[3]), wi::to_wide (captures[2]));
2066 1511739 : if (((cmp == LE_EXPR || cmp == GT_EXPR) && wi::eq_p (c2, max))
2067 3080227 : || ((cmp == LT_EXPR || cmp == GE_EXPR) && wi::eq_p (c2, min))
2068 : )
2069 : {
2070 15102 : {
2071 15102 : wide_int c1 = rop == PLUS_EXPR
2072 15102 : ? wi::add (wi::bit_not (c2), wi::to_wide (captures[2]))
2073 30204 : : wi::sub (wi::bit_not (c2), wi::to_wide (captures[2]));
2074 15102 : tree c1_cst = wide_int_to_tree (TREE_TYPE (captures[1]), c1);
2075 15102 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail717;
2076 15102 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail717;
2077 15102 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail717;
2078 15102 : {
2079 15102 : tree res_op0;
2080 15102 : res_op0 = captures[1];
2081 15102 : tree res_op1;
2082 15102 : res_op1 = c1_cst;
2083 15102 : tree _r;
2084 15102 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
2085 15102 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 590, __FILE__, __LINE__, true);
2086 15102 : return _r;
2087 : }
2088 0 : next_after_fail717:;
2089 15102 : }
2090 : }
2091 1583434 : }
2092 : }
2093 : }
2094 : return NULL_TREE;
2095 : }
2096 :
2097 : tree
2098 2546 : generic_simplify_418 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2099 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2100 : const enum tree_code ARG_UNUSED (shiftrotate))
2101 : {
2102 2546 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2103 2546 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail742;
2104 2546 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail742;
2105 2546 : {
2106 2546 : tree res_op0;
2107 2546 : res_op0 = captures[0];
2108 2546 : tree _r;
2109 2546 : _r = non_lvalue_loc (loc, res_op0);
2110 2546 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 611, __FILE__, __LINE__, true);
2111 : return _r;
2112 : }
2113 : next_after_fail742:;
2114 : return NULL_TREE;
2115 : }
2116 :
2117 : tree
2118 86 : generic_simplify_422 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2119 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2120 : const enum tree_code ARG_UNUSED (op))
2121 : {
2122 86 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2123 86 : {
2124 86 : unsigned int prec = element_precision (type);
2125 86 : if (wi::ge_p (wi::to_wide (captures[1]), 0, TYPE_SIGN (TREE_TYPE (captures[1])))
2126 86 : && wi::lt_p (wi::to_wide (captures[1]), prec, TYPE_SIGN (TREE_TYPE (captures[1])))
2127 86 : && wi::ge_p (wi::to_wide (captures[2]), 0, TYPE_SIGN (TREE_TYPE (captures[2])))
2128 172 : && wi::lt_p (wi::to_wide (captures[2]), prec, TYPE_SIGN (TREE_TYPE (captures[2])))
2129 : )
2130 : {
2131 86 : {
2132 86 : unsigned int low = (tree_to_uhwi (captures[1])
2133 86 : + tree_to_uhwi (captures[2]));
2134 86 : if (low >= prec
2135 : )
2136 : {
2137 25 : if (op == LROTATE_EXPR || op == RROTATE_EXPR
2138 : )
2139 : {
2140 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail746;
2141 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail746;
2142 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail746;
2143 0 : {
2144 0 : tree res_op0;
2145 0 : res_op0 = captures[0];
2146 0 : tree res_op1;
2147 0 : res_op1 = build_int_cst (TREE_TYPE (captures[1]), low % prec);
2148 0 : tree _r;
2149 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2150 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 614, __FILE__, __LINE__, true);
2151 86 : return _r;
2152 : }
2153 : next_after_fail746:;
2154 : }
2155 : else
2156 : {
2157 25 : if (TYPE_UNSIGNED (type) || op == LSHIFT_EXPR
2158 : )
2159 : {
2160 24 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail747;
2161 24 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail747;
2162 24 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail747;
2163 24 : {
2164 24 : tree _r;
2165 24 : _r = build_zero_cst (type);
2166 24 : if (TREE_SIDE_EFFECTS (captures[0]))
2167 14 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2168 24 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 615, __FILE__, __LINE__, true);
2169 24 : return _r;
2170 : }
2171 : next_after_fail747:;
2172 : }
2173 : else
2174 : {
2175 1 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail748;
2176 1 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail748;
2177 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail748;
2178 1 : {
2179 1 : tree res_op0;
2180 1 : res_op0 = captures[0];
2181 1 : tree res_op1;
2182 1 : res_op1 = build_int_cst (TREE_TYPE (captures[1]), prec - 1);
2183 1 : tree _r;
2184 1 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2185 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 616, __FILE__, __LINE__, true);
2186 1 : return _r;
2187 : }
2188 : next_after_fail748:;
2189 : }
2190 : }
2191 : }
2192 : else
2193 : {
2194 61 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail749;
2195 61 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail749;
2196 61 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail749;
2197 61 : {
2198 61 : tree res_op0;
2199 61 : res_op0 = captures[0];
2200 61 : tree res_op1;
2201 61 : res_op1 = build_int_cst (TREE_TYPE (captures[1]), low);
2202 61 : tree _r;
2203 61 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2204 61 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 617, __FILE__, __LINE__, true);
2205 61 : return _r;
2206 : }
2207 : next_after_fail749:;
2208 : }
2209 : }
2210 : }
2211 : }
2212 0 : return NULL_TREE;
2213 : }
2214 :
2215 : tree
2216 0 : generic_simplify_437 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2217 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2218 : const combined_fn ARG_UNUSED (coss),
2219 : const combined_fn ARG_UNUSED (atans),
2220 : const combined_fn ARG_UNUSED (sqrts),
2221 : const combined_fn ARG_UNUSED (copysigns))
2222 : {
2223 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2224 0 : {
2225 0 : REAL_VALUE_TYPE r_cst;
2226 0 : build_sinatan_real (&r_cst, type);
2227 0 : tree t_cst = build_real (type, r_cst);
2228 0 : tree t_one = build_one_cst (type);
2229 0 : tree t_zero = build_zero_cst (type);
2230 0 : if (SCALAR_FLOAT_TYPE_P (type)
2231 : )
2232 : {
2233 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail782;
2234 0 : {
2235 0 : if (! tree_invariant_p (captures[1])) goto next_after_fail782;
2236 0 : tree res_op0;
2237 0 : {
2238 0 : tree _o1[2], _r1;
2239 0 : {
2240 0 : tree _o2[1], _r2;
2241 0 : _o2[0] = unshare_expr (captures[1]);
2242 0 : _r2 = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
2243 0 : _o1[0] = _r2;
2244 : }
2245 0 : _o1[1] = t_cst;
2246 0 : _r1 = fold_build2_loc (loc, LT_EXPR, boolean_type_node, _o1[0], _o1[1]);
2247 0 : res_op0 = _r1;
2248 : }
2249 0 : tree res_op1;
2250 0 : {
2251 0 : tree _o1[2], _r1;
2252 0 : _o1[0] = t_one;
2253 0 : {
2254 0 : tree _o2[1], _r2;
2255 0 : {
2256 0 : tree _o3[2], _r3;
2257 0 : {
2258 0 : tree _o4[2], _r4;
2259 0 : _o4[0] = unshare_expr (captures[1]);
2260 0 : _o4[1] = unshare_expr (captures[1]);
2261 0 : _r4 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o4[0]), _o4[0], _o4[1]);
2262 0 : _o3[0] = _r4;
2263 : }
2264 0 : _o3[1] = t_one;
2265 0 : _r3 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
2266 0 : _o2[0] = _r3;
2267 : }
2268 0 : _r2 = maybe_build_call_expr_loc (loc, sqrts, TREE_TYPE (_o2[0]), 1, _o2[0]);
2269 0 : if (!_r2)
2270 0 : goto next_after_fail782;
2271 0 : _o1[1] = _r2;
2272 : }
2273 0 : _r1 = fold_build2_loc (loc, RDIV_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2274 0 : res_op1 = _r1;
2275 : }
2276 0 : tree res_op2;
2277 0 : {
2278 0 : tree _o1[2], _r1;
2279 0 : _o1[0] = t_zero;
2280 0 : _o1[1] = captures[1];
2281 0 : _r1 = maybe_build_call_expr_loc (loc, copysigns, TREE_TYPE (_o1[0]), 2, _o1[0], _o1[1]);
2282 0 : if (!_r1)
2283 0 : goto next_after_fail782;
2284 0 : res_op2 = _r1;
2285 : }
2286 0 : tree _r;
2287 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
2288 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 637, __FILE__, __LINE__, true);
2289 0 : return _r;
2290 : }
2291 0 : next_after_fail782:;
2292 : }
2293 : }
2294 0 : return NULL_TREE;
2295 : }
2296 :
2297 : tree
2298 0 : generic_simplify_443 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2299 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2300 : {
2301 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2302 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail788;
2303 0 : {
2304 0 : tree _r;
2305 0 : _r = captures[0];
2306 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2307 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2308 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 643, __FILE__, __LINE__, true);
2309 : return _r;
2310 : }
2311 0 : next_after_fail788:;
2312 0 : return NULL_TREE;
2313 : }
2314 :
2315 : tree
2316 0 : generic_simplify_447 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2317 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2318 : const combined_fn ARG_UNUSED (HYPOT))
2319 : {
2320 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2321 0 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
2322 : )
2323 : {
2324 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail792;
2325 0 : {
2326 0 : tree res_op0;
2327 0 : {
2328 0 : tree _o1[1], _r1;
2329 0 : _o1[0] = captures[0];
2330 0 : _r1 = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2331 0 : res_op0 = _r1;
2332 : }
2333 0 : tree res_op1;
2334 0 : res_op1 = build_real_truncate (type, dconst_sqrt2 ());
2335 0 : tree _r;
2336 0 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
2337 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 647, __FILE__, __LINE__, true);
2338 0 : return _r;
2339 : }
2340 0 : next_after_fail792:;
2341 : }
2342 : return NULL_TREE;
2343 : }
2344 :
2345 : tree
2346 1 : generic_simplify_452 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2347 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2348 : {
2349 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2350 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail797;
2351 1 : {
2352 1 : tree res_op0;
2353 1 : res_op0 = captures[0];
2354 1 : tree res_op1;
2355 1 : res_op1 = captures[1];
2356 1 : tree _r;
2357 1 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2358 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 652, __FILE__, __LINE__, true);
2359 : return _r;
2360 : }
2361 0 : next_after_fail797:;
2362 0 : return NULL_TREE;
2363 : }
2364 :
2365 : tree
2366 891249 : generic_simplify_458 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2367 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2368 : const enum tree_code ARG_UNUSED (op))
2369 : {
2370 891249 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2371 891249 : {
2372 891249 : tree pmop[2];
2373 891249 : tree utype = fold_bit_and_mask (TREE_TYPE (captures[1]), captures[3], op, captures[1], ERROR_MARK,
2374 : NULL_TREE, NULL_TREE, captures[2], ERROR_MARK,
2375 : NULL_TREE, NULL_TREE, pmop);
2376 891249 : if (utype
2377 : )
2378 : {
2379 317817 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail803;
2380 317817 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail803;
2381 317817 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail803;
2382 317817 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail803;
2383 317817 : {
2384 317817 : tree res_op0;
2385 317817 : {
2386 317817 : tree _o1[2], _r1;
2387 317817 : {
2388 317817 : tree _o2[2], _r2;
2389 317817 : {
2390 317817 : tree _o3[1], _r3;
2391 317817 : _o3[0] = pmop[0];
2392 317817 : if (TREE_TYPE (_o3[0]) != utype)
2393 : {
2394 202 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
2395 : }
2396 : else
2397 : _r3 = _o3[0];
2398 317817 : _o2[0] = _r3;
2399 : }
2400 317817 : {
2401 317817 : tree _o3[1], _r3;
2402 317817 : _o3[0] = pmop[1];
2403 317817 : if (TREE_TYPE (_o3[0]) != utype)
2404 : {
2405 202 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
2406 : }
2407 : else
2408 : _r3 = _o3[0];
2409 317817 : _o2[1] = _r3;
2410 : }
2411 317817 : _r2 = fold_build2_loc (loc, op, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
2412 317817 : _o1[0] = _r2;
2413 : }
2414 317817 : {
2415 317817 : tree _o2[1], _r2;
2416 317817 : _o2[0] = captures[3];
2417 317817 : if (TREE_TYPE (_o2[0]) != utype)
2418 : {
2419 202 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2420 : }
2421 : else
2422 : _r2 = _o2[0];
2423 317817 : _o1[1] = _r2;
2424 : }
2425 317817 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2426 317817 : res_op0 = _r1;
2427 : }
2428 317817 : tree _r;
2429 317817 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2430 317817 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 657, __FILE__, __LINE__, true);
2431 317817 : return _r;
2432 : }
2433 573432 : next_after_fail803:;
2434 : }
2435 : }
2436 573432 : return NULL_TREE;
2437 : }
2438 :
2439 : tree
2440 0 : generic_simplify_474 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2441 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2442 : const enum tree_code ARG_UNUSED (eqne))
2443 : {
2444 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2445 0 : if (eqne == EQ_EXPR
2446 : )
2447 : {
2448 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail839;
2449 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail839;
2450 0 : {
2451 0 : tree _r;
2452 0 : _r = constant_boolean_node (false, type);
2453 0 : if (TREE_SIDE_EFFECTS (captures[2]))
2454 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2455 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 667, __FILE__, __LINE__, true);
2456 0 : return _r;
2457 : }
2458 : next_after_fail839:;
2459 : }
2460 : else
2461 : {
2462 0 : if (eqne == NE_EXPR
2463 : )
2464 : {
2465 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail840;
2466 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail840;
2467 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail840;
2468 0 : {
2469 0 : tree _r;
2470 0 : _r = captures[0];
2471 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 668, __FILE__, __LINE__, true);
2472 0 : return _r;
2473 : }
2474 : next_after_fail840:;
2475 : }
2476 : }
2477 : return NULL_TREE;
2478 : }
2479 :
2480 : tree
2481 0 : generic_simplify_483 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2482 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2483 : {
2484 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2485 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2486 0 : && TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))
2487 : )
2488 : {
2489 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail862;
2490 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail862;
2491 0 : {
2492 0 : tree res_op0;
2493 0 : res_op0 = captures[3];
2494 0 : tree res_op1;
2495 0 : {
2496 0 : tree _o1[2], _r1;
2497 0 : _o1[0] = captures[1];
2498 0 : _o1[1] = build_int_cst (TREE_TYPE (captures[1]), 1);
2499 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2500 0 : res_op1 = _r1;
2501 : }
2502 0 : tree _r;
2503 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
2504 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 687, __FILE__, __LINE__, true);
2505 0 : return _r;
2506 : }
2507 : next_after_fail862:;
2508 : }
2509 : return NULL_TREE;
2510 : }
2511 :
2512 : tree
2513 38880 : generic_simplify_488 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2514 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2515 : const enum tree_code ARG_UNUSED (shift))
2516 : {
2517 38880 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2518 38880 : if (tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
2519 23550 : && TYPE_PRECISION (type) <= HOST_BITS_PER_WIDE_INT
2520 23550 : && tree_fits_uhwi_p (captures[4])
2521 23550 : && tree_to_uhwi (captures[4]) > 0
2522 62428 : && tree_to_uhwi (captures[4]) < TYPE_PRECISION (type)
2523 : )
2524 : {
2525 23548 : {
2526 23548 : unsigned int shiftc = tree_to_uhwi (captures[4]);
2527 23548 : unsigned HOST_WIDE_INT mask = TREE_INT_CST_LOW (captures[5]);
2528 23548 : unsigned HOST_WIDE_INT newmask, zerobits = 0;
2529 23548 : tree shift_type = TREE_TYPE (captures[2]);
2530 23548 : unsigned int prec;
2531 23548 : if (shift == LSHIFT_EXPR)
2532 0 : zerobits = ((HOST_WIDE_INT_1U << shiftc) - 1);
2533 23548 : else if (shift == RSHIFT_EXPR
2534 23548 : && type_has_mode_precision_p (shift_type))
2535 : {
2536 23548 : prec = TYPE_PRECISION (TREE_TYPE (captures[2]));
2537 23548 : tree arg00 = captures[3];
2538 23548 : if (captures[2] != captures[3]
2539 23548 : && TYPE_UNSIGNED (TREE_TYPE (captures[3])))
2540 : {
2541 0 : tree inner_type = TREE_TYPE (captures[3]);
2542 0 : if (type_has_mode_precision_p (inner_type)
2543 0 : && TYPE_PRECISION (inner_type) < prec)
2544 : {
2545 0 : prec = TYPE_PRECISION (inner_type);
2546 0 : if (shiftc < prec)
2547 0 : shift_type = inner_type;
2548 : }
2549 : }
2550 23548 : zerobits = HOST_WIDE_INT_M1U;
2551 23548 : if (shiftc < prec)
2552 : {
2553 23548 : zerobits >>= HOST_BITS_PER_WIDE_INT - shiftc;
2554 23548 : zerobits <<= prec - shiftc;
2555 : }
2556 23548 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[2]))
2557 23548 : && prec == TYPE_PRECISION (TREE_TYPE (captures[2])))
2558 : {
2559 98 : if ((mask & zerobits) == 0)
2560 82 : shift_type = unsigned_type_for (TREE_TYPE (captures[2]));
2561 : else
2562 : zerobits = 0;
2563 : }
2564 : }
2565 23532 : if ((mask & zerobits) == mask
2566 : )
2567 : {
2568 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail873;
2569 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail873;
2570 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail873;
2571 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail873;
2572 0 : {
2573 0 : tree _r;
2574 0 : _r = build_int_cst (type, 0);
2575 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 689, __FILE__, __LINE__, true);
2576 0 : return _r;
2577 : }
2578 : next_after_fail873:;
2579 : }
2580 : else
2581 : {
2582 23548 : {
2583 23548 : newmask = mask | zerobits;
2584 23548 : if (newmask != mask && (newmask & (newmask + 1)) == 0
2585 : )
2586 : {
2587 : {
2588 109 : for (prec = BITS_PER_UNIT;
2589 181 : prec < HOST_BITS_PER_WIDE_INT; prec <<= 1)
2590 171 : if (newmask == (HOST_WIDE_INT_1U << prec) - 1)
2591 : break;
2592 72 : if (prec < HOST_BITS_PER_WIDE_INT
2593 10 : || newmask == HOST_WIDE_INT_M1U
2594 : )
2595 : {
2596 72 : {
2597 72 : tree newmaskt = build_int_cst_type (TREE_TYPE (captures[5]), newmask);
2598 72 : if (!tree_int_cst_equal (newmaskt, captures[5])
2599 : )
2600 : {
2601 72 : if (shift_type != TREE_TYPE (captures[2])
2602 : )
2603 : {
2604 11 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail874;
2605 11 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail874;
2606 11 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail874;
2607 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail874;
2608 11 : {
2609 11 : tree res_op0;
2610 11 : {
2611 11 : tree _o1[1], _r1;
2612 11 : {
2613 11 : tree _o2[2], _r2;
2614 11 : {
2615 11 : tree _o3[1], _r3;
2616 11 : _o3[0] = captures[2];
2617 11 : if (TREE_TYPE (_o3[0]) != shift_type)
2618 : {
2619 11 : _r3 = fold_build1_loc (loc, NOP_EXPR, shift_type, _o3[0]);
2620 : }
2621 : else
2622 : _r3 = _o3[0];
2623 11 : _o2[0] = _r3;
2624 : }
2625 11 : _o2[1] = captures[4];
2626 11 : _r2 = fold_build2_loc (loc, shift, shift_type, _o2[0], _o2[1]);
2627 11 : _o1[0] = _r2;
2628 : }
2629 11 : if (TREE_TYPE (_o1[0]) != type)
2630 : {
2631 11 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2632 : }
2633 : else
2634 : _r1 = _o1[0];
2635 11 : res_op0 = _r1;
2636 : }
2637 11 : tree res_op1;
2638 11 : res_op1 = newmaskt;
2639 11 : tree _r;
2640 11 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2641 11 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 690, __FILE__, __LINE__, true);
2642 11 : return _r;
2643 : }
2644 : next_after_fail874:;
2645 : }
2646 : else
2647 : {
2648 61 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail875;
2649 61 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail875;
2650 61 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail875;
2651 61 : {
2652 61 : tree res_op0;
2653 61 : res_op0 = captures[0];
2654 61 : tree res_op1;
2655 61 : res_op1 = newmaskt;
2656 61 : tree _r;
2657 61 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2658 61 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 691, __FILE__, __LINE__, true);
2659 61 : return _r;
2660 : }
2661 : next_after_fail875:;
2662 : }
2663 : }
2664 : }
2665 : }
2666 : }
2667 : }
2668 : }
2669 : }
2670 : }
2671 : }
2672 : return NULL_TREE;
2673 : }
2674 :
2675 : tree
2676 17 : generic_simplify_499 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2677 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2678 : {
2679 17 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2680 17 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail888;
2681 17 : {
2682 17 : tree res_op0;
2683 17 : res_op0 = captures[0];
2684 17 : tree res_op1;
2685 17 : res_op1 = captures[1];
2686 17 : tree _r;
2687 17 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
2688 17 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 703, __FILE__, __LINE__, true);
2689 : return _r;
2690 : }
2691 0 : next_after_fail888:;
2692 0 : return NULL_TREE;
2693 : }
2694 :
2695 : tree
2696 4 : generic_simplify_505 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2697 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2698 : {
2699 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2700 4 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[2]))
2701 7 : && (element_precision (TREE_TYPE (captures[2]))
2702 3 : <= element_precision (TREE_TYPE (captures[3]))
2703 0 : || !TYPE_UNSIGNED (TREE_TYPE (captures[3])))
2704 : )
2705 : {
2706 3 : {
2707 3 : tree shift_type = TREE_TYPE (captures[2]);
2708 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail894;
2709 3 : {
2710 3 : tree res_op0;
2711 3 : {
2712 3 : tree _o1[2], _r1;
2713 3 : {
2714 3 : tree _o2[1], _r2;
2715 3 : _o2[0] = captures[3];
2716 3 : if (TREE_TYPE (_o2[0]) != shift_type)
2717 : {
2718 1 : _r2 = fold_build1_loc (loc, NOP_EXPR, shift_type, _o2[0]);
2719 : }
2720 : else
2721 : _r2 = _o2[0];
2722 3 : _o1[0] = _r2;
2723 : }
2724 3 : _o1[1] = captures[4];
2725 3 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2726 3 : res_op0 = _r1;
2727 : }
2728 3 : tree _r;
2729 3 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2730 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 705, __FILE__, __LINE__, true);
2731 3 : return _r;
2732 : }
2733 0 : next_after_fail894:;
2734 : }
2735 : }
2736 : return NULL_TREE;
2737 : }
2738 :
2739 : tree
2740 419 : generic_simplify_515 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2741 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2742 : {
2743 419 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2744 419 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
2745 419 : && wi::to_wide (captures[1]) == element_precision (type) - 1
2746 : )
2747 : {
2748 44 : {
2749 44 : tree stype = TREE_TYPE (captures[0]);
2750 44 : tree ntype = TYPE_UNSIGNED (stype) ? signed_type_for (stype)
2751 9 : : unsigned_type_for (stype);
2752 44 : if (VECTOR_TYPE_P (type)
2753 : )
2754 : {
2755 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail905;
2756 0 : {
2757 0 : tree res_op0;
2758 0 : {
2759 0 : tree _o1[2], _r1;
2760 0 : {
2761 0 : tree _o2[1], _r2;
2762 0 : _o2[0] = captures[0];
2763 0 : if (TREE_TYPE (_o2[0]) != ntype)
2764 : {
2765 0 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, ntype, _o2[0]);
2766 : }
2767 : else
2768 : _r2 = _o2[0];
2769 0 : _o1[0] = _r2;
2770 : }
2771 0 : _o1[1] = captures[1];
2772 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2773 0 : res_op0 = _r1;
2774 : }
2775 0 : tree _r;
2776 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
2777 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 718, __FILE__, __LINE__, true);
2778 0 : return _r;
2779 : }
2780 0 : next_after_fail905:;
2781 : }
2782 : else
2783 : {
2784 44 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail906;
2785 44 : {
2786 44 : tree res_op0;
2787 44 : {
2788 44 : tree _o1[2], _r1;
2789 44 : {
2790 44 : tree _o2[1], _r2;
2791 44 : _o2[0] = captures[0];
2792 44 : if (TREE_TYPE (_o2[0]) != ntype)
2793 : {
2794 44 : _r2 = fold_build1_loc (loc, NOP_EXPR, ntype, _o2[0]);
2795 : }
2796 : else
2797 : _r2 = _o2[0];
2798 44 : _o1[0] = _r2;
2799 : }
2800 44 : _o1[1] = captures[1];
2801 44 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2802 44 : res_op0 = _r1;
2803 : }
2804 44 : tree _r;
2805 44 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2806 44 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 719, __FILE__, __LINE__, true);
2807 44 : return _r;
2808 : }
2809 0 : next_after_fail906:;
2810 : }
2811 : }
2812 : }
2813 : return NULL_TREE;
2814 : }
2815 :
2816 : tree
2817 2 : generic_simplify_533 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2818 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2819 : {
2820 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2821 2 : if (TREE_CODE (type) != COMPLEX_TYPE
2822 2 : && (! ANY_INTEGRAL_TYPE_P (type)
2823 1 : || TYPE_OVERFLOW_UNDEFINED (type))
2824 : )
2825 : {
2826 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail938;
2827 2 : {
2828 2 : tree res_op0;
2829 2 : res_op0 = captures[0];
2830 2 : tree _r;
2831 2 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
2832 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 738, __FILE__, __LINE__, true);
2833 2 : return _r;
2834 : }
2835 0 : next_after_fail938:;
2836 : }
2837 : return NULL_TREE;
2838 : }
2839 :
2840 : tree
2841 12 : generic_simplify_540 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2842 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
2843 : const enum tree_code ARG_UNUSED (op))
2844 : {
2845 12 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2846 12 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail945;
2847 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail945;
2848 12 : {
2849 12 : tree _r;
2850 12 : _r = captures[2];
2851 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 530, __FILE__, __LINE__, true);
2852 : return _r;
2853 : }
2854 : next_after_fail945:;
2855 : return NULL_TREE;
2856 : }
2857 :
2858 : tree
2859 0 : generic_simplify_545 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2860 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
2861 : const combined_fn ARG_UNUSED (cond_op))
2862 : {
2863 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2864 0 : {
2865 0 : tree op_type = TREE_TYPE (captures[4]);
2866 0 : if (element_precision (type) == element_precision (op_type)
2867 : )
2868 : {
2869 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail950;
2870 0 : {
2871 0 : tree res_op0;
2872 0 : {
2873 0 : tree _o1[5], _r1;
2874 0 : _o1[0] = captures[0];
2875 0 : _o1[1] = captures[1];
2876 0 : _o1[2] = captures[2];
2877 0 : _o1[3] = captures[3];
2878 0 : {
2879 0 : tree _o2[1], _r2;
2880 0 : _o2[0] = captures[5];
2881 0 : if (TREE_TYPE (_o2[0]) != op_type)
2882 : {
2883 0 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
2884 : }
2885 : else
2886 : _r2 = _o2[0];
2887 0 : _o1[4] = _r2;
2888 : }
2889 0 : _r1 = maybe_build_call_expr_loc (loc, cond_op, TREE_TYPE (_o1[1]), 5, _o1[0], _o1[1], _o1[2], _o1[3], _o1[4]);
2890 0 : if (!_r1)
2891 0 : goto next_after_fail950;
2892 0 : res_op0 = _r1;
2893 : }
2894 0 : tree _r;
2895 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
2896 0 : if (TREE_SIDE_EFFECTS (captures[4]))
2897 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
2898 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 745, __FILE__, __LINE__, true);
2899 0 : return _r;
2900 : }
2901 : next_after_fail950:;
2902 : }
2903 : }
2904 : return NULL_TREE;
2905 : }
2906 :
2907 : tree
2908 0 : generic_simplify_554 (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 enum tree_code ARG_UNUSED (rotate),
2911 : const enum tree_code ARG_UNUSED (orotate))
2912 : {
2913 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2914 0 : {
2915 0 : auto prec = element_precision (TREE_TYPE (captures[0]));
2916 0 : if (prec == wi::to_wide (captures[2])
2917 : )
2918 : {
2919 0 : if (expr_not_equal_to (captures[3], wi::uhwi (prec,
2920 0 : TYPE_PRECISION (TREE_TYPE (captures[3]))),
2921 : gimple_match_ctx (captures[1]))
2922 : )
2923 : {
2924 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail959;
2925 0 : {
2926 0 : tree res_op0;
2927 0 : res_op0 = captures[0];
2928 0 : tree res_op1;
2929 0 : res_op1 = captures[3];
2930 0 : tree _r;
2931 0 : _r = fold_build2_loc (loc, orotate, type, res_op0, res_op1);
2932 0 : if (TREE_SIDE_EFFECTS (captures[2]))
2933 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2934 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 754, __FILE__, __LINE__, true);
2935 0 : return _r;
2936 : }
2937 0 : next_after_fail959:;
2938 : }
2939 : else
2940 : {
2941 0 : if (single_use (captures[1])
2942 0 : && pow2p_hwi (prec)
2943 0 : && cfun
2944 0 : && (fold_before_rtl_expansion_p ()
2945 0 : || !flag_tree_vrp
2946 0 : || optimize_debug)
2947 : )
2948 : {
2949 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail960;
2950 0 : {
2951 0 : tree res_op0;
2952 0 : res_op0 = captures[0];
2953 0 : tree res_op1;
2954 0 : {
2955 0 : tree _o1[2], _r1;
2956 0 : _o1[0] = captures[3];
2957 0 : _o1[1] = build_int_cst (TREE_TYPE (captures[3]), prec - 1);
2958 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2959 0 : res_op1 = _r1;
2960 : }
2961 0 : tree _r;
2962 0 : _r = fold_build2_loc (loc, orotate, type, res_op0, res_op1);
2963 0 : if (TREE_SIDE_EFFECTS (captures[2]))
2964 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2965 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 755, __FILE__, __LINE__, true);
2966 0 : return _r;
2967 : }
2968 0 : next_after_fail960:;
2969 : }
2970 : }
2971 : }
2972 : }
2973 0 : return NULL_TREE;
2974 : }
2975 :
2976 : tree
2977 0 : generic_simplify_576 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2978 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2979 : {
2980 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2981 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail984;
2982 0 : {
2983 0 : tree _r;
2984 0 : _r = captures[0];
2985 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2986 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2987 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 779, __FILE__, __LINE__, true);
2988 : return _r;
2989 : }
2990 0 : next_after_fail984:;
2991 0 : return NULL_TREE;
2992 : }
2993 :
2994 : tree
2995 0 : generic_simplify_581 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2996 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2997 : const combined_fn ARG_UNUSED (fns))
2998 : {
2999 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3000 0 : if (canonicalize_math_p ()
3001 : )
3002 : {
3003 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail989;
3004 0 : {
3005 0 : tree res_op0;
3006 0 : res_op0 = captures[0];
3007 0 : tree _r;
3008 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3009 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 784, __FILE__, __LINE__, true);
3010 0 : return _r;
3011 : }
3012 0 : next_after_fail989:;
3013 : }
3014 : return NULL_TREE;
3015 : }
3016 :
3017 : tree
3018 0 : generic_simplify_589 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3019 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
3020 : const combined_fn ARG_UNUSED (fmas))
3021 : {
3022 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3023 0 : if (canonicalize_math_after_vectorization_p ()
3024 : )
3025 : {
3026 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail997;
3027 : {
3028 : tree res_op0;
3029 : res_op0 = captures[0];
3030 : tree res_op1;
3031 : res_op1 = captures[1];
3032 : tree res_op2;
3033 : res_op2 = captures[2];
3034 : tree _r;
3035 : _r = maybe_build_call_expr_loc (loc, CFN_FMS, type, 3, res_op0, res_op1, res_op2);
3036 : if (!_r)
3037 : goto next_after_fail997;
3038 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 792, __FILE__, __LINE__, true);
3039 : return _r;
3040 : }
3041 0 : next_after_fail997:;
3042 : }
3043 0 : return NULL_TREE;
3044 : }
3045 :
3046 : tree
3047 0 : generic_simplify_599 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3048 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree ARG_UNUSED (_p3), tree ARG_UNUSED (_p4), tree *ARG_UNUSED (captures))
3049 : {
3050 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3051 0 : if (canonicalize_math_after_vectorization_p ()
3052 : )
3053 : {
3054 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1007;
3055 : {
3056 : tree res_op0;
3057 : res_op0 = captures[0];
3058 : tree res_op1;
3059 : res_op1 = captures[1];
3060 : tree res_op2;
3061 : res_op2 = captures[2];
3062 : tree res_op3;
3063 : res_op3 = captures[3];
3064 : tree res_op4;
3065 : res_op4 = captures[4];
3066 : tree _r;
3067 : _r = maybe_build_call_expr_loc (loc, CFN_COND_FNMA, type, 5, res_op0, res_op1, res_op2, res_op3, res_op4);
3068 : if (!_r)
3069 : goto next_after_fail1007;
3070 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 802, __FILE__, __LINE__, true);
3071 : return _r;
3072 : }
3073 0 : next_after_fail1007:;
3074 : }
3075 0 : return NULL_TREE;
3076 : }
3077 :
3078 : tree
3079 0 : generic_simplify_609 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3080 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3081 : const enum tree_code ARG_UNUSED (rot),
3082 : const combined_fn ARG_UNUSED (popcount))
3083 : {
3084 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3085 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3086 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
3087 0 : && (
3088 :
3089 0 : || !TREE_SIDE_EFFECTS (captures[3]))
3090 : )
3091 : {
3092 0 : {
3093 0 : tree type0 = TREE_TYPE (captures[0]);
3094 0 : tree type1 = TREE_TYPE (captures[1]);
3095 0 : unsigned int prec0 = TYPE_PRECISION (type0);
3096 0 : unsigned int prec1 = TYPE_PRECISION (type1);
3097 0 : if (prec0 == prec1 || (prec0 > prec1 && TYPE_UNSIGNED (type1))
3098 : )
3099 : {
3100 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1017;
3101 0 : {
3102 0 : tree res_op0;
3103 0 : {
3104 0 : tree _o1[1], _r1;
3105 0 : _o1[0] = captures[2];
3106 0 : if (TREE_TYPE (_o1[0]) != type0)
3107 : {
3108 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type0, _o1[0]);
3109 : }
3110 : else
3111 : _r1 = _o1[0];
3112 0 : res_op0 = _r1;
3113 : }
3114 0 : tree _r;
3115 0 : _r = maybe_build_call_expr_loc (loc, popcount, type, 1, res_op0);
3116 0 : if (!_r)
3117 0 : goto next_after_fail1017;
3118 0 : if (TREE_SIDE_EFFECTS (captures[3]))
3119 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
3120 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 809, __FILE__, __LINE__, true);
3121 0 : return _r;
3122 : }
3123 : next_after_fail1017:;
3124 : }
3125 : }
3126 : }
3127 : return NULL_TREE;
3128 : }
3129 :
3130 : tree
3131 0 : generic_simplify_621 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3132 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
3133 : const enum tree_code ARG_UNUSED (plusminus),
3134 : const enum tree_code ARG_UNUSED (minusplus))
3135 : {
3136 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3137 0 : if (!VECTOR_INTEGER_TYPE_P (type)
3138 : && !FLOAT_WORDS_BIG_ENDIAN
3139 0 : && (operand_equal_p (captures[0], captures[2], 0)
3140 0 : ? operand_equal_p (captures[1], captures[3], 0)
3141 0 : : operand_equal_p (captures[0], captures[3], 0) && operand_equal_p (captures[1], captures[2], 0))
3142 : )
3143 : {
3144 0 : {
3145 0 : vec_perm_builder builder;
3146 0 : if (tree_to_vec_perm_builder (&builder, captures[4])
3147 : )
3148 : {
3149 0 : {
3150 0 : poly_uint64 nelts = TYPE_VECTOR_SUBPARTS (type);
3151 0 : vec_perm_indices sel (builder, 2, nelts);
3152 0 : machine_mode vec_mode = TYPE_MODE (type);
3153 0 : machine_mode wide_mode;
3154 0 : scalar_mode wide_elt_mode;
3155 0 : poly_uint64 wide_nunits;
3156 0 : scalar_mode inner_mode = GET_MODE_INNER (vec_mode);
3157 0 : if (VECTOR_MODE_P (vec_mode)
3158 0 : && sel.series_p (0, 2, 0, 2)
3159 0 : && sel.series_p (1, 2, nelts + 1, 2)
3160 0 : && GET_MODE_2XWIDER_MODE (inner_mode).exists (&wide_elt_mode)
3161 0 : && multiple_p (GET_MODE_NUNITS (vec_mode), 2, &wide_nunits)
3162 0 : && related_vector_mode (vec_mode, wide_elt_mode,
3163 0 : wide_nunits).exists (&wide_mode)
3164 : )
3165 : {
3166 0 : {
3167 0 : tree stype
3168 0 : = lang_hooks.types.type_for_mode (GET_MODE_INNER (wide_mode),
3169 0 : TYPE_UNSIGNED (type));
3170 0 : tree ntype = build_vector_type_for_mode (stype, wide_mode);
3171 0 : const struct real_format *fmt_old = FLOAT_MODE_FORMAT (vec_mode);
3172 0 : const struct real_format *fmt_new = FLOAT_MODE_FORMAT (wide_mode);
3173 0 : if (TYPE_MODE (stype) != BLKmode
3174 0 : && VECTOR_TYPE_P (ntype)
3175 0 : && fmt_old != NULL
3176 0 : && fmt_new != NULL
3177 : )
3178 : {
3179 0 : {
3180 0 : if (known_eq (GET_MODE_NUNITS (wide_mode), 1)
3181 0 : && !target_supports_op_p (ntype, NEGATE_EXPR, optab_vector))
3182 : ntype = stype;
3183 0 : if (fmt_new->signbit_rw
3184 0 : == fmt_old->signbit_rw + GET_MODE_UNIT_BITSIZE (vec_mode)
3185 0 : && fmt_new->signbit_rw == fmt_new->signbit_ro
3186 0 : && targetm.can_change_mode_class (TYPE_MODE (ntype),
3187 0 : TYPE_MODE (type), ALL_REGS)
3188 0 : && ((optimize_vectors_before_lowering_p ()
3189 0 : && VECTOR_TYPE_P (ntype))
3190 0 : || target_supports_op_p (ntype, NEGATE_EXPR, optab_vector))
3191 : )
3192 : {
3193 0 : if (plusminus == PLUS_EXPR
3194 : )
3195 : {
3196 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1030;
3197 0 : {
3198 0 : tree res_op0;
3199 0 : {
3200 0 : tree _o1[1], _r1;
3201 0 : {
3202 0 : tree _o2[1], _r2;
3203 0 : {
3204 0 : tree _o3[1], _r3;
3205 0 : _o3[0] = captures[3];
3206 0 : if (TREE_TYPE (_o3[0]) != ntype)
3207 : {
3208 0 : _r3 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, ntype, _o3[0]);
3209 : }
3210 : else
3211 : _r3 = _o3[0];
3212 0 : _o2[0] = _r3;
3213 : }
3214 0 : _r2 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
3215 0 : _o1[0] = _r2;
3216 : }
3217 0 : if (TREE_TYPE (_o1[0]) != type)
3218 : {
3219 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
3220 : }
3221 : else
3222 : _r1 = _o1[0];
3223 0 : res_op0 = _r1;
3224 : }
3225 0 : tree res_op1;
3226 0 : res_op1 = captures[2];
3227 0 : tree _r;
3228 0 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
3229 0 : if (TREE_SIDE_EFFECTS (captures[0]))
3230 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3231 0 : if (TREE_SIDE_EFFECTS (captures[1]))
3232 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3233 0 : if (TREE_SIDE_EFFECTS (captures[4]))
3234 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
3235 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 818, __FILE__, __LINE__, true);
3236 0 : return _r;
3237 : }
3238 0 : next_after_fail1030:;
3239 : }
3240 : else
3241 : {
3242 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1031;
3243 0 : {
3244 0 : tree res_op0;
3245 0 : res_op0 = captures[0];
3246 0 : tree res_op1;
3247 0 : {
3248 0 : tree _o1[1], _r1;
3249 0 : {
3250 0 : tree _o2[1], _r2;
3251 0 : {
3252 0 : tree _o3[1], _r3;
3253 0 : _o3[0] = captures[1];
3254 0 : if (TREE_TYPE (_o3[0]) != ntype)
3255 : {
3256 0 : _r3 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, ntype, _o3[0]);
3257 : }
3258 : else
3259 : _r3 = _o3[0];
3260 0 : _o2[0] = _r3;
3261 : }
3262 0 : _r2 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
3263 0 : _o1[0] = _r2;
3264 : }
3265 0 : if (TREE_TYPE (_o1[0]) != type)
3266 : {
3267 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
3268 : }
3269 : else
3270 : _r1 = _o1[0];
3271 0 : res_op1 = _r1;
3272 : }
3273 0 : tree _r;
3274 0 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
3275 0 : if (TREE_SIDE_EFFECTS (captures[2]))
3276 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
3277 0 : if (TREE_SIDE_EFFECTS (captures[3]))
3278 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
3279 0 : if (TREE_SIDE_EFFECTS (captures[4]))
3280 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
3281 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 819, __FILE__, __LINE__, true);
3282 0 : return _r;
3283 : }
3284 0 : next_after_fail1031:;
3285 : }
3286 : }
3287 : }
3288 : }
3289 : }
3290 : }
3291 0 : }
3292 : }
3293 0 : }
3294 : }
3295 : return NULL_TREE;
3296 : }
3297 :
3298 : tree
3299 1330 : generic_simplify_CONJ_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0)
3300 : {
3301 1330 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3302 1330 : switch (TREE_CODE (_p0))
3303 : {
3304 0 : CASE_CONVERT:
3305 0 : {
3306 0 : tree _q20 = TREE_OPERAND (_p0, 0);
3307 0 : switch (TREE_CODE (_q20))
3308 : {
3309 0 : case CONJ_EXPR:
3310 0 : {
3311 0 : tree _q30 = TREE_OPERAND (_q20, 0);
3312 0 : {
3313 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
3314 0 : tree res = generic_simplify_556 (loc, type, _p0, captures);
3315 0 : if (res) return res;
3316 : }
3317 0 : break;
3318 : }
3319 0 : case COMPLEX_EXPR:
3320 0 : {
3321 0 : tree _q30 = TREE_OPERAND (_q20, 0);
3322 0 : tree _q31 = TREE_OPERAND (_q20, 1);
3323 0 : {
3324 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
3325 0 : {
3326 0 : tree itype = TREE_TYPE (type);
3327 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1154;
3328 0 : {
3329 0 : tree res_op0;
3330 0 : {
3331 0 : tree _o1[1], _r1;
3332 0 : _o1[0] = captures[2];
3333 0 : if (TREE_TYPE (_o1[0]) != itype)
3334 : {
3335 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, itype, _o1[0]);
3336 : }
3337 : else
3338 : _r1 = _o1[0];
3339 0 : res_op0 = _r1;
3340 : }
3341 0 : tree res_op1;
3342 0 : {
3343 0 : tree _o1[1], _r1;
3344 0 : {
3345 0 : tree _o2[1], _r2;
3346 0 : _o2[0] = captures[3];
3347 0 : if (TREE_TYPE (_o2[0]) != itype)
3348 : {
3349 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, itype, _o2[0]);
3350 : }
3351 : else
3352 : _r2 = _o2[0];
3353 0 : _o1[0] = _r2;
3354 : }
3355 0 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
3356 0 : res_op1 = _r1;
3357 : }
3358 0 : tree _r;
3359 0 : _r = fold_build2_loc (loc, COMPLEX_EXPR, type, res_op0, res_op1);
3360 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 881, __FILE__, __LINE__, true);
3361 0 : return _r;
3362 : }
3363 0 : next_after_fail1154:;
3364 : }
3365 : }
3366 0 : break;
3367 : }
3368 : default:;
3369 : }
3370 : break;
3371 : }
3372 1 : case CONJ_EXPR:
3373 1 : {
3374 1 : tree _q20 = TREE_OPERAND (_p0, 0);
3375 1 : {
3376 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3377 1 : tree res = generic_simplify_556 (loc, type, _p0, captures);
3378 1 : if (res) return res;
3379 : }
3380 0 : break;
3381 : }
3382 12 : case COMPLEX_EXPR:
3383 12 : {
3384 12 : tree _q20 = TREE_OPERAND (_p0, 0);
3385 12 : tree _q21 = TREE_OPERAND (_p0, 1);
3386 12 : {
3387 12 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
3388 12 : {
3389 12 : tree itype = TREE_TYPE (type);
3390 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1155;
3391 12 : {
3392 12 : tree res_op0;
3393 12 : {
3394 12 : tree _o1[1], _r1;
3395 12 : _o1[0] = captures[2];
3396 12 : if (TREE_TYPE (_o1[0]) != itype)
3397 : {
3398 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, itype, _o1[0]);
3399 : }
3400 : else
3401 : _r1 = _o1[0];
3402 12 : res_op0 = _r1;
3403 : }
3404 12 : tree res_op1;
3405 12 : {
3406 12 : tree _o1[1], _r1;
3407 12 : {
3408 12 : tree _o2[1], _r2;
3409 12 : _o2[0] = captures[3];
3410 12 : if (TREE_TYPE (_o2[0]) != itype)
3411 : {
3412 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, itype, _o2[0]);
3413 : }
3414 : else
3415 : _r2 = _o2[0];
3416 12 : _o1[0] = _r2;
3417 : }
3418 12 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
3419 12 : res_op1 = _r1;
3420 : }
3421 12 : tree _r;
3422 12 : _r = fold_build2_loc (loc, COMPLEX_EXPR, type, res_op0, res_op1);
3423 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 881, __FILE__, __LINE__, true);
3424 12 : return _r;
3425 : }
3426 0 : next_after_fail1155:;
3427 : }
3428 : }
3429 0 : break;
3430 : }
3431 : default:;
3432 : }
3433 : return NULL_TREE;
3434 : }
3435 :
3436 : tree
3437 95738625 : generic_simplify_PLUS_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
3438 : {
3439 95738625 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3440 95738625 : if (integer_zerop (_p1))
3441 : {
3442 27612383 : {
3443 27612383 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3444 27612383 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1235;
3445 27612383 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1235;
3446 27612383 : {
3447 27612383 : tree res_op0;
3448 27612383 : res_op0 = captures[0];
3449 27612383 : tree _r;
3450 27612383 : _r = non_lvalue_loc (loc, res_op0);
3451 27612383 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 883, __FILE__, __LINE__, true);
3452 27612383 : return _r;
3453 : }
3454 : next_after_fail1235:;
3455 : }
3456 : }
3457 68126242 : if (real_zerop (_p1))
3458 : {
3459 5301 : {
3460 5301 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
3461 5301 : tree res = generic_simplify_52 (loc, type, _p0, _p1, captures);
3462 5301 : if (res) return res;
3463 : }
3464 : }
3465 68126147 : switch (TREE_CODE (_p0))
3466 : {
3467 6421215 : case PLUS_EXPR:
3468 6421215 : {
3469 6421215 : tree _q20 = TREE_OPERAND (_p0, 0);
3470 6421215 : tree _q21 = TREE_OPERAND (_p0, 1);
3471 6421215 : switch (TREE_CODE (_q21))
3472 : {
3473 115594 : case REAL_CST:
3474 115594 : {
3475 115594 : switch (TREE_CODE (_p1))
3476 : {
3477 70 : case REAL_CST:
3478 70 : {
3479 70 : {
3480 70 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
3481 70 : tree res = generic_simplify_53 (loc, type, _p0, _p1, captures, PLUS_EXPR, PLUS_EXPR);
3482 70 : if (res) return res;
3483 : }
3484 67 : break;
3485 : }
3486 : default:;
3487 : }
3488 : break;
3489 : }
3490 : default:;
3491 : }
3492 : break;
3493 : }
3494 2008012 : case MINUS_EXPR:
3495 2008012 : {
3496 2008012 : tree _q20 = TREE_OPERAND (_p0, 0);
3497 2008012 : tree _q21 = TREE_OPERAND (_p0, 1);
3498 2008012 : switch (TREE_CODE (_q21))
3499 : {
3500 21873 : case REAL_CST:
3501 21873 : {
3502 21873 : switch (TREE_CODE (_p1))
3503 : {
3504 191 : case REAL_CST:
3505 191 : {
3506 191 : {
3507 191 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
3508 191 : tree res = generic_simplify_53 (loc, type, _p0, _p1, captures, PLUS_EXPR, MINUS_EXPR);
3509 191 : if (res) return res;
3510 : }
3511 189 : break;
3512 : }
3513 : default:;
3514 : }
3515 : break;
3516 : }
3517 : default:;
3518 : }
3519 : break;
3520 : }
3521 12142 : case MAX_EXPR:
3522 12142 : {
3523 12142 : tree _q20 = TREE_OPERAND (_p0, 0);
3524 12142 : tree _q21 = TREE_OPERAND (_p0, 1);
3525 12142 : if (integer_zerop (_q21))
3526 : {
3527 4625 : switch (TREE_CODE (_p1))
3528 : {
3529 114 : case MAX_EXPR:
3530 114 : {
3531 114 : tree _q50 = TREE_OPERAND (_p1, 0);
3532 114 : tree _q51 = TREE_OPERAND (_p1, 1);
3533 114 : switch (TREE_CODE (_q50))
3534 : {
3535 48 : case NEGATE_EXPR:
3536 48 : {
3537 48 : tree _q60 = TREE_OPERAND (_q50, 0);
3538 48 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
3539 : {
3540 48 : if (integer_zerop (_q51))
3541 : {
3542 48 : {
3543 48 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3544 48 : tree res = generic_simplify_54 (loc, type, _p0, _p1, captures);
3545 48 : if (res) return res;
3546 : }
3547 : }
3548 : }
3549 : break;
3550 : }
3551 : default:;
3552 : }
3553 : break;
3554 : }
3555 : default:;
3556 : }
3557 : }
3558 12094 : switch (TREE_CODE (_q20))
3559 : {
3560 18 : case NEGATE_EXPR:
3561 18 : {
3562 18 : tree _q30 = TREE_OPERAND (_q20, 0);
3563 18 : if (integer_zerop (_q21))
3564 : {
3565 18 : switch (TREE_CODE (_p1))
3566 : {
3567 18 : case MAX_EXPR:
3568 18 : {
3569 18 : tree _q60 = TREE_OPERAND (_p1, 0);
3570 18 : tree _q61 = TREE_OPERAND (_p1, 1);
3571 18 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
3572 : {
3573 18 : if (integer_zerop (_q61))
3574 : {
3575 18 : {
3576 18 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
3577 18 : tree res = generic_simplify_54 (loc, type, _p0, _p1, captures);
3578 18 : if (res) return res;
3579 : }
3580 : }
3581 : }
3582 : break;
3583 : }
3584 : default:;
3585 : }
3586 : }
3587 : break;
3588 : }
3589 : default:;
3590 : }
3591 : break;
3592 : }
3593 12877112 : case MULT_EXPR:
3594 12877112 : {
3595 12877112 : tree _q20 = TREE_OPERAND (_p0, 0);
3596 12877112 : tree _q21 = TREE_OPERAND (_p0, 1);
3597 12877112 : switch (TREE_CODE (_q20))
3598 : {
3599 1796971 : case PLUS_EXPR:
3600 1796971 : {
3601 1796971 : tree _q30 = TREE_OPERAND (_q20, 0);
3602 1796971 : tree _q31 = TREE_OPERAND (_q20, 1);
3603 1796971 : switch (TREE_CODE (_q31))
3604 : {
3605 485466 : case INTEGER_CST:
3606 485466 : {
3607 485466 : switch (TREE_CODE (_q21))
3608 : {
3609 172886 : case INTEGER_CST:
3610 172886 : {
3611 172886 : switch (TREE_CODE (_p1))
3612 : {
3613 121281 : case INTEGER_CST:
3614 121281 : {
3615 121281 : {
3616 121281 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1 };
3617 121281 : {
3618 121281 : bool overflowed = true;
3619 121281 : wi::overflow_type ovf1;
3620 121281 : wi::overflow_type ovf2;
3621 121281 : wide_int mul = wi::mul (wi::to_wide (captures[3]), wi::to_wide (captures[4]),
3622 242562 : TYPE_SIGN (type), &ovf1);
3623 363843 : wide_int add = wi::add (mul, wi::to_wide (captures[5]),
3624 121281 : TYPE_SIGN (type), &ovf2);
3625 121281 : if (TYPE_OVERFLOW_UNDEFINED (type))
3626 : {
3627 : }
3628 : else
3629 60402 : overflowed = false;
3630 60402 : if (!overflowed
3631 : )
3632 : {
3633 60402 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1236;
3634 60402 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1236;
3635 60402 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail1236;
3636 60402 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1236;
3637 60402 : {
3638 60402 : tree res_op0;
3639 60402 : {
3640 60402 : tree _o1[2], _r1;
3641 60402 : _o1[0] = captures[2];
3642 60402 : _o1[1] = captures[4];
3643 60402 : _r1 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3644 60402 : res_op0 = _r1;
3645 : }
3646 60402 : tree res_op1;
3647 60402 : res_op1 = wide_int_to_tree (type, add);
3648 60402 : tree _r;
3649 60402 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
3650 60402 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 895, __FILE__, __LINE__, true);
3651 60402 : return _r;
3652 : }
3653 60879 : next_after_fail1236:;
3654 : }
3655 121281 : }
3656 : }
3657 60879 : break;
3658 : }
3659 : default:;
3660 : }
3661 : break;
3662 : }
3663 : default:;
3664 : }
3665 : break;
3666 : }
3667 : default:;
3668 : }
3669 : break;
3670 : }
3671 : default:;
3672 : }
3673 : break;
3674 : }
3675 25800 : case LSHIFT_EXPR:
3676 25800 : {
3677 25800 : tree _q20 = TREE_OPERAND (_p0, 0);
3678 25800 : tree _q21 = TREE_OPERAND (_p0, 1);
3679 25800 : switch (TREE_CODE (_p1))
3680 : {
3681 688 : case LSHIFT_EXPR:
3682 688 : {
3683 688 : tree _q50 = TREE_OPERAND (_p1, 0);
3684 688 : tree _q51 = TREE_OPERAND (_p1, 1);
3685 688 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
3686 : {
3687 7 : {
3688 7 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
3689 7 : tree res = generic_simplify_55 (loc, type, _p0, _p1, captures, PLUS_EXPR);
3690 7 : if (res) return res;
3691 : }
3692 : }
3693 : break;
3694 : }
3695 : default:;
3696 : }
3697 : break;
3698 : }
3699 212329 : case BIT_AND_EXPR:
3700 212329 : {
3701 212329 : tree _q20 = TREE_OPERAND (_p0, 0);
3702 212329 : tree _q21 = TREE_OPERAND (_p0, 1);
3703 212329 : switch (TREE_CODE (_p1))
3704 : {
3705 300 : case BIT_AND_EXPR:
3706 300 : {
3707 300 : tree _q50 = TREE_OPERAND (_p1, 0);
3708 300 : tree _q51 = TREE_OPERAND (_p1, 1);
3709 300 : {
3710 300 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51 };
3711 300 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures, PLUS_EXPR);
3712 300 : if (res) return res;
3713 : }
3714 300 : {
3715 300 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q51, _q50 };
3716 300 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures, PLUS_EXPR);
3717 300 : if (res) return res;
3718 : }
3719 300 : {
3720 300 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q50, _q51 };
3721 300 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures, PLUS_EXPR);
3722 300 : if (res) return res;
3723 : }
3724 300 : {
3725 300 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q51, _q50 };
3726 300 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures, PLUS_EXPR);
3727 300 : if (res) return res;
3728 : }
3729 300 : break;
3730 : }
3731 212329 : default:;
3732 : }
3733 212329 : if (integer_onep (_q21))
3734 : {
3735 119948 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
3736 : {
3737 29 : {
3738 29 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
3739 29 : tree res = generic_simplify_56 (loc, type, _p0, _p1, captures);
3740 29 : if (res) return res;
3741 : }
3742 : }
3743 : }
3744 : break;
3745 : }
3746 68065638 : default:;
3747 : }
3748 68065638 : if (real_zerop (_p0))
3749 : {
3750 0 : {
3751 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _p0 };
3752 0 : tree res = generic_simplify_52 (loc, type, _p0, _p1, captures);
3753 0 : if (res) return res;
3754 : }
3755 : }
3756 68065638 : switch (TREE_CODE (_p1))
3757 : {
3758 5328 : case BIT_AND_EXPR:
3759 5328 : {
3760 5328 : tree _q30 = TREE_OPERAND (_p1, 0);
3761 5328 : tree _q31 = TREE_OPERAND (_p1, 1);
3762 5328 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
3763 : {
3764 16 : if (integer_onep (_q31))
3765 : {
3766 16 : {
3767 16 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
3768 16 : tree res = generic_simplify_56 (loc, type, _p0, _p1, captures);
3769 16 : if (res) return res;
3770 : }
3771 : }
3772 : }
3773 : break;
3774 : }
3775 68065622 : default:;
3776 : }
3777 68065622 : switch (TREE_CODE (_p0))
3778 : {
3779 212300 : case BIT_AND_EXPR:
3780 212300 : {
3781 212300 : tree _q20 = TREE_OPERAND (_p0, 0);
3782 212300 : tree _q21 = TREE_OPERAND (_p0, 1);
3783 212300 : switch (TREE_CODE (_p1))
3784 : {
3785 9 : case BIT_XOR_EXPR:
3786 9 : {
3787 9 : tree _q50 = TREE_OPERAND (_p1, 0);
3788 9 : tree _q51 = TREE_OPERAND (_p1, 1);
3789 9 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
3790 : {
3791 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
3792 : {
3793 0 : {
3794 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3795 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures, PLUS_EXPR);
3796 0 : if (res) return res;
3797 : }
3798 : }
3799 : }
3800 : break;
3801 : }
3802 1 : case BIT_IOR_EXPR:
3803 1 : {
3804 1 : tree _q50 = TREE_OPERAND (_p1, 0);
3805 1 : tree _q51 = TREE_OPERAND (_p1, 1);
3806 1 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
3807 : {
3808 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
3809 : {
3810 0 : {
3811 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3812 0 : tree res = generic_simplify_57 (loc, type, _p0, _p1, captures);
3813 0 : if (res) return res;
3814 : }
3815 : }
3816 : }
3817 : break;
3818 : }
3819 212300 : default:;
3820 : }
3821 212300 : switch (TREE_CODE (_q21))
3822 : {
3823 211996 : case INTEGER_CST:
3824 211996 : {
3825 211996 : switch (TREE_CODE (_p1))
3826 : {
3827 14285 : CASE_CONVERT:
3828 14285 : {
3829 14285 : tree _q50 = TREE_OPERAND (_p1, 0);
3830 14285 : switch (TREE_CODE (_q50))
3831 : {
3832 0 : case BIT_AND_EXPR:
3833 0 : {
3834 0 : tree _q60 = TREE_OPERAND (_q50, 0);
3835 0 : tree _q61 = TREE_OPERAND (_q50, 1);
3836 0 : switch (TREE_CODE (_q61))
3837 : {
3838 0 : case INTEGER_CST:
3839 0 : {
3840 0 : {
3841 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50, _q60, _q61 };
3842 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures, PLUS_EXPR);
3843 0 : if (res) return res;
3844 : }
3845 0 : break;
3846 : }
3847 : default:;
3848 : }
3849 : break;
3850 : }
3851 : default:;
3852 : }
3853 : break;
3854 : }
3855 300 : case BIT_AND_EXPR:
3856 300 : {
3857 300 : tree _q50 = TREE_OPERAND (_p1, 0);
3858 300 : tree _q51 = TREE_OPERAND (_p1, 1);
3859 300 : switch (TREE_CODE (_q51))
3860 : {
3861 300 : case INTEGER_CST:
3862 300 : {
3863 300 : {
3864 300 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50, _q51 };
3865 300 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures, PLUS_EXPR);
3866 300 : if (res) return res;
3867 : }
3868 200 : break;
3869 : }
3870 : default:;
3871 : }
3872 : break;
3873 : }
3874 : default:;
3875 : }
3876 : break;
3877 : }
3878 : default:;
3879 : }
3880 : break;
3881 : }
3882 1507 : case BIT_XOR_EXPR:
3883 1507 : {
3884 1507 : tree _q20 = TREE_OPERAND (_p0, 0);
3885 1507 : tree _q21 = TREE_OPERAND (_p0, 1);
3886 1507 : switch (TREE_CODE (_p1))
3887 : {
3888 0 : case BIT_AND_EXPR:
3889 0 : {
3890 0 : tree _q50 = TREE_OPERAND (_p1, 0);
3891 0 : tree _q51 = TREE_OPERAND (_p1, 1);
3892 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
3893 : {
3894 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
3895 : {
3896 0 : {
3897 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3898 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures, PLUS_EXPR);
3899 0 : if (res) return res;
3900 : }
3901 : }
3902 : }
3903 : break;
3904 : }
3905 : default:;
3906 : }
3907 : break;
3908 : }
3909 552 : case BIT_IOR_EXPR:
3910 552 : {
3911 552 : tree _q20 = TREE_OPERAND (_p0, 0);
3912 552 : tree _q21 = TREE_OPERAND (_p0, 1);
3913 552 : switch (TREE_CODE (_p1))
3914 : {
3915 0 : case BIT_AND_EXPR:
3916 0 : {
3917 0 : tree _q50 = TREE_OPERAND (_p1, 0);
3918 0 : tree _q51 = TREE_OPERAND (_p1, 1);
3919 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
3920 : {
3921 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
3922 : {
3923 0 : {
3924 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3925 0 : tree res = generic_simplify_57 (loc, type, _p0, _p1, captures);
3926 0 : if (res) return res;
3927 : }
3928 : }
3929 : }
3930 : break;
3931 : }
3932 : default:;
3933 : }
3934 : break;
3935 : }
3936 2008010 : case MINUS_EXPR:
3937 2008010 : {
3938 2008010 : tree _q20 = TREE_OPERAND (_p0, 0);
3939 2008010 : tree _q21 = TREE_OPERAND (_p0, 1);
3940 2008010 : switch (TREE_CODE (_q20))
3941 : {
3942 2 : case BIT_AND_EXPR:
3943 2 : {
3944 2 : tree _q30 = TREE_OPERAND (_q20, 0);
3945 2 : tree _q31 = TREE_OPERAND (_q20, 1);
3946 2 : switch (TREE_CODE (_q21))
3947 : {
3948 1 : case BIT_IOR_EXPR:
3949 1 : {
3950 1 : tree _q60 = TREE_OPERAND (_q21, 0);
3951 1 : tree _q61 = TREE_OPERAND (_q21, 1);
3952 1 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
3953 : {
3954 1 : if ((_q61 == _q31 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q31, 0) && types_match (_q61, _q31)))
3955 : {
3956 1 : if (integer_all_onesp (_p1))
3957 : {
3958 1 : {
3959 1 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q31 };
3960 1 : tree res = generic_simplify_58 (loc, type, _p0, _p1, captures);
3961 1 : if (res) return res;
3962 : }
3963 : }
3964 : }
3965 : }
3966 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
3967 : {
3968 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
3969 : {
3970 0 : if (integer_all_onesp (_p1))
3971 : {
3972 0 : {
3973 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q31, _q30 };
3974 0 : tree res = generic_simplify_58 (loc, type, _p0, _p1, captures);
3975 0 : if (res) return res;
3976 : }
3977 : }
3978 : }
3979 : }
3980 : break;
3981 : }
3982 : default:;
3983 : }
3984 : break;
3985 : }
3986 2008009 : default:;
3987 : }
3988 2008009 : {
3989 2008009 : tree _q20_pops[1];
3990 2008009 : if (tree_nop_convert (_q20, _q20_pops))
3991 : {
3992 872788 : tree _q30 = _q20_pops[0];
3993 872788 : switch (TREE_CODE (_q30))
3994 : {
3995 0 : case BIT_AND_EXPR:
3996 0 : {
3997 0 : tree _q40 = TREE_OPERAND (_q30, 0);
3998 0 : tree _q41 = TREE_OPERAND (_q30, 1);
3999 0 : {
4000 0 : tree _q21_pops[1];
4001 0 : if (tree_nop_convert (_q21, _q21_pops))
4002 : {
4003 0 : tree _q70 = _q21_pops[0];
4004 0 : switch (TREE_CODE (_q70))
4005 : {
4006 0 : case BIT_IOR_EXPR:
4007 0 : {
4008 0 : tree _q80 = TREE_OPERAND (_q70, 0);
4009 0 : tree _q81 = TREE_OPERAND (_q70, 1);
4010 0 : if ((_q80 == _q40 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q40, 0) && types_match (_q80, _q40)))
4011 : {
4012 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
4013 : {
4014 0 : if (integer_all_onesp (_p1))
4015 : {
4016 0 : {
4017 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q41 };
4018 0 : tree res = generic_simplify_58 (loc, type, _p0, _p1, captures);
4019 0 : if (res) return res;
4020 : }
4021 : }
4022 : }
4023 : }
4024 0 : if ((_q80 == _q41 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q41, 0) && types_match (_q80, _q41)))
4025 : {
4026 0 : if ((_q81 == _q40 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q40, 0) && types_match (_q81, _q40)))
4027 : {
4028 0 : if (integer_all_onesp (_p1))
4029 : {
4030 0 : {
4031 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q40 };
4032 0 : tree res = generic_simplify_58 (loc, type, _p0, _p1, captures);
4033 0 : if (res) return res;
4034 : }
4035 : }
4036 : }
4037 : }
4038 : break;
4039 : }
4040 : default:;
4041 : }
4042 : }
4043 : }
4044 0 : break;
4045 : }
4046 : default:;
4047 : }
4048 : }
4049 : }
4050 2008009 : {
4051 2008009 : tree _q21_pops[1];
4052 2008009 : if (tree_nop_convert (_q21, _q21_pops))
4053 : {
4054 1106279 : tree _q40 = _q21_pops[0];
4055 1106279 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
4056 : {
4057 34 : {
4058 34 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
4059 34 : tree res = generic_simplify_59 (loc, type, _p0, _p1, captures);
4060 34 : if (res) return res;
4061 : }
4062 : }
4063 : }
4064 : }
4065 2007979 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
4066 : {
4067 46537 : {
4068 46537 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4069 46537 : tree res = generic_simplify_59 (loc, type, _p0, _p1, captures);
4070 46537 : if (res) return res;
4071 : }
4072 : }
4073 : break;
4074 : }
4075 18274354 : CASE_CONVERT:
4076 18274354 : {
4077 18274354 : tree _q20 = TREE_OPERAND (_p0, 0);
4078 18274354 : switch (TREE_CODE (_q20))
4079 : {
4080 72 : case BIT_AND_EXPR:
4081 72 : {
4082 72 : tree _q30 = TREE_OPERAND (_q20, 0);
4083 72 : tree _q31 = TREE_OPERAND (_q20, 1);
4084 72 : switch (TREE_CODE (_q31))
4085 : {
4086 8 : case INTEGER_CST:
4087 8 : {
4088 8 : switch (TREE_CODE (_p1))
4089 : {
4090 0 : CASE_CONVERT:
4091 0 : {
4092 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4093 0 : switch (TREE_CODE (_q60))
4094 : {
4095 0 : case BIT_AND_EXPR:
4096 0 : {
4097 0 : tree _q70 = TREE_OPERAND (_q60, 0);
4098 0 : tree _q71 = TREE_OPERAND (_q60, 1);
4099 0 : switch (TREE_CODE (_q71))
4100 : {
4101 0 : case INTEGER_CST:
4102 0 : {
4103 0 : {
4104 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q60, _q70, _q71 };
4105 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures, PLUS_EXPR);
4106 0 : if (res) return res;
4107 : }
4108 0 : break;
4109 : }
4110 : default:;
4111 : }
4112 : break;
4113 : }
4114 : default:;
4115 : }
4116 : break;
4117 : }
4118 0 : case BIT_AND_EXPR:
4119 0 : {
4120 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4121 0 : tree _q61 = TREE_OPERAND (_p1, 1);
4122 0 : switch (TREE_CODE (_q61))
4123 : {
4124 0 : case INTEGER_CST:
4125 0 : {
4126 0 : {
4127 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _p1, _q60, _q61 };
4128 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures, PLUS_EXPR);
4129 0 : if (res) return res;
4130 : }
4131 0 : break;
4132 : }
4133 : default:;
4134 : }
4135 : break;
4136 : }
4137 : default:;
4138 : }
4139 : break;
4140 : }
4141 : default:;
4142 : }
4143 : break;
4144 : }
4145 4922 : case NEGATE_EXPR:
4146 4922 : {
4147 4922 : tree _q30 = TREE_OPERAND (_q20, 0);
4148 4922 : {
4149 4922 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _q30 };
4150 4922 : tree res = generic_simplify_60 (loc, type, _p0, _p1, captures);
4151 4922 : if (res) return res;
4152 : }
4153 1771 : break;
4154 : }
4155 : default:;
4156 : }
4157 : break;
4158 : }
4159 124170 : case COND_EXPR:
4160 124170 : {
4161 124170 : tree _q20 = TREE_OPERAND (_p0, 0);
4162 124170 : tree _q21 = TREE_OPERAND (_p0, 1);
4163 124170 : tree _q22 = TREE_OPERAND (_p0, 2);
4164 124170 : if (integer_zerop (_q22))
4165 : {
4166 115362 : switch (TREE_CODE (_p1))
4167 : {
4168 44 : case COND_EXPR:
4169 44 : {
4170 44 : tree _q60 = TREE_OPERAND (_p1, 0);
4171 44 : tree _q61 = TREE_OPERAND (_p1, 1);
4172 44 : tree _q62 = TREE_OPERAND (_p1, 2);
4173 44 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4174 : {
4175 6 : if (integer_zerop (_q61))
4176 : {
4177 0 : {
4178 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q62 };
4179 0 : const enum tree_code op = PLUS_EXPR;
4180 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1237;
4181 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1237;
4182 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1237;
4183 0 : {
4184 0 : tree res_op0;
4185 0 : res_op0 = captures[1];
4186 0 : tree res_op1;
4187 0 : res_op1 = captures[2];
4188 0 : tree res_op2;
4189 0 : res_op2 = captures[4];
4190 0 : tree _r;
4191 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
4192 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 886, __FILE__, __LINE__, true);
4193 0 : return _r;
4194 : }
4195 0 : next_after_fail1237:;
4196 : }
4197 : }
4198 : }
4199 : break;
4200 : }
4201 : default:;
4202 : }
4203 : }
4204 124170 : if (integer_zerop (_q21))
4205 : {
4206 1022 : switch (TREE_CODE (_p1))
4207 : {
4208 0 : case COND_EXPR:
4209 0 : {
4210 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4211 0 : tree _q61 = TREE_OPERAND (_p1, 1);
4212 0 : tree _q62 = TREE_OPERAND (_p1, 2);
4213 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4214 : {
4215 0 : if (integer_zerop (_q62))
4216 : {
4217 0 : {
4218 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q20, _q61, _p0, _q22 };
4219 0 : const enum tree_code op = PLUS_EXPR;
4220 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1238;
4221 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1238;
4222 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1238;
4223 0 : {
4224 0 : tree res_op0;
4225 0 : res_op0 = captures[1];
4226 0 : tree res_op1;
4227 0 : res_op1 = captures[2];
4228 0 : tree res_op2;
4229 0 : res_op2 = captures[4];
4230 0 : tree _r;
4231 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
4232 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 886, __FILE__, __LINE__, true);
4233 0 : return _r;
4234 : }
4235 0 : next_after_fail1238:;
4236 : }
4237 : }
4238 : }
4239 : break;
4240 : }
4241 : default:;
4242 : }
4243 : }
4244 124170 : switch (TREE_CODE (_q20))
4245 : {
4246 29526 : case LT_EXPR:
4247 29526 : {
4248 29526 : tree _q30 = TREE_OPERAND (_q20, 0);
4249 29526 : tree _q31 = TREE_OPERAND (_q20, 1);
4250 29526 : if (zerop (_q22))
4251 : {
4252 29460 : switch (TREE_CODE (_p1))
4253 : {
4254 0 : case COND_EXPR:
4255 0 : {
4256 0 : tree _q80 = TREE_OPERAND (_p1, 0);
4257 0 : tree _q81 = TREE_OPERAND (_p1, 1);
4258 0 : tree _q82 = TREE_OPERAND (_p1, 2);
4259 0 : switch (TREE_CODE (_q80))
4260 : {
4261 0 : case GE_EXPR:
4262 0 : {
4263 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4264 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4265 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
4266 : {
4267 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
4268 : {
4269 0 : if (zerop (_q82))
4270 : {
4271 0 : {
4272 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
4273 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, PLUS_EXPR, LT_EXPR, GE_EXPR);
4274 0 : if (res) return res;
4275 : }
4276 : }
4277 : }
4278 : }
4279 : break;
4280 : }
4281 : default:;
4282 : }
4283 : break;
4284 : }
4285 : default:;
4286 : }
4287 : }
4288 : break;
4289 : }
4290 30555 : case LE_EXPR:
4291 30555 : {
4292 30555 : tree _q30 = TREE_OPERAND (_q20, 0);
4293 30555 : tree _q31 = TREE_OPERAND (_q20, 1);
4294 30555 : if (zerop (_q22))
4295 : {
4296 30297 : switch (TREE_CODE (_p1))
4297 : {
4298 5 : case COND_EXPR:
4299 5 : {
4300 5 : tree _q80 = TREE_OPERAND (_p1, 0);
4301 5 : tree _q81 = TREE_OPERAND (_p1, 1);
4302 5 : tree _q82 = TREE_OPERAND (_p1, 2);
4303 5 : switch (TREE_CODE (_q80))
4304 : {
4305 0 : case GT_EXPR:
4306 0 : {
4307 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4308 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4309 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
4310 : {
4311 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
4312 : {
4313 0 : if (zerop (_q82))
4314 : {
4315 0 : {
4316 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
4317 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, PLUS_EXPR, LE_EXPR, GT_EXPR);
4318 0 : if (res) return res;
4319 : }
4320 : }
4321 : }
4322 : }
4323 : break;
4324 : }
4325 : default:;
4326 : }
4327 : break;
4328 : }
4329 : default:;
4330 : }
4331 : }
4332 : break;
4333 : }
4334 1051 : case EQ_EXPR:
4335 1051 : {
4336 1051 : tree _q30 = TREE_OPERAND (_q20, 0);
4337 1051 : tree _q31 = TREE_OPERAND (_q20, 1);
4338 1051 : if (zerop (_q22))
4339 : {
4340 570 : switch (TREE_CODE (_p1))
4341 : {
4342 32 : case COND_EXPR:
4343 32 : {
4344 32 : tree _q80 = TREE_OPERAND (_p1, 0);
4345 32 : tree _q81 = TREE_OPERAND (_p1, 1);
4346 32 : tree _q82 = TREE_OPERAND (_p1, 2);
4347 32 : switch (TREE_CODE (_q80))
4348 : {
4349 0 : case NE_EXPR:
4350 0 : {
4351 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4352 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4353 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
4354 : {
4355 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
4356 : {
4357 0 : if (zerop (_q82))
4358 : {
4359 0 : {
4360 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
4361 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, PLUS_EXPR, EQ_EXPR, NE_EXPR);
4362 0 : if (res) return res;
4363 : }
4364 : }
4365 : }
4366 : }
4367 : break;
4368 : }
4369 : default:;
4370 : }
4371 : break;
4372 : }
4373 : default:;
4374 : }
4375 : }
4376 : break;
4377 : }
4378 7951 : case NE_EXPR:
4379 7951 : {
4380 7951 : tree _q30 = TREE_OPERAND (_q20, 0);
4381 7951 : tree _q31 = TREE_OPERAND (_q20, 1);
4382 7951 : if (zerop (_q22))
4383 : {
4384 5350 : switch (TREE_CODE (_p1))
4385 : {
4386 7 : case COND_EXPR:
4387 7 : {
4388 7 : tree _q80 = TREE_OPERAND (_p1, 0);
4389 7 : tree _q81 = TREE_OPERAND (_p1, 1);
4390 7 : tree _q82 = TREE_OPERAND (_p1, 2);
4391 7 : switch (TREE_CODE (_q80))
4392 : {
4393 0 : case EQ_EXPR:
4394 0 : {
4395 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4396 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4397 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
4398 : {
4399 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
4400 : {
4401 0 : if (zerop (_q82))
4402 : {
4403 0 : {
4404 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
4405 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, PLUS_EXPR, NE_EXPR, EQ_EXPR);
4406 0 : if (res) return res;
4407 : }
4408 : }
4409 : }
4410 : }
4411 : break;
4412 : }
4413 : default:;
4414 : }
4415 : break;
4416 : }
4417 : default:;
4418 : }
4419 : }
4420 : break;
4421 : }
4422 20554 : case GE_EXPR:
4423 20554 : {
4424 20554 : tree _q30 = TREE_OPERAND (_q20, 0);
4425 20554 : tree _q31 = TREE_OPERAND (_q20, 1);
4426 20554 : if (zerop (_q22))
4427 : {
4428 19239 : switch (TREE_CODE (_p1))
4429 : {
4430 0 : case COND_EXPR:
4431 0 : {
4432 0 : tree _q80 = TREE_OPERAND (_p1, 0);
4433 0 : tree _q81 = TREE_OPERAND (_p1, 1);
4434 0 : tree _q82 = TREE_OPERAND (_p1, 2);
4435 0 : switch (TREE_CODE (_q80))
4436 : {
4437 0 : case LT_EXPR:
4438 0 : {
4439 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4440 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4441 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
4442 : {
4443 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
4444 : {
4445 0 : if (zerop (_q82))
4446 : {
4447 0 : {
4448 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
4449 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, PLUS_EXPR, GE_EXPR, LT_EXPR);
4450 0 : if (res) return res;
4451 : }
4452 : }
4453 : }
4454 : }
4455 : break;
4456 : }
4457 : default:;
4458 : }
4459 : break;
4460 : }
4461 : default:;
4462 : }
4463 : }
4464 : break;
4465 : }
4466 27725 : case GT_EXPR:
4467 27725 : {
4468 27725 : tree _q30 = TREE_OPERAND (_q20, 0);
4469 27725 : tree _q31 = TREE_OPERAND (_q20, 1);
4470 27725 : if (zerop (_q22))
4471 : {
4472 27696 : switch (TREE_CODE (_p1))
4473 : {
4474 0 : case COND_EXPR:
4475 0 : {
4476 0 : tree _q80 = TREE_OPERAND (_p1, 0);
4477 0 : tree _q81 = TREE_OPERAND (_p1, 1);
4478 0 : tree _q82 = TREE_OPERAND (_p1, 2);
4479 0 : switch (TREE_CODE (_q80))
4480 : {
4481 0 : case LE_EXPR:
4482 0 : {
4483 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4484 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4485 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
4486 : {
4487 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
4488 : {
4489 0 : if (zerop (_q82))
4490 : {
4491 0 : {
4492 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
4493 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, PLUS_EXPR, GT_EXPR, LE_EXPR);
4494 0 : if (res) return res;
4495 : }
4496 : }
4497 : }
4498 : }
4499 : break;
4500 : }
4501 : default:;
4502 : }
4503 : break;
4504 : }
4505 : default:;
4506 : }
4507 : }
4508 : break;
4509 : }
4510 0 : case UNORDERED_EXPR:
4511 0 : {
4512 0 : tree _q30 = TREE_OPERAND (_q20, 0);
4513 0 : tree _q31 = TREE_OPERAND (_q20, 1);
4514 0 : if (zerop (_q22))
4515 : {
4516 0 : switch (TREE_CODE (_p1))
4517 : {
4518 0 : case COND_EXPR:
4519 0 : {
4520 0 : tree _q80 = TREE_OPERAND (_p1, 0);
4521 0 : tree _q81 = TREE_OPERAND (_p1, 1);
4522 0 : tree _q82 = TREE_OPERAND (_p1, 2);
4523 0 : switch (TREE_CODE (_q80))
4524 : {
4525 0 : case ORDERED_EXPR:
4526 0 : {
4527 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4528 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4529 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
4530 : {
4531 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
4532 : {
4533 0 : if (zerop (_q82))
4534 : {
4535 0 : {
4536 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
4537 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, PLUS_EXPR, UNORDERED_EXPR, ORDERED_EXPR);
4538 0 : if (res) return res;
4539 : }
4540 : }
4541 : }
4542 : }
4543 : break;
4544 : }
4545 : default:;
4546 : }
4547 : break;
4548 : }
4549 : default:;
4550 : }
4551 : }
4552 : break;
4553 : }
4554 0 : case ORDERED_EXPR:
4555 0 : {
4556 0 : tree _q30 = TREE_OPERAND (_q20, 0);
4557 0 : tree _q31 = TREE_OPERAND (_q20, 1);
4558 0 : if (zerop (_q22))
4559 : {
4560 0 : switch (TREE_CODE (_p1))
4561 : {
4562 0 : case COND_EXPR:
4563 0 : {
4564 0 : tree _q80 = TREE_OPERAND (_p1, 0);
4565 0 : tree _q81 = TREE_OPERAND (_p1, 1);
4566 0 : tree _q82 = TREE_OPERAND (_p1, 2);
4567 0 : switch (TREE_CODE (_q80))
4568 : {
4569 0 : case UNORDERED_EXPR:
4570 0 : {
4571 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4572 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4573 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
4574 : {
4575 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
4576 : {
4577 0 : if (zerop (_q82))
4578 : {
4579 0 : {
4580 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
4581 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, PLUS_EXPR, ORDERED_EXPR, UNORDERED_EXPR);
4582 0 : if (res) return res;
4583 : }
4584 : }
4585 : }
4586 : }
4587 : break;
4588 : }
4589 : default:;
4590 : }
4591 : break;
4592 : }
4593 : default:;
4594 : }
4595 : }
4596 : break;
4597 : }
4598 0 : case UNLT_EXPR:
4599 0 : {
4600 0 : tree _q30 = TREE_OPERAND (_q20, 0);
4601 0 : tree _q31 = TREE_OPERAND (_q20, 1);
4602 0 : if (zerop (_q22))
4603 : {
4604 0 : switch (TREE_CODE (_p1))
4605 : {
4606 0 : case COND_EXPR:
4607 0 : {
4608 0 : tree _q80 = TREE_OPERAND (_p1, 0);
4609 0 : tree _q81 = TREE_OPERAND (_p1, 1);
4610 0 : tree _q82 = TREE_OPERAND (_p1, 2);
4611 0 : switch (TREE_CODE (_q80))
4612 : {
4613 0 : case GE_EXPR:
4614 0 : {
4615 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4616 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4617 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
4618 : {
4619 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
4620 : {
4621 0 : if (zerop (_q82))
4622 : {
4623 0 : {
4624 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
4625 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, PLUS_EXPR, UNLT_EXPR, GE_EXPR);
4626 0 : if (res) return res;
4627 : }
4628 : }
4629 : }
4630 : }
4631 : break;
4632 : }
4633 : default:;
4634 : }
4635 : break;
4636 : }
4637 : default:;
4638 : }
4639 : }
4640 : break;
4641 : }
4642 0 : case UNLE_EXPR:
4643 0 : {
4644 0 : tree _q30 = TREE_OPERAND (_q20, 0);
4645 0 : tree _q31 = TREE_OPERAND (_q20, 1);
4646 0 : if (zerop (_q22))
4647 : {
4648 0 : switch (TREE_CODE (_p1))
4649 : {
4650 0 : case COND_EXPR:
4651 0 : {
4652 0 : tree _q80 = TREE_OPERAND (_p1, 0);
4653 0 : tree _q81 = TREE_OPERAND (_p1, 1);
4654 0 : tree _q82 = TREE_OPERAND (_p1, 2);
4655 0 : switch (TREE_CODE (_q80))
4656 : {
4657 0 : case GT_EXPR:
4658 0 : {
4659 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4660 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4661 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
4662 : {
4663 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
4664 : {
4665 0 : if (zerop (_q82))
4666 : {
4667 0 : {
4668 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
4669 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, PLUS_EXPR, UNLE_EXPR, GT_EXPR);
4670 0 : if (res) return res;
4671 : }
4672 : }
4673 : }
4674 : }
4675 : break;
4676 : }
4677 : default:;
4678 : }
4679 : break;
4680 : }
4681 : default:;
4682 : }
4683 : }
4684 : break;
4685 : }
4686 0 : case UNGT_EXPR:
4687 0 : {
4688 0 : tree _q30 = TREE_OPERAND (_q20, 0);
4689 0 : tree _q31 = TREE_OPERAND (_q20, 1);
4690 0 : if (zerop (_q22))
4691 : {
4692 0 : switch (TREE_CODE (_p1))
4693 : {
4694 0 : case COND_EXPR:
4695 0 : {
4696 0 : tree _q80 = TREE_OPERAND (_p1, 0);
4697 0 : tree _q81 = TREE_OPERAND (_p1, 1);
4698 0 : tree _q82 = TREE_OPERAND (_p1, 2);
4699 0 : switch (TREE_CODE (_q80))
4700 : {
4701 0 : case LE_EXPR:
4702 0 : {
4703 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4704 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4705 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
4706 : {
4707 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
4708 : {
4709 0 : if (zerop (_q82))
4710 : {
4711 0 : {
4712 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
4713 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, PLUS_EXPR, UNGT_EXPR, LE_EXPR);
4714 0 : if (res) return res;
4715 : }
4716 : }
4717 : }
4718 : }
4719 : break;
4720 : }
4721 : default:;
4722 : }
4723 : break;
4724 : }
4725 : default:;
4726 : }
4727 : }
4728 : break;
4729 : }
4730 0 : case UNGE_EXPR:
4731 0 : {
4732 0 : tree _q30 = TREE_OPERAND (_q20, 0);
4733 0 : tree _q31 = TREE_OPERAND (_q20, 1);
4734 0 : if (zerop (_q22))
4735 : {
4736 0 : switch (TREE_CODE (_p1))
4737 : {
4738 0 : case COND_EXPR:
4739 0 : {
4740 0 : tree _q80 = TREE_OPERAND (_p1, 0);
4741 0 : tree _q81 = TREE_OPERAND (_p1, 1);
4742 0 : tree _q82 = TREE_OPERAND (_p1, 2);
4743 0 : switch (TREE_CODE (_q80))
4744 : {
4745 0 : case LT_EXPR:
4746 0 : {
4747 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4748 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4749 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
4750 : {
4751 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
4752 : {
4753 0 : if (zerop (_q82))
4754 : {
4755 0 : {
4756 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
4757 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, PLUS_EXPR, UNGE_EXPR, LT_EXPR);
4758 0 : if (res) return res;
4759 : }
4760 : }
4761 : }
4762 : }
4763 : break;
4764 : }
4765 : default:;
4766 : }
4767 : break;
4768 : }
4769 : default:;
4770 : }
4771 : }
4772 : break;
4773 : }
4774 0 : case UNEQ_EXPR:
4775 0 : {
4776 0 : tree _q30 = TREE_OPERAND (_q20, 0);
4777 0 : tree _q31 = TREE_OPERAND (_q20, 1);
4778 0 : if (zerop (_q22))
4779 : {
4780 0 : switch (TREE_CODE (_p1))
4781 : {
4782 0 : case COND_EXPR:
4783 0 : {
4784 0 : tree _q80 = TREE_OPERAND (_p1, 0);
4785 0 : tree _q81 = TREE_OPERAND (_p1, 1);
4786 0 : tree _q82 = TREE_OPERAND (_p1, 2);
4787 0 : switch (TREE_CODE (_q80))
4788 : {
4789 0 : case LTGT_EXPR:
4790 0 : {
4791 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4792 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4793 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
4794 : {
4795 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
4796 : {
4797 0 : if (zerop (_q82))
4798 : {
4799 0 : {
4800 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
4801 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, PLUS_EXPR, UNEQ_EXPR, LTGT_EXPR);
4802 0 : if (res) return res;
4803 : }
4804 : }
4805 : }
4806 : }
4807 : break;
4808 : }
4809 : default:;
4810 : }
4811 : break;
4812 : }
4813 : default:;
4814 : }
4815 : }
4816 : break;
4817 : }
4818 0 : case LTGT_EXPR:
4819 0 : {
4820 0 : tree _q30 = TREE_OPERAND (_q20, 0);
4821 0 : tree _q31 = TREE_OPERAND (_q20, 1);
4822 0 : if (zerop (_q22))
4823 : {
4824 0 : switch (TREE_CODE (_p1))
4825 : {
4826 0 : case COND_EXPR:
4827 0 : {
4828 0 : tree _q80 = TREE_OPERAND (_p1, 0);
4829 0 : tree _q81 = TREE_OPERAND (_p1, 1);
4830 0 : tree _q82 = TREE_OPERAND (_p1, 2);
4831 0 : switch (TREE_CODE (_q80))
4832 : {
4833 0 : case UNEQ_EXPR:
4834 0 : {
4835 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4836 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4837 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
4838 : {
4839 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
4840 : {
4841 0 : if (zerop (_q82))
4842 : {
4843 0 : {
4844 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
4845 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, PLUS_EXPR, LTGT_EXPR, UNEQ_EXPR);
4846 0 : if (res) return res;
4847 : }
4848 : }
4849 : }
4850 : }
4851 : break;
4852 : }
4853 : default:;
4854 : }
4855 : break;
4856 : }
4857 : default:;
4858 : }
4859 : }
4860 : break;
4861 : }
4862 : default:;
4863 : }
4864 : break;
4865 : }
4866 168 : case VEC_COND_EXPR:
4867 168 : {
4868 168 : tree _q20 = TREE_OPERAND (_p0, 0);
4869 168 : tree _q21 = TREE_OPERAND (_p0, 1);
4870 168 : tree _q22 = TREE_OPERAND (_p0, 2);
4871 168 : if (integer_zerop (_q22))
4872 : {
4873 106 : switch (TREE_CODE (_p1))
4874 : {
4875 24 : case VEC_COND_EXPR:
4876 24 : {
4877 24 : tree _q60 = TREE_OPERAND (_p1, 0);
4878 24 : tree _q61 = TREE_OPERAND (_p1, 1);
4879 24 : tree _q62 = TREE_OPERAND (_p1, 2);
4880 24 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4881 : {
4882 0 : if (integer_zerop (_q61))
4883 : {
4884 0 : {
4885 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q62 };
4886 0 : const enum tree_code op = PLUS_EXPR;
4887 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1239;
4888 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1239;
4889 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1239;
4890 0 : {
4891 0 : tree res_op0;
4892 0 : res_op0 = captures[1];
4893 0 : tree res_op1;
4894 0 : res_op1 = captures[2];
4895 0 : tree res_op2;
4896 0 : res_op2 = captures[4];
4897 0 : tree _r;
4898 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4899 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 886, __FILE__, __LINE__, true);
4900 0 : return _r;
4901 : }
4902 0 : next_after_fail1239:;
4903 : }
4904 : }
4905 : }
4906 : break;
4907 : }
4908 : default:;
4909 : }
4910 : }
4911 168 : if (integer_zerop (_q21))
4912 : {
4913 0 : switch (TREE_CODE (_p1))
4914 : {
4915 0 : case VEC_COND_EXPR:
4916 0 : {
4917 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4918 0 : tree _q61 = TREE_OPERAND (_p1, 1);
4919 0 : tree _q62 = TREE_OPERAND (_p1, 2);
4920 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4921 : {
4922 0 : if (integer_zerop (_q62))
4923 : {
4924 0 : {
4925 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q20, _q61, _p0, _q22 };
4926 0 : const enum tree_code op = PLUS_EXPR;
4927 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1240;
4928 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1240;
4929 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1240;
4930 0 : {
4931 0 : tree res_op0;
4932 0 : res_op0 = captures[1];
4933 0 : tree res_op1;
4934 0 : res_op1 = captures[2];
4935 0 : tree res_op2;
4936 0 : res_op2 = captures[4];
4937 0 : tree _r;
4938 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
4939 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 886, __FILE__, __LINE__, true);
4940 0 : return _r;
4941 : }
4942 0 : next_after_fail1240:;
4943 : }
4944 : }
4945 : }
4946 : break;
4947 : }
4948 : default:;
4949 : }
4950 : }
4951 168 : switch (TREE_CODE (_q20))
4952 : {
4953 8 : case LT_EXPR:
4954 8 : {
4955 8 : tree _q30 = TREE_OPERAND (_q20, 0);
4956 8 : tree _q31 = TREE_OPERAND (_q20, 1);
4957 8 : if (integer_zerop (_q22))
4958 : {
4959 8 : switch (TREE_CODE (_p1))
4960 : {
4961 0 : case VEC_COND_EXPR:
4962 0 : {
4963 0 : tree _q80 = TREE_OPERAND (_p1, 0);
4964 0 : tree _q81 = TREE_OPERAND (_p1, 1);
4965 0 : tree _q82 = TREE_OPERAND (_p1, 2);
4966 0 : switch (TREE_CODE (_q80))
4967 : {
4968 0 : case GE_EXPR:
4969 0 : {
4970 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4971 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4972 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
4973 : {
4974 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
4975 : {
4976 0 : if (integer_zerop (_q82))
4977 : {
4978 0 : {
4979 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
4980 0 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, PLUS_EXPR, LT_EXPR, GE_EXPR);
4981 0 : if (res) return res;
4982 : }
4983 : }
4984 : }
4985 : }
4986 : break;
4987 : }
4988 : default:;
4989 : }
4990 : break;
4991 : }
4992 : default:;
4993 : }
4994 : }
4995 : break;
4996 : }
4997 8 : case LE_EXPR:
4998 8 : {
4999 8 : tree _q30 = TREE_OPERAND (_q20, 0);
5000 8 : tree _q31 = TREE_OPERAND (_q20, 1);
5001 8 : if (integer_zerop (_q22))
5002 : {
5003 8 : switch (TREE_CODE (_p1))
5004 : {
5005 0 : case VEC_COND_EXPR:
5006 0 : {
5007 0 : tree _q80 = TREE_OPERAND (_p1, 0);
5008 0 : tree _q81 = TREE_OPERAND (_p1, 1);
5009 0 : tree _q82 = TREE_OPERAND (_p1, 2);
5010 0 : switch (TREE_CODE (_q80))
5011 : {
5012 0 : case GT_EXPR:
5013 0 : {
5014 0 : tree _q90 = TREE_OPERAND (_q80, 0);
5015 0 : tree _q91 = TREE_OPERAND (_q80, 1);
5016 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
5017 : {
5018 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
5019 : {
5020 0 : if (integer_zerop (_q82))
5021 : {
5022 0 : {
5023 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
5024 0 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, PLUS_EXPR, LE_EXPR, GT_EXPR);
5025 0 : if (res) return res;
5026 : }
5027 : }
5028 : }
5029 : }
5030 : break;
5031 : }
5032 : default:;
5033 : }
5034 : break;
5035 : }
5036 : default:;
5037 : }
5038 : }
5039 : break;
5040 : }
5041 34 : case EQ_EXPR:
5042 34 : {
5043 34 : tree _q30 = TREE_OPERAND (_q20, 0);
5044 34 : tree _q31 = TREE_OPERAND (_q20, 1);
5045 34 : if (integer_zerop (_q22))
5046 : {
5047 34 : switch (TREE_CODE (_p1))
5048 : {
5049 24 : case VEC_COND_EXPR:
5050 24 : {
5051 24 : tree _q80 = TREE_OPERAND (_p1, 0);
5052 24 : tree _q81 = TREE_OPERAND (_p1, 1);
5053 24 : tree _q82 = TREE_OPERAND (_p1, 2);
5054 24 : switch (TREE_CODE (_q80))
5055 : {
5056 24 : case NE_EXPR:
5057 24 : {
5058 24 : tree _q90 = TREE_OPERAND (_q80, 0);
5059 24 : tree _q91 = TREE_OPERAND (_q80, 1);
5060 24 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
5061 : {
5062 24 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
5063 : {
5064 24 : if (integer_zerop (_q82))
5065 : {
5066 24 : {
5067 24 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
5068 24 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, PLUS_EXPR, EQ_EXPR, NE_EXPR);
5069 24 : if (res) return res;
5070 : }
5071 : }
5072 : }
5073 : }
5074 : break;
5075 : }
5076 : default:;
5077 : }
5078 : break;
5079 : }
5080 : default:;
5081 : }
5082 : }
5083 : break;
5084 : }
5085 22 : case NE_EXPR:
5086 22 : {
5087 22 : tree _q30 = TREE_OPERAND (_q20, 0);
5088 22 : tree _q31 = TREE_OPERAND (_q20, 1);
5089 22 : if (integer_zerop (_q22))
5090 : {
5091 8 : switch (TREE_CODE (_p1))
5092 : {
5093 0 : case VEC_COND_EXPR:
5094 0 : {
5095 0 : tree _q80 = TREE_OPERAND (_p1, 0);
5096 0 : tree _q81 = TREE_OPERAND (_p1, 1);
5097 0 : tree _q82 = TREE_OPERAND (_p1, 2);
5098 0 : switch (TREE_CODE (_q80))
5099 : {
5100 0 : case EQ_EXPR:
5101 0 : {
5102 0 : tree _q90 = TREE_OPERAND (_q80, 0);
5103 0 : tree _q91 = TREE_OPERAND (_q80, 1);
5104 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
5105 : {
5106 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
5107 : {
5108 0 : if (integer_zerop (_q82))
5109 : {
5110 0 : {
5111 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
5112 0 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, PLUS_EXPR, NE_EXPR, EQ_EXPR);
5113 0 : if (res) return res;
5114 : }
5115 : }
5116 : }
5117 : }
5118 : break;
5119 : }
5120 : default:;
5121 : }
5122 : break;
5123 : }
5124 : default:;
5125 : }
5126 : }
5127 : break;
5128 : }
5129 15 : case GE_EXPR:
5130 15 : {
5131 15 : tree _q30 = TREE_OPERAND (_q20, 0);
5132 15 : tree _q31 = TREE_OPERAND (_q20, 1);
5133 15 : if (integer_zerop (_q22))
5134 : {
5135 15 : switch (TREE_CODE (_p1))
5136 : {
5137 0 : case VEC_COND_EXPR:
5138 0 : {
5139 0 : tree _q80 = TREE_OPERAND (_p1, 0);
5140 0 : tree _q81 = TREE_OPERAND (_p1, 1);
5141 0 : tree _q82 = TREE_OPERAND (_p1, 2);
5142 0 : switch (TREE_CODE (_q80))
5143 : {
5144 0 : case LT_EXPR:
5145 0 : {
5146 0 : tree _q90 = TREE_OPERAND (_q80, 0);
5147 0 : tree _q91 = TREE_OPERAND (_q80, 1);
5148 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
5149 : {
5150 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
5151 : {
5152 0 : if (integer_zerop (_q82))
5153 : {
5154 0 : {
5155 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
5156 0 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, PLUS_EXPR, GE_EXPR, LT_EXPR);
5157 0 : if (res) return res;
5158 : }
5159 : }
5160 : }
5161 : }
5162 : break;
5163 : }
5164 : default:;
5165 : }
5166 : break;
5167 : }
5168 : default:;
5169 : }
5170 : }
5171 : break;
5172 : }
5173 81 : case GT_EXPR:
5174 81 : {
5175 81 : tree _q30 = TREE_OPERAND (_q20, 0);
5176 81 : tree _q31 = TREE_OPERAND (_q20, 1);
5177 81 : if (integer_zerop (_q22))
5178 : {
5179 33 : switch (TREE_CODE (_p1))
5180 : {
5181 0 : case VEC_COND_EXPR:
5182 0 : {
5183 0 : tree _q80 = TREE_OPERAND (_p1, 0);
5184 0 : tree _q81 = TREE_OPERAND (_p1, 1);
5185 0 : tree _q82 = TREE_OPERAND (_p1, 2);
5186 0 : switch (TREE_CODE (_q80))
5187 : {
5188 0 : case LE_EXPR:
5189 0 : {
5190 0 : tree _q90 = TREE_OPERAND (_q80, 0);
5191 0 : tree _q91 = TREE_OPERAND (_q80, 1);
5192 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
5193 : {
5194 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
5195 : {
5196 0 : if (integer_zerop (_q82))
5197 : {
5198 0 : {
5199 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
5200 0 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, PLUS_EXPR, GT_EXPR, LE_EXPR);
5201 0 : if (res) return res;
5202 : }
5203 : }
5204 : }
5205 : }
5206 : break;
5207 : }
5208 : default:;
5209 : }
5210 : break;
5211 : }
5212 : default:;
5213 : }
5214 : }
5215 : break;
5216 : }
5217 0 : case UNORDERED_EXPR:
5218 0 : {
5219 0 : tree _q30 = TREE_OPERAND (_q20, 0);
5220 0 : tree _q31 = TREE_OPERAND (_q20, 1);
5221 0 : if (integer_zerop (_q22))
5222 : {
5223 0 : switch (TREE_CODE (_p1))
5224 : {
5225 0 : case VEC_COND_EXPR:
5226 0 : {
5227 0 : tree _q80 = TREE_OPERAND (_p1, 0);
5228 0 : tree _q81 = TREE_OPERAND (_p1, 1);
5229 0 : tree _q82 = TREE_OPERAND (_p1, 2);
5230 0 : switch (TREE_CODE (_q80))
5231 : {
5232 0 : case ORDERED_EXPR:
5233 0 : {
5234 0 : tree _q90 = TREE_OPERAND (_q80, 0);
5235 0 : tree _q91 = TREE_OPERAND (_q80, 1);
5236 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
5237 : {
5238 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
5239 : {
5240 0 : if (integer_zerop (_q82))
5241 : {
5242 0 : {
5243 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
5244 0 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, PLUS_EXPR, UNORDERED_EXPR, ORDERED_EXPR);
5245 0 : if (res) return res;
5246 : }
5247 : }
5248 : }
5249 : }
5250 : break;
5251 : }
5252 : default:;
5253 : }
5254 : break;
5255 : }
5256 : default:;
5257 : }
5258 : }
5259 : break;
5260 : }
5261 0 : case ORDERED_EXPR:
5262 0 : {
5263 0 : tree _q30 = TREE_OPERAND (_q20, 0);
5264 0 : tree _q31 = TREE_OPERAND (_q20, 1);
5265 0 : if (integer_zerop (_q22))
5266 : {
5267 0 : switch (TREE_CODE (_p1))
5268 : {
5269 0 : case VEC_COND_EXPR:
5270 0 : {
5271 0 : tree _q80 = TREE_OPERAND (_p1, 0);
5272 0 : tree _q81 = TREE_OPERAND (_p1, 1);
5273 0 : tree _q82 = TREE_OPERAND (_p1, 2);
5274 0 : switch (TREE_CODE (_q80))
5275 : {
5276 0 : case UNORDERED_EXPR:
5277 0 : {
5278 0 : tree _q90 = TREE_OPERAND (_q80, 0);
5279 0 : tree _q91 = TREE_OPERAND (_q80, 1);
5280 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
5281 : {
5282 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
5283 : {
5284 0 : if (integer_zerop (_q82))
5285 : {
5286 0 : {
5287 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
5288 0 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, PLUS_EXPR, ORDERED_EXPR, UNORDERED_EXPR);
5289 0 : if (res) return res;
5290 : }
5291 : }
5292 : }
5293 : }
5294 : break;
5295 : }
5296 : default:;
5297 : }
5298 : break;
5299 : }
5300 : default:;
5301 : }
5302 : }
5303 : break;
5304 : }
5305 0 : case UNLT_EXPR:
5306 0 : {
5307 0 : tree _q30 = TREE_OPERAND (_q20, 0);
5308 0 : tree _q31 = TREE_OPERAND (_q20, 1);
5309 0 : if (integer_zerop (_q22))
5310 : {
5311 0 : switch (TREE_CODE (_p1))
5312 : {
5313 0 : case VEC_COND_EXPR:
5314 0 : {
5315 0 : tree _q80 = TREE_OPERAND (_p1, 0);
5316 0 : tree _q81 = TREE_OPERAND (_p1, 1);
5317 0 : tree _q82 = TREE_OPERAND (_p1, 2);
5318 0 : switch (TREE_CODE (_q80))
5319 : {
5320 0 : case GE_EXPR:
5321 0 : {
5322 0 : tree _q90 = TREE_OPERAND (_q80, 0);
5323 0 : tree _q91 = TREE_OPERAND (_q80, 1);
5324 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
5325 : {
5326 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
5327 : {
5328 0 : if (integer_zerop (_q82))
5329 : {
5330 0 : {
5331 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
5332 0 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, PLUS_EXPR, UNLT_EXPR, GE_EXPR);
5333 0 : if (res) return res;
5334 : }
5335 : }
5336 : }
5337 : }
5338 : break;
5339 : }
5340 : default:;
5341 : }
5342 : break;
5343 : }
5344 : default:;
5345 : }
5346 : }
5347 : break;
5348 : }
5349 0 : case UNLE_EXPR:
5350 0 : {
5351 0 : tree _q30 = TREE_OPERAND (_q20, 0);
5352 0 : tree _q31 = TREE_OPERAND (_q20, 1);
5353 0 : if (integer_zerop (_q22))
5354 : {
5355 0 : switch (TREE_CODE (_p1))
5356 : {
5357 0 : case VEC_COND_EXPR:
5358 0 : {
5359 0 : tree _q80 = TREE_OPERAND (_p1, 0);
5360 0 : tree _q81 = TREE_OPERAND (_p1, 1);
5361 0 : tree _q82 = TREE_OPERAND (_p1, 2);
5362 0 : switch (TREE_CODE (_q80))
5363 : {
5364 0 : case GT_EXPR:
5365 0 : {
5366 0 : tree _q90 = TREE_OPERAND (_q80, 0);
5367 0 : tree _q91 = TREE_OPERAND (_q80, 1);
5368 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
5369 : {
5370 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
5371 : {
5372 0 : if (integer_zerop (_q82))
5373 : {
5374 0 : {
5375 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
5376 0 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, PLUS_EXPR, UNLE_EXPR, GT_EXPR);
5377 0 : if (res) return res;
5378 : }
5379 : }
5380 : }
5381 : }
5382 : break;
5383 : }
5384 : default:;
5385 : }
5386 : break;
5387 : }
5388 : default:;
5389 : }
5390 : }
5391 : break;
5392 : }
5393 0 : case UNGT_EXPR:
5394 0 : {
5395 0 : tree _q30 = TREE_OPERAND (_q20, 0);
5396 0 : tree _q31 = TREE_OPERAND (_q20, 1);
5397 0 : if (integer_zerop (_q22))
5398 : {
5399 0 : switch (TREE_CODE (_p1))
5400 : {
5401 0 : case VEC_COND_EXPR:
5402 0 : {
5403 0 : tree _q80 = TREE_OPERAND (_p1, 0);
5404 0 : tree _q81 = TREE_OPERAND (_p1, 1);
5405 0 : tree _q82 = TREE_OPERAND (_p1, 2);
5406 0 : switch (TREE_CODE (_q80))
5407 : {
5408 0 : case LE_EXPR:
5409 0 : {
5410 0 : tree _q90 = TREE_OPERAND (_q80, 0);
5411 0 : tree _q91 = TREE_OPERAND (_q80, 1);
5412 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
5413 : {
5414 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
5415 : {
5416 0 : if (integer_zerop (_q82))
5417 : {
5418 0 : {
5419 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
5420 0 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, PLUS_EXPR, UNGT_EXPR, LE_EXPR);
5421 0 : if (res) return res;
5422 : }
5423 : }
5424 : }
5425 : }
5426 : break;
5427 : }
5428 : default:;
5429 : }
5430 : break;
5431 : }
5432 : default:;
5433 : }
5434 : }
5435 : break;
5436 : }
5437 0 : case UNGE_EXPR:
5438 0 : {
5439 0 : tree _q30 = TREE_OPERAND (_q20, 0);
5440 0 : tree _q31 = TREE_OPERAND (_q20, 1);
5441 0 : if (integer_zerop (_q22))
5442 : {
5443 0 : switch (TREE_CODE (_p1))
5444 : {
5445 0 : case VEC_COND_EXPR:
5446 0 : {
5447 0 : tree _q80 = TREE_OPERAND (_p1, 0);
5448 0 : tree _q81 = TREE_OPERAND (_p1, 1);
5449 0 : tree _q82 = TREE_OPERAND (_p1, 2);
5450 0 : switch (TREE_CODE (_q80))
5451 : {
5452 0 : case LT_EXPR:
5453 0 : {
5454 0 : tree _q90 = TREE_OPERAND (_q80, 0);
5455 0 : tree _q91 = TREE_OPERAND (_q80, 1);
5456 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
5457 : {
5458 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
5459 : {
5460 0 : if (integer_zerop (_q82))
5461 : {
5462 0 : {
5463 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
5464 0 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, PLUS_EXPR, UNGE_EXPR, LT_EXPR);
5465 0 : if (res) return res;
5466 : }
5467 : }
5468 : }
5469 : }
5470 : break;
5471 : }
5472 : default:;
5473 : }
5474 : break;
5475 : }
5476 : default:;
5477 : }
5478 : }
5479 : break;
5480 : }
5481 0 : case UNEQ_EXPR:
5482 0 : {
5483 0 : tree _q30 = TREE_OPERAND (_q20, 0);
5484 0 : tree _q31 = TREE_OPERAND (_q20, 1);
5485 0 : if (integer_zerop (_q22))
5486 : {
5487 0 : switch (TREE_CODE (_p1))
5488 : {
5489 0 : case VEC_COND_EXPR:
5490 0 : {
5491 0 : tree _q80 = TREE_OPERAND (_p1, 0);
5492 0 : tree _q81 = TREE_OPERAND (_p1, 1);
5493 0 : tree _q82 = TREE_OPERAND (_p1, 2);
5494 0 : switch (TREE_CODE (_q80))
5495 : {
5496 0 : case LTGT_EXPR:
5497 0 : {
5498 0 : tree _q90 = TREE_OPERAND (_q80, 0);
5499 0 : tree _q91 = TREE_OPERAND (_q80, 1);
5500 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
5501 : {
5502 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
5503 : {
5504 0 : if (integer_zerop (_q82))
5505 : {
5506 0 : {
5507 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
5508 0 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, PLUS_EXPR, UNEQ_EXPR, LTGT_EXPR);
5509 0 : if (res) return res;
5510 : }
5511 : }
5512 : }
5513 : }
5514 : break;
5515 : }
5516 : default:;
5517 : }
5518 : break;
5519 : }
5520 : default:;
5521 : }
5522 : }
5523 : break;
5524 : }
5525 0 : case LTGT_EXPR:
5526 0 : {
5527 0 : tree _q30 = TREE_OPERAND (_q20, 0);
5528 0 : tree _q31 = TREE_OPERAND (_q20, 1);
5529 0 : if (integer_zerop (_q22))
5530 : {
5531 0 : switch (TREE_CODE (_p1))
5532 : {
5533 0 : case VEC_COND_EXPR:
5534 0 : {
5535 0 : tree _q80 = TREE_OPERAND (_p1, 0);
5536 0 : tree _q81 = TREE_OPERAND (_p1, 1);
5537 0 : tree _q82 = TREE_OPERAND (_p1, 2);
5538 0 : switch (TREE_CODE (_q80))
5539 : {
5540 0 : case UNEQ_EXPR:
5541 0 : {
5542 0 : tree _q90 = TREE_OPERAND (_q80, 0);
5543 0 : tree _q91 = TREE_OPERAND (_q80, 1);
5544 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
5545 : {
5546 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
5547 : {
5548 0 : if (integer_zerop (_q82))
5549 : {
5550 0 : {
5551 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
5552 0 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, PLUS_EXPR, LTGT_EXPR, UNEQ_EXPR);
5553 0 : if (res) return res;
5554 : }
5555 : }
5556 : }
5557 : }
5558 : break;
5559 : }
5560 : default:;
5561 : }
5562 : break;
5563 : }
5564 : default:;
5565 : }
5566 : }
5567 : break;
5568 : }
5569 : default:;
5570 : }
5571 : break;
5572 : }
5573 68015845 : default:;
5574 : }
5575 68015845 : {
5576 68015845 : tree _p0_pops[1];
5577 68015845 : if (tree_nop_convert (_p0, _p0_pops))
5578 : {
5579 13549987 : tree _q20 = _p0_pops[0];
5580 13549987 : switch (TREE_CODE (_q20))
5581 : {
5582 138787 : case MINUS_EXPR:
5583 138787 : {
5584 138787 : tree _q30 = TREE_OPERAND (_q20, 0);
5585 138787 : tree _q31 = TREE_OPERAND (_q20, 1);
5586 138787 : switch (TREE_CODE (_q30))
5587 : {
5588 2 : case BIT_AND_EXPR:
5589 2 : {
5590 2 : tree _q40 = TREE_OPERAND (_q30, 0);
5591 2 : tree _q41 = TREE_OPERAND (_q30, 1);
5592 2 : switch (TREE_CODE (_q31))
5593 : {
5594 1 : case BIT_IOR_EXPR:
5595 1 : {
5596 1 : tree _q70 = TREE_OPERAND (_q31, 0);
5597 1 : tree _q71 = TREE_OPERAND (_q31, 1);
5598 1 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
5599 : {
5600 1 : if ((_q71 == _q41 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q41, 0) && types_match (_q71, _q41)))
5601 : {
5602 1 : if (integer_all_onesp (_p1))
5603 : {
5604 1 : {
5605 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q40, _q41 };
5606 1 : tree res = generic_simplify_58 (loc, type, _p0, _p1, captures);
5607 1 : if (res) return res;
5608 : }
5609 : }
5610 : }
5611 : }
5612 0 : if ((_q70 == _q41 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q41, 0) && types_match (_q70, _q41)))
5613 : {
5614 0 : if ((_q71 == _q40 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q40, 0) && types_match (_q71, _q40)))
5615 : {
5616 0 : if (integer_all_onesp (_p1))
5617 : {
5618 0 : {
5619 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q41, _q40 };
5620 0 : tree res = generic_simplify_58 (loc, type, _p0, _p1, captures);
5621 0 : if (res) return res;
5622 : }
5623 : }
5624 : }
5625 : }
5626 : break;
5627 : }
5628 : default:;
5629 : }
5630 : break;
5631 : }
5632 138786 : default:;
5633 : }
5634 138786 : {
5635 138786 : tree _q30_pops[1];
5636 138786 : if (tree_nop_convert (_q30, _q30_pops))
5637 : {
5638 90430 : tree _q40 = _q30_pops[0];
5639 90430 : switch (TREE_CODE (_q40))
5640 : {
5641 0 : case BIT_AND_EXPR:
5642 0 : {
5643 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5644 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5645 0 : {
5646 0 : tree _q31_pops[1];
5647 0 : if (tree_nop_convert (_q31, _q31_pops))
5648 : {
5649 0 : tree _q80 = _q31_pops[0];
5650 0 : switch (TREE_CODE (_q80))
5651 : {
5652 0 : case BIT_IOR_EXPR:
5653 0 : {
5654 0 : tree _q90 = TREE_OPERAND (_q80, 0);
5655 0 : tree _q91 = TREE_OPERAND (_q80, 1);
5656 0 : if ((_q90 == _q50 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q50, 0) && types_match (_q90, _q50)))
5657 : {
5658 0 : if ((_q91 == _q51 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q51, 0) && types_match (_q91, _q51)))
5659 : {
5660 0 : if (integer_all_onesp (_p1))
5661 : {
5662 0 : {
5663 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q50, _q51 };
5664 0 : tree res = generic_simplify_58 (loc, type, _p0, _p1, captures);
5665 0 : if (res) return res;
5666 : }
5667 : }
5668 : }
5669 : }
5670 0 : if ((_q90 == _q51 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q51, 0) && types_match (_q90, _q51)))
5671 : {
5672 0 : if ((_q91 == _q50 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q50, 0) && types_match (_q91, _q50)))
5673 : {
5674 0 : if (integer_all_onesp (_p1))
5675 : {
5676 0 : {
5677 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q51, _q50 };
5678 0 : tree res = generic_simplify_58 (loc, type, _p0, _p1, captures);
5679 0 : if (res) return res;
5680 : }
5681 : }
5682 : }
5683 : }
5684 : break;
5685 : }
5686 : default:;
5687 : }
5688 : }
5689 : }
5690 0 : break;
5691 : }
5692 : default:;
5693 : }
5694 : }
5695 : }
5696 138786 : break;
5697 : }
5698 : default:;
5699 : }
5700 : }
5701 : }
5702 68015844 : switch (TREE_CODE (_p1))
5703 : {
5704 7892722 : CASE_CONVERT:
5705 7892722 : {
5706 7892722 : tree _q30 = TREE_OPERAND (_p1, 0);
5707 7892722 : switch (TREE_CODE (_q30))
5708 : {
5709 1833 : case NEGATE_EXPR:
5710 1833 : {
5711 1833 : tree _q40 = TREE_OPERAND (_q30, 0);
5712 1833 : {
5713 1833 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
5714 1833 : tree res = generic_simplify_60 (loc, type, _p0, _p1, captures);
5715 1833 : if (res) return res;
5716 : }
5717 295 : break;
5718 : }
5719 : default:;
5720 : }
5721 : break;
5722 : }
5723 7841 : case NEGATE_EXPR:
5724 7841 : {
5725 7841 : tree _q30 = TREE_OPERAND (_p1, 0);
5726 7841 : {
5727 7841 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
5728 7841 : tree res = generic_simplify_60 (loc, type, _p0, _p1, captures);
5729 7841 : if (res) return res;
5730 : }
5731 0 : break;
5732 : }
5733 68006465 : default:;
5734 : }
5735 68006465 : switch (TREE_CODE (_p0))
5736 : {
5737 203272 : case NEGATE_EXPR:
5738 203272 : {
5739 203272 : tree _q20 = TREE_OPERAND (_p0, 0);
5740 203272 : {
5741 203272 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _q20 };
5742 203272 : tree res = generic_simplify_60 (loc, type, _p0, _p1, captures);
5743 203272 : if (res) return res;
5744 : }
5745 134 : break;
5746 : }
5747 67803327 : default:;
5748 : }
5749 67803327 : {
5750 67803327 : tree _p0_pops[1];
5751 67803327 : if (tree_nop_convert (_p0, _p0_pops))
5752 : {
5753 13543939 : tree _q20 = _p0_pops[0];
5754 13543939 : switch (TREE_CODE (_q20))
5755 : {
5756 138278 : case MINUS_EXPR:
5757 138278 : {
5758 138278 : tree _q30 = TREE_OPERAND (_q20, 0);
5759 138278 : tree _q31 = TREE_OPERAND (_q20, 1);
5760 138278 : {
5761 138278 : tree _q31_pops[1];
5762 138278 : if (tree_nop_convert (_q31, _q31_pops))
5763 : {
5764 100722 : tree _q50 = _q31_pops[0];
5765 100722 : if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
5766 : {
5767 30 : {
5768 30 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q50 };
5769 30 : tree res = generic_simplify_59 (loc, type, _p0, _p1, captures);
5770 30 : if (res) return res;
5771 : }
5772 : }
5773 : }
5774 : }
5775 138248 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
5776 : {
5777 0 : {
5778 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
5779 0 : tree res = generic_simplify_59 (loc, type, _p0, _p1, captures);
5780 0 : if (res) return res;
5781 : }
5782 : }
5783 138248 : if (CONSTANT_CLASS_P (_q31))
5784 : {
5785 18066 : if (CONSTANT_CLASS_P (_p1))
5786 : {
5787 17903 : {
5788 17903 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
5789 17903 : tree res = generic_simplify_61 (loc, type, _p0, _p1, captures, MINUS_EXPR, PLUS_EXPR, PLUS_EXPR);
5790 17903 : if (res) return res;
5791 : }
5792 : }
5793 : }
5794 120345 : if (CONSTANT_CLASS_P (_q30))
5795 : {
5796 14694 : if (CONSTANT_CLASS_P (_p1))
5797 : {
5798 5865 : {
5799 5865 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
5800 5865 : tree res = generic_simplify_62 (loc, type, _p0, _p1, captures, PLUS_EXPR);
5801 5865 : if (res) return res;
5802 : }
5803 : }
5804 : }
5805 : break;
5806 : }
5807 1324006 : case PLUS_EXPR:
5808 1324006 : {
5809 1324006 : tree _q30 = TREE_OPERAND (_q20, 0);
5810 1324006 : tree _q31 = TREE_OPERAND (_q20, 1);
5811 1324006 : if (CONSTANT_CLASS_P (_q31))
5812 : {
5813 1125422 : if (CONSTANT_CLASS_P (_p1))
5814 : {
5815 1037039 : {
5816 1037039 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
5817 1037039 : tree res = generic_simplify_61 (loc, type, _p0, _p1, captures, PLUS_EXPR, MINUS_EXPR, PLUS_EXPR);
5818 1037039 : if (res) return res;
5819 : }
5820 : }
5821 : }
5822 : break;
5823 : }
5824 : default:;
5825 : }
5826 : }
5827 : }
5828 66743390 : switch (TREE_CODE (_p1))
5829 : {
5830 171356 : case MINUS_EXPR:
5831 171356 : {
5832 171356 : tree _q30 = TREE_OPERAND (_p1, 0);
5833 171356 : tree _q31 = TREE_OPERAND (_p1, 1);
5834 171356 : {
5835 171356 : tree _q31_pops[1];
5836 171356 : if (tree_nop_convert (_q31, _q31_pops))
5837 : {
5838 60780 : tree _q50 = _q31_pops[0];
5839 60780 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
5840 : {
5841 0 : {
5842 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
5843 0 : tree res = generic_simplify_59 (loc, type, _p0, _p1, captures);
5844 0 : if (res) return res;
5845 : }
5846 : }
5847 : }
5848 : }
5849 171356 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5850 : {
5851 316 : {
5852 316 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
5853 316 : tree res = generic_simplify_59 (loc, type, _p0, _p1, captures);
5854 316 : if (res) return res;
5855 : }
5856 : }
5857 : break;
5858 : }
5859 66743074 : default:;
5860 : }
5861 66743074 : {
5862 66743074 : tree _p1_pops[1];
5863 66743074 : if (tree_nop_convert (_p1, _p1_pops))
5864 : {
5865 7608080 : tree _q30 = _p1_pops[0];
5866 7608080 : switch (TREE_CODE (_q30))
5867 : {
5868 3610 : case MINUS_EXPR:
5869 3610 : {
5870 3610 : tree _q40 = TREE_OPERAND (_q30, 0);
5871 3610 : tree _q41 = TREE_OPERAND (_q30, 1);
5872 3610 : {
5873 3610 : tree _q41_pops[1];
5874 3610 : if (tree_nop_convert (_q41, _q41_pops))
5875 : {
5876 530 : tree _q60 = _q41_pops[0];
5877 530 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
5878 : {
5879 0 : {
5880 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _p0 };
5881 0 : tree res = generic_simplify_59 (loc, type, _p0, _p1, captures);
5882 0 : if (res) return res;
5883 : }
5884 : }
5885 : }
5886 : }
5887 3610 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
5888 : {
5889 0 : {
5890 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _p0 };
5891 0 : tree res = generic_simplify_59 (loc, type, _p0, _p1, captures);
5892 0 : if (res) return res;
5893 : }
5894 : }
5895 : break;
5896 : }
5897 : default:;
5898 : }
5899 : }
5900 : }
5901 66743074 : switch (TREE_CODE (_p0))
5902 : {
5903 6420674 : case PLUS_EXPR:
5904 6420674 : {
5905 6420674 : tree _q20 = TREE_OPERAND (_p0, 0);
5906 6420674 : tree _q21 = TREE_OPERAND (_p0, 1);
5907 6420674 : switch (TREE_CODE (_p1))
5908 : {
5909 46252 : case MINUS_EXPR:
5910 46252 : {
5911 46252 : tree _q50 = TREE_OPERAND (_p1, 0);
5912 46252 : tree _q51 = TREE_OPERAND (_p1, 1);
5913 46252 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5914 : {
5915 142 : {
5916 142 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5917 142 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures);
5918 142 : if (res) return res;
5919 : }
5920 : }
5921 46110 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5922 : {
5923 311 : {
5924 311 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
5925 311 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures);
5926 311 : if (res) return res;
5927 : }
5928 : }
5929 : break;
5930 : }
5931 6420221 : default:;
5932 : }
5933 6420221 : if (CONSTANT_CLASS_P (_q21))
5934 : {
5935 2558002 : if (CONSTANT_CLASS_P (_p1))
5936 : {
5937 1887797 : {
5938 1887797 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
5939 1887797 : tree res = generic_simplify_61 (loc, type, _p0, _p1, captures, PLUS_EXPR, MINUS_EXPR, PLUS_EXPR);
5940 1887797 : if (res) return res;
5941 : }
5942 : }
5943 : }
5944 : break;
5945 : }
5946 1960512 : case MINUS_EXPR:
5947 1960512 : {
5948 1960512 : tree _q20 = TREE_OPERAND (_p0, 0);
5949 1960512 : tree _q21 = TREE_OPERAND (_p0, 1);
5950 1960512 : switch (TREE_CODE (_p1))
5951 : {
5952 1955 : case PLUS_EXPR:
5953 1955 : {
5954 1955 : tree _q50 = TREE_OPERAND (_p1, 0);
5955 1955 : tree _q51 = TREE_OPERAND (_p1, 1);
5956 1955 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5957 : {
5958 352 : {
5959 352 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q51, _q20 };
5960 352 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures);
5961 352 : if (res) return res;
5962 : }
5963 : }
5964 1603 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5965 : {
5966 27 : {
5967 27 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q50, _q20 };
5968 27 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures);
5969 27 : if (res) return res;
5970 : }
5971 : }
5972 : break;
5973 : }
5974 460 : case MINUS_EXPR:
5975 460 : {
5976 460 : tree _q50 = TREE_OPERAND (_p1, 0);
5977 460 : tree _q51 = TREE_OPERAND (_p1, 1);
5978 460 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5979 : {
5980 1 : {
5981 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5982 1 : tree res = generic_simplify_64 (loc, type, _p0, _p1, captures);
5983 1 : if (res) return res;
5984 : }
5985 : }
5986 459 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5987 : {
5988 9 : {
5989 9 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q51, _q20 };
5990 9 : tree res = generic_simplify_64 (loc, type, _p0, _p1, captures);
5991 9 : if (res) return res;
5992 : }
5993 : }
5994 : break;
5995 : }
5996 1960123 : default:;
5997 : }
5998 1960123 : if (CONSTANT_CLASS_P (_q21))
5999 : {
6000 122811 : if (CONSTANT_CLASS_P (_p1))
6001 : {
6002 82673 : {
6003 82673 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6004 82673 : tree res = generic_simplify_61 (loc, type, _p0, _p1, captures, MINUS_EXPR, PLUS_EXPR, PLUS_EXPR);
6005 82673 : if (res) return res;
6006 : }
6007 : }
6008 : }
6009 1877643 : if (CONSTANT_CLASS_P (_q20))
6010 : {
6011 401324 : if (CONSTANT_CLASS_P (_p1))
6012 : {
6013 235559 : {
6014 235559 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6015 235559 : tree res = generic_simplify_62 (loc, type, _p0, _p1, captures, PLUS_EXPR);
6016 235559 : if (res) return res;
6017 : }
6018 : }
6019 : }
6020 : break;
6021 : }
6022 473 : case POINTER_DIFF_EXPR:
6023 473 : {
6024 473 : tree _q20 = TREE_OPERAND (_p0, 0);
6025 473 : tree _q21 = TREE_OPERAND (_p0, 1);
6026 473 : switch (TREE_CODE (_p1))
6027 : {
6028 7 : case POINTER_DIFF_EXPR:
6029 7 : {
6030 7 : tree _q50 = TREE_OPERAND (_p1, 0);
6031 7 : tree _q51 = TREE_OPERAND (_p1, 1);
6032 7 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6033 : {
6034 7 : {
6035 7 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
6036 7 : tree res = generic_simplify_65 (loc, type, _p0, _p1, captures);
6037 7 : if (res) return res;
6038 : }
6039 : }
6040 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6041 : {
6042 0 : {
6043 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q51, _q20 };
6044 0 : tree res = generic_simplify_65 (loc, type, _p0, _p1, captures);
6045 0 : if (res) return res;
6046 : }
6047 : }
6048 : break;
6049 : }
6050 : default:;
6051 : }
6052 : break;
6053 : }
6054 17204711 : CASE_CONVERT:
6055 17204711 : {
6056 17204711 : tree _q20 = TREE_OPERAND (_p0, 0);
6057 17204711 : switch (TREE_CODE (_p1))
6058 : {
6059 2740259 : CASE_CONVERT:
6060 2740259 : {
6061 2740259 : tree _q40 = TREE_OPERAND (_p1, 0);
6062 2740259 : {
6063 2740259 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6064 2740259 : tree res = generic_simplify_66 (loc, type, _p0, _p1, captures, PLUS_EXPR);
6065 2740259 : if (res) return res;
6066 : }
6067 2740110 : break;
6068 : }
6069 17204562 : default:;
6070 : }
6071 17204562 : switch (TREE_CODE (_q20))
6072 : {
6073 113485 : case BIT_NOT_EXPR:
6074 113485 : {
6075 113485 : tree _q30 = TREE_OPERAND (_q20, 0);
6076 113485 : switch (TREE_CODE (_p1))
6077 : {
6078 185 : CASE_CONVERT:
6079 185 : {
6080 185 : tree _q50 = TREE_OPERAND (_p1, 0);
6081 185 : if ((_q50 == _q30 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q30, 0) && types_match (_q50, _q30)))
6082 : {
6083 0 : {
6084 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
6085 0 : tree res = generic_simplify_67 (loc, type, _p0, _p1, captures);
6086 0 : if (res) return res;
6087 : }
6088 : }
6089 : break;
6090 : }
6091 : default:;
6092 : }
6093 : break;
6094 : }
6095 17204562 : default:;
6096 : }
6097 17204562 : switch (TREE_CODE (_p1))
6098 : {
6099 2740110 : CASE_CONVERT:
6100 2740110 : {
6101 2740110 : tree _q40 = TREE_OPERAND (_p1, 0);
6102 2740110 : switch (TREE_CODE (_q40))
6103 : {
6104 441 : case BIT_NOT_EXPR:
6105 441 : {
6106 441 : tree _q50 = TREE_OPERAND (_q40, 0);
6107 441 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6108 : {
6109 0 : {
6110 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
6111 0 : tree res = generic_simplify_67 (loc, type, _p0, _p1, captures);
6112 0 : if (res) return res;
6113 : }
6114 : }
6115 : break;
6116 : }
6117 : default:;
6118 : }
6119 : break;
6120 : }
6121 : default:;
6122 : }
6123 : break;
6124 : }
6125 317436 : case BIT_NOT_EXPR:
6126 317436 : {
6127 317436 : tree _q20 = TREE_OPERAND (_p0, 0);
6128 317436 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
6129 : {
6130 539 : {
6131 539 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
6132 539 : tree res = generic_simplify_67 (loc, type, _p0, _p1, captures);
6133 539 : if (res) return res;
6134 : }
6135 : }
6136 316897 : if (integer_each_onep (_p1))
6137 : {
6138 2629 : {
6139 2629 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
6140 2629 : tree res = generic_simplify_68 (loc, type, _p0, _p1, captures);
6141 2629 : if (res) return res;
6142 : }
6143 : }
6144 : break;
6145 : }
6146 64533428 : default:;
6147 : }
6148 64533428 : switch (TREE_CODE (_p1))
6149 : {
6150 40071 : case BIT_NOT_EXPR:
6151 40071 : {
6152 40071 : tree _q30 = TREE_OPERAND (_p1, 0);
6153 40071 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
6154 : {
6155 0 : {
6156 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
6157 0 : tree res = generic_simplify_67 (loc, type, _p0, _p1, captures);
6158 0 : if (res) return res;
6159 : }
6160 : }
6161 : break;
6162 : }
6163 64533428 : default:;
6164 : }
6165 64533428 : switch (TREE_CODE (_p0))
6166 : {
6167 17204562 : CASE_CONVERT:
6168 17204562 : {
6169 17204562 : tree _q20 = TREE_OPERAND (_p0, 0);
6170 17204562 : switch (TREE_CODE (_q20))
6171 : {
6172 113485 : case BIT_NOT_EXPR:
6173 113485 : {
6174 113485 : tree _q30 = TREE_OPERAND (_q20, 0);
6175 113485 : if (integer_each_onep (_p1))
6176 : {
6177 109894 : {
6178 109894 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
6179 109894 : tree res = generic_simplify_68 (loc, type, _p0, _p1, captures);
6180 109894 : if (res) return res;
6181 : }
6182 : }
6183 : break;
6184 : }
6185 : default:;
6186 : }
6187 : break;
6188 : }
6189 12816223 : case MULT_EXPR:
6190 12816223 : {
6191 12816223 : tree _q20 = TREE_OPERAND (_p0, 0);
6192 12816223 : tree _q21 = TREE_OPERAND (_p0, 1);
6193 12816223 : switch (TREE_CODE (_p1))
6194 : {
6195 3294385 : case MULT_EXPR:
6196 3294385 : {
6197 3294385 : tree _q50 = TREE_OPERAND (_p1, 0);
6198 3294385 : tree _q51 = TREE_OPERAND (_p1, 1);
6199 3294385 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6200 : {
6201 792173 : {
6202 792173 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
6203 792173 : tree res = generic_simplify_69 (loc, type, _p0, _p1, captures, PLUS_EXPR);
6204 792173 : if (res) return res;
6205 : }
6206 : }
6207 3289546 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6208 : {
6209 21 : {
6210 21 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
6211 21 : tree res = generic_simplify_69 (loc, type, _p0, _p1, captures, PLUS_EXPR);
6212 21 : if (res) return res;
6213 : }
6214 : }
6215 3289541 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6216 : {
6217 243 : {
6218 243 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q51 };
6219 243 : tree res = generic_simplify_69 (loc, type, _p0, _p1, captures, PLUS_EXPR);
6220 243 : if (res) return res;
6221 : }
6222 : }
6223 3289368 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6224 : {
6225 1245542 : {
6226 1245542 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q50 };
6227 1245542 : tree res = generic_simplify_69 (loc, type, _p0, _p1, captures, PLUS_EXPR);
6228 1245542 : if (res) return res;
6229 : }
6230 : }
6231 : break;
6232 : }
6233 : default:;
6234 : }
6235 : break;
6236 : }
6237 63174083 : default:;
6238 : }
6239 63174083 : switch (TREE_CODE (_p1))
6240 : {
6241 3455305 : case MULT_EXPR:
6242 3455305 : {
6243 3455305 : tree _q30 = TREE_OPERAND (_p1, 0);
6244 3455305 : tree _q31 = TREE_OPERAND (_p1, 1);
6245 3455305 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
6246 : {
6247 3853 : {
6248 3853 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
6249 3853 : tree res = generic_simplify_70 (loc, type, _p0, _p1, captures, PLUS_EXPR);
6250 3853 : if (res) return res;
6251 : }
6252 : }
6253 3451499 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6254 : {
6255 0 : {
6256 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q30 };
6257 0 : tree res = generic_simplify_70 (loc, type, _p0, _p1, captures, PLUS_EXPR);
6258 0 : if (res) return res;
6259 : }
6260 : }
6261 : break;
6262 : }
6263 63170277 : default:;
6264 : }
6265 63170277 : switch (TREE_CODE (_p0))
6266 : {
6267 11565912 : case MULT_EXPR:
6268 11565912 : {
6269 11565912 : tree _q20 = TREE_OPERAND (_p0, 0);
6270 11565912 : tree _q21 = TREE_OPERAND (_p0, 1);
6271 11565912 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
6272 : {
6273 32755 : {
6274 32755 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
6275 32755 : tree res = generic_simplify_71 (loc, type, _p0, _p1, captures, PLUS_EXPR);
6276 32755 : if (res) return res;
6277 : }
6278 : }
6279 11533803 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
6280 : {
6281 326723 : {
6282 326723 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
6283 326723 : tree res = generic_simplify_71 (loc, type, _p0, _p1, captures, PLUS_EXPR);
6284 326723 : if (res) return res;
6285 : }
6286 : }
6287 11207708 : if (integer_nonzerop (_q20))
6288 : {
6289 102 : switch (TREE_CODE (_p1))
6290 : {
6291 50 : case INTEGER_CST:
6292 50 : {
6293 50 : {
6294 50 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
6295 50 : tree res = generic_simplify_72 (loc, type, _p0, _p1, captures);
6296 50 : if (res) return res;
6297 : }
6298 50 : break;
6299 : }
6300 : default:;
6301 : }
6302 : }
6303 11207708 : if (integer_nonzerop (_q21))
6304 : {
6305 7429000 : switch (TREE_CODE (_p1))
6306 : {
6307 3705344 : case INTEGER_CST:
6308 3705344 : {
6309 3705344 : {
6310 3705344 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1 };
6311 3705344 : tree res = generic_simplify_72 (loc, type, _p0, _p1, captures);
6312 3705344 : if (res) return res;
6313 : }
6314 3256782 : break;
6315 : }
6316 : default:;
6317 : }
6318 : }
6319 10759146 : switch (TREE_CODE (_q20))
6320 : {
6321 201368 : case MINUS_EXPR:
6322 201368 : {
6323 201368 : tree _q30 = TREE_OPERAND (_q20, 0);
6324 201368 : tree _q31 = TREE_OPERAND (_q20, 1);
6325 201368 : if (tree_zero_one_valued_p (_q21))
6326 : {
6327 0 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
6328 : {
6329 0 : {
6330 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q21 };
6331 0 : tree res = generic_simplify_73 (loc, type, _p0, _p1, captures);
6332 0 : if (res) return res;
6333 : }
6334 : }
6335 : }
6336 : break;
6337 : }
6338 10759146 : default:;
6339 : }
6340 10759146 : if (tree_zero_one_valued_p (_q20))
6341 : {
6342 38318 : switch (TREE_CODE (_q21))
6343 : {
6344 9 : case MINUS_EXPR:
6345 9 : {
6346 9 : tree _q40 = TREE_OPERAND (_q21, 0);
6347 9 : tree _q41 = TREE_OPERAND (_q21, 1);
6348 9 : if ((_p1 == _q41 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q41, 0) && types_match (_p1, _q41)))
6349 : {
6350 9 : {
6351 9 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q20 };
6352 9 : tree res = generic_simplify_73 (loc, type, _p0, _p1, captures);
6353 9 : if (res) return res;
6354 : }
6355 : }
6356 : break;
6357 : }
6358 : default:;
6359 : }
6360 : }
6361 : break;
6362 : }
6363 3112 : case MIN_EXPR:
6364 3112 : {
6365 3112 : tree _q20 = TREE_OPERAND (_p0, 0);
6366 3112 : tree _q21 = TREE_OPERAND (_p0, 1);
6367 3112 : switch (TREE_CODE (_p1))
6368 : {
6369 0 : case MAX_EXPR:
6370 0 : {
6371 0 : tree _q50 = TREE_OPERAND (_p1, 0);
6372 0 : tree _q51 = TREE_OPERAND (_p1, 1);
6373 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6374 : {
6375 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6376 : {
6377 0 : {
6378 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6379 0 : if (!HONOR_NANS (captures[0])
6380 : )
6381 : {
6382 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1241;
6383 0 : {
6384 0 : tree res_op0;
6385 0 : res_op0 = captures[0];
6386 0 : tree res_op1;
6387 0 : res_op1 = captures[1];
6388 0 : tree _r;
6389 0 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
6390 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 889, __FILE__, __LINE__, true);
6391 0 : return _r;
6392 : }
6393 0 : next_after_fail1241:;
6394 : }
6395 : }
6396 : }
6397 : }
6398 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6399 : {
6400 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6401 : {
6402 0 : {
6403 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6404 0 : if (!HONOR_NANS (captures[0])
6405 : )
6406 : {
6407 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1242;
6408 0 : {
6409 0 : tree res_op0;
6410 0 : res_op0 = captures[0];
6411 0 : tree res_op1;
6412 0 : res_op1 = captures[1];
6413 0 : tree _r;
6414 0 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
6415 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 889, __FILE__, __LINE__, true);
6416 0 : return _r;
6417 : }
6418 0 : next_after_fail1242:;
6419 : }
6420 : }
6421 : }
6422 : }
6423 : break;
6424 : }
6425 : default:;
6426 : }
6427 : break;
6428 : }
6429 12076 : case MAX_EXPR:
6430 12076 : {
6431 12076 : tree _q20 = TREE_OPERAND (_p0, 0);
6432 12076 : tree _q21 = TREE_OPERAND (_p0, 1);
6433 12076 : switch (TREE_CODE (_p1))
6434 : {
6435 0 : case MIN_EXPR:
6436 0 : {
6437 0 : tree _q50 = TREE_OPERAND (_p1, 0);
6438 0 : tree _q51 = TREE_OPERAND (_p1, 1);
6439 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6440 : {
6441 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6442 : {
6443 0 : {
6444 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6445 0 : if (!HONOR_NANS (captures[0])
6446 : )
6447 : {
6448 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1243;
6449 0 : {
6450 0 : tree res_op0;
6451 0 : res_op0 = captures[0];
6452 0 : tree res_op1;
6453 0 : res_op1 = captures[1];
6454 0 : tree _r;
6455 0 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
6456 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 889, __FILE__, __LINE__, true);
6457 0 : return _r;
6458 : }
6459 0 : next_after_fail1243:;
6460 : }
6461 : }
6462 : }
6463 : }
6464 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6465 : {
6466 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6467 : {
6468 0 : {
6469 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6470 0 : if (!HONOR_NANS (captures[0])
6471 : )
6472 : {
6473 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1244;
6474 0 : {
6475 0 : tree res_op0;
6476 0 : res_op0 = captures[0];
6477 0 : tree res_op1;
6478 0 : res_op1 = captures[1];
6479 0 : tree _r;
6480 0 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
6481 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 889, __FILE__, __LINE__, true);
6482 0 : return _r;
6483 : }
6484 0 : next_after_fail1244:;
6485 : }
6486 : }
6487 : }
6488 : }
6489 : break;
6490 : }
6491 : default:;
6492 : }
6493 : break;
6494 : }
6495 62363509 : default:;
6496 : }
6497 62363509 : switch (TREE_CODE (_p1))
6498 : {
6499 3451435 : case MULT_EXPR:
6500 3451435 : {
6501 3451435 : tree _q30 = TREE_OPERAND (_p1, 0);
6502 3451435 : tree _q31 = TREE_OPERAND (_p1, 1);
6503 3451435 : switch (TREE_CODE (_q30))
6504 : {
6505 145004 : case MINUS_EXPR:
6506 145004 : {
6507 145004 : tree _q40 = TREE_OPERAND (_q30, 0);
6508 145004 : tree _q41 = TREE_OPERAND (_q30, 1);
6509 145004 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
6510 : {
6511 16 : if (tree_zero_one_valued_p (_q31))
6512 : {
6513 0 : {
6514 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q31 };
6515 0 : tree res = generic_simplify_73 (loc, type, _p0, _p1, captures);
6516 0 : if (res) return res;
6517 : }
6518 : }
6519 : }
6520 : break;
6521 : }
6522 3451435 : default:;
6523 : }
6524 3451435 : if (tree_zero_one_valued_p (_q30))
6525 : {
6526 13763 : switch (TREE_CODE (_q31))
6527 : {
6528 0 : case MINUS_EXPR:
6529 0 : {
6530 0 : tree _q50 = TREE_OPERAND (_q31, 0);
6531 0 : tree _q51 = TREE_OPERAND (_q31, 1);
6532 0 : if ((_q51 == _p0 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _p0, 0) && types_match (_q51, _p0)))
6533 : {
6534 0 : {
6535 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q50, _q30 };
6536 0 : tree res = generic_simplify_73 (loc, type, _p0, _p1, captures);
6537 0 : if (res) return res;
6538 : }
6539 : }
6540 : break;
6541 : }
6542 : default:;
6543 : }
6544 : }
6545 : break;
6546 : }
6547 62363509 : default:;
6548 : }
6549 62363509 : switch (TREE_CODE (_p0))
6550 : {
6551 10759144 : case MULT_EXPR:
6552 10759144 : {
6553 10759144 : tree _q20 = TREE_OPERAND (_p0, 0);
6554 10759144 : tree _q21 = TREE_OPERAND (_p0, 1);
6555 10759144 : switch (TREE_CODE (_q20))
6556 : {
6557 18875 : case TRUNC_DIV_EXPR:
6558 18875 : {
6559 18875 : tree _q30 = TREE_OPERAND (_q20, 0);
6560 18875 : tree _q31 = TREE_OPERAND (_q20, 1);
6561 18875 : if ((_q21 == _q31 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q31, 0) && types_match (_q21, _q31)))
6562 : {
6563 2322 : switch (TREE_CODE (_p1))
6564 : {
6565 2 : case TRUNC_MOD_EXPR:
6566 2 : {
6567 2 : tree _q70 = TREE_OPERAND (_p1, 0);
6568 2 : tree _q71 = TREE_OPERAND (_p1, 1);
6569 2 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
6570 : {
6571 2 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
6572 : {
6573 2 : {
6574 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
6575 2 : tree res = generic_simplify_74 (loc, type, _p0, _p1, captures, TRUNC_DIV_EXPR, TRUNC_MOD_EXPR);
6576 2 : if (res) return res;
6577 : }
6578 : }
6579 : }
6580 : break;
6581 : }
6582 : default:;
6583 : }
6584 : }
6585 : break;
6586 : }
6587 0 : case CEIL_DIV_EXPR:
6588 0 : {
6589 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6590 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6591 0 : if ((_q21 == _q31 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q31, 0) && types_match (_q21, _q31)))
6592 : {
6593 0 : switch (TREE_CODE (_p1))
6594 : {
6595 0 : case CEIL_MOD_EXPR:
6596 0 : {
6597 0 : tree _q70 = TREE_OPERAND (_p1, 0);
6598 0 : tree _q71 = TREE_OPERAND (_p1, 1);
6599 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
6600 : {
6601 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
6602 : {
6603 0 : {
6604 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
6605 0 : tree res = generic_simplify_74 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR, CEIL_MOD_EXPR);
6606 0 : if (res) return res;
6607 : }
6608 : }
6609 : }
6610 : break;
6611 : }
6612 : default:;
6613 : }
6614 : }
6615 : break;
6616 : }
6617 0 : case FLOOR_DIV_EXPR:
6618 0 : {
6619 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6620 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6621 0 : if ((_q21 == _q31 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q31, 0) && types_match (_q21, _q31)))
6622 : {
6623 0 : switch (TREE_CODE (_p1))
6624 : {
6625 0 : case FLOOR_MOD_EXPR:
6626 0 : {
6627 0 : tree _q70 = TREE_OPERAND (_p1, 0);
6628 0 : tree _q71 = TREE_OPERAND (_p1, 1);
6629 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
6630 : {
6631 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
6632 : {
6633 0 : {
6634 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
6635 0 : tree res = generic_simplify_74 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR, FLOOR_MOD_EXPR);
6636 0 : if (res) return res;
6637 : }
6638 : }
6639 : }
6640 : break;
6641 : }
6642 : default:;
6643 : }
6644 : }
6645 : break;
6646 : }
6647 0 : case ROUND_DIV_EXPR:
6648 0 : {
6649 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6650 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6651 0 : if ((_q21 == _q31 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q31, 0) && types_match (_q21, _q31)))
6652 : {
6653 0 : switch (TREE_CODE (_p1))
6654 : {
6655 0 : case ROUND_MOD_EXPR:
6656 0 : {
6657 0 : tree _q70 = TREE_OPERAND (_p1, 0);
6658 0 : tree _q71 = TREE_OPERAND (_p1, 1);
6659 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
6660 : {
6661 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
6662 : {
6663 0 : {
6664 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
6665 0 : tree res = generic_simplify_74 (loc, type, _p0, _p1, captures, ROUND_DIV_EXPR, ROUND_MOD_EXPR);
6666 0 : if (res) return res;
6667 : }
6668 : }
6669 : }
6670 : break;
6671 : }
6672 : default:;
6673 : }
6674 : }
6675 : break;
6676 : }
6677 10759142 : default:;
6678 : }
6679 10759142 : switch (TREE_CODE (_q21))
6680 : {
6681 6 : case TRUNC_DIV_EXPR:
6682 6 : {
6683 6 : tree _q40 = TREE_OPERAND (_q21, 0);
6684 6 : tree _q41 = TREE_OPERAND (_q21, 1);
6685 6 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
6686 : {
6687 0 : switch (TREE_CODE (_p1))
6688 : {
6689 0 : case TRUNC_MOD_EXPR:
6690 0 : {
6691 0 : tree _q70 = TREE_OPERAND (_p1, 0);
6692 0 : tree _q71 = TREE_OPERAND (_p1, 1);
6693 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
6694 : {
6695 0 : if ((_q71 == _q20 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q20, 0) && types_match (_q71, _q20)))
6696 : {
6697 0 : {
6698 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
6699 0 : tree res = generic_simplify_74 (loc, type, _p0, _p1, captures, TRUNC_DIV_EXPR, TRUNC_MOD_EXPR);
6700 0 : if (res) return res;
6701 : }
6702 : }
6703 : }
6704 : break;
6705 : }
6706 : default:;
6707 : }
6708 : }
6709 : break;
6710 : }
6711 4 : case CEIL_DIV_EXPR:
6712 4 : {
6713 4 : tree _q40 = TREE_OPERAND (_q21, 0);
6714 4 : tree _q41 = TREE_OPERAND (_q21, 1);
6715 4 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
6716 : {
6717 0 : switch (TREE_CODE (_p1))
6718 : {
6719 0 : case CEIL_MOD_EXPR:
6720 0 : {
6721 0 : tree _q70 = TREE_OPERAND (_p1, 0);
6722 0 : tree _q71 = TREE_OPERAND (_p1, 1);
6723 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
6724 : {
6725 0 : if ((_q71 == _q20 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q20, 0) && types_match (_q71, _q20)))
6726 : {
6727 0 : {
6728 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
6729 0 : tree res = generic_simplify_74 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR, CEIL_MOD_EXPR);
6730 0 : if (res) return res;
6731 : }
6732 : }
6733 : }
6734 : break;
6735 : }
6736 : default:;
6737 : }
6738 : }
6739 : break;
6740 : }
6741 0 : case FLOOR_DIV_EXPR:
6742 0 : {
6743 0 : tree _q40 = TREE_OPERAND (_q21, 0);
6744 0 : tree _q41 = TREE_OPERAND (_q21, 1);
6745 0 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
6746 : {
6747 0 : switch (TREE_CODE (_p1))
6748 : {
6749 0 : case FLOOR_MOD_EXPR:
6750 0 : {
6751 0 : tree _q70 = TREE_OPERAND (_p1, 0);
6752 0 : tree _q71 = TREE_OPERAND (_p1, 1);
6753 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
6754 : {
6755 0 : if ((_q71 == _q20 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q20, 0) && types_match (_q71, _q20)))
6756 : {
6757 0 : {
6758 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
6759 0 : tree res = generic_simplify_74 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR, FLOOR_MOD_EXPR);
6760 0 : if (res) return res;
6761 : }
6762 : }
6763 : }
6764 : break;
6765 : }
6766 : default:;
6767 : }
6768 : }
6769 : break;
6770 : }
6771 0 : case ROUND_DIV_EXPR:
6772 0 : {
6773 0 : tree _q40 = TREE_OPERAND (_q21, 0);
6774 0 : tree _q41 = TREE_OPERAND (_q21, 1);
6775 0 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
6776 : {
6777 0 : switch (TREE_CODE (_p1))
6778 : {
6779 0 : case ROUND_MOD_EXPR:
6780 0 : {
6781 0 : tree _q70 = TREE_OPERAND (_p1, 0);
6782 0 : tree _q71 = TREE_OPERAND (_p1, 1);
6783 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
6784 : {
6785 0 : if ((_q71 == _q20 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q20, 0) && types_match (_q71, _q20)))
6786 : {
6787 0 : {
6788 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
6789 0 : tree res = generic_simplify_74 (loc, type, _p0, _p1, captures, ROUND_DIV_EXPR, ROUND_MOD_EXPR);
6790 0 : if (res) return res;
6791 : }
6792 : }
6793 : }
6794 : break;
6795 : }
6796 : default:;
6797 : }
6798 : }
6799 : break;
6800 : }
6801 : default:;
6802 : }
6803 : break;
6804 : }
6805 29918 : case TRUNC_MOD_EXPR:
6806 29918 : {
6807 29918 : tree _q20 = TREE_OPERAND (_p0, 0);
6808 29918 : tree _q21 = TREE_OPERAND (_p0, 1);
6809 29918 : switch (TREE_CODE (_p1))
6810 : {
6811 119 : case MULT_EXPR:
6812 119 : {
6813 119 : tree _q50 = TREE_OPERAND (_p1, 0);
6814 119 : tree _q51 = TREE_OPERAND (_p1, 1);
6815 119 : switch (TREE_CODE (_q50))
6816 : {
6817 106 : case TRUNC_DIV_EXPR:
6818 106 : {
6819 106 : tree _q60 = TREE_OPERAND (_q50, 0);
6820 106 : tree _q61 = TREE_OPERAND (_q50, 1);
6821 106 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6822 : {
6823 106 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
6824 : {
6825 94 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6826 : {
6827 0 : {
6828 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6829 0 : tree res = generic_simplify_74 (loc, type, _p0, _p1, captures, TRUNC_DIV_EXPR, TRUNC_MOD_EXPR);
6830 0 : if (res) return res;
6831 : }
6832 : }
6833 : }
6834 : }
6835 : break;
6836 : }
6837 119 : default:;
6838 : }
6839 119 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6840 : {
6841 0 : switch (TREE_CODE (_q51))
6842 : {
6843 0 : case TRUNC_DIV_EXPR:
6844 0 : {
6845 0 : tree _q70 = TREE_OPERAND (_q51, 0);
6846 0 : tree _q71 = TREE_OPERAND (_q51, 1);
6847 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
6848 : {
6849 0 : if ((_q71 == _q21 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q21, 0) && types_match (_q71, _q21)))
6850 : {
6851 0 : {
6852 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6853 0 : tree res = generic_simplify_74 (loc, type, _p0, _p1, captures, TRUNC_DIV_EXPR, TRUNC_MOD_EXPR);
6854 0 : if (res) return res;
6855 : }
6856 : }
6857 : }
6858 : break;
6859 : }
6860 : default:;
6861 : }
6862 : }
6863 : break;
6864 : }
6865 : default:;
6866 : }
6867 : break;
6868 : }
6869 0 : case CEIL_MOD_EXPR:
6870 0 : {
6871 0 : tree _q20 = TREE_OPERAND (_p0, 0);
6872 0 : tree _q21 = TREE_OPERAND (_p0, 1);
6873 0 : switch (TREE_CODE (_p1))
6874 : {
6875 0 : case MULT_EXPR:
6876 0 : {
6877 0 : tree _q50 = TREE_OPERAND (_p1, 0);
6878 0 : tree _q51 = TREE_OPERAND (_p1, 1);
6879 0 : switch (TREE_CODE (_q50))
6880 : {
6881 0 : case CEIL_DIV_EXPR:
6882 0 : {
6883 0 : tree _q60 = TREE_OPERAND (_q50, 0);
6884 0 : tree _q61 = TREE_OPERAND (_q50, 1);
6885 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6886 : {
6887 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
6888 : {
6889 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6890 : {
6891 0 : {
6892 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6893 0 : tree res = generic_simplify_74 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR, CEIL_MOD_EXPR);
6894 0 : if (res) return res;
6895 : }
6896 : }
6897 : }
6898 : }
6899 : break;
6900 : }
6901 0 : default:;
6902 : }
6903 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6904 : {
6905 0 : switch (TREE_CODE (_q51))
6906 : {
6907 0 : case CEIL_DIV_EXPR:
6908 0 : {
6909 0 : tree _q70 = TREE_OPERAND (_q51, 0);
6910 0 : tree _q71 = TREE_OPERAND (_q51, 1);
6911 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
6912 : {
6913 0 : if ((_q71 == _q21 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q21, 0) && types_match (_q71, _q21)))
6914 : {
6915 0 : {
6916 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6917 0 : tree res = generic_simplify_74 (loc, type, _p0, _p1, captures, CEIL_DIV_EXPR, CEIL_MOD_EXPR);
6918 0 : if (res) return res;
6919 : }
6920 : }
6921 : }
6922 : break;
6923 : }
6924 : default:;
6925 : }
6926 : }
6927 : break;
6928 : }
6929 : default:;
6930 : }
6931 : break;
6932 : }
6933 126 : case FLOOR_MOD_EXPR:
6934 126 : {
6935 126 : tree _q20 = TREE_OPERAND (_p0, 0);
6936 126 : tree _q21 = TREE_OPERAND (_p0, 1);
6937 126 : switch (TREE_CODE (_p1))
6938 : {
6939 0 : case MULT_EXPR:
6940 0 : {
6941 0 : tree _q50 = TREE_OPERAND (_p1, 0);
6942 0 : tree _q51 = TREE_OPERAND (_p1, 1);
6943 0 : switch (TREE_CODE (_q50))
6944 : {
6945 0 : case FLOOR_DIV_EXPR:
6946 0 : {
6947 0 : tree _q60 = TREE_OPERAND (_q50, 0);
6948 0 : tree _q61 = TREE_OPERAND (_q50, 1);
6949 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6950 : {
6951 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
6952 : {
6953 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6954 : {
6955 0 : {
6956 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6957 0 : tree res = generic_simplify_74 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR, FLOOR_MOD_EXPR);
6958 0 : if (res) return res;
6959 : }
6960 : }
6961 : }
6962 : }
6963 : break;
6964 : }
6965 0 : default:;
6966 : }
6967 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6968 : {
6969 0 : switch (TREE_CODE (_q51))
6970 : {
6971 0 : case FLOOR_DIV_EXPR:
6972 0 : {
6973 0 : tree _q70 = TREE_OPERAND (_q51, 0);
6974 0 : tree _q71 = TREE_OPERAND (_q51, 1);
6975 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
6976 : {
6977 0 : if ((_q71 == _q21 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q21, 0) && types_match (_q71, _q21)))
6978 : {
6979 0 : {
6980 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6981 0 : tree res = generic_simplify_74 (loc, type, _p0, _p1, captures, FLOOR_DIV_EXPR, FLOOR_MOD_EXPR);
6982 0 : if (res) return res;
6983 : }
6984 : }
6985 : }
6986 : break;
6987 : }
6988 : default:;
6989 : }
6990 : }
6991 : break;
6992 : }
6993 : default:;
6994 : }
6995 : break;
6996 : }
6997 0 : case ROUND_MOD_EXPR:
6998 0 : {
6999 0 : tree _q20 = TREE_OPERAND (_p0, 0);
7000 0 : tree _q21 = TREE_OPERAND (_p0, 1);
7001 0 : switch (TREE_CODE (_p1))
7002 : {
7003 0 : case MULT_EXPR:
7004 0 : {
7005 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7006 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7007 0 : switch (TREE_CODE (_q50))
7008 : {
7009 0 : case ROUND_DIV_EXPR:
7010 0 : {
7011 0 : tree _q60 = TREE_OPERAND (_q50, 0);
7012 0 : tree _q61 = TREE_OPERAND (_q50, 1);
7013 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7014 : {
7015 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
7016 : {
7017 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7018 : {
7019 0 : {
7020 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7021 0 : tree res = generic_simplify_74 (loc, type, _p0, _p1, captures, ROUND_DIV_EXPR, ROUND_MOD_EXPR);
7022 0 : if (res) return res;
7023 : }
7024 : }
7025 : }
7026 : }
7027 : break;
7028 : }
7029 0 : default:;
7030 : }
7031 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7032 : {
7033 0 : switch (TREE_CODE (_q51))
7034 : {
7035 0 : case ROUND_DIV_EXPR:
7036 0 : {
7037 0 : tree _q70 = TREE_OPERAND (_q51, 0);
7038 0 : tree _q71 = TREE_OPERAND (_q51, 1);
7039 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
7040 : {
7041 0 : if ((_q71 == _q21 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q21, 0) && types_match (_q71, _q21)))
7042 : {
7043 0 : {
7044 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7045 0 : tree res = generic_simplify_74 (loc, type, _p0, _p1, captures, ROUND_DIV_EXPR, ROUND_MOD_EXPR);
7046 0 : if (res) return res;
7047 : }
7048 : }
7049 : }
7050 : break;
7051 : }
7052 : default:;
7053 : }
7054 : }
7055 : break;
7056 : }
7057 : default:;
7058 : }
7059 : break;
7060 : }
7061 62363507 : default:;
7062 : }
7063 62363507 : switch (TREE_CODE (_p1))
7064 : {
7065 3074596 : case REAL_CST:
7066 3074596 : {
7067 3074596 : {
7068 3074596 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
7069 3074596 : if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (captures[1]))
7070 : )
7071 : {
7072 113852 : {
7073 113852 : tree tem = const_unop (NEGATE_EXPR, type, captures[1]);
7074 113852 : if (!TREE_OVERFLOW (tem) || !flag_trapping_math
7075 : )
7076 : {
7077 113852 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1245;
7078 113852 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1245;
7079 113852 : {
7080 113852 : tree res_op0;
7081 113852 : res_op0 = captures[0];
7082 113852 : tree res_op1;
7083 113852 : res_op1 = tem;
7084 113852 : tree _r;
7085 113852 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
7086 113852 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
7087 113852 : return _r;
7088 : }
7089 2960744 : next_after_fail1245:;
7090 : }
7091 : }
7092 : }
7093 : }
7094 2960744 : break;
7095 : }
7096 62249655 : default:;
7097 : }
7098 62249655 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
7099 : {
7100 1585313 : {
7101 1585313 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
7102 1585313 : if (SCALAR_FLOAT_TYPE_P (type)
7103 : )
7104 : {
7105 683 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1246;
7106 683 : {
7107 683 : tree res_op0;
7108 683 : res_op0 = captures[0];
7109 683 : tree res_op1;
7110 683 : res_op1 = build_real (type, dconst2);
7111 683 : tree _r;
7112 683 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
7113 683 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
7114 683 : return _r;
7115 : }
7116 0 : next_after_fail1246:;
7117 : }
7118 : else
7119 : {
7120 1584630 : if (INTEGRAL_TYPE_P (type)
7121 : )
7122 : {
7123 1584554 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1247;
7124 1584554 : {
7125 1584554 : tree res_op0;
7126 1584554 : res_op0 = captures[0];
7127 1584554 : tree res_op1;
7128 1584554 : res_op1 = build_int_cst (type, 2);
7129 1584554 : tree _r;
7130 1584554 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
7131 1584554 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 898, __FILE__, __LINE__, true);
7132 1584554 : return _r;
7133 : }
7134 0 : next_after_fail1247:;
7135 : }
7136 : }
7137 : }
7138 : }
7139 60664418 : switch (TREE_CODE (_p0))
7140 : {
7141 144 : case VEC_COND_EXPR:
7142 144 : {
7143 144 : tree _q20 = TREE_OPERAND (_p0, 0);
7144 144 : tree _q21 = TREE_OPERAND (_p0, 1);
7145 144 : tree _q22 = TREE_OPERAND (_p0, 2);
7146 144 : switch (TREE_CODE (_p1))
7147 : {
7148 48 : case VEC_COND_EXPR:
7149 48 : {
7150 48 : tree _q60 = TREE_OPERAND (_p1, 0);
7151 48 : tree _q61 = TREE_OPERAND (_p1, 1);
7152 48 : tree _q62 = TREE_OPERAND (_p1, 2);
7153 48 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7154 : {
7155 24 : {
7156 24 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
7157 24 : if (VECTOR_TYPE_P (type)
7158 24 : && (TREE_CODE_CLASS (PLUS_EXPR) != tcc_comparison
7159 : || types_match (type, TREE_TYPE (captures[2]))
7160 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
7161 : || (optimize_vectors_before_lowering_p ()
7162 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
7163 : )
7164 : {
7165 24 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1248;
7166 24 : {
7167 24 : tree res_op0;
7168 24 : res_op0 = captures[1];
7169 24 : tree res_op1;
7170 24 : {
7171 24 : tree _o1[2], _r1;
7172 24 : _o1[0] = captures[2];
7173 24 : _o1[1] = captures[5];
7174 24 : _r1 = fold_build2_loc (loc, PLUS_EXPR, type, _o1[0], _o1[1]);
7175 24 : if (EXPR_P (_r1))
7176 0 : goto next_after_fail1248;
7177 24 : res_op1 = _r1;
7178 : }
7179 24 : tree res_op2;
7180 24 : {
7181 24 : tree _o1[2], _r1;
7182 24 : _o1[0] = captures[3];
7183 24 : _o1[1] = captures[6];
7184 24 : _r1 = fold_build2_loc (loc, PLUS_EXPR, type, _o1[0], _o1[1]);
7185 24 : if (EXPR_P (_r1))
7186 0 : goto next_after_fail1248;
7187 24 : res_op2 = _r1;
7188 : }
7189 24 : tree _r;
7190 24 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7191 24 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 890, __FILE__, __LINE__, true);
7192 24 : return _r;
7193 : }
7194 0 : next_after_fail1248:;
7195 : }
7196 : }
7197 : }
7198 : break;
7199 : }
7200 120 : default:;
7201 : }
7202 120 : {
7203 120 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
7204 120 : if (VECTOR_TYPE_P (type)
7205 120 : && (TREE_CODE_CLASS (PLUS_EXPR) != tcc_comparison
7206 : || types_match (type, TREE_TYPE (captures[2]))
7207 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
7208 : || (optimize_vectors_before_lowering_p ()
7209 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
7210 : )
7211 : {
7212 120 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1249;
7213 120 : {
7214 120 : if (! tree_invariant_p (captures[4])) goto next_after_fail1249;
7215 26 : tree res_op0;
7216 26 : res_op0 = captures[1];
7217 26 : tree res_op1;
7218 26 : {
7219 26 : tree _o1[2], _r1;
7220 26 : _o1[0] = captures[2];
7221 26 : _o1[1] = unshare_expr (captures[4]);
7222 26 : _r1 = fold_build2_loc (loc, PLUS_EXPR, type, _o1[0], _o1[1]);
7223 26 : if (EXPR_P (_r1))
7224 0 : goto next_after_fail1249;
7225 26 : res_op1 = _r1;
7226 : }
7227 26 : tree res_op2;
7228 26 : {
7229 26 : tree _o1[2], _r1;
7230 26 : _o1[0] = captures[3];
7231 26 : _o1[1] = captures[4];
7232 26 : _r1 = fold_build2_loc (loc, PLUS_EXPR, type, _o1[0], _o1[1]);
7233 26 : if (EXPR_P (_r1))
7234 0 : goto next_after_fail1249;
7235 26 : res_op2 = _r1;
7236 : }
7237 26 : tree _r;
7238 26 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7239 26 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
7240 26 : return _r;
7241 : }
7242 94 : next_after_fail1249:;
7243 : }
7244 : }
7245 94 : if (integer_each_onep (_q21))
7246 : {
7247 0 : if (integer_zerop (_q22))
7248 : {
7249 0 : {
7250 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _p0, _q20, _q21, _q22 };
7251 0 : tree res = generic_simplify_75 (loc, type, _p0, _p1, captures);
7252 0 : if (res) return res;
7253 : }
7254 : }
7255 : }
7256 : break;
7257 : }
7258 60664368 : default:;
7259 : }
7260 60664368 : switch (TREE_CODE (_p1))
7261 : {
7262 40 : case VEC_COND_EXPR:
7263 40 : {
7264 40 : tree _q30 = TREE_OPERAND (_p1, 0);
7265 40 : tree _q31 = TREE_OPERAND (_p1, 1);
7266 40 : tree _q32 = TREE_OPERAND (_p1, 2);
7267 40 : {
7268 40 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
7269 40 : if (VECTOR_TYPE_P (type)
7270 40 : && (TREE_CODE_CLASS (PLUS_EXPR) != tcc_comparison
7271 : || types_match (type, TREE_TYPE (captures[3]))
7272 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
7273 : || (optimize_vectors_before_lowering_p ()
7274 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
7275 : )
7276 : {
7277 40 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1250;
7278 40 : {
7279 40 : if (! tree_invariant_p (captures[0])) goto next_after_fail1250;
7280 0 : tree res_op0;
7281 0 : res_op0 = captures[2];
7282 0 : tree res_op1;
7283 0 : {
7284 0 : tree _o1[2], _r1;
7285 0 : _o1[0] = unshare_expr (captures[0]);
7286 0 : _o1[1] = captures[3];
7287 0 : _r1 = fold_build2_loc (loc, PLUS_EXPR, type, _o1[0], _o1[1]);
7288 0 : if (EXPR_P (_r1))
7289 0 : goto next_after_fail1250;
7290 0 : res_op1 = _r1;
7291 : }
7292 0 : tree res_op2;
7293 0 : {
7294 0 : tree _o1[2], _r1;
7295 0 : _o1[0] = captures[0];
7296 0 : _o1[1] = captures[4];
7297 0 : _r1 = fold_build2_loc (loc, PLUS_EXPR, type, _o1[0], _o1[1]);
7298 0 : if (EXPR_P (_r1))
7299 0 : goto next_after_fail1250;
7300 0 : res_op2 = _r1;
7301 : }
7302 0 : tree _r;
7303 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7304 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
7305 0 : return _r;
7306 : }
7307 40 : next_after_fail1250:;
7308 : }
7309 : }
7310 40 : break;
7311 : }
7312 327256 : case VIEW_CONVERT_EXPR:
7313 327256 : {
7314 327256 : tree _q30 = TREE_OPERAND (_p1, 0);
7315 327256 : switch (TREE_CODE (_q30))
7316 : {
7317 0 : case VEC_COND_EXPR:
7318 0 : {
7319 0 : tree _q40 = TREE_OPERAND (_q30, 0);
7320 0 : tree _q41 = TREE_OPERAND (_q30, 1);
7321 0 : tree _q42 = TREE_OPERAND (_q30, 2);
7322 0 : if (integer_each_onep (_q41))
7323 : {
7324 0 : if (integer_zerop (_q42))
7325 : {
7326 0 : {
7327 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q30, _q40, _q41, _q42 };
7328 0 : tree res = generic_simplify_75 (loc, type, _p0, _p1, captures);
7329 0 : if (res) return res;
7330 : }
7331 : }
7332 : }
7333 : break;
7334 : }
7335 : default:;
7336 : }
7337 : break;
7338 : }
7339 60664368 : default:;
7340 : }
7341 60664368 : switch (TREE_CODE (_p0))
7342 : {
7343 316396 : case VIEW_CONVERT_EXPR:
7344 316396 : {
7345 316396 : tree _q20 = TREE_OPERAND (_p0, 0);
7346 316396 : switch (TREE_CODE (_q20))
7347 : {
7348 0 : case VEC_COND_EXPR:
7349 0 : {
7350 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7351 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7352 0 : tree _q32 = TREE_OPERAND (_q20, 2);
7353 0 : if (integer_each_onep (_q31))
7354 : {
7355 0 : if (integer_zerop (_q32))
7356 : {
7357 0 : {
7358 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q20, _q30, _q31, _q32 };
7359 0 : tree res = generic_simplify_75 (loc, type, _p0, _p1, captures);
7360 0 : if (res) return res;
7361 : }
7362 : }
7363 : }
7364 : break;
7365 : }
7366 : default:;
7367 : }
7368 : break;
7369 : }
7370 60664368 : default:;
7371 : }
7372 60664368 : switch (TREE_CODE (_p1))
7373 : {
7374 40 : case VEC_COND_EXPR:
7375 40 : {
7376 40 : tree _q30 = TREE_OPERAND (_p1, 0);
7377 40 : tree _q31 = TREE_OPERAND (_p1, 1);
7378 40 : tree _q32 = TREE_OPERAND (_p1, 2);
7379 40 : if (integer_each_onep (_q31))
7380 : {
7381 0 : if (integer_zerop (_q32))
7382 : {
7383 0 : {
7384 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
7385 0 : tree res = generic_simplify_75 (loc, type, _p0, _p1, captures);
7386 0 : if (res) return res;
7387 : }
7388 : }
7389 : }
7390 : break;
7391 : }
7392 60664368 : default:;
7393 : }
7394 60664368 : switch (TREE_CODE (_p0))
7395 : {
7396 17088975 : CASE_CONVERT:
7397 17088975 : {
7398 17088975 : tree _q20 = TREE_OPERAND (_p0, 0);
7399 17088975 : switch (TREE_CODE (_q20))
7400 : {
7401 0 : case LT_EXPR:
7402 0 : {
7403 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7404 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7405 0 : if (integer_minus_onep (_p1))
7406 : {
7407 0 : {
7408 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7409 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, LT_EXPR, GE_EXPR, UNGE_EXPR);
7410 0 : if (res) return res;
7411 : }
7412 : }
7413 : break;
7414 : }
7415 0 : case LE_EXPR:
7416 0 : {
7417 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7418 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7419 0 : if (integer_minus_onep (_p1))
7420 : {
7421 0 : {
7422 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7423 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR, UNGT_EXPR);
7424 0 : if (res) return res;
7425 : }
7426 : }
7427 : break;
7428 : }
7429 78 : case EQ_EXPR:
7430 78 : {
7431 78 : tree _q30 = TREE_OPERAND (_q20, 0);
7432 78 : tree _q31 = TREE_OPERAND (_q20, 1);
7433 78 : if (integer_minus_onep (_p1))
7434 : {
7435 0 : {
7436 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7437 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR, NE_EXPR);
7438 0 : if (res) return res;
7439 : }
7440 : }
7441 : break;
7442 : }
7443 224 : case NE_EXPR:
7444 224 : {
7445 224 : tree _q30 = TREE_OPERAND (_q20, 0);
7446 224 : tree _q31 = TREE_OPERAND (_q20, 1);
7447 224 : if (integer_minus_onep (_p1))
7448 : {
7449 0 : {
7450 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7451 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR, EQ_EXPR);
7452 0 : if (res) return res;
7453 : }
7454 : }
7455 : break;
7456 : }
7457 12 : case GE_EXPR:
7458 12 : {
7459 12 : tree _q30 = TREE_OPERAND (_q20, 0);
7460 12 : tree _q31 = TREE_OPERAND (_q20, 1);
7461 12 : if (integer_minus_onep (_p1))
7462 : {
7463 0 : {
7464 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7465 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, GE_EXPR, LT_EXPR, UNLT_EXPR);
7466 0 : if (res) return res;
7467 : }
7468 : }
7469 : break;
7470 : }
7471 1 : case GT_EXPR:
7472 1 : {
7473 1 : tree _q30 = TREE_OPERAND (_q20, 0);
7474 1 : tree _q31 = TREE_OPERAND (_q20, 1);
7475 1 : if (integer_minus_onep (_p1))
7476 : {
7477 0 : {
7478 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7479 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, GT_EXPR, LE_EXPR, UNLE_EXPR);
7480 0 : if (res) return res;
7481 : }
7482 : }
7483 : break;
7484 : }
7485 0 : case UNORDERED_EXPR:
7486 0 : {
7487 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7488 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7489 0 : if (integer_minus_onep (_p1))
7490 : {
7491 0 : {
7492 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7493 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR);
7494 0 : if (res) return res;
7495 : }
7496 : }
7497 : break;
7498 : }
7499 0 : case ORDERED_EXPR:
7500 0 : {
7501 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7502 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7503 0 : if (integer_minus_onep (_p1))
7504 : {
7505 0 : {
7506 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7507 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR);
7508 0 : if (res) return res;
7509 : }
7510 : }
7511 : break;
7512 : }
7513 0 : case UNLT_EXPR:
7514 0 : {
7515 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7516 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7517 0 : if (integer_minus_onep (_p1))
7518 : {
7519 0 : {
7520 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7521 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, UNLT_EXPR, GE_EXPR, GE_EXPR);
7522 0 : if (res) return res;
7523 : }
7524 : }
7525 : break;
7526 : }
7527 0 : case UNLE_EXPR:
7528 0 : {
7529 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7530 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7531 0 : if (integer_minus_onep (_p1))
7532 : {
7533 0 : {
7534 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7535 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, UNLE_EXPR, GT_EXPR, GT_EXPR);
7536 0 : if (res) return res;
7537 : }
7538 : }
7539 : break;
7540 : }
7541 0 : case UNGT_EXPR:
7542 0 : {
7543 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7544 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7545 0 : if (integer_minus_onep (_p1))
7546 : {
7547 0 : {
7548 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7549 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, UNGT_EXPR, LE_EXPR, LE_EXPR);
7550 0 : if (res) return res;
7551 : }
7552 : }
7553 : break;
7554 : }
7555 0 : case UNGE_EXPR:
7556 0 : {
7557 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7558 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7559 0 : if (integer_minus_onep (_p1))
7560 : {
7561 0 : {
7562 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7563 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, UNGE_EXPR, LT_EXPR, LT_EXPR);
7564 0 : if (res) return res;
7565 : }
7566 : }
7567 : break;
7568 : }
7569 0 : case UNEQ_EXPR:
7570 0 : {
7571 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7572 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7573 0 : if (integer_minus_onep (_p1))
7574 : {
7575 0 : {
7576 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7577 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR);
7578 0 : if (res) return res;
7579 : }
7580 : }
7581 : break;
7582 : }
7583 0 : case LTGT_EXPR:
7584 0 : {
7585 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7586 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7587 0 : if (integer_minus_onep (_p1))
7588 : {
7589 0 : {
7590 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
7591 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR);
7592 0 : if (res) return res;
7593 : }
7594 : }
7595 : break;
7596 : }
7597 : default:;
7598 : }
7599 : break;
7600 : }
7601 155 : case LT_EXPR:
7602 155 : {
7603 155 : tree _q20 = TREE_OPERAND (_p0, 0);
7604 155 : tree _q21 = TREE_OPERAND (_p0, 1);
7605 155 : if (integer_minus_onep (_p1))
7606 : {
7607 0 : {
7608 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
7609 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, LT_EXPR, GE_EXPR, UNGE_EXPR);
7610 0 : if (res) return res;
7611 : }
7612 : }
7613 : break;
7614 : }
7615 49 : case LE_EXPR:
7616 49 : {
7617 49 : tree _q20 = TREE_OPERAND (_p0, 0);
7618 49 : tree _q21 = TREE_OPERAND (_p0, 1);
7619 49 : if (integer_minus_onep (_p1))
7620 : {
7621 0 : {
7622 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
7623 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR, UNGT_EXPR);
7624 0 : if (res) return res;
7625 : }
7626 : }
7627 : break;
7628 : }
7629 14901 : case EQ_EXPR:
7630 14901 : {
7631 14901 : tree _q20 = TREE_OPERAND (_p0, 0);
7632 14901 : tree _q21 = TREE_OPERAND (_p0, 1);
7633 14901 : if (integer_minus_onep (_p1))
7634 : {
7635 23 : {
7636 23 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
7637 23 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR, NE_EXPR);
7638 23 : if (res) return res;
7639 : }
7640 : }
7641 : break;
7642 : }
7643 1677 : case NE_EXPR:
7644 1677 : {
7645 1677 : tree _q20 = TREE_OPERAND (_p0, 0);
7646 1677 : tree _q21 = TREE_OPERAND (_p0, 1);
7647 1677 : if (integer_minus_onep (_p1))
7648 : {
7649 33 : {
7650 33 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
7651 33 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR, EQ_EXPR);
7652 33 : if (res) return res;
7653 : }
7654 : }
7655 : break;
7656 : }
7657 35 : case GE_EXPR:
7658 35 : {
7659 35 : tree _q20 = TREE_OPERAND (_p0, 0);
7660 35 : tree _q21 = TREE_OPERAND (_p0, 1);
7661 35 : if (integer_minus_onep (_p1))
7662 : {
7663 0 : {
7664 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
7665 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, GE_EXPR, LT_EXPR, UNLT_EXPR);
7666 0 : if (res) return res;
7667 : }
7668 : }
7669 : break;
7670 : }
7671 103 : case GT_EXPR:
7672 103 : {
7673 103 : tree _q20 = TREE_OPERAND (_p0, 0);
7674 103 : tree _q21 = TREE_OPERAND (_p0, 1);
7675 103 : if (integer_minus_onep (_p1))
7676 : {
7677 0 : {
7678 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
7679 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, GT_EXPR, LE_EXPR, UNLE_EXPR);
7680 0 : if (res) return res;
7681 : }
7682 : }
7683 : break;
7684 : }
7685 0 : case UNORDERED_EXPR:
7686 0 : {
7687 0 : tree _q20 = TREE_OPERAND (_p0, 0);
7688 0 : tree _q21 = TREE_OPERAND (_p0, 1);
7689 0 : if (integer_minus_onep (_p1))
7690 : {
7691 0 : {
7692 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
7693 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR);
7694 0 : if (res) return res;
7695 : }
7696 : }
7697 : break;
7698 : }
7699 0 : case ORDERED_EXPR:
7700 0 : {
7701 0 : tree _q20 = TREE_OPERAND (_p0, 0);
7702 0 : tree _q21 = TREE_OPERAND (_p0, 1);
7703 0 : if (integer_minus_onep (_p1))
7704 : {
7705 0 : {
7706 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
7707 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR);
7708 0 : if (res) return res;
7709 : }
7710 : }
7711 : break;
7712 : }
7713 0 : case UNLT_EXPR:
7714 0 : {
7715 0 : tree _q20 = TREE_OPERAND (_p0, 0);
7716 0 : tree _q21 = TREE_OPERAND (_p0, 1);
7717 0 : if (integer_minus_onep (_p1))
7718 : {
7719 0 : {
7720 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
7721 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, UNLT_EXPR, GE_EXPR, GE_EXPR);
7722 0 : if (res) return res;
7723 : }
7724 : }
7725 : break;
7726 : }
7727 0 : case UNLE_EXPR:
7728 0 : {
7729 0 : tree _q20 = TREE_OPERAND (_p0, 0);
7730 0 : tree _q21 = TREE_OPERAND (_p0, 1);
7731 0 : if (integer_minus_onep (_p1))
7732 : {
7733 0 : {
7734 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
7735 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, UNLE_EXPR, GT_EXPR, GT_EXPR);
7736 0 : if (res) return res;
7737 : }
7738 : }
7739 : break;
7740 : }
7741 0 : case UNGT_EXPR:
7742 0 : {
7743 0 : tree _q20 = TREE_OPERAND (_p0, 0);
7744 0 : tree _q21 = TREE_OPERAND (_p0, 1);
7745 0 : if (integer_minus_onep (_p1))
7746 : {
7747 0 : {
7748 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
7749 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, UNGT_EXPR, LE_EXPR, LE_EXPR);
7750 0 : if (res) return res;
7751 : }
7752 : }
7753 : break;
7754 : }
7755 0 : case UNGE_EXPR:
7756 0 : {
7757 0 : tree _q20 = TREE_OPERAND (_p0, 0);
7758 0 : tree _q21 = TREE_OPERAND (_p0, 1);
7759 0 : if (integer_minus_onep (_p1))
7760 : {
7761 0 : {
7762 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
7763 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, UNGE_EXPR, LT_EXPR, LT_EXPR);
7764 0 : if (res) return res;
7765 : }
7766 : }
7767 : break;
7768 : }
7769 0 : case UNEQ_EXPR:
7770 0 : {
7771 0 : tree _q20 = TREE_OPERAND (_p0, 0);
7772 0 : tree _q21 = TREE_OPERAND (_p0, 1);
7773 0 : if (integer_minus_onep (_p1))
7774 : {
7775 0 : {
7776 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
7777 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR);
7778 0 : if (res) return res;
7779 : }
7780 : }
7781 : break;
7782 : }
7783 0 : case LTGT_EXPR:
7784 0 : {
7785 0 : tree _q20 = TREE_OPERAND (_p0, 0);
7786 0 : tree _q21 = TREE_OPERAND (_p0, 1);
7787 0 : if (integer_minus_onep (_p1))
7788 : {
7789 0 : {
7790 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
7791 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR);
7792 0 : if (res) return res;
7793 : }
7794 : }
7795 : break;
7796 : }
7797 522051 : case RDIV_EXPR:
7798 522051 : {
7799 522051 : tree _q20 = TREE_OPERAND (_p0, 0);
7800 522051 : tree _q21 = TREE_OPERAND (_p0, 1);
7801 522051 : switch (TREE_CODE (_p1))
7802 : {
7803 111138 : case RDIV_EXPR:
7804 111138 : {
7805 111138 : tree _q50 = TREE_OPERAND (_p1, 0);
7806 111138 : tree _q51 = TREE_OPERAND (_p1, 1);
7807 111138 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7808 : {
7809 1 : {
7810 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
7811 1 : tree res = generic_simplify_77 (loc, type, _p0, _p1, captures, PLUS_EXPR);
7812 1 : if (res) return res;
7813 : }
7814 : }
7815 : break;
7816 : }
7817 : default:;
7818 : }
7819 : break;
7820 : }
7821 1642089 : case MINUS_EXPR:
7822 1642089 : {
7823 1642089 : tree _q20 = TREE_OPERAND (_p0, 0);
7824 1642089 : tree _q21 = TREE_OPERAND (_p0, 1);
7825 1642089 : switch (TREE_CODE (_q20))
7826 : {
7827 41 : case CALL_EXPR:
7828 41 : switch (get_call_combined_fn (_q20))
7829 : {
7830 4 : case CFN_BUILT_IN_POPCOUNT:
7831 4 : if (call_expr_nargs (_q20) == 1)
7832 : {
7833 4 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
7834 4 : switch (TREE_CODE (_q21))
7835 : {
7836 4 : case CALL_EXPR:
7837 4 : switch (get_call_combined_fn (_q21))
7838 : {
7839 4 : case CFN_BUILT_IN_POPCOUNT:
7840 4 : if (call_expr_nargs (_q21) == 1)
7841 : {
7842 4 : tree _q50 = CALL_EXPR_ARG (_q21, 0);
7843 4 : switch (TREE_CODE (_q50))
7844 : {
7845 2 : case BIT_AND_EXPR:
7846 2 : {
7847 2 : tree _q60 = TREE_OPERAND (_q50, 0);
7848 2 : tree _q61 = TREE_OPERAND (_q50, 1);
7849 2 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
7850 : {
7851 1 : switch (TREE_CODE (_p1))
7852 : {
7853 1 : case CALL_EXPR:
7854 1 : switch (get_call_combined_fn (_p1))
7855 : {
7856 1 : case CFN_BUILT_IN_POPCOUNT:
7857 1 : if (call_expr_nargs (_p1) == 1)
7858 : {
7859 1 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
7860 1 : if ((_q90 == _q61 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q61, 0) && types_match (_q90, _q61)))
7861 : {
7862 1 : {
7863 1 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q61, _p1 };
7864 1 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNT);
7865 1 : if (res) return res;
7866 : }
7867 : }
7868 : }
7869 : break;
7870 : default:;
7871 : }
7872 : break;
7873 : default:;
7874 : }
7875 : }
7876 1 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
7877 : {
7878 1 : switch (TREE_CODE (_p1))
7879 : {
7880 1 : case CALL_EXPR:
7881 1 : switch (get_call_combined_fn (_p1))
7882 : {
7883 1 : case CFN_BUILT_IN_POPCOUNT:
7884 1 : if (call_expr_nargs (_p1) == 1)
7885 : {
7886 1 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
7887 1 : if ((_q90 == _q60 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q60, 0) && types_match (_q90, _q60)))
7888 : {
7889 1 : {
7890 1 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q60, _p1 };
7891 1 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNT);
7892 1 : if (res) return res;
7893 : }
7894 : }
7895 : }
7896 : break;
7897 : default:;
7898 : }
7899 : break;
7900 : default:;
7901 : }
7902 : }
7903 : break;
7904 : }
7905 2 : case BIT_IOR_EXPR:
7906 2 : {
7907 2 : tree _q60 = TREE_OPERAND (_q50, 0);
7908 2 : tree _q61 = TREE_OPERAND (_q50, 1);
7909 2 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
7910 : {
7911 1 : switch (TREE_CODE (_p1))
7912 : {
7913 1 : case CALL_EXPR:
7914 1 : switch (get_call_combined_fn (_p1))
7915 : {
7916 1 : case CFN_BUILT_IN_POPCOUNT:
7917 1 : if (call_expr_nargs (_p1) == 1)
7918 : {
7919 1 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
7920 1 : if ((_q90 == _q61 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q61, 0) && types_match (_q90, _q61)))
7921 : {
7922 1 : {
7923 1 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q61, _p1 };
7924 1 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNT);
7925 1 : if (res) return res;
7926 : }
7927 : }
7928 : }
7929 : break;
7930 : default:;
7931 : }
7932 : break;
7933 : default:;
7934 : }
7935 : }
7936 1 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
7937 : {
7938 1 : switch (TREE_CODE (_p1))
7939 : {
7940 1 : case CALL_EXPR:
7941 1 : switch (get_call_combined_fn (_p1))
7942 : {
7943 1 : case CFN_BUILT_IN_POPCOUNT:
7944 1 : if (call_expr_nargs (_p1) == 1)
7945 : {
7946 1 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
7947 1 : if ((_q90 == _q60 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q60, 0) && types_match (_q90, _q60)))
7948 : {
7949 1 : {
7950 1 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q60, _p1 };
7951 1 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNT);
7952 1 : if (res) return res;
7953 : }
7954 : }
7955 : }
7956 : break;
7957 : default:;
7958 : }
7959 : break;
7960 : default:;
7961 : }
7962 : }
7963 : break;
7964 : }
7965 : default:;
7966 : }
7967 : }
7968 : break;
7969 : default:;
7970 : }
7971 : break;
7972 : default:;
7973 : }
7974 : }
7975 : break;
7976 0 : case CFN_BUILT_IN_POPCOUNTLL:
7977 0 : if (call_expr_nargs (_q20) == 1)
7978 : {
7979 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
7980 0 : switch (TREE_CODE (_q21))
7981 : {
7982 0 : case CALL_EXPR:
7983 0 : switch (get_call_combined_fn (_q21))
7984 : {
7985 0 : case CFN_BUILT_IN_POPCOUNTLL:
7986 0 : if (call_expr_nargs (_q21) == 1)
7987 : {
7988 0 : tree _q50 = CALL_EXPR_ARG (_q21, 0);
7989 0 : switch (TREE_CODE (_q50))
7990 : {
7991 0 : case BIT_AND_EXPR:
7992 0 : {
7993 0 : tree _q60 = TREE_OPERAND (_q50, 0);
7994 0 : tree _q61 = TREE_OPERAND (_q50, 1);
7995 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
7996 : {
7997 0 : switch (TREE_CODE (_p1))
7998 : {
7999 0 : case CALL_EXPR:
8000 0 : switch (get_call_combined_fn (_p1))
8001 : {
8002 0 : case CFN_BUILT_IN_POPCOUNTLL:
8003 0 : if (call_expr_nargs (_p1) == 1)
8004 : {
8005 0 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
8006 0 : if ((_q90 == _q61 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q61, 0) && types_match (_q90, _q61)))
8007 : {
8008 0 : {
8009 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q61, _p1 };
8010 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTLL);
8011 0 : if (res) return res;
8012 : }
8013 : }
8014 : }
8015 : break;
8016 : default:;
8017 : }
8018 : break;
8019 : default:;
8020 : }
8021 : }
8022 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
8023 : {
8024 0 : switch (TREE_CODE (_p1))
8025 : {
8026 0 : case CALL_EXPR:
8027 0 : switch (get_call_combined_fn (_p1))
8028 : {
8029 0 : case CFN_BUILT_IN_POPCOUNTLL:
8030 0 : if (call_expr_nargs (_p1) == 1)
8031 : {
8032 0 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
8033 0 : if ((_q90 == _q60 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q60, 0) && types_match (_q90, _q60)))
8034 : {
8035 0 : {
8036 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q60, _p1 };
8037 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTLL);
8038 0 : if (res) return res;
8039 : }
8040 : }
8041 : }
8042 : break;
8043 : default:;
8044 : }
8045 : break;
8046 : default:;
8047 : }
8048 : }
8049 : break;
8050 : }
8051 0 : case BIT_IOR_EXPR:
8052 0 : {
8053 0 : tree _q60 = TREE_OPERAND (_q50, 0);
8054 0 : tree _q61 = TREE_OPERAND (_q50, 1);
8055 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
8056 : {
8057 0 : switch (TREE_CODE (_p1))
8058 : {
8059 0 : case CALL_EXPR:
8060 0 : switch (get_call_combined_fn (_p1))
8061 : {
8062 0 : case CFN_BUILT_IN_POPCOUNTLL:
8063 0 : if (call_expr_nargs (_p1) == 1)
8064 : {
8065 0 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
8066 0 : if ((_q90 == _q61 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q61, 0) && types_match (_q90, _q61)))
8067 : {
8068 0 : {
8069 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q61, _p1 };
8070 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTLL);
8071 0 : if (res) return res;
8072 : }
8073 : }
8074 : }
8075 : break;
8076 : default:;
8077 : }
8078 : break;
8079 : default:;
8080 : }
8081 : }
8082 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
8083 : {
8084 0 : switch (TREE_CODE (_p1))
8085 : {
8086 0 : case CALL_EXPR:
8087 0 : switch (get_call_combined_fn (_p1))
8088 : {
8089 0 : case CFN_BUILT_IN_POPCOUNTLL:
8090 0 : if (call_expr_nargs (_p1) == 1)
8091 : {
8092 0 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
8093 0 : if ((_q90 == _q60 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q60, 0) && types_match (_q90, _q60)))
8094 : {
8095 0 : {
8096 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q60, _p1 };
8097 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTLL);
8098 0 : if (res) return res;
8099 : }
8100 : }
8101 : }
8102 : break;
8103 : default:;
8104 : }
8105 : break;
8106 : default:;
8107 : }
8108 : }
8109 : break;
8110 : }
8111 : default:;
8112 : }
8113 : }
8114 : break;
8115 : default:;
8116 : }
8117 : break;
8118 : default:;
8119 : }
8120 : }
8121 : break;
8122 0 : case CFN_POPCOUNT:
8123 0 : if (call_expr_nargs (_q20) == 1)
8124 : {
8125 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
8126 0 : switch (TREE_CODE (_q21))
8127 : {
8128 0 : case CALL_EXPR:
8129 0 : switch (get_call_combined_fn (_q21))
8130 : {
8131 0 : case CFN_POPCOUNT:
8132 0 : if (call_expr_nargs (_q21) == 1)
8133 : {
8134 0 : tree _q50 = CALL_EXPR_ARG (_q21, 0);
8135 0 : switch (TREE_CODE (_q50))
8136 : {
8137 0 : case BIT_AND_EXPR:
8138 0 : {
8139 0 : tree _q60 = TREE_OPERAND (_q50, 0);
8140 0 : tree _q61 = TREE_OPERAND (_q50, 1);
8141 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
8142 : {
8143 0 : switch (TREE_CODE (_p1))
8144 : {
8145 0 : case CALL_EXPR:
8146 0 : switch (get_call_combined_fn (_p1))
8147 : {
8148 0 : case CFN_POPCOUNT:
8149 0 : if (call_expr_nargs (_p1) == 1)
8150 : {
8151 0 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
8152 0 : if ((_q90 == _q61 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q61, 0) && types_match (_q90, _q61)))
8153 : {
8154 0 : {
8155 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q61, _p1 };
8156 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_POPCOUNT);
8157 0 : if (res) return res;
8158 : }
8159 : }
8160 : }
8161 : break;
8162 : default:;
8163 : }
8164 : break;
8165 : default:;
8166 : }
8167 : }
8168 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
8169 : {
8170 0 : switch (TREE_CODE (_p1))
8171 : {
8172 0 : case CALL_EXPR:
8173 0 : switch (get_call_combined_fn (_p1))
8174 : {
8175 0 : case CFN_POPCOUNT:
8176 0 : if (call_expr_nargs (_p1) == 1)
8177 : {
8178 0 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
8179 0 : if ((_q90 == _q60 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q60, 0) && types_match (_q90, _q60)))
8180 : {
8181 0 : {
8182 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q60, _p1 };
8183 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_POPCOUNT);
8184 0 : if (res) return res;
8185 : }
8186 : }
8187 : }
8188 : break;
8189 : default:;
8190 : }
8191 : break;
8192 : default:;
8193 : }
8194 : }
8195 : break;
8196 : }
8197 0 : case BIT_IOR_EXPR:
8198 0 : {
8199 0 : tree _q60 = TREE_OPERAND (_q50, 0);
8200 0 : tree _q61 = TREE_OPERAND (_q50, 1);
8201 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
8202 : {
8203 0 : switch (TREE_CODE (_p1))
8204 : {
8205 0 : case CALL_EXPR:
8206 0 : switch (get_call_combined_fn (_p1))
8207 : {
8208 0 : case CFN_POPCOUNT:
8209 0 : if (call_expr_nargs (_p1) == 1)
8210 : {
8211 0 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
8212 0 : if ((_q90 == _q61 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q61, 0) && types_match (_q90, _q61)))
8213 : {
8214 0 : {
8215 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q61, _p1 };
8216 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_POPCOUNT);
8217 0 : if (res) return res;
8218 : }
8219 : }
8220 : }
8221 : break;
8222 : default:;
8223 : }
8224 : break;
8225 : default:;
8226 : }
8227 : }
8228 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
8229 : {
8230 0 : switch (TREE_CODE (_p1))
8231 : {
8232 0 : case CALL_EXPR:
8233 0 : switch (get_call_combined_fn (_p1))
8234 : {
8235 0 : case CFN_POPCOUNT:
8236 0 : if (call_expr_nargs (_p1) == 1)
8237 : {
8238 0 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
8239 0 : if ((_q90 == _q60 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q60, 0) && types_match (_q90, _q60)))
8240 : {
8241 0 : {
8242 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q60, _p1 };
8243 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_POPCOUNT);
8244 0 : if (res) return res;
8245 : }
8246 : }
8247 : }
8248 : break;
8249 : default:;
8250 : }
8251 : break;
8252 : default:;
8253 : }
8254 : }
8255 : break;
8256 : }
8257 : default:;
8258 : }
8259 : }
8260 : break;
8261 : default:;
8262 : }
8263 : break;
8264 : default:;
8265 : }
8266 : }
8267 : break;
8268 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
8269 0 : if (call_expr_nargs (_q20) == 1)
8270 : {
8271 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
8272 0 : switch (TREE_CODE (_q21))
8273 : {
8274 0 : case CALL_EXPR:
8275 0 : switch (get_call_combined_fn (_q21))
8276 : {
8277 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
8278 0 : if (call_expr_nargs (_q21) == 1)
8279 : {
8280 0 : tree _q50 = CALL_EXPR_ARG (_q21, 0);
8281 0 : switch (TREE_CODE (_q50))
8282 : {
8283 0 : case BIT_AND_EXPR:
8284 0 : {
8285 0 : tree _q60 = TREE_OPERAND (_q50, 0);
8286 0 : tree _q61 = TREE_OPERAND (_q50, 1);
8287 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
8288 : {
8289 0 : switch (TREE_CODE (_p1))
8290 : {
8291 0 : case CALL_EXPR:
8292 0 : switch (get_call_combined_fn (_p1))
8293 : {
8294 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
8295 0 : if (call_expr_nargs (_p1) == 1)
8296 : {
8297 0 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
8298 0 : if ((_q90 == _q61 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q61, 0) && types_match (_q90, _q61)))
8299 : {
8300 0 : {
8301 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q61, _p1 };
8302 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
8303 0 : if (res) return res;
8304 : }
8305 : }
8306 : }
8307 : break;
8308 : default:;
8309 : }
8310 : break;
8311 : default:;
8312 : }
8313 : }
8314 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
8315 : {
8316 0 : switch (TREE_CODE (_p1))
8317 : {
8318 0 : case CALL_EXPR:
8319 0 : switch (get_call_combined_fn (_p1))
8320 : {
8321 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
8322 0 : if (call_expr_nargs (_p1) == 1)
8323 : {
8324 0 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
8325 0 : if ((_q90 == _q60 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q60, 0) && types_match (_q90, _q60)))
8326 : {
8327 0 : {
8328 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q60, _p1 };
8329 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
8330 0 : if (res) return res;
8331 : }
8332 : }
8333 : }
8334 : break;
8335 : default:;
8336 : }
8337 : break;
8338 : default:;
8339 : }
8340 : }
8341 : break;
8342 : }
8343 0 : case BIT_IOR_EXPR:
8344 0 : {
8345 0 : tree _q60 = TREE_OPERAND (_q50, 0);
8346 0 : tree _q61 = TREE_OPERAND (_q50, 1);
8347 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
8348 : {
8349 0 : switch (TREE_CODE (_p1))
8350 : {
8351 0 : case CALL_EXPR:
8352 0 : switch (get_call_combined_fn (_p1))
8353 : {
8354 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
8355 0 : if (call_expr_nargs (_p1) == 1)
8356 : {
8357 0 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
8358 0 : if ((_q90 == _q61 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q61, 0) && types_match (_q90, _q61)))
8359 : {
8360 0 : {
8361 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q61, _p1 };
8362 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
8363 0 : if (res) return res;
8364 : }
8365 : }
8366 : }
8367 : break;
8368 : default:;
8369 : }
8370 : break;
8371 : default:;
8372 : }
8373 : }
8374 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
8375 : {
8376 0 : switch (TREE_CODE (_p1))
8377 : {
8378 0 : case CALL_EXPR:
8379 0 : switch (get_call_combined_fn (_p1))
8380 : {
8381 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
8382 0 : if (call_expr_nargs (_p1) == 1)
8383 : {
8384 0 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
8385 0 : if ((_q90 == _q60 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q60, 0) && types_match (_q90, _q60)))
8386 : {
8387 0 : {
8388 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q60, _p1 };
8389 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
8390 0 : if (res) return res;
8391 : }
8392 : }
8393 : }
8394 : break;
8395 : default:;
8396 : }
8397 : break;
8398 : default:;
8399 : }
8400 : }
8401 : break;
8402 : }
8403 : default:;
8404 : }
8405 : }
8406 : break;
8407 : default:;
8408 : }
8409 : break;
8410 : default:;
8411 : }
8412 : }
8413 : break;
8414 0 : case CFN_BUILT_IN_POPCOUNTL:
8415 0 : if (call_expr_nargs (_q20) == 1)
8416 : {
8417 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
8418 0 : switch (TREE_CODE (_q21))
8419 : {
8420 0 : case CALL_EXPR:
8421 0 : switch (get_call_combined_fn (_q21))
8422 : {
8423 0 : case CFN_BUILT_IN_POPCOUNTL:
8424 0 : if (call_expr_nargs (_q21) == 1)
8425 : {
8426 0 : tree _q50 = CALL_EXPR_ARG (_q21, 0);
8427 0 : switch (TREE_CODE (_q50))
8428 : {
8429 0 : case BIT_AND_EXPR:
8430 0 : {
8431 0 : tree _q60 = TREE_OPERAND (_q50, 0);
8432 0 : tree _q61 = TREE_OPERAND (_q50, 1);
8433 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
8434 : {
8435 0 : switch (TREE_CODE (_p1))
8436 : {
8437 0 : case CALL_EXPR:
8438 0 : switch (get_call_combined_fn (_p1))
8439 : {
8440 0 : case CFN_BUILT_IN_POPCOUNTL:
8441 0 : if (call_expr_nargs (_p1) == 1)
8442 : {
8443 0 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
8444 0 : if ((_q90 == _q61 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q61, 0) && types_match (_q90, _q61)))
8445 : {
8446 0 : {
8447 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q61, _p1 };
8448 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTL);
8449 0 : if (res) return res;
8450 : }
8451 : }
8452 : }
8453 : break;
8454 : default:;
8455 : }
8456 : break;
8457 : default:;
8458 : }
8459 : }
8460 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
8461 : {
8462 0 : switch (TREE_CODE (_p1))
8463 : {
8464 0 : case CALL_EXPR:
8465 0 : switch (get_call_combined_fn (_p1))
8466 : {
8467 0 : case CFN_BUILT_IN_POPCOUNTL:
8468 0 : if (call_expr_nargs (_p1) == 1)
8469 : {
8470 0 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
8471 0 : if ((_q90 == _q60 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q60, 0) && types_match (_q90, _q60)))
8472 : {
8473 0 : {
8474 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q60, _p1 };
8475 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTL);
8476 0 : if (res) return res;
8477 : }
8478 : }
8479 : }
8480 : break;
8481 : default:;
8482 : }
8483 : break;
8484 : default:;
8485 : }
8486 : }
8487 : break;
8488 : }
8489 0 : case BIT_IOR_EXPR:
8490 0 : {
8491 0 : tree _q60 = TREE_OPERAND (_q50, 0);
8492 0 : tree _q61 = TREE_OPERAND (_q50, 1);
8493 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
8494 : {
8495 0 : switch (TREE_CODE (_p1))
8496 : {
8497 0 : case CALL_EXPR:
8498 0 : switch (get_call_combined_fn (_p1))
8499 : {
8500 0 : case CFN_BUILT_IN_POPCOUNTL:
8501 0 : if (call_expr_nargs (_p1) == 1)
8502 : {
8503 0 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
8504 0 : if ((_q90 == _q61 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q61, 0) && types_match (_q90, _q61)))
8505 : {
8506 0 : {
8507 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q61, _p1 };
8508 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTL);
8509 0 : if (res) return res;
8510 : }
8511 : }
8512 : }
8513 : break;
8514 : default:;
8515 : }
8516 : break;
8517 : default:;
8518 : }
8519 : }
8520 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
8521 : {
8522 0 : switch (TREE_CODE (_p1))
8523 : {
8524 0 : case CALL_EXPR:
8525 0 : switch (get_call_combined_fn (_p1))
8526 : {
8527 0 : case CFN_BUILT_IN_POPCOUNTL:
8528 0 : if (call_expr_nargs (_p1) == 1)
8529 : {
8530 0 : tree _q90 = CALL_EXPR_ARG (_p1, 0);
8531 0 : if ((_q90 == _q60 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q60, 0) && types_match (_q90, _q60)))
8532 : {
8533 0 : {
8534 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _q60, _p1 };
8535 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTL);
8536 0 : if (res) return res;
8537 : }
8538 : }
8539 : }
8540 : break;
8541 : default:;
8542 : }
8543 : break;
8544 : default:;
8545 : }
8546 : }
8547 : break;
8548 : }
8549 : default:;
8550 : }
8551 : }
8552 : break;
8553 : default:;
8554 : }
8555 : break;
8556 : default:;
8557 : }
8558 : }
8559 : break;
8560 : default:;
8561 : }
8562 : break;
8563 : default:;
8564 : }
8565 : break;
8566 : }
8567 1 : case VEC_PERM_EXPR:
8568 1 : {
8569 1 : tree _q20 = TREE_OPERAND (_p0, 0);
8570 1 : tree _q21 = TREE_OPERAND (_p0, 1);
8571 1 : tree _q22 = TREE_OPERAND (_p0, 2);
8572 1 : switch (TREE_CODE (_q20))
8573 : {
8574 0 : case MULT_EXPR:
8575 0 : {
8576 0 : tree _q30 = TREE_OPERAND (_q20, 0);
8577 0 : tree _q31 = TREE_OPERAND (_q20, 1);
8578 0 : if (tree_vec_same_elem_p (_q31))
8579 : {
8580 0 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
8581 : {
8582 0 : {
8583 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q22, _p1 };
8584 0 : tree res = generic_simplify_82 (loc, type, _p0, _p1, captures);
8585 0 : if (res) return res;
8586 : }
8587 : }
8588 : }
8589 0 : if (tree_vec_same_elem_p (_q30))
8590 : {
8591 0 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
8592 : {
8593 0 : {
8594 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q30, _q22, _p1 };
8595 0 : tree res = generic_simplify_82 (loc, type, _p0, _p1, captures);
8596 0 : if (res) return res;
8597 : }
8598 : }
8599 : }
8600 : break;
8601 : }
8602 1 : default:;
8603 : }
8604 1 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
8605 : {
8606 0 : switch (TREE_CODE (_p1))
8607 : {
8608 0 : case VEC_PERM_EXPR:
8609 0 : {
8610 0 : tree _q60 = TREE_OPERAND (_p1, 0);
8611 0 : tree _q61 = TREE_OPERAND (_p1, 1);
8612 0 : tree _q62 = TREE_OPERAND (_p1, 2);
8613 0 : if ((_q61 == _q60 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q60, 0) && types_match (_q61, _q60)))
8614 : {
8615 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
8616 : {
8617 0 : {
8618 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q22, _q60 };
8619 0 : if (VECTOR_INTEGER_TYPE_P (type)
8620 : )
8621 : {
8622 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1251;
8623 0 : {
8624 0 : tree res_op0;
8625 0 : {
8626 0 : tree _o1[2], _r1;
8627 0 : _o1[0] = captures[0];
8628 0 : _o1[1] = captures[2];
8629 0 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8630 0 : captures[3] = _r1;
8631 : }
8632 0 : res_op0 = unshare_expr (captures[3]);
8633 0 : tree res_op1;
8634 0 : res_op1 = captures[3];
8635 0 : tree res_op2;
8636 0 : res_op2 = captures[1];
8637 0 : tree _r;
8638 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
8639 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8640 0 : return _r;
8641 : }
8642 0 : next_after_fail1251:;
8643 : }
8644 : }
8645 : }
8646 : }
8647 : break;
8648 : }
8649 0 : default:;
8650 : }
8651 0 : switch (TREE_CODE (_q22))
8652 : {
8653 0 : case VECTOR_CST:
8654 0 : {
8655 0 : switch (TREE_CODE (_p1))
8656 : {
8657 0 : case VEC_PERM_EXPR:
8658 0 : {
8659 0 : tree _q60 = TREE_OPERAND (_p1, 0);
8660 0 : tree _q61 = TREE_OPERAND (_p1, 1);
8661 0 : tree _q62 = TREE_OPERAND (_p1, 2);
8662 0 : if ((_q61 == _q60 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q60, 0) && types_match (_q61, _q60)))
8663 : {
8664 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
8665 : {
8666 0 : switch (TREE_CODE (_q62))
8667 : {
8668 0 : case VECTOR_CST:
8669 0 : {
8670 0 : {
8671 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q22, _q60 };
8672 0 : tree res = generic_simplify_83 (loc, type, _p0, _p1, captures, PLUS_EXPR);
8673 0 : if (res) return res;
8674 : }
8675 0 : break;
8676 : }
8677 : default:;
8678 : }
8679 : }
8680 : }
8681 : break;
8682 : }
8683 : default:;
8684 : }
8685 : break;
8686 : }
8687 : default:;
8688 : }
8689 : }
8690 : break;
8691 : }
8692 1368351 : case CALL_EXPR:
8693 1368351 : switch (get_call_combined_fn (_p0))
8694 : {
8695 9 : case CFN_BUILT_IN_LOG:
8696 9 : if (call_expr_nargs (_p0) == 1)
8697 : {
8698 9 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8699 9 : switch (TREE_CODE (_p1))
8700 : {
8701 0 : case CALL_EXPR:
8702 0 : switch (get_call_combined_fn (_p1))
8703 : {
8704 0 : case CFN_BUILT_IN_LOG:
8705 0 : if (call_expr_nargs (_p1) == 1)
8706 : {
8707 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8708 0 : {
8709 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8710 0 : tree res = generic_simplify_78 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG);
8711 0 : if (res) return res;
8712 : }
8713 : }
8714 : break;
8715 : default:;
8716 : }
8717 : break;
8718 : default:;
8719 : }
8720 : }
8721 : break;
8722 1090 : case CFN_BUILT_IN_POPCOUNT:
8723 1090 : if (call_expr_nargs (_p0) == 1)
8724 : {
8725 1090 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8726 1090 : switch (TREE_CODE (_p1))
8727 : {
8728 22 : case CALL_EXPR:
8729 22 : switch (get_call_combined_fn (_p1))
8730 : {
8731 22 : case CFN_BUILT_IN_POPCOUNT:
8732 22 : if (call_expr_nargs (_p1) == 1)
8733 : {
8734 22 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8735 22 : {
8736 22 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8737 22 : tree res = generic_simplify_79 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNT);
8738 22 : if (res) return res;
8739 : }
8740 : }
8741 : break;
8742 : default:;
8743 : }
8744 : break;
8745 1089 : default:;
8746 : }
8747 1089 : switch (TREE_CODE (_q20))
8748 : {
8749 9 : case BIT_AND_EXPR:
8750 9 : {
8751 9 : tree _q30 = TREE_OPERAND (_q20, 0);
8752 9 : tree _q31 = TREE_OPERAND (_q20, 1);
8753 9 : switch (TREE_CODE (_p1))
8754 : {
8755 9 : case CALL_EXPR:
8756 9 : switch (get_call_combined_fn (_p1))
8757 : {
8758 9 : case CFN_BUILT_IN_POPCOUNT:
8759 9 : if (call_expr_nargs (_p1) == 1)
8760 : {
8761 9 : tree _q60 = CALL_EXPR_ARG (_p1, 0);
8762 9 : switch (TREE_CODE (_q60))
8763 : {
8764 9 : case BIT_IOR_EXPR:
8765 9 : {
8766 9 : tree _q70 = TREE_OPERAND (_q60, 0);
8767 9 : tree _q71 = TREE_OPERAND (_q60, 1);
8768 9 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
8769 : {
8770 1 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
8771 : {
8772 1 : {
8773 1 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1, _q60 };
8774 1 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNT);
8775 1 : if (res) return res;
8776 : }
8777 : }
8778 : }
8779 8 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
8780 : {
8781 1 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
8782 : {
8783 1 : {
8784 1 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1, _q60 };
8785 1 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNT);
8786 1 : if (res) return res;
8787 : }
8788 : }
8789 : }
8790 : break;
8791 : }
8792 : default:;
8793 : }
8794 : }
8795 : break;
8796 : default:;
8797 : }
8798 : break;
8799 : default:;
8800 : }
8801 : break;
8802 : }
8803 2 : case BIT_IOR_EXPR:
8804 2 : {
8805 2 : tree _q30 = TREE_OPERAND (_q20, 0);
8806 2 : tree _q31 = TREE_OPERAND (_q20, 1);
8807 2 : switch (TREE_CODE (_p1))
8808 : {
8809 2 : case CALL_EXPR:
8810 2 : switch (get_call_combined_fn (_p1))
8811 : {
8812 2 : case CFN_BUILT_IN_POPCOUNT:
8813 2 : if (call_expr_nargs (_p1) == 1)
8814 : {
8815 2 : tree _q60 = CALL_EXPR_ARG (_p1, 0);
8816 2 : switch (TREE_CODE (_q60))
8817 : {
8818 2 : case BIT_AND_EXPR:
8819 2 : {
8820 2 : tree _q70 = TREE_OPERAND (_q60, 0);
8821 2 : tree _q71 = TREE_OPERAND (_q60, 1);
8822 2 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
8823 : {
8824 1 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
8825 : {
8826 1 : {
8827 1 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _q60, _q30, _q31, _p0, _q20 };
8828 1 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNT);
8829 1 : if (res) return res;
8830 : }
8831 : }
8832 : }
8833 1 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
8834 : {
8835 1 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
8836 : {
8837 1 : {
8838 1 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _q60, _q31, _q30, _p0, _q20 };
8839 1 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNT);
8840 1 : if (res) return res;
8841 : }
8842 : }
8843 : }
8844 : break;
8845 : }
8846 : default:;
8847 : }
8848 : }
8849 : break;
8850 : default:;
8851 : }
8852 : break;
8853 : default:;
8854 : }
8855 : break;
8856 : }
8857 1085 : default:;
8858 : }
8859 1085 : switch (TREE_CODE (_p1))
8860 : {
8861 0 : case MINUS_EXPR:
8862 0 : {
8863 0 : tree _q40 = TREE_OPERAND (_p1, 0);
8864 0 : tree _q41 = TREE_OPERAND (_p1, 1);
8865 0 : switch (TREE_CODE (_q40))
8866 : {
8867 0 : case CALL_EXPR:
8868 0 : switch (get_call_combined_fn (_q40))
8869 : {
8870 0 : case CFN_BUILT_IN_POPCOUNT:
8871 0 : if (call_expr_nargs (_q40) == 1)
8872 : {
8873 0 : tree _q50 = CALL_EXPR_ARG (_q40, 0);
8874 0 : switch (TREE_CODE (_q41))
8875 : {
8876 0 : case CALL_EXPR:
8877 0 : switch (get_call_combined_fn (_q41))
8878 : {
8879 0 : case CFN_BUILT_IN_POPCOUNT:
8880 0 : if (call_expr_nargs (_q41) == 1)
8881 : {
8882 0 : tree _q70 = CALL_EXPR_ARG (_q41, 0);
8883 0 : switch (TREE_CODE (_q70))
8884 : {
8885 0 : case BIT_AND_EXPR:
8886 0 : {
8887 0 : tree _q80 = TREE_OPERAND (_q70, 0);
8888 0 : tree _q81 = TREE_OPERAND (_q70, 1);
8889 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
8890 : {
8891 0 : if ((_q81 == _q20 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q20, 0) && types_match (_q81, _q20)))
8892 : {
8893 0 : {
8894 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
8895 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNT);
8896 0 : if (res) return res;
8897 : }
8898 : }
8899 : }
8900 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
8901 : {
8902 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
8903 : {
8904 0 : {
8905 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
8906 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNT);
8907 0 : if (res) return res;
8908 : }
8909 : }
8910 : }
8911 : break;
8912 : }
8913 0 : case BIT_IOR_EXPR:
8914 0 : {
8915 0 : tree _q80 = TREE_OPERAND (_q70, 0);
8916 0 : tree _q81 = TREE_OPERAND (_q70, 1);
8917 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
8918 : {
8919 0 : if ((_q81 == _q20 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q20, 0) && types_match (_q81, _q20)))
8920 : {
8921 0 : {
8922 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
8923 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNT);
8924 0 : if (res) return res;
8925 : }
8926 : }
8927 : }
8928 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
8929 : {
8930 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
8931 : {
8932 0 : {
8933 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
8934 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNT);
8935 0 : if (res) return res;
8936 : }
8937 : }
8938 : }
8939 : break;
8940 : }
8941 : default:;
8942 : }
8943 : }
8944 : break;
8945 : default:;
8946 : }
8947 : break;
8948 : default:;
8949 : }
8950 : }
8951 : break;
8952 : default:;
8953 : }
8954 : break;
8955 : default:;
8956 : }
8957 : break;
8958 : }
8959 : default:;
8960 : }
8961 : }
8962 : break;
8963 1 : case CFN_BUILT_IN_LOG2:
8964 1 : if (call_expr_nargs (_p0) == 1)
8965 : {
8966 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8967 1 : switch (TREE_CODE (_p1))
8968 : {
8969 1 : case CALL_EXPR:
8970 1 : switch (get_call_combined_fn (_p1))
8971 : {
8972 1 : case CFN_BUILT_IN_LOG2:
8973 1 : if (call_expr_nargs (_p1) == 1)
8974 : {
8975 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8976 1 : {
8977 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8978 1 : tree res = generic_simplify_78 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2);
8979 1 : if (res) return res;
8980 : }
8981 : }
8982 : break;
8983 : default:;
8984 : }
8985 : break;
8986 : default:;
8987 : }
8988 : }
8989 : break;
8990 0 : case CFN_BUILT_IN_LOGF:
8991 0 : if (call_expr_nargs (_p0) == 1)
8992 : {
8993 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8994 0 : switch (TREE_CODE (_p1))
8995 : {
8996 0 : case CALL_EXPR:
8997 0 : switch (get_call_combined_fn (_p1))
8998 : {
8999 0 : case CFN_BUILT_IN_LOGF:
9000 0 : if (call_expr_nargs (_p1) == 1)
9001 : {
9002 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9003 0 : {
9004 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
9005 0 : tree res = generic_simplify_78 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF);
9006 0 : if (res) return res;
9007 : }
9008 : }
9009 : break;
9010 : default:;
9011 : }
9012 : break;
9013 : default:;
9014 : }
9015 : }
9016 : break;
9017 0 : case CFN_BUILT_IN_LOGL:
9018 0 : if (call_expr_nargs (_p0) == 1)
9019 : {
9020 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9021 0 : switch (TREE_CODE (_p1))
9022 : {
9023 0 : case CALL_EXPR:
9024 0 : switch (get_call_combined_fn (_p1))
9025 : {
9026 0 : case CFN_BUILT_IN_LOGL:
9027 0 : if (call_expr_nargs (_p1) == 1)
9028 : {
9029 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9030 0 : {
9031 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
9032 0 : tree res = generic_simplify_78 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL);
9033 0 : if (res) return res;
9034 : }
9035 : }
9036 : break;
9037 : default:;
9038 : }
9039 : break;
9040 : default:;
9041 : }
9042 : }
9043 : break;
9044 26 : case CFN_BUILT_IN_POPCOUNTLL:
9045 26 : if (call_expr_nargs (_p0) == 1)
9046 : {
9047 26 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9048 26 : switch (TREE_CODE (_p1))
9049 : {
9050 24 : case CALL_EXPR:
9051 24 : switch (get_call_combined_fn (_p1))
9052 : {
9053 24 : case CFN_BUILT_IN_POPCOUNTLL:
9054 24 : if (call_expr_nargs (_p1) == 1)
9055 : {
9056 24 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9057 24 : {
9058 24 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
9059 24 : tree res = generic_simplify_79 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNTLL);
9060 24 : if (res) return res;
9061 : }
9062 : }
9063 : break;
9064 : default:;
9065 : }
9066 : break;
9067 26 : default:;
9068 : }
9069 26 : switch (TREE_CODE (_q20))
9070 : {
9071 0 : case BIT_AND_EXPR:
9072 0 : {
9073 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9074 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9075 0 : switch (TREE_CODE (_p1))
9076 : {
9077 0 : case CALL_EXPR:
9078 0 : switch (get_call_combined_fn (_p1))
9079 : {
9080 0 : case CFN_BUILT_IN_POPCOUNTLL:
9081 0 : if (call_expr_nargs (_p1) == 1)
9082 : {
9083 0 : tree _q60 = CALL_EXPR_ARG (_p1, 0);
9084 0 : switch (TREE_CODE (_q60))
9085 : {
9086 0 : case BIT_IOR_EXPR:
9087 0 : {
9088 0 : tree _q70 = TREE_OPERAND (_q60, 0);
9089 0 : tree _q71 = TREE_OPERAND (_q60, 1);
9090 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
9091 : {
9092 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
9093 : {
9094 0 : {
9095 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1, _q60 };
9096 0 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNTLL);
9097 0 : if (res) return res;
9098 : }
9099 : }
9100 : }
9101 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
9102 : {
9103 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
9104 : {
9105 0 : {
9106 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1, _q60 };
9107 0 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNTLL);
9108 0 : if (res) return res;
9109 : }
9110 : }
9111 : }
9112 : break;
9113 : }
9114 : default:;
9115 : }
9116 : }
9117 : break;
9118 : default:;
9119 : }
9120 : break;
9121 : default:;
9122 : }
9123 : break;
9124 : }
9125 0 : case BIT_IOR_EXPR:
9126 0 : {
9127 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9128 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9129 0 : switch (TREE_CODE (_p1))
9130 : {
9131 0 : case CALL_EXPR:
9132 0 : switch (get_call_combined_fn (_p1))
9133 : {
9134 0 : case CFN_BUILT_IN_POPCOUNTLL:
9135 0 : if (call_expr_nargs (_p1) == 1)
9136 : {
9137 0 : tree _q60 = CALL_EXPR_ARG (_p1, 0);
9138 0 : switch (TREE_CODE (_q60))
9139 : {
9140 0 : case BIT_AND_EXPR:
9141 0 : {
9142 0 : tree _q70 = TREE_OPERAND (_q60, 0);
9143 0 : tree _q71 = TREE_OPERAND (_q60, 1);
9144 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
9145 : {
9146 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
9147 : {
9148 0 : {
9149 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _q60, _q30, _q31, _p0, _q20 };
9150 0 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNTLL);
9151 0 : if (res) return res;
9152 : }
9153 : }
9154 : }
9155 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
9156 : {
9157 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
9158 : {
9159 0 : {
9160 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _q60, _q31, _q30, _p0, _q20 };
9161 0 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNTLL);
9162 0 : if (res) return res;
9163 : }
9164 : }
9165 : }
9166 : break;
9167 : }
9168 : default:;
9169 : }
9170 : }
9171 : break;
9172 : default:;
9173 : }
9174 : break;
9175 : default:;
9176 : }
9177 : break;
9178 : }
9179 26 : default:;
9180 : }
9181 26 : switch (TREE_CODE (_p1))
9182 : {
9183 0 : case MINUS_EXPR:
9184 0 : {
9185 0 : tree _q40 = TREE_OPERAND (_p1, 0);
9186 0 : tree _q41 = TREE_OPERAND (_p1, 1);
9187 0 : switch (TREE_CODE (_q40))
9188 : {
9189 0 : case CALL_EXPR:
9190 0 : switch (get_call_combined_fn (_q40))
9191 : {
9192 0 : case CFN_BUILT_IN_POPCOUNTLL:
9193 0 : if (call_expr_nargs (_q40) == 1)
9194 : {
9195 0 : tree _q50 = CALL_EXPR_ARG (_q40, 0);
9196 0 : switch (TREE_CODE (_q41))
9197 : {
9198 0 : case CALL_EXPR:
9199 0 : switch (get_call_combined_fn (_q41))
9200 : {
9201 0 : case CFN_BUILT_IN_POPCOUNTLL:
9202 0 : if (call_expr_nargs (_q41) == 1)
9203 : {
9204 0 : tree _q70 = CALL_EXPR_ARG (_q41, 0);
9205 0 : switch (TREE_CODE (_q70))
9206 : {
9207 0 : case BIT_AND_EXPR:
9208 0 : {
9209 0 : tree _q80 = TREE_OPERAND (_q70, 0);
9210 0 : tree _q81 = TREE_OPERAND (_q70, 1);
9211 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
9212 : {
9213 0 : if ((_q81 == _q20 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q20, 0) && types_match (_q81, _q20)))
9214 : {
9215 0 : {
9216 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
9217 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTLL);
9218 0 : if (res) return res;
9219 : }
9220 : }
9221 : }
9222 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
9223 : {
9224 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
9225 : {
9226 0 : {
9227 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
9228 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTLL);
9229 0 : if (res) return res;
9230 : }
9231 : }
9232 : }
9233 : break;
9234 : }
9235 0 : case BIT_IOR_EXPR:
9236 0 : {
9237 0 : tree _q80 = TREE_OPERAND (_q70, 0);
9238 0 : tree _q81 = TREE_OPERAND (_q70, 1);
9239 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
9240 : {
9241 0 : if ((_q81 == _q20 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q20, 0) && types_match (_q81, _q20)))
9242 : {
9243 0 : {
9244 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
9245 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTLL);
9246 0 : if (res) return res;
9247 : }
9248 : }
9249 : }
9250 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
9251 : {
9252 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
9253 : {
9254 0 : {
9255 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
9256 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTLL);
9257 0 : if (res) return res;
9258 : }
9259 : }
9260 : }
9261 : break;
9262 : }
9263 : default:;
9264 : }
9265 : }
9266 : break;
9267 : default:;
9268 : }
9269 : break;
9270 : default:;
9271 : }
9272 : }
9273 : break;
9274 : default:;
9275 : }
9276 : break;
9277 : default:;
9278 : }
9279 : break;
9280 : }
9281 : default:;
9282 : }
9283 : }
9284 : break;
9285 0 : case CFN_BUILT_IN_LOG10F:
9286 0 : if (call_expr_nargs (_p0) == 1)
9287 : {
9288 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9289 0 : switch (TREE_CODE (_p1))
9290 : {
9291 0 : case CALL_EXPR:
9292 0 : switch (get_call_combined_fn (_p1))
9293 : {
9294 0 : case CFN_BUILT_IN_LOG10F:
9295 0 : if (call_expr_nargs (_p1) == 1)
9296 : {
9297 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9298 0 : {
9299 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
9300 0 : tree res = generic_simplify_78 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F);
9301 0 : if (res) return res;
9302 : }
9303 : }
9304 : break;
9305 : default:;
9306 : }
9307 : break;
9308 : default:;
9309 : }
9310 : }
9311 : break;
9312 0 : case CFN_BUILT_IN_LOG10L:
9313 0 : if (call_expr_nargs (_p0) == 1)
9314 : {
9315 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9316 0 : switch (TREE_CODE (_p1))
9317 : {
9318 0 : case CALL_EXPR:
9319 0 : switch (get_call_combined_fn (_p1))
9320 : {
9321 0 : case CFN_BUILT_IN_LOG10L:
9322 0 : if (call_expr_nargs (_p1) == 1)
9323 : {
9324 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9325 0 : {
9326 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
9327 0 : tree res = generic_simplify_78 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L);
9328 0 : if (res) return res;
9329 : }
9330 : }
9331 : break;
9332 : default:;
9333 : }
9334 : break;
9335 : default:;
9336 : }
9337 : }
9338 : break;
9339 4 : case CFN_POPCOUNT:
9340 4 : if (call_expr_nargs (_p0) == 1)
9341 : {
9342 4 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9343 4 : switch (TREE_CODE (_p1))
9344 : {
9345 1 : case CALL_EXPR:
9346 1 : switch (get_call_combined_fn (_p1))
9347 : {
9348 1 : case CFN_POPCOUNT:
9349 1 : if (call_expr_nargs (_p1) == 1)
9350 : {
9351 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9352 1 : {
9353 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
9354 1 : tree res = generic_simplify_79 (loc, type, _p0, _p1, captures, CFN_POPCOUNT);
9355 1 : if (res) return res;
9356 : }
9357 : }
9358 : break;
9359 : default:;
9360 : }
9361 : break;
9362 4 : default:;
9363 : }
9364 4 : switch (TREE_CODE (_q20))
9365 : {
9366 0 : case BIT_AND_EXPR:
9367 0 : {
9368 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9369 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9370 0 : switch (TREE_CODE (_p1))
9371 : {
9372 0 : case CALL_EXPR:
9373 0 : switch (get_call_combined_fn (_p1))
9374 : {
9375 0 : case CFN_POPCOUNT:
9376 0 : if (call_expr_nargs (_p1) == 1)
9377 : {
9378 0 : tree _q60 = CALL_EXPR_ARG (_p1, 0);
9379 0 : switch (TREE_CODE (_q60))
9380 : {
9381 0 : case BIT_IOR_EXPR:
9382 0 : {
9383 0 : tree _q70 = TREE_OPERAND (_q60, 0);
9384 0 : tree _q71 = TREE_OPERAND (_q60, 1);
9385 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
9386 : {
9387 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
9388 : {
9389 0 : {
9390 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1, _q60 };
9391 0 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_POPCOUNT);
9392 0 : if (res) return res;
9393 : }
9394 : }
9395 : }
9396 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
9397 : {
9398 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
9399 : {
9400 0 : {
9401 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1, _q60 };
9402 0 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_POPCOUNT);
9403 0 : if (res) return res;
9404 : }
9405 : }
9406 : }
9407 : break;
9408 : }
9409 : default:;
9410 : }
9411 : }
9412 : break;
9413 : default:;
9414 : }
9415 : break;
9416 : default:;
9417 : }
9418 : break;
9419 : }
9420 0 : case BIT_IOR_EXPR:
9421 0 : {
9422 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9423 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9424 0 : switch (TREE_CODE (_p1))
9425 : {
9426 0 : case CALL_EXPR:
9427 0 : switch (get_call_combined_fn (_p1))
9428 : {
9429 0 : case CFN_POPCOUNT:
9430 0 : if (call_expr_nargs (_p1) == 1)
9431 : {
9432 0 : tree _q60 = CALL_EXPR_ARG (_p1, 0);
9433 0 : switch (TREE_CODE (_q60))
9434 : {
9435 0 : case BIT_AND_EXPR:
9436 0 : {
9437 0 : tree _q70 = TREE_OPERAND (_q60, 0);
9438 0 : tree _q71 = TREE_OPERAND (_q60, 1);
9439 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
9440 : {
9441 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
9442 : {
9443 0 : {
9444 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _q60, _q30, _q31, _p0, _q20 };
9445 0 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_POPCOUNT);
9446 0 : if (res) return res;
9447 : }
9448 : }
9449 : }
9450 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
9451 : {
9452 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
9453 : {
9454 0 : {
9455 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _q60, _q31, _q30, _p0, _q20 };
9456 0 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_POPCOUNT);
9457 0 : if (res) return res;
9458 : }
9459 : }
9460 : }
9461 : break;
9462 : }
9463 : default:;
9464 : }
9465 : }
9466 : break;
9467 : default:;
9468 : }
9469 : break;
9470 : default:;
9471 : }
9472 : break;
9473 : }
9474 4 : default:;
9475 : }
9476 4 : switch (TREE_CODE (_p1))
9477 : {
9478 0 : case MINUS_EXPR:
9479 0 : {
9480 0 : tree _q40 = TREE_OPERAND (_p1, 0);
9481 0 : tree _q41 = TREE_OPERAND (_p1, 1);
9482 0 : switch (TREE_CODE (_q40))
9483 : {
9484 0 : case CALL_EXPR:
9485 0 : switch (get_call_combined_fn (_q40))
9486 : {
9487 0 : case CFN_POPCOUNT:
9488 0 : if (call_expr_nargs (_q40) == 1)
9489 : {
9490 0 : tree _q50 = CALL_EXPR_ARG (_q40, 0);
9491 0 : switch (TREE_CODE (_q41))
9492 : {
9493 0 : case CALL_EXPR:
9494 0 : switch (get_call_combined_fn (_q41))
9495 : {
9496 0 : case CFN_POPCOUNT:
9497 0 : if (call_expr_nargs (_q41) == 1)
9498 : {
9499 0 : tree _q70 = CALL_EXPR_ARG (_q41, 0);
9500 0 : switch (TREE_CODE (_q70))
9501 : {
9502 0 : case BIT_AND_EXPR:
9503 0 : {
9504 0 : tree _q80 = TREE_OPERAND (_q70, 0);
9505 0 : tree _q81 = TREE_OPERAND (_q70, 1);
9506 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
9507 : {
9508 0 : if ((_q81 == _q20 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q20, 0) && types_match (_q81, _q20)))
9509 : {
9510 0 : {
9511 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
9512 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_POPCOUNT);
9513 0 : if (res) return res;
9514 : }
9515 : }
9516 : }
9517 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
9518 : {
9519 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
9520 : {
9521 0 : {
9522 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
9523 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_POPCOUNT);
9524 0 : if (res) return res;
9525 : }
9526 : }
9527 : }
9528 : break;
9529 : }
9530 0 : case BIT_IOR_EXPR:
9531 0 : {
9532 0 : tree _q80 = TREE_OPERAND (_q70, 0);
9533 0 : tree _q81 = TREE_OPERAND (_q70, 1);
9534 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
9535 : {
9536 0 : if ((_q81 == _q20 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q20, 0) && types_match (_q81, _q20)))
9537 : {
9538 0 : {
9539 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
9540 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_POPCOUNT);
9541 0 : if (res) return res;
9542 : }
9543 : }
9544 : }
9545 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
9546 : {
9547 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
9548 : {
9549 0 : {
9550 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
9551 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_POPCOUNT);
9552 0 : if (res) return res;
9553 : }
9554 : }
9555 : }
9556 : break;
9557 : }
9558 : default:;
9559 : }
9560 : }
9561 : break;
9562 : default:;
9563 : }
9564 : break;
9565 : default:;
9566 : }
9567 : }
9568 : break;
9569 : default:;
9570 : }
9571 : break;
9572 : default:;
9573 : }
9574 : break;
9575 : }
9576 : default:;
9577 : }
9578 : }
9579 : break;
9580 0 : case CFN_LOG:
9581 0 : if (call_expr_nargs (_p0) == 1)
9582 : {
9583 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9584 0 : switch (TREE_CODE (_p1))
9585 : {
9586 0 : case CALL_EXPR:
9587 0 : switch (get_call_combined_fn (_p1))
9588 : {
9589 0 : case CFN_LOG:
9590 0 : if (call_expr_nargs (_p1) == 1)
9591 : {
9592 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9593 0 : {
9594 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
9595 0 : tree res = generic_simplify_78 (loc, type, _p0, _p1, captures, CFN_LOG);
9596 0 : if (res) return res;
9597 : }
9598 : }
9599 : break;
9600 : default:;
9601 : }
9602 : break;
9603 : default:;
9604 : }
9605 : }
9606 : break;
9607 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
9608 0 : if (call_expr_nargs (_p0) == 1)
9609 : {
9610 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9611 0 : switch (TREE_CODE (_p1))
9612 : {
9613 0 : case CALL_EXPR:
9614 0 : switch (get_call_combined_fn (_p1))
9615 : {
9616 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
9617 0 : if (call_expr_nargs (_p1) == 1)
9618 : {
9619 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9620 0 : {
9621 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
9622 0 : tree res = generic_simplify_79 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNTIMAX);
9623 0 : if (res) return res;
9624 : }
9625 : }
9626 : break;
9627 : default:;
9628 : }
9629 : break;
9630 0 : default:;
9631 : }
9632 0 : switch (TREE_CODE (_q20))
9633 : {
9634 0 : case BIT_AND_EXPR:
9635 0 : {
9636 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9637 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9638 0 : switch (TREE_CODE (_p1))
9639 : {
9640 0 : case CALL_EXPR:
9641 0 : switch (get_call_combined_fn (_p1))
9642 : {
9643 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
9644 0 : if (call_expr_nargs (_p1) == 1)
9645 : {
9646 0 : tree _q60 = CALL_EXPR_ARG (_p1, 0);
9647 0 : switch (TREE_CODE (_q60))
9648 : {
9649 0 : case BIT_IOR_EXPR:
9650 0 : {
9651 0 : tree _q70 = TREE_OPERAND (_q60, 0);
9652 0 : tree _q71 = TREE_OPERAND (_q60, 1);
9653 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
9654 : {
9655 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
9656 : {
9657 0 : {
9658 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1, _q60 };
9659 0 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNTIMAX);
9660 0 : if (res) return res;
9661 : }
9662 : }
9663 : }
9664 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
9665 : {
9666 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
9667 : {
9668 0 : {
9669 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1, _q60 };
9670 0 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNTIMAX);
9671 0 : if (res) return res;
9672 : }
9673 : }
9674 : }
9675 : break;
9676 : }
9677 : default:;
9678 : }
9679 : }
9680 : break;
9681 : default:;
9682 : }
9683 : break;
9684 : default:;
9685 : }
9686 : break;
9687 : }
9688 0 : case BIT_IOR_EXPR:
9689 0 : {
9690 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9691 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9692 0 : switch (TREE_CODE (_p1))
9693 : {
9694 0 : case CALL_EXPR:
9695 0 : switch (get_call_combined_fn (_p1))
9696 : {
9697 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
9698 0 : if (call_expr_nargs (_p1) == 1)
9699 : {
9700 0 : tree _q60 = CALL_EXPR_ARG (_p1, 0);
9701 0 : switch (TREE_CODE (_q60))
9702 : {
9703 0 : case BIT_AND_EXPR:
9704 0 : {
9705 0 : tree _q70 = TREE_OPERAND (_q60, 0);
9706 0 : tree _q71 = TREE_OPERAND (_q60, 1);
9707 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
9708 : {
9709 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
9710 : {
9711 0 : {
9712 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _q60, _q30, _q31, _p0, _q20 };
9713 0 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNTIMAX);
9714 0 : if (res) return res;
9715 : }
9716 : }
9717 : }
9718 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
9719 : {
9720 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
9721 : {
9722 0 : {
9723 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _q60, _q31, _q30, _p0, _q20 };
9724 0 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNTIMAX);
9725 0 : if (res) return res;
9726 : }
9727 : }
9728 : }
9729 : break;
9730 : }
9731 : default:;
9732 : }
9733 : }
9734 : break;
9735 : default:;
9736 : }
9737 : break;
9738 : default:;
9739 : }
9740 : break;
9741 : }
9742 0 : default:;
9743 : }
9744 0 : switch (TREE_CODE (_p1))
9745 : {
9746 0 : case MINUS_EXPR:
9747 0 : {
9748 0 : tree _q40 = TREE_OPERAND (_p1, 0);
9749 0 : tree _q41 = TREE_OPERAND (_p1, 1);
9750 0 : switch (TREE_CODE (_q40))
9751 : {
9752 0 : case CALL_EXPR:
9753 0 : switch (get_call_combined_fn (_q40))
9754 : {
9755 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
9756 0 : if (call_expr_nargs (_q40) == 1)
9757 : {
9758 0 : tree _q50 = CALL_EXPR_ARG (_q40, 0);
9759 0 : switch (TREE_CODE (_q41))
9760 : {
9761 0 : case CALL_EXPR:
9762 0 : switch (get_call_combined_fn (_q41))
9763 : {
9764 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
9765 0 : if (call_expr_nargs (_q41) == 1)
9766 : {
9767 0 : tree _q70 = CALL_EXPR_ARG (_q41, 0);
9768 0 : switch (TREE_CODE (_q70))
9769 : {
9770 0 : case BIT_AND_EXPR:
9771 0 : {
9772 0 : tree _q80 = TREE_OPERAND (_q70, 0);
9773 0 : tree _q81 = TREE_OPERAND (_q70, 1);
9774 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
9775 : {
9776 0 : if ((_q81 == _q20 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q20, 0) && types_match (_q81, _q20)))
9777 : {
9778 0 : {
9779 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
9780 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
9781 0 : if (res) return res;
9782 : }
9783 : }
9784 : }
9785 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
9786 : {
9787 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
9788 : {
9789 0 : {
9790 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
9791 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
9792 0 : if (res) return res;
9793 : }
9794 : }
9795 : }
9796 : break;
9797 : }
9798 0 : case BIT_IOR_EXPR:
9799 0 : {
9800 0 : tree _q80 = TREE_OPERAND (_q70, 0);
9801 0 : tree _q81 = TREE_OPERAND (_q70, 1);
9802 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
9803 : {
9804 0 : if ((_q81 == _q20 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q20, 0) && types_match (_q81, _q20)))
9805 : {
9806 0 : {
9807 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
9808 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
9809 0 : if (res) return res;
9810 : }
9811 : }
9812 : }
9813 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
9814 : {
9815 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
9816 : {
9817 0 : {
9818 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
9819 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
9820 0 : if (res) return res;
9821 : }
9822 : }
9823 : }
9824 : break;
9825 : }
9826 : default:;
9827 : }
9828 : }
9829 : break;
9830 : default:;
9831 : }
9832 : break;
9833 : default:;
9834 : }
9835 : }
9836 : break;
9837 : default:;
9838 : }
9839 : break;
9840 : default:;
9841 : }
9842 : break;
9843 : }
9844 : default:;
9845 : }
9846 : }
9847 : break;
9848 0 : case CFN_LOG2:
9849 0 : if (call_expr_nargs (_p0) == 1)
9850 : {
9851 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9852 0 : switch (TREE_CODE (_p1))
9853 : {
9854 0 : case CALL_EXPR:
9855 0 : switch (get_call_combined_fn (_p1))
9856 : {
9857 0 : case CFN_LOG2:
9858 0 : if (call_expr_nargs (_p1) == 1)
9859 : {
9860 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9861 0 : {
9862 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
9863 0 : tree res = generic_simplify_78 (loc, type, _p0, _p1, captures, CFN_LOG2);
9864 0 : if (res) return res;
9865 : }
9866 : }
9867 : break;
9868 : default:;
9869 : }
9870 : break;
9871 : default:;
9872 : }
9873 : }
9874 : break;
9875 135 : case CFN_BUILT_IN_POPCOUNTL:
9876 135 : if (call_expr_nargs (_p0) == 1)
9877 : {
9878 135 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
9879 135 : switch (TREE_CODE (_p1))
9880 : {
9881 69 : case CALL_EXPR:
9882 69 : switch (get_call_combined_fn (_p1))
9883 : {
9884 69 : case CFN_BUILT_IN_POPCOUNTL:
9885 69 : if (call_expr_nargs (_p1) == 1)
9886 : {
9887 69 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
9888 69 : {
9889 69 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
9890 69 : tree res = generic_simplify_79 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNTL);
9891 69 : if (res) return res;
9892 : }
9893 : }
9894 : break;
9895 : default:;
9896 : }
9897 : break;
9898 135 : default:;
9899 : }
9900 135 : switch (TREE_CODE (_q20))
9901 : {
9902 0 : case BIT_AND_EXPR:
9903 0 : {
9904 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9905 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9906 0 : switch (TREE_CODE (_p1))
9907 : {
9908 0 : case CALL_EXPR:
9909 0 : switch (get_call_combined_fn (_p1))
9910 : {
9911 0 : case CFN_BUILT_IN_POPCOUNTL:
9912 0 : if (call_expr_nargs (_p1) == 1)
9913 : {
9914 0 : tree _q60 = CALL_EXPR_ARG (_p1, 0);
9915 0 : switch (TREE_CODE (_q60))
9916 : {
9917 0 : case BIT_IOR_EXPR:
9918 0 : {
9919 0 : tree _q70 = TREE_OPERAND (_q60, 0);
9920 0 : tree _q71 = TREE_OPERAND (_q60, 1);
9921 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
9922 : {
9923 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
9924 : {
9925 0 : {
9926 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1, _q60 };
9927 0 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNTL);
9928 0 : if (res) return res;
9929 : }
9930 : }
9931 : }
9932 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
9933 : {
9934 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
9935 : {
9936 0 : {
9937 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1, _q60 };
9938 0 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNTL);
9939 0 : if (res) return res;
9940 : }
9941 : }
9942 : }
9943 : break;
9944 : }
9945 : default:;
9946 : }
9947 : }
9948 : break;
9949 : default:;
9950 : }
9951 : break;
9952 : default:;
9953 : }
9954 : break;
9955 : }
9956 0 : case BIT_IOR_EXPR:
9957 0 : {
9958 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9959 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9960 0 : switch (TREE_CODE (_p1))
9961 : {
9962 0 : case CALL_EXPR:
9963 0 : switch (get_call_combined_fn (_p1))
9964 : {
9965 0 : case CFN_BUILT_IN_POPCOUNTL:
9966 0 : if (call_expr_nargs (_p1) == 1)
9967 : {
9968 0 : tree _q60 = CALL_EXPR_ARG (_p1, 0);
9969 0 : switch (TREE_CODE (_q60))
9970 : {
9971 0 : case BIT_AND_EXPR:
9972 0 : {
9973 0 : tree _q70 = TREE_OPERAND (_q60, 0);
9974 0 : tree _q71 = TREE_OPERAND (_q60, 1);
9975 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
9976 : {
9977 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
9978 : {
9979 0 : {
9980 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _q60, _q30, _q31, _p0, _q20 };
9981 0 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNTL);
9982 0 : if (res) return res;
9983 : }
9984 : }
9985 : }
9986 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
9987 : {
9988 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
9989 : {
9990 0 : {
9991 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _q60, _q31, _q30, _p0, _q20 };
9992 0 : tree res = generic_simplify_80 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_POPCOUNTL);
9993 0 : if (res) return res;
9994 : }
9995 : }
9996 : }
9997 : break;
9998 : }
9999 : default:;
10000 : }
10001 : }
10002 : break;
10003 : default:;
10004 : }
10005 : break;
10006 : default:;
10007 : }
10008 : break;
10009 : }
10010 135 : default:;
10011 : }
10012 135 : switch (TREE_CODE (_p1))
10013 : {
10014 0 : case MINUS_EXPR:
10015 0 : {
10016 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10017 0 : tree _q41 = TREE_OPERAND (_p1, 1);
10018 0 : switch (TREE_CODE (_q40))
10019 : {
10020 0 : case CALL_EXPR:
10021 0 : switch (get_call_combined_fn (_q40))
10022 : {
10023 0 : case CFN_BUILT_IN_POPCOUNTL:
10024 0 : if (call_expr_nargs (_q40) == 1)
10025 : {
10026 0 : tree _q50 = CALL_EXPR_ARG (_q40, 0);
10027 0 : switch (TREE_CODE (_q41))
10028 : {
10029 0 : case CALL_EXPR:
10030 0 : switch (get_call_combined_fn (_q41))
10031 : {
10032 0 : case CFN_BUILT_IN_POPCOUNTL:
10033 0 : if (call_expr_nargs (_q41) == 1)
10034 : {
10035 0 : tree _q70 = CALL_EXPR_ARG (_q41, 0);
10036 0 : switch (TREE_CODE (_q70))
10037 : {
10038 0 : case BIT_AND_EXPR:
10039 0 : {
10040 0 : tree _q80 = TREE_OPERAND (_q70, 0);
10041 0 : tree _q81 = TREE_OPERAND (_q70, 1);
10042 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
10043 : {
10044 0 : if ((_q81 == _q20 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q20, 0) && types_match (_q81, _q20)))
10045 : {
10046 0 : {
10047 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
10048 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTL);
10049 0 : if (res) return res;
10050 : }
10051 : }
10052 : }
10053 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
10054 : {
10055 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
10056 : {
10057 0 : {
10058 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
10059 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTL);
10060 0 : if (res) return res;
10061 : }
10062 : }
10063 : }
10064 : break;
10065 : }
10066 0 : case BIT_IOR_EXPR:
10067 0 : {
10068 0 : tree _q80 = TREE_OPERAND (_q70, 0);
10069 0 : tree _q81 = TREE_OPERAND (_q70, 1);
10070 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
10071 : {
10072 0 : if ((_q81 == _q20 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q20, 0) && types_match (_q81, _q20)))
10073 : {
10074 0 : {
10075 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
10076 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTL);
10077 0 : if (res) return res;
10078 : }
10079 : }
10080 : }
10081 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
10082 : {
10083 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
10084 : {
10085 0 : {
10086 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q41, _q70, _q20, _p0 };
10087 0 : tree res = generic_simplify_81 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTL);
10088 0 : if (res) return res;
10089 : }
10090 : }
10091 : }
10092 : break;
10093 : }
10094 : default:;
10095 : }
10096 : }
10097 : break;
10098 : default:;
10099 : }
10100 : break;
10101 : default:;
10102 : }
10103 : }
10104 : break;
10105 : default:;
10106 : }
10107 : break;
10108 : default:;
10109 : }
10110 : break;
10111 : }
10112 : default:;
10113 : }
10114 : }
10115 : break;
10116 0 : case CFN_LOG10:
10117 0 : if (call_expr_nargs (_p0) == 1)
10118 : {
10119 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10120 0 : switch (TREE_CODE (_p1))
10121 : {
10122 0 : case CALL_EXPR:
10123 0 : switch (get_call_combined_fn (_p1))
10124 : {
10125 0 : case CFN_LOG10:
10126 0 : if (call_expr_nargs (_p1) == 1)
10127 : {
10128 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
10129 0 : {
10130 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10131 0 : tree res = generic_simplify_78 (loc, type, _p0, _p1, captures, CFN_LOG10);
10132 0 : if (res) return res;
10133 : }
10134 : }
10135 : break;
10136 : default:;
10137 : }
10138 : break;
10139 : default:;
10140 : }
10141 : }
10142 : break;
10143 0 : case CFN_BUILT_IN_LOG10:
10144 0 : if (call_expr_nargs (_p0) == 1)
10145 : {
10146 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10147 0 : switch (TREE_CODE (_p1))
10148 : {
10149 0 : case CALL_EXPR:
10150 0 : switch (get_call_combined_fn (_p1))
10151 : {
10152 0 : case CFN_BUILT_IN_LOG10:
10153 0 : if (call_expr_nargs (_p1) == 1)
10154 : {
10155 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
10156 0 : {
10157 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10158 0 : tree res = generic_simplify_78 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10);
10159 0 : if (res) return res;
10160 : }
10161 : }
10162 : break;
10163 : default:;
10164 : }
10165 : break;
10166 : default:;
10167 : }
10168 : }
10169 : break;
10170 0 : case CFN_BUILT_IN_LOG2F:
10171 0 : if (call_expr_nargs (_p0) == 1)
10172 : {
10173 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10174 0 : switch (TREE_CODE (_p1))
10175 : {
10176 0 : case CALL_EXPR:
10177 0 : switch (get_call_combined_fn (_p1))
10178 : {
10179 0 : case CFN_BUILT_IN_LOG2F:
10180 0 : if (call_expr_nargs (_p1) == 1)
10181 : {
10182 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
10183 0 : {
10184 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10185 0 : tree res = generic_simplify_78 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F);
10186 0 : if (res) return res;
10187 : }
10188 : }
10189 : break;
10190 : default:;
10191 : }
10192 : break;
10193 : default:;
10194 : }
10195 : }
10196 : break;
10197 0 : case CFN_BUILT_IN_LOG2L:
10198 0 : if (call_expr_nargs (_p0) == 1)
10199 : {
10200 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10201 0 : switch (TREE_CODE (_p1))
10202 : {
10203 0 : case CALL_EXPR:
10204 0 : switch (get_call_combined_fn (_p1))
10205 : {
10206 0 : case CFN_BUILT_IN_LOG2L:
10207 0 : if (call_expr_nargs (_p1) == 1)
10208 : {
10209 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
10210 0 : {
10211 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10212 0 : tree res = generic_simplify_78 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L);
10213 0 : if (res) return res;
10214 : }
10215 : }
10216 : break;
10217 : default:;
10218 : }
10219 : break;
10220 : default:;
10221 : }
10222 : }
10223 : break;
10224 : default:;
10225 : }
10226 : break;
10227 60664357 : default:;
10228 : }
10229 60664357 : switch (TREE_CODE (_p1))
10230 : {
10231 0 : case VEC_PERM_EXPR:
10232 0 : {
10233 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10234 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10235 0 : tree _q32 = TREE_OPERAND (_p1, 2);
10236 0 : switch (TREE_CODE (_q30))
10237 : {
10238 0 : case MULT_EXPR:
10239 0 : {
10240 0 : tree _q40 = TREE_OPERAND (_q30, 0);
10241 0 : tree _q41 = TREE_OPERAND (_q30, 1);
10242 0 : if (tree_vec_same_elem_p (_q41))
10243 : {
10244 0 : if ((_q31 == _q30 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _q30, 0) && types_match (_q31, _q30)))
10245 : {
10246 0 : {
10247 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _q41, _q32, _p0 };
10248 0 : tree res = generic_simplify_82 (loc, type, _p0, _p1, captures);
10249 0 : if (res) return res;
10250 : }
10251 : }
10252 : }
10253 0 : if (tree_vec_same_elem_p (_q40))
10254 : {
10255 0 : if ((_q31 == _q30 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _q30, 0) && types_match (_q31, _q30)))
10256 : {
10257 0 : {
10258 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _q30, _q41, _q40, _q32, _p0 };
10259 0 : tree res = generic_simplify_82 (loc, type, _p0, _p1, captures);
10260 0 : if (res) return res;
10261 : }
10262 : }
10263 : }
10264 : break;
10265 : }
10266 : default:;
10267 : }
10268 : break;
10269 : }
10270 : default:;
10271 : }
10272 : return NULL_TREE;
10273 : }
10274 :
10275 : tree
10276 1251190 : generic_simplify_UNGT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
10277 : {
10278 1251190 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10279 1251190 : switch (TREE_CODE (_p0))
10280 : {
10281 0 : case VEC_COND_EXPR:
10282 0 : {
10283 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10284 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10285 0 : tree _q22 = TREE_OPERAND (_p0, 2);
10286 0 : switch (TREE_CODE (_p1))
10287 : {
10288 0 : case VEC_COND_EXPR:
10289 0 : {
10290 0 : tree _q60 = TREE_OPERAND (_p1, 0);
10291 0 : tree _q61 = TREE_OPERAND (_p1, 1);
10292 0 : tree _q62 = TREE_OPERAND (_p1, 2);
10293 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
10294 : {
10295 0 : {
10296 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
10297 0 : if (VECTOR_TYPE_P (type)
10298 0 : && (TREE_CODE_CLASS (UNGT_EXPR) != tcc_comparison
10299 0 : || types_match (type, TREE_TYPE (captures[2]))
10300 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10301 : || (optimize_vectors_before_lowering_p ()
10302 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10303 : )
10304 : {
10305 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1768;
10306 0 : {
10307 0 : tree res_op0;
10308 0 : res_op0 = captures[1];
10309 0 : tree res_op1;
10310 0 : {
10311 0 : tree _o1[2], _r1;
10312 0 : _o1[0] = captures[2];
10313 0 : _o1[1] = captures[5];
10314 0 : _r1 = fold_build2_loc (loc, UNGT_EXPR, type, _o1[0], _o1[1]);
10315 0 : if (EXPR_P (_r1))
10316 0 : goto next_after_fail1768;
10317 0 : res_op1 = _r1;
10318 : }
10319 0 : tree res_op2;
10320 0 : {
10321 0 : tree _o1[2], _r1;
10322 0 : _o1[0] = captures[3];
10323 0 : _o1[1] = captures[6];
10324 0 : _r1 = fold_build2_loc (loc, UNGT_EXPR, type, _o1[0], _o1[1]);
10325 0 : if (EXPR_P (_r1))
10326 0 : goto next_after_fail1768;
10327 0 : res_op2 = _r1;
10328 : }
10329 0 : tree _r;
10330 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10331 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 890, __FILE__, __LINE__, true);
10332 0 : return _r;
10333 : }
10334 0 : next_after_fail1768:;
10335 : }
10336 : }
10337 : }
10338 : break;
10339 : }
10340 0 : default:;
10341 : }
10342 0 : {
10343 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
10344 0 : if (VECTOR_TYPE_P (type)
10345 0 : && (TREE_CODE_CLASS (UNGT_EXPR) != tcc_comparison
10346 0 : || types_match (type, TREE_TYPE (captures[2]))
10347 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10348 : || (optimize_vectors_before_lowering_p ()
10349 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10350 : )
10351 : {
10352 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1769;
10353 0 : {
10354 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1769;
10355 0 : tree res_op0;
10356 0 : res_op0 = captures[1];
10357 0 : tree res_op1;
10358 0 : {
10359 0 : tree _o1[2], _r1;
10360 0 : _o1[0] = captures[2];
10361 0 : _o1[1] = unshare_expr (captures[4]);
10362 0 : _r1 = fold_build2_loc (loc, UNGT_EXPR, type, _o1[0], _o1[1]);
10363 0 : if (EXPR_P (_r1))
10364 0 : goto next_after_fail1769;
10365 0 : res_op1 = _r1;
10366 : }
10367 0 : tree res_op2;
10368 0 : {
10369 0 : tree _o1[2], _r1;
10370 0 : _o1[0] = captures[3];
10371 0 : _o1[1] = captures[4];
10372 0 : _r1 = fold_build2_loc (loc, UNGT_EXPR, type, _o1[0], _o1[1]);
10373 0 : if (EXPR_P (_r1))
10374 0 : goto next_after_fail1769;
10375 0 : res_op2 = _r1;
10376 : }
10377 0 : tree _r;
10378 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10379 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
10380 0 : return _r;
10381 : }
10382 0 : next_after_fail1769:;
10383 : }
10384 : }
10385 0 : break;
10386 : }
10387 1251190 : default:;
10388 : }
10389 1251190 : switch (TREE_CODE (_p1))
10390 : {
10391 0 : case VEC_COND_EXPR:
10392 0 : {
10393 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10394 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10395 0 : tree _q32 = TREE_OPERAND (_p1, 2);
10396 0 : {
10397 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
10398 0 : if (VECTOR_TYPE_P (type)
10399 0 : && (TREE_CODE_CLASS (UNGT_EXPR) != tcc_comparison
10400 0 : || types_match (type, TREE_TYPE (captures[3]))
10401 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
10402 : || (optimize_vectors_before_lowering_p ()
10403 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
10404 : )
10405 : {
10406 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1770;
10407 0 : {
10408 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1770;
10409 0 : tree res_op0;
10410 0 : res_op0 = captures[2];
10411 0 : tree res_op1;
10412 0 : {
10413 0 : tree _o1[2], _r1;
10414 0 : _o1[0] = unshare_expr (captures[0]);
10415 0 : _o1[1] = captures[3];
10416 0 : _r1 = fold_build2_loc (loc, UNGT_EXPR, type, _o1[0], _o1[1]);
10417 0 : if (EXPR_P (_r1))
10418 0 : goto next_after_fail1770;
10419 0 : res_op1 = _r1;
10420 : }
10421 0 : tree res_op2;
10422 0 : {
10423 0 : tree _o1[2], _r1;
10424 0 : _o1[0] = captures[0];
10425 0 : _o1[1] = captures[4];
10426 0 : _r1 = fold_build2_loc (loc, UNGT_EXPR, type, _o1[0], _o1[1]);
10427 0 : if (EXPR_P (_r1))
10428 0 : goto next_after_fail1770;
10429 0 : res_op2 = _r1;
10430 : }
10431 0 : tree _r;
10432 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10433 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
10434 0 : return _r;
10435 : }
10436 0 : next_after_fail1770:;
10437 : }
10438 : }
10439 0 : break;
10440 : }
10441 1251190 : default:;
10442 : }
10443 1251190 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
10444 : {
10445 0 : {
10446 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10447 0 : tree res = generic_simplify_561 (loc, type, _p0, _p1, captures, UNGT_EXPR);
10448 0 : if (res) return res;
10449 : }
10450 : }
10451 1251190 : switch (TREE_CODE (_p0))
10452 : {
10453 339 : case FLOAT_EXPR:
10454 339 : {
10455 339 : tree _q20 = TREE_OPERAND (_p0, 0);
10456 339 : switch (TREE_CODE (_p1))
10457 : {
10458 0 : case FLOAT_EXPR:
10459 0 : {
10460 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10461 0 : {
10462 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
10463 0 : tree res = generic_simplify_260 (loc, type, _p0, _p1, captures, UNGT_EXPR, GT_EXPR);
10464 0 : if (res) return res;
10465 : }
10466 0 : break;
10467 : }
10468 : default:;
10469 : }
10470 : break;
10471 : }
10472 0 : case NEGATE_EXPR:
10473 0 : {
10474 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10475 0 : switch (TREE_CODE (_p1))
10476 : {
10477 0 : case NEGATE_EXPR:
10478 0 : {
10479 0 : tree _q40 = TREE_OPERAND (_p1, 0);
10480 0 : {
10481 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
10482 0 : tree res = generic_simplify_263 (loc, type, _p0, _p1, captures, UNGT_EXPR, UNLT_EXPR);
10483 0 : if (res) return res;
10484 : }
10485 0 : break;
10486 : }
10487 0 : default:;
10488 : }
10489 0 : if (CONSTANT_CLASS_P (_p1))
10490 : {
10491 0 : {
10492 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
10493 0 : tree res = generic_simplify_264 (loc, type, _p0, _p1, captures, UNGT_EXPR, UNLT_EXPR);
10494 0 : if (res) return res;
10495 : }
10496 : }
10497 : break;
10498 : }
10499 1251190 : default:;
10500 : }
10501 1251190 : switch (TREE_CODE (_p1))
10502 : {
10503 901431 : case REAL_CST:
10504 901431 : {
10505 901431 : {
10506 901431 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
10507 901431 : tree res = generic_simplify_560 (loc, type, _p0, _p1, captures, UNGT_EXPR);
10508 901431 : if (res) return res;
10509 : }
10510 901429 : break;
10511 : }
10512 : default:;
10513 : }
10514 : return NULL_TREE;
10515 : }
10516 :
10517 : tree
10518 9301019 : generic_simplify_TRUTH_OR_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
10519 : {
10520 9301019 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10521 9301019 : switch (TREE_CODE (_p0))
10522 : {
10523 1328193 : case LE_EXPR:
10524 1328193 : {
10525 1328193 : tree _q20 = TREE_OPERAND (_p0, 0);
10526 1328193 : tree _q21 = TREE_OPERAND (_p0, 1);
10527 1328193 : switch (TREE_CODE (_q20))
10528 : {
10529 3898 : case POINTER_PLUS_EXPR:
10530 3898 : {
10531 3898 : tree _q30 = TREE_OPERAND (_q20, 0);
10532 3898 : tree _q31 = TREE_OPERAND (_q20, 1);
10533 3898 : switch (TREE_CODE (_q31))
10534 : {
10535 3668 : case INTEGER_CST:
10536 3668 : {
10537 3668 : switch (TREE_CODE (_p1))
10538 : {
10539 1086 : case LE_EXPR:
10540 1086 : {
10541 1086 : tree _q70 = TREE_OPERAND (_p1, 0);
10542 1086 : tree _q71 = TREE_OPERAND (_p1, 1);
10543 1086 : switch (TREE_CODE (_q70))
10544 : {
10545 800 : case POINTER_PLUS_EXPR:
10546 800 : {
10547 800 : tree _q80 = TREE_OPERAND (_q70, 0);
10548 800 : tree _q81 = TREE_OPERAND (_q70, 1);
10549 800 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
10550 : {
10551 514 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
10552 : {
10553 395 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
10554 : {
10555 395 : {
10556 395 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70 };
10557 395 : const enum tree_code cmp = LE_EXPR;
10558 395 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
10559 394 : && TYPE_OVERFLOW_WRAPS (sizetype)
10560 789 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
10561 : )
10562 : {
10563 394 : {
10564 394 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
10565 394 : offset_int rhs = off * 2;
10566 394 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
10567 : )
10568 : {
10569 394 : {
10570 394 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
10571 394 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
10572 394 : if (cmp == LT_EXPR
10573 : )
10574 : {
10575 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1797;
10576 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1797;
10577 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1797;
10578 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1797;
10579 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1797;
10580 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1797;
10581 : {
10582 : tree res_op0;
10583 : {
10584 : tree _o1[1], _r1;
10585 : {
10586 : tree _o2[2], _r2;
10587 : _o2[0] = swap_p ? captures[6] : captures[1];
10588 : _o2[1] = swap_p ? captures[2] : captures[4];
10589 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10590 : _o1[0] = _r2;
10591 : }
10592 : if (TREE_TYPE (_o1[0]) != sizetype)
10593 : {
10594 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10595 : }
10596 : else
10597 : _r1 = _o1[0];
10598 : res_op0 = _r1;
10599 : }
10600 : tree res_op1;
10601 : res_op1 = rhs_tree;
10602 : tree _r;
10603 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10604 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 940, __FILE__, __LINE__, true);
10605 394 : return _r;
10606 : }
10607 : next_after_fail1797:;
10608 : }
10609 : else
10610 : {
10611 394 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1798;
10612 394 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1798;
10613 394 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1798;
10614 394 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1798;
10615 394 : {
10616 394 : tree res_op0;
10617 394 : {
10618 394 : tree _o1[1], _r1;
10619 394 : {
10620 394 : tree _o2[2], _r2;
10621 394 : {
10622 394 : tree _o3[2], _r3;
10623 394 : _o3[0] = swap_p ? captures[4] : captures[2];
10624 394 : _o3[1] = wide_int_to_tree (sizetype, off);
10625 394 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
10626 394 : _o2[0] = _r3;
10627 : }
10628 394 : _o2[1] = swap_p ? captures[2] : captures[4];
10629 394 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10630 394 : _o1[0] = _r2;
10631 : }
10632 394 : if (TREE_TYPE (_o1[0]) != sizetype)
10633 : {
10634 394 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10635 : }
10636 : else
10637 : _r1 = _o1[0];
10638 394 : res_op0 = _r1;
10639 : }
10640 394 : tree res_op1;
10641 394 : res_op1 = rhs_tree;
10642 394 : tree _r;
10643 394 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10644 394 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 941, __FILE__, __LINE__, true);
10645 394 : return _r;
10646 : }
10647 0 : next_after_fail1798:;
10648 : }
10649 : }
10650 : }
10651 : }
10652 : }
10653 : }
10654 : }
10655 : }
10656 : }
10657 : break;
10658 : }
10659 : default:;
10660 : }
10661 : break;
10662 : }
10663 117 : case GE_EXPR:
10664 117 : {
10665 117 : tree _q70 = TREE_OPERAND (_p1, 0);
10666 117 : tree _q71 = TREE_OPERAND (_p1, 1);
10667 117 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
10668 : {
10669 18 : switch (TREE_CODE (_q71))
10670 : {
10671 18 : case POINTER_PLUS_EXPR:
10672 18 : {
10673 18 : tree _q90 = TREE_OPERAND (_q71, 0);
10674 18 : tree _q91 = TREE_OPERAND (_q71, 1);
10675 18 : if ((_q90 == _q21 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q21, 0) && types_match (_q90, _q21)))
10676 : {
10677 16 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
10678 : {
10679 11 : {
10680 11 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q71 };
10681 11 : const enum tree_code cmp = LE_EXPR;
10682 11 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
10683 11 : && TYPE_OVERFLOW_WRAPS (sizetype)
10684 22 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
10685 : )
10686 : {
10687 11 : {
10688 11 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
10689 11 : offset_int rhs = off * 2;
10690 11 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
10691 : )
10692 : {
10693 11 : {
10694 11 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
10695 11 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
10696 11 : if (cmp == LT_EXPR
10697 : )
10698 : {
10699 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1799;
10700 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1799;
10701 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1799;
10702 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1799;
10703 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1799;
10704 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1799;
10705 : {
10706 : tree res_op0;
10707 : {
10708 : tree _o1[1], _r1;
10709 : {
10710 : tree _o2[2], _r2;
10711 : _o2[0] = swap_p ? captures[6] : captures[1];
10712 : _o2[1] = swap_p ? captures[2] : captures[4];
10713 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10714 : _o1[0] = _r2;
10715 : }
10716 : if (TREE_TYPE (_o1[0]) != sizetype)
10717 : {
10718 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10719 : }
10720 : else
10721 : _r1 = _o1[0];
10722 : res_op0 = _r1;
10723 : }
10724 : tree res_op1;
10725 : res_op1 = rhs_tree;
10726 : tree _r;
10727 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10728 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 940, __FILE__, __LINE__, true);
10729 11 : return _r;
10730 : }
10731 : next_after_fail1799:;
10732 : }
10733 : else
10734 : {
10735 11 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1800;
10736 11 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1800;
10737 11 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1800;
10738 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1800;
10739 11 : {
10740 11 : tree res_op0;
10741 11 : {
10742 11 : tree _o1[1], _r1;
10743 11 : {
10744 11 : tree _o2[2], _r2;
10745 11 : {
10746 11 : tree _o3[2], _r3;
10747 11 : _o3[0] = swap_p ? captures[4] : captures[2];
10748 11 : _o3[1] = wide_int_to_tree (sizetype, off);
10749 11 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
10750 11 : _o2[0] = _r3;
10751 : }
10752 11 : _o2[1] = swap_p ? captures[2] : captures[4];
10753 11 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10754 11 : _o1[0] = _r2;
10755 : }
10756 11 : if (TREE_TYPE (_o1[0]) != sizetype)
10757 : {
10758 11 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10759 : }
10760 : else
10761 : _r1 = _o1[0];
10762 11 : res_op0 = _r1;
10763 : }
10764 11 : tree res_op1;
10765 11 : res_op1 = rhs_tree;
10766 11 : tree _r;
10767 11 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10768 11 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 941, __FILE__, __LINE__, true);
10769 11 : return _r;
10770 : }
10771 0 : next_after_fail1800:;
10772 : }
10773 : }
10774 : }
10775 : }
10776 : }
10777 : }
10778 : }
10779 : }
10780 : break;
10781 : }
10782 : default:;
10783 : }
10784 : }
10785 : break;
10786 : }
10787 : default:;
10788 : }
10789 : break;
10790 : }
10791 : default:;
10792 : }
10793 : break;
10794 : }
10795 : default:;
10796 : }
10797 : break;
10798 : }
10799 1045476 : case LT_EXPR:
10800 1045476 : {
10801 1045476 : tree _q20 = TREE_OPERAND (_p0, 0);
10802 1045476 : tree _q21 = TREE_OPERAND (_p0, 1);
10803 1045476 : switch (TREE_CODE (_q20))
10804 : {
10805 2386 : case POINTER_PLUS_EXPR:
10806 2386 : {
10807 2386 : tree _q30 = TREE_OPERAND (_q20, 0);
10808 2386 : tree _q31 = TREE_OPERAND (_q20, 1);
10809 2386 : switch (TREE_CODE (_q31))
10810 : {
10811 2200 : case INTEGER_CST:
10812 2200 : {
10813 2200 : switch (TREE_CODE (_p1))
10814 : {
10815 158 : case LT_EXPR:
10816 158 : {
10817 158 : tree _q70 = TREE_OPERAND (_p1, 0);
10818 158 : tree _q71 = TREE_OPERAND (_p1, 1);
10819 158 : switch (TREE_CODE (_q70))
10820 : {
10821 10 : case POINTER_PLUS_EXPR:
10822 10 : {
10823 10 : tree _q80 = TREE_OPERAND (_q70, 0);
10824 10 : tree _q81 = TREE_OPERAND (_q70, 1);
10825 10 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
10826 : {
10827 1 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
10828 : {
10829 1 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
10830 : {
10831 1 : {
10832 1 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70 };
10833 1 : const enum tree_code cmp = LT_EXPR;
10834 1 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
10835 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
10836 1 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
10837 : )
10838 : {
10839 0 : {
10840 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
10841 0 : offset_int rhs = off * 2;
10842 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
10843 : )
10844 : {
10845 0 : {
10846 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
10847 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
10848 0 : if (cmp == LT_EXPR
10849 : )
10850 : {
10851 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1801;
10852 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1801;
10853 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1801;
10854 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1801;
10855 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1801;
10856 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1801;
10857 0 : {
10858 0 : tree res_op0;
10859 0 : {
10860 0 : tree _o1[1], _r1;
10861 0 : {
10862 0 : tree _o2[2], _r2;
10863 0 : _o2[0] = swap_p ? captures[6] : captures[1];
10864 0 : _o2[1] = swap_p ? captures[2] : captures[4];
10865 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10866 0 : _o1[0] = _r2;
10867 : }
10868 0 : if (TREE_TYPE (_o1[0]) != sizetype)
10869 : {
10870 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10871 : }
10872 : else
10873 : _r1 = _o1[0];
10874 0 : res_op0 = _r1;
10875 : }
10876 0 : tree res_op1;
10877 0 : res_op1 = rhs_tree;
10878 0 : tree _r;
10879 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10880 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 940, __FILE__, __LINE__, true);
10881 0 : return _r;
10882 : }
10883 0 : next_after_fail1801:;
10884 : }
10885 : else
10886 : {
10887 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1802;
10888 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1802;
10889 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1802;
10890 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1802;
10891 : {
10892 : tree res_op0;
10893 : {
10894 : tree _o1[1], _r1;
10895 : {
10896 : tree _o2[2], _r2;
10897 : {
10898 : tree _o3[2], _r3;
10899 : _o3[0] = swap_p ? captures[4] : captures[2];
10900 : _o3[1] = wide_int_to_tree (sizetype, off);
10901 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
10902 : _o2[0] = _r3;
10903 : }
10904 : _o2[1] = swap_p ? captures[2] : captures[4];
10905 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10906 : _o1[0] = _r2;
10907 : }
10908 : if (TREE_TYPE (_o1[0]) != sizetype)
10909 : {
10910 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10911 : }
10912 : else
10913 : _r1 = _o1[0];
10914 : res_op0 = _r1;
10915 : }
10916 : tree res_op1;
10917 : res_op1 = rhs_tree;
10918 : tree _r;
10919 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10920 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 941, __FILE__, __LINE__, true);
10921 : return _r;
10922 : }
10923 : next_after_fail1802:;
10924 : }
10925 : }
10926 : }
10927 : }
10928 : }
10929 : }
10930 : }
10931 : }
10932 : }
10933 : break;
10934 : }
10935 : default:;
10936 : }
10937 : break;
10938 : }
10939 778 : case GT_EXPR:
10940 778 : {
10941 778 : tree _q70 = TREE_OPERAND (_p1, 0);
10942 778 : tree _q71 = TREE_OPERAND (_p1, 1);
10943 778 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
10944 : {
10945 0 : switch (TREE_CODE (_q71))
10946 : {
10947 0 : case POINTER_PLUS_EXPR:
10948 0 : {
10949 0 : tree _q90 = TREE_OPERAND (_q71, 0);
10950 0 : tree _q91 = TREE_OPERAND (_q71, 1);
10951 0 : if ((_q90 == _q21 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q21, 0) && types_match (_q90, _q21)))
10952 : {
10953 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
10954 : {
10955 0 : {
10956 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q71 };
10957 0 : const enum tree_code cmp = LT_EXPR;
10958 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
10959 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
10960 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
10961 : )
10962 : {
10963 0 : {
10964 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
10965 0 : offset_int rhs = off * 2;
10966 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
10967 : )
10968 : {
10969 0 : {
10970 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
10971 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
10972 0 : if (cmp == LT_EXPR
10973 : )
10974 : {
10975 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1803;
10976 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1803;
10977 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1803;
10978 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1803;
10979 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1803;
10980 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1803;
10981 0 : {
10982 0 : tree res_op0;
10983 0 : {
10984 0 : tree _o1[1], _r1;
10985 0 : {
10986 0 : tree _o2[2], _r2;
10987 0 : _o2[0] = swap_p ? captures[6] : captures[1];
10988 0 : _o2[1] = swap_p ? captures[2] : captures[4];
10989 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10990 0 : _o1[0] = _r2;
10991 : }
10992 0 : if (TREE_TYPE (_o1[0]) != sizetype)
10993 : {
10994 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10995 : }
10996 : else
10997 : _r1 = _o1[0];
10998 0 : res_op0 = _r1;
10999 : }
11000 0 : tree res_op1;
11001 0 : res_op1 = rhs_tree;
11002 0 : tree _r;
11003 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11004 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 940, __FILE__, __LINE__, true);
11005 0 : return _r;
11006 : }
11007 0 : next_after_fail1803:;
11008 : }
11009 : else
11010 : {
11011 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1804;
11012 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1804;
11013 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1804;
11014 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1804;
11015 : {
11016 : tree res_op0;
11017 : {
11018 : tree _o1[1], _r1;
11019 : {
11020 : tree _o2[2], _r2;
11021 : {
11022 : tree _o3[2], _r3;
11023 : _o3[0] = swap_p ? captures[4] : captures[2];
11024 : _o3[1] = wide_int_to_tree (sizetype, off);
11025 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11026 : _o2[0] = _r3;
11027 : }
11028 : _o2[1] = swap_p ? captures[2] : captures[4];
11029 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11030 : _o1[0] = _r2;
11031 : }
11032 : if (TREE_TYPE (_o1[0]) != sizetype)
11033 : {
11034 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11035 : }
11036 : else
11037 : _r1 = _o1[0];
11038 : res_op0 = _r1;
11039 : }
11040 : tree res_op1;
11041 : res_op1 = rhs_tree;
11042 : tree _r;
11043 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11044 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 941, __FILE__, __LINE__, true);
11045 : return _r;
11046 : }
11047 : next_after_fail1804:;
11048 : }
11049 : }
11050 : }
11051 : }
11052 : }
11053 : }
11054 : }
11055 : }
11056 : break;
11057 : }
11058 : default:;
11059 : }
11060 : }
11061 : break;
11062 : }
11063 : default:;
11064 : }
11065 : break;
11066 : }
11067 : default:;
11068 : }
11069 : break;
11070 : }
11071 : default:;
11072 : }
11073 : break;
11074 : }
11075 794956 : case GE_EXPR:
11076 794956 : {
11077 794956 : tree _q20 = TREE_OPERAND (_p0, 0);
11078 794956 : tree _q21 = TREE_OPERAND (_p0, 1);
11079 794956 : switch (TREE_CODE (_q21))
11080 : {
11081 52 : case POINTER_PLUS_EXPR:
11082 52 : {
11083 52 : tree _q40 = TREE_OPERAND (_q21, 0);
11084 52 : tree _q41 = TREE_OPERAND (_q21, 1);
11085 52 : switch (TREE_CODE (_q41))
11086 : {
11087 52 : case INTEGER_CST:
11088 52 : {
11089 52 : switch (TREE_CODE (_p1))
11090 : {
11091 52 : case LE_EXPR:
11092 52 : {
11093 52 : tree _q70 = TREE_OPERAND (_p1, 0);
11094 52 : tree _q71 = TREE_OPERAND (_p1, 1);
11095 52 : switch (TREE_CODE (_q70))
11096 : {
11097 42 : case POINTER_PLUS_EXPR:
11098 42 : {
11099 42 : tree _q80 = TREE_OPERAND (_q70, 0);
11100 42 : tree _q81 = TREE_OPERAND (_q70, 1);
11101 42 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
11102 : {
11103 27 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
11104 : {
11105 3 : if ((_q71 == _q40 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q40, 0) && types_match (_q71, _q40)))
11106 : {
11107 3 : {
11108 3 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q70 };
11109 3 : const enum tree_code cmp = LE_EXPR;
11110 3 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11111 3 : && TYPE_OVERFLOW_WRAPS (sizetype)
11112 6 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11113 : )
11114 : {
11115 3 : {
11116 3 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11117 3 : offset_int rhs = off * 2;
11118 3 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11119 : )
11120 : {
11121 3 : {
11122 3 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11123 3 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11124 3 : if (cmp == LT_EXPR
11125 : )
11126 : {
11127 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1805;
11128 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1805;
11129 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1805;
11130 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1805;
11131 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1805;
11132 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1805;
11133 : {
11134 : tree res_op0;
11135 : {
11136 : tree _o1[1], _r1;
11137 : {
11138 : tree _o2[2], _r2;
11139 : _o2[0] = swap_p ? captures[6] : captures[1];
11140 : _o2[1] = swap_p ? captures[2] : captures[4];
11141 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11142 : _o1[0] = _r2;
11143 : }
11144 : if (TREE_TYPE (_o1[0]) != sizetype)
11145 : {
11146 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11147 : }
11148 : else
11149 : _r1 = _o1[0];
11150 : res_op0 = _r1;
11151 : }
11152 : tree res_op1;
11153 : res_op1 = rhs_tree;
11154 : tree _r;
11155 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11156 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 940, __FILE__, __LINE__, true);
11157 3 : return _r;
11158 : }
11159 : next_after_fail1805:;
11160 : }
11161 : else
11162 : {
11163 3 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1806;
11164 3 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1806;
11165 3 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1806;
11166 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1806;
11167 3 : {
11168 3 : tree res_op0;
11169 3 : {
11170 3 : tree _o1[1], _r1;
11171 3 : {
11172 3 : tree _o2[2], _r2;
11173 3 : {
11174 3 : tree _o3[2], _r3;
11175 3 : _o3[0] = swap_p ? captures[4] : captures[2];
11176 3 : _o3[1] = wide_int_to_tree (sizetype, off);
11177 3 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11178 3 : _o2[0] = _r3;
11179 : }
11180 3 : _o2[1] = swap_p ? captures[2] : captures[4];
11181 3 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11182 3 : _o1[0] = _r2;
11183 : }
11184 3 : if (TREE_TYPE (_o1[0]) != sizetype)
11185 : {
11186 3 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11187 : }
11188 : else
11189 : _r1 = _o1[0];
11190 3 : res_op0 = _r1;
11191 : }
11192 3 : tree res_op1;
11193 3 : res_op1 = rhs_tree;
11194 3 : tree _r;
11195 3 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11196 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 941, __FILE__, __LINE__, true);
11197 3 : return _r;
11198 : }
11199 0 : next_after_fail1806:;
11200 : }
11201 : }
11202 : }
11203 : }
11204 : }
11205 : }
11206 : }
11207 : }
11208 : }
11209 : break;
11210 : }
11211 : default:;
11212 : }
11213 : break;
11214 : }
11215 0 : case GE_EXPR:
11216 0 : {
11217 0 : tree _q70 = TREE_OPERAND (_p1, 0);
11218 0 : tree _q71 = TREE_OPERAND (_p1, 1);
11219 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
11220 : {
11221 0 : switch (TREE_CODE (_q71))
11222 : {
11223 0 : case POINTER_PLUS_EXPR:
11224 0 : {
11225 0 : tree _q90 = TREE_OPERAND (_q71, 0);
11226 0 : tree _q91 = TREE_OPERAND (_q71, 1);
11227 0 : if ((_q90 == _q20 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q20, 0) && types_match (_q90, _q20)))
11228 : {
11229 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
11230 : {
11231 0 : {
11232 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q71 };
11233 0 : const enum tree_code cmp = LE_EXPR;
11234 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11235 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
11236 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11237 : )
11238 : {
11239 0 : {
11240 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11241 0 : offset_int rhs = off * 2;
11242 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11243 : )
11244 : {
11245 0 : {
11246 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11247 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11248 0 : if (cmp == LT_EXPR
11249 : )
11250 : {
11251 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1807;
11252 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1807;
11253 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1807;
11254 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1807;
11255 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1807;
11256 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1807;
11257 : {
11258 : tree res_op0;
11259 : {
11260 : tree _o1[1], _r1;
11261 : {
11262 : tree _o2[2], _r2;
11263 : _o2[0] = swap_p ? captures[6] : captures[1];
11264 : _o2[1] = swap_p ? captures[2] : captures[4];
11265 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11266 : _o1[0] = _r2;
11267 : }
11268 : if (TREE_TYPE (_o1[0]) != sizetype)
11269 : {
11270 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11271 : }
11272 : else
11273 : _r1 = _o1[0];
11274 : res_op0 = _r1;
11275 : }
11276 : tree res_op1;
11277 : res_op1 = rhs_tree;
11278 : tree _r;
11279 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11280 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 940, __FILE__, __LINE__, true);
11281 0 : return _r;
11282 : }
11283 : next_after_fail1807:;
11284 : }
11285 : else
11286 : {
11287 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1808;
11288 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1808;
11289 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1808;
11290 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1808;
11291 0 : {
11292 0 : tree res_op0;
11293 0 : {
11294 0 : tree _o1[1], _r1;
11295 0 : {
11296 0 : tree _o2[2], _r2;
11297 0 : {
11298 0 : tree _o3[2], _r3;
11299 0 : _o3[0] = swap_p ? captures[4] : captures[2];
11300 0 : _o3[1] = wide_int_to_tree (sizetype, off);
11301 0 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11302 0 : _o2[0] = _r3;
11303 : }
11304 0 : _o2[1] = swap_p ? captures[2] : captures[4];
11305 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11306 0 : _o1[0] = _r2;
11307 : }
11308 0 : if (TREE_TYPE (_o1[0]) != sizetype)
11309 : {
11310 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11311 : }
11312 : else
11313 : _r1 = _o1[0];
11314 0 : res_op0 = _r1;
11315 : }
11316 0 : tree res_op1;
11317 0 : res_op1 = rhs_tree;
11318 0 : tree _r;
11319 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11320 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 941, __FILE__, __LINE__, true);
11321 0 : return _r;
11322 : }
11323 0 : next_after_fail1808:;
11324 : }
11325 : }
11326 : }
11327 : }
11328 : }
11329 : }
11330 : }
11331 : }
11332 : break;
11333 : }
11334 : default:;
11335 : }
11336 : }
11337 : break;
11338 : }
11339 : default:;
11340 : }
11341 : break;
11342 : }
11343 : default:;
11344 : }
11345 : break;
11346 : }
11347 : default:;
11348 : }
11349 : break;
11350 : }
11351 1162545 : case GT_EXPR:
11352 1162545 : {
11353 1162545 : tree _q20 = TREE_OPERAND (_p0, 0);
11354 1162545 : tree _q21 = TREE_OPERAND (_p0, 1);
11355 1162545 : switch (TREE_CODE (_q21))
11356 : {
11357 46 : case POINTER_PLUS_EXPR:
11358 46 : {
11359 46 : tree _q40 = TREE_OPERAND (_q21, 0);
11360 46 : tree _q41 = TREE_OPERAND (_q21, 1);
11361 46 : switch (TREE_CODE (_q41))
11362 : {
11363 46 : case INTEGER_CST:
11364 46 : {
11365 46 : switch (TREE_CODE (_p1))
11366 : {
11367 0 : case LT_EXPR:
11368 0 : {
11369 0 : tree _q70 = TREE_OPERAND (_p1, 0);
11370 0 : tree _q71 = TREE_OPERAND (_p1, 1);
11371 0 : switch (TREE_CODE (_q70))
11372 : {
11373 0 : case POINTER_PLUS_EXPR:
11374 0 : {
11375 0 : tree _q80 = TREE_OPERAND (_q70, 0);
11376 0 : tree _q81 = TREE_OPERAND (_q70, 1);
11377 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
11378 : {
11379 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
11380 : {
11381 0 : if ((_q71 == _q40 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q40, 0) && types_match (_q71, _q40)))
11382 : {
11383 0 : {
11384 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q70 };
11385 0 : const enum tree_code cmp = LT_EXPR;
11386 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11387 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
11388 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11389 : )
11390 : {
11391 0 : {
11392 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11393 0 : offset_int rhs = off * 2;
11394 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11395 : )
11396 : {
11397 0 : {
11398 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11399 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11400 0 : if (cmp == LT_EXPR
11401 : )
11402 : {
11403 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1809;
11404 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1809;
11405 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1809;
11406 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1809;
11407 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1809;
11408 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1809;
11409 0 : {
11410 0 : tree res_op0;
11411 0 : {
11412 0 : tree _o1[1], _r1;
11413 0 : {
11414 0 : tree _o2[2], _r2;
11415 0 : _o2[0] = swap_p ? captures[6] : captures[1];
11416 0 : _o2[1] = swap_p ? captures[2] : captures[4];
11417 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11418 0 : _o1[0] = _r2;
11419 : }
11420 0 : if (TREE_TYPE (_o1[0]) != sizetype)
11421 : {
11422 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11423 : }
11424 : else
11425 : _r1 = _o1[0];
11426 0 : res_op0 = _r1;
11427 : }
11428 0 : tree res_op1;
11429 0 : res_op1 = rhs_tree;
11430 0 : tree _r;
11431 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11432 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 940, __FILE__, __LINE__, true);
11433 0 : return _r;
11434 : }
11435 0 : next_after_fail1809:;
11436 : }
11437 : else
11438 : {
11439 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1810;
11440 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1810;
11441 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1810;
11442 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1810;
11443 : {
11444 : tree res_op0;
11445 : {
11446 : tree _o1[1], _r1;
11447 : {
11448 : tree _o2[2], _r2;
11449 : {
11450 : tree _o3[2], _r3;
11451 : _o3[0] = swap_p ? captures[4] : captures[2];
11452 : _o3[1] = wide_int_to_tree (sizetype, off);
11453 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11454 : _o2[0] = _r3;
11455 : }
11456 : _o2[1] = swap_p ? captures[2] : captures[4];
11457 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11458 : _o1[0] = _r2;
11459 : }
11460 : if (TREE_TYPE (_o1[0]) != sizetype)
11461 : {
11462 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11463 : }
11464 : else
11465 : _r1 = _o1[0];
11466 : res_op0 = _r1;
11467 : }
11468 : tree res_op1;
11469 : res_op1 = rhs_tree;
11470 : tree _r;
11471 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11472 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 941, __FILE__, __LINE__, true);
11473 : return _r;
11474 : }
11475 : next_after_fail1810:;
11476 : }
11477 : }
11478 : }
11479 : }
11480 : }
11481 : }
11482 : }
11483 : }
11484 : }
11485 : break;
11486 : }
11487 : default:;
11488 : }
11489 : break;
11490 : }
11491 18 : case GT_EXPR:
11492 18 : {
11493 18 : tree _q70 = TREE_OPERAND (_p1, 0);
11494 18 : tree _q71 = TREE_OPERAND (_p1, 1);
11495 18 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
11496 : {
11497 0 : switch (TREE_CODE (_q71))
11498 : {
11499 0 : case POINTER_PLUS_EXPR:
11500 0 : {
11501 0 : tree _q90 = TREE_OPERAND (_q71, 0);
11502 0 : tree _q91 = TREE_OPERAND (_q71, 1);
11503 0 : if ((_q90 == _q20 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q20, 0) && types_match (_q90, _q20)))
11504 : {
11505 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
11506 : {
11507 0 : {
11508 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q71 };
11509 0 : const enum tree_code cmp = LT_EXPR;
11510 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
11511 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
11512 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
11513 : )
11514 : {
11515 0 : {
11516 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
11517 0 : offset_int rhs = off * 2;
11518 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
11519 : )
11520 : {
11521 0 : {
11522 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
11523 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
11524 0 : if (cmp == LT_EXPR
11525 : )
11526 : {
11527 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1811;
11528 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1811;
11529 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1811;
11530 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1811;
11531 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1811;
11532 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1811;
11533 0 : {
11534 0 : tree res_op0;
11535 0 : {
11536 0 : tree _o1[1], _r1;
11537 0 : {
11538 0 : tree _o2[2], _r2;
11539 0 : _o2[0] = swap_p ? captures[6] : captures[1];
11540 0 : _o2[1] = swap_p ? captures[2] : captures[4];
11541 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11542 0 : _o1[0] = _r2;
11543 : }
11544 0 : if (TREE_TYPE (_o1[0]) != sizetype)
11545 : {
11546 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11547 : }
11548 : else
11549 : _r1 = _o1[0];
11550 0 : res_op0 = _r1;
11551 : }
11552 0 : tree res_op1;
11553 0 : res_op1 = rhs_tree;
11554 0 : tree _r;
11555 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11556 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 940, __FILE__, __LINE__, true);
11557 0 : return _r;
11558 : }
11559 0 : next_after_fail1811:;
11560 : }
11561 : else
11562 : {
11563 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1812;
11564 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1812;
11565 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1812;
11566 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1812;
11567 : {
11568 : tree res_op0;
11569 : {
11570 : tree _o1[1], _r1;
11571 : {
11572 : tree _o2[2], _r2;
11573 : {
11574 : tree _o3[2], _r3;
11575 : _o3[0] = swap_p ? captures[4] : captures[2];
11576 : _o3[1] = wide_int_to_tree (sizetype, off);
11577 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
11578 : _o2[0] = _r3;
11579 : }
11580 : _o2[1] = swap_p ? captures[2] : captures[4];
11581 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
11582 : _o1[0] = _r2;
11583 : }
11584 : if (TREE_TYPE (_o1[0]) != sizetype)
11585 : {
11586 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
11587 : }
11588 : else
11589 : _r1 = _o1[0];
11590 : res_op0 = _r1;
11591 : }
11592 : tree res_op1;
11593 : res_op1 = rhs_tree;
11594 : tree _r;
11595 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
11596 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 941, __FILE__, __LINE__, true);
11597 : return _r;
11598 : }
11599 : next_after_fail1812:;
11600 : }
11601 : }
11602 : }
11603 : }
11604 : }
11605 : }
11606 : }
11607 : }
11608 : break;
11609 : }
11610 : default:;
11611 : }
11612 : }
11613 : break;
11614 : }
11615 : default:;
11616 : }
11617 : break;
11618 : }
11619 : default:;
11620 : }
11621 : break;
11622 : }
11623 : default:;
11624 : }
11625 : break;
11626 : }
11627 : default:;
11628 : }
11629 : return NULL_TREE;
11630 : }
11631 : #pragma GCC diagnostic pop
|
