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 1913642 : tree_power_of_two_cand (tree t, tree *res_ops)
11 : {
12 1913642 : const tree type = TREE_TYPE (t);
13 1913642 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 1913642 : if (TREE_SIDE_EFFECTS (t)) return false;
15 1912903 : switch (TREE_CODE (t))
16 : {
17 1589616 : case INTEGER_CST:
18 1589616 : {
19 1589616 : {
20 1589616 : tree captures[1] ATTRIBUTE_UNUSED = { t };
21 1589616 : {
22 1589616 : res_ops[0] = captures[0];
23 1589616 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 12, __FILE__, __LINE__, false);
24 : return true;
25 : }
26 : }
27 16 : break;
28 : }
29 16 : case LSHIFT_EXPR:
30 16 : {
31 16 : tree _p0 = TREE_OPERAND (t, 0);
32 16 : tree _p1 = TREE_OPERAND (t, 1);
33 16 : switch (TREE_CODE (_p0))
34 : {
35 16 : case INTEGER_CST:
36 16 : {
37 16 : {
38 16 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
39 16 : {
40 16 : res_ops[0] = captures[0];
41 16 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 13, __FILE__, __LINE__, false);
42 16 : return true;
43 : }
44 : }
45 : break;
46 : }
47 : default:;
48 : }
49 : break;
50 : }
51 : default:;
52 : }
53 : return false;
54 : }
55 :
56 : bool
57 91940700 : tree_with_possible_nonzero_bits (tree t)
58 : {
59 91940700 : const tree type = TREE_TYPE (t);
60 91940700 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
61 91940700 : if (TREE_SIDE_EFFECTS (t)) return false;
62 85732088 : switch (TREE_CODE (t))
63 : {
64 2141199 : case BIT_AND_EXPR:
65 2141199 : {
66 2141199 : tree _p0 = TREE_OPERAND (t, 0);
67 2141199 : tree _p1 = TREE_OPERAND (t, 1);
68 2141199 : if (tree_with_possible_nonzero_bits_1 (_p0))
69 : {
70 898236 : {
71 898236 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
72 898236 : {
73 898236 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 35, __FILE__, __LINE__, false);
74 898236 : return true;
75 : }
76 : }
77 : }
78 1242963 : if (tree_with_possible_nonzero_bits_1 (_p1))
79 : {
80 1068863 : {
81 1068863 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _p0 };
82 1068863 : {
83 1068863 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 35, __FILE__, __LINE__, false);
84 1068863 : return true;
85 : }
86 : }
87 : }
88 : break;
89 : }
90 83764989 : default:;
91 : }
92 83764989 : if (tree_with_possible_nonzero_bits_1 (t))
93 : {
94 41291383 : {
95 41291383 : tree captures[1] ATTRIBUTE_UNUSED = { t };
96 41291383 : {
97 41291383 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 36, __FILE__, __LINE__, false);
98 41291383 : return true;
99 : }
100 : }
101 : }
102 : return false;
103 : }
104 :
105 : bool
106 731877 : tree_vec_same_elem_p (tree t)
107 : {
108 731877 : const tree type = TREE_TYPE (t);
109 731877 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
110 731877 : if (TREE_SIDE_EFFECTS (t)) return false;
111 731877 : switch (TREE_CODE (t))
112 : {
113 0 : case VEC_DUPLICATE_EXPR:
114 0 : {
115 0 : tree _p0 = TREE_OPERAND (t, 0);
116 0 : {
117 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
118 0 : {
119 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 46, __FILE__, __LINE__, false);
120 0 : return true;
121 : }
122 : }
123 : break;
124 : }
125 : case CONSTRUCTOR:
126 : {
127 : {
128 : tree captures[1] ATTRIBUTE_UNUSED = { t };
129 : if (TREE_CODE (captures[0]) == SSA_NAME
130 : && uniform_vector_p (gimple_assign_rhs1 (SSA_NAME_DEF_STMT (captures[0])))
131 : )
132 : {
133 : {
134 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 47, __FILE__, __LINE__, false);
135 : return true;
136 : }
137 : }
138 : }
139 : break;
140 : }
141 731877 : default:;
142 : }
143 731877 : {
144 731877 : tree captures[1] ATTRIBUTE_UNUSED = { t };
145 731877 : if (uniform_vector_p (captures[0])
146 : )
147 : {
148 13913 : {
149 13913 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 48, __FILE__, __LINE__, false);
150 13913 : return true;
151 : }
152 : }
153 : }
154 : return false;
155 : }
156 :
157 : tree
158 47886 : generic_simplify_13 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
159 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
160 : {
161 47886 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
162 47886 : if (!TYPE_SATURATING (type)
163 : )
164 : {
165 47886 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
166 95698 : && !FIXED_POINT_TYPE_P (type)
167 : )
168 : {
169 47812 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail85;
170 47812 : {
171 47812 : tree res_op0;
172 47812 : res_op0 = captures[0];
173 47812 : tree _r;
174 47812 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
175 47812 : if (TREE_SIDE_EFFECTS (captures[1]))
176 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
177 47812 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 62, __FILE__, __LINE__, true);
178 47812 : return _r;
179 : }
180 0 : next_after_fail85:;
181 : }
182 : }
183 : return NULL_TREE;
184 : }
185 :
186 : tree
187 10 : generic_simplify_20 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
188 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
189 : {
190 10 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
191 10 : if (!TYPE_SATURATING (type)
192 : )
193 : {
194 10 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
195 20 : && !FIXED_POINT_TYPE_P (type)
196 : )
197 : {
198 10 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail100;
199 10 : {
200 10 : tree res_op0;
201 10 : res_op0 = captures[2];
202 10 : tree res_op1;
203 10 : res_op1 = captures[1];
204 10 : tree _r;
205 10 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
206 10 : if (TREE_SIDE_EFFECTS (captures[0]))
207 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
208 10 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 77, __FILE__, __LINE__, true);
209 10 : return _r;
210 : }
211 0 : next_after_fail100:;
212 : }
213 : }
214 : return NULL_TREE;
215 : }
216 :
217 : tree
218 425591 : generic_simplify_27 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
219 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
220 : const enum tree_code ARG_UNUSED (plusminus))
221 : {
222 425591 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
223 425591 : if (!TYPE_SATURATING (type)
224 425591 : && (!FLOAT_TYPE_P (type) || flag_associative_math)
225 : )
226 : {
227 425051 : if (!ALL_FRACT_MODE_P (TYPE_MODE (type))
228 : )
229 : {
230 55 : if ((!ANY_INTEGRAL_TYPE_P (type)
231 425010 : || TYPE_OVERFLOW_WRAPS (type)
232 87543 : || (INTEGRAL_TYPE_P (type)
233 87529 : && ((tree_expr_nonzero_p (captures[1])
234 60239 : && (plusminus == MINUS_EXPR
235 60098 : || expr_not_equal_to (captures[1],
236 485149 : wi::minus_one (TYPE_PRECISION (type)),
237 : gimple_match_ctx (captures[0]))))
238 27290 : || expr_not_equal_to (captures[2],
239 : (plusminus == PLUS_EXPR
240 452341 : ? wi::max_value (TYPE_PRECISION (type), SIGNED)
241 1556 : : wi::min_value (TYPE_PRECISION (type), SIGNED)),
242 : gimple_match_ctx (captures[0])))))
243 425051 : && single_use (captures[0])
244 : )
245 : {
246 423686 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail108;
247 423686 : {
248 423686 : tree res_op0;
249 423686 : {
250 423686 : tree _o1[2], _r1;
251 423686 : _o1[0] = captures[2];
252 423686 : _o1[1] = build_one_cst (type);
253 423686 : _r1 = fold_build2_loc (loc, plusminus, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
254 423686 : res_op0 = _r1;
255 : }
256 423686 : tree res_op1;
257 423686 : res_op1 = captures[1];
258 423686 : tree _r;
259 423686 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
260 423686 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 85, __FILE__, __LINE__, true);
261 423686 : return _r;
262 : }
263 0 : next_after_fail108:;
264 : }
265 : }
266 : }
267 : return NULL_TREE;
268 : }
269 :
270 : tree
271 1 : generic_simplify_34 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
272 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
273 : const combined_fn ARG_UNUSED (logs))
274 : {
275 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
276 1 : if (flag_unsafe_math_optimizations
277 : )
278 : {
279 1 : if (! HONOR_SIGN_DEPENDENT_ROUNDING (type)
280 1 : && ! HONOR_NANS (type) && ! HONOR_INFINITIES (type)
281 1 : && ! flag_trapping_math
282 2 : && ! flag_errno_math
283 : )
284 : {
285 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail116;
286 1 : {
287 1 : tree res_op0;
288 1 : {
289 1 : tree _o1[2], _r1;
290 1 : _o1[0] = captures[1];
291 1 : _o1[1] = captures[3];
292 1 : _r1 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
293 1 : res_op0 = _r1;
294 : }
295 1 : tree _r;
296 1 : _r = maybe_build_call_expr_loc (loc, logs, type, 1, res_op0);
297 1 : if (!_r)
298 0 : goto next_after_fail116;
299 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 93, __FILE__, __LINE__, true);
300 1 : return _r;
301 : }
302 : next_after_fail116:;
303 : }
304 : }
305 : return NULL_TREE;
306 : }
307 :
308 : tree
309 21 : generic_simplify_42 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
310 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
311 : {
312 21 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
313 21 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail124;
314 21 : {
315 21 : tree res_op0;
316 21 : {
317 21 : tree _o1[2], _r1;
318 21 : _o1[0] = captures[1];
319 21 : _o1[1] = unshare_expr (captures[2]);
320 21 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
321 21 : res_op0 = _r1;
322 : }
323 21 : tree res_op1;
324 21 : res_op1 = captures[2];
325 21 : tree _r;
326 21 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
327 21 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 101, __FILE__, __LINE__, true);
328 : return _r;
329 : }
330 0 : next_after_fail124:;
331 0 : return NULL_TREE;
332 : }
333 :
334 : tree
335 1512 : generic_simplify_49 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
336 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
337 : {
338 1512 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
339 1512 : if (!TYPE_SATURATING (type)
340 : )
341 : {
342 1512 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[1]))
343 1512 : && !TYPE_OVERFLOW_SANITIZED (type)
344 : )
345 : {
346 5 : {
347 5 : tree t1 = type;
348 5 : if (INTEGRAL_TYPE_P (type)
349 5 : && TYPE_OVERFLOW_WRAPS (type) != TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1])))
350 0 : t1 = TYPE_OVERFLOW_WRAPS (type) ? type : TREE_TYPE (captures[1]);
351 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail131;
352 5 : {
353 5 : tree res_op0;
354 5 : {
355 5 : tree _o1[2], _r1;
356 5 : {
357 5 : tree _o2[1], _r2;
358 5 : _o2[0] = captures[0];
359 5 : if (TREE_TYPE (_o2[0]) != t1)
360 : {
361 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, t1, _o2[0]);
362 : }
363 : else
364 : _r2 = _o2[0];
365 5 : _o1[0] = _r2;
366 : }
367 5 : {
368 5 : tree _o2[1], _r2;
369 5 : _o2[0] = captures[1];
370 5 : if (TREE_TYPE (_o2[0]) != t1)
371 : {
372 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, t1, _o2[0]);
373 : }
374 : else
375 : _r2 = _o2[0];
376 5 : _o1[1] = _r2;
377 : }
378 5 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
379 5 : res_op0 = _r1;
380 : }
381 5 : tree _r;
382 5 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
383 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 107, __FILE__, __LINE__, true);
384 5 : return _r;
385 : }
386 0 : next_after_fail131:;
387 : }
388 : }
389 : }
390 : return NULL_TREE;
391 : }
392 :
393 : tree
394 0 : generic_simplify_61 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
395 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
396 : {
397 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
398 0 : if (VECTOR_TYPE_P (type)
399 0 : && known_eq (TYPE_VECTOR_SUBPARTS (type),
400 : TYPE_VECTOR_SUBPARTS (TREE_TYPE (captures[3])))
401 0 : && (TYPE_MODE (TREE_TYPE (type))
402 0 : == TYPE_MODE (TREE_TYPE (TREE_TYPE (captures[3]))))
403 : )
404 : {
405 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail149;
406 0 : {
407 0 : tree res_op0;
408 0 : res_op0 = captures[0];
409 0 : tree res_op1;
410 0 : {
411 0 : tree _o1[1], _r1;
412 0 : {
413 0 : tree _o2[3], _r2;
414 0 : _o2[0] = captures[2];
415 0 : {
416 0 : tree _o3[1], _r3;
417 0 : _o3[0] = captures[3];
418 0 : _r3 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o3[0]), _o3[0]);
419 0 : _o2[1] = _r3;
420 : }
421 0 : _o2[2] = captures[4];
422 0 : _r2 = fold_build3_loc (loc, VEC_COND_EXPR, TREE_TYPE (_o2[1]), _o2[0], _o2[1], _o2[2]);
423 0 : _o1[0] = _r2;
424 : }
425 0 : if (TREE_TYPE (_o1[0]) != type)
426 : {
427 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
428 : }
429 : else
430 : _r1 = _o1[0];
431 0 : res_op1 = _r1;
432 : }
433 0 : tree _r;
434 0 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
435 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 125, __FILE__, __LINE__, true);
436 0 : return _r;
437 : }
438 0 : next_after_fail149:;
439 : }
440 : return NULL_TREE;
441 : }
442 :
443 : tree
444 0 : generic_simplify_68 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
445 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
446 : const enum tree_code ARG_UNUSED (bitop),
447 : const enum tree_code ARG_UNUSED (cmp))
448 : {
449 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
450 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
451 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
452 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == TYPE_PRECISION (TREE_TYPE (captures[2]))
453 : )
454 : {
455 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail156;
456 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail156;
457 0 : {
458 0 : tree res_op0;
459 0 : {
460 0 : tree _o1[2], _r1;
461 0 : _o1[0] = captures[0];
462 0 : {
463 0 : tree _o2[1], _r2;
464 0 : _o2[0] = captures[2];
465 0 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
466 : {
467 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
468 : }
469 : else
470 : _r2 = _o2[0];
471 0 : _o1[1] = _r2;
472 : }
473 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
474 0 : res_op0 = _r1;
475 : }
476 0 : tree res_op1;
477 0 : res_op1 = captures[1];
478 0 : tree _r;
479 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
480 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 132, __FILE__, __LINE__, true);
481 0 : return _r;
482 : }
483 : next_after_fail156:;
484 : }
485 : return NULL_TREE;
486 : }
487 :
488 : tree
489 0 : generic_simplify_80 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
490 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
491 : const enum tree_code ARG_UNUSED (op))
492 : {
493 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
494 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail172;
495 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail172;
496 0 : {
497 0 : tree _r;
498 0 : _r = captures[0];
499 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 143, __FILE__, __LINE__, true);
500 : return _r;
501 : }
502 : next_after_fail172:;
503 : return NULL_TREE;
504 : }
505 :
506 : tree
507 253 : generic_simplify_89 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
508 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
509 : const enum tree_code ARG_UNUSED (bitop))
510 : {
511 253 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
512 253 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail181;
513 253 : {
514 253 : tree res_op0;
515 253 : res_op0 = captures[0];
516 253 : tree _r;
517 253 : _r = non_lvalue_loc (loc, res_op0);
518 253 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 148, __FILE__, __LINE__, true);
519 : return _r;
520 : }
521 0 : next_after_fail181:;
522 0 : return NULL_TREE;
523 : }
524 :
525 : tree
526 18391 : generic_simplify_98 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
527 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
528 : {
529 18391 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
530 18391 : {
531 18391 : bool wascmp;
532 18391 : if ((bitwise_inverted_equal_p (captures[0], captures[2], wascmp)
533 18391 : || bitwise_inverted_equal_p (captures[1], captures[2], wascmp))
534 18391 : && (!wascmp || element_precision (type) == 1)
535 : )
536 : {
537 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail190;
538 0 : {
539 0 : tree _r;
540 0 : _r = build_all_ones_cst (TREE_TYPE (captures[0]));
541 0 : if (TREE_SIDE_EFFECTS (captures[0]))
542 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
543 0 : if (TREE_SIDE_EFFECTS (captures[1]))
544 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
545 0 : if (TREE_SIDE_EFFECTS (captures[2]))
546 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
547 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 155, __FILE__, __LINE__, true);
548 0 : return _r;
549 : }
550 0 : next_after_fail190:;
551 : }
552 : }
553 18391 : return NULL_TREE;
554 : }
555 :
556 : tree
557 2 : generic_simplify_107 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
558 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
559 : const enum tree_code ARG_UNUSED (bitop),
560 : const enum tree_code ARG_UNUSED (rbitop))
561 : {
562 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
563 2 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail203;
564 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail203;
565 2 : {
566 2 : tree _r;
567 2 : _r = captures[2];
568 2 : if (TREE_SIDE_EFFECTS (captures[1]))
569 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
570 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 161, __FILE__, __LINE__, true);
571 : return _r;
572 : }
573 : next_after_fail203:;
574 : return NULL_TREE;
575 : }
576 :
577 : tree
578 0 : generic_simplify_111 (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 (rbitop))
582 : {
583 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
584 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail207;
585 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail207;
586 0 : {
587 0 : tree _r;
588 0 : _r = captures[2];
589 0 : if (TREE_SIDE_EFFECTS (captures[1]))
590 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
591 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 161, __FILE__, __LINE__, true);
592 : return _r;
593 : }
594 : next_after_fail207:;
595 : return NULL_TREE;
596 : }
597 :
598 : tree
599 599 : generic_simplify_119 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
600 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
601 : const enum tree_code ARG_UNUSED (bitop))
602 : {
603 599 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
604 599 : if (!CONSTANT_CLASS_P (captures[0])
605 : )
606 : {
607 599 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail216;
608 599 : {
609 599 : tree res_op0;
610 599 : res_op0 = captures[0];
611 599 : tree res_op1;
612 599 : {
613 599 : tree _o1[2], _r1;
614 599 : _o1[0] = captures[1];
615 599 : _o1[1] = captures[2];
616 599 : _r1 = fold_build2_loc (loc, bitop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
617 599 : if (EXPR_P (_r1))
618 0 : goto next_after_fail216;
619 599 : res_op1 = _r1;
620 : }
621 599 : tree _r;
622 599 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
623 599 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 169, __FILE__, __LINE__, true);
624 599 : return _r;
625 : }
626 : next_after_fail216:;
627 : }
628 : else
629 : {
630 0 : {
631 0 : tree cst1 = const_binop (bitop, type, captures[0], captures[2]);
632 0 : if (cst1
633 : )
634 : {
635 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail217;
636 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail217;
637 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail217;
638 0 : {
639 0 : tree res_op0;
640 0 : res_op0 = captures[1];
641 0 : tree res_op1;
642 0 : res_op1 = cst1;
643 0 : tree _r;
644 0 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
645 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 170, __FILE__, __LINE__, true);
646 0 : return _r;
647 : }
648 : next_after_fail217:;
649 : }
650 : else
651 : {
652 0 : {
653 0 : tree cst2 = const_binop (bitop, type, captures[1], captures[2]);
654 0 : if (cst2
655 : )
656 : {
657 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail218;
658 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail218;
659 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail218;
660 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail218;
661 0 : {
662 0 : tree res_op0;
663 0 : res_op0 = captures[0];
664 0 : tree res_op1;
665 0 : res_op1 = cst2;
666 0 : tree _r;
667 0 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
668 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 171, __FILE__, __LINE__, true);
669 0 : return _r;
670 : }
671 : next_after_fail218:;
672 : }
673 : }
674 : }
675 : }
676 : }
677 : return NULL_TREE;
678 : }
679 :
680 : tree
681 0 : generic_simplify_135 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
682 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
683 : {
684 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
685 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail256;
686 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail256;
687 0 : {
688 0 : tree _r;
689 0 : _r = captures[2];
690 0 : if (TREE_SIDE_EFFECTS (captures[1]))
691 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
692 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 182, __FILE__, __LINE__, true);
693 : return _r;
694 : }
695 : next_after_fail256:;
696 : return NULL_TREE;
697 : }
698 :
699 : tree
700 8 : generic_simplify_140 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
701 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
702 : const enum tree_code ARG_UNUSED (eqne))
703 : {
704 8 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
705 8 : if (eqne == EQ_EXPR
706 : )
707 : {
708 4 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail274;
709 4 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail274;
710 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail274;
711 4 : {
712 4 : tree _r;
713 4 : _r = captures[0];
714 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 201, __FILE__, __LINE__, true);
715 4 : return _r;
716 : }
717 : next_after_fail274:;
718 : }
719 : else
720 : {
721 4 : if (eqne == NE_EXPR
722 : )
723 : {
724 4 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail275;
725 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail275;
726 4 : {
727 4 : tree _r;
728 4 : _r = constant_boolean_node (true, type);
729 4 : if (TREE_SIDE_EFFECTS (captures[2]))
730 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
731 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 202, __FILE__, __LINE__, true);
732 4 : return _r;
733 : }
734 : next_after_fail275:;
735 : }
736 : }
737 : return NULL_TREE;
738 : }
739 :
740 : tree
741 7 : generic_simplify_146 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
742 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
743 : const enum tree_code ARG_UNUSED (op))
744 : {
745 7 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
746 14 : if (INTEGRAL_TYPE_P (type)
747 7 : && tree_int_cst_sgn (captures[2]) > 0
748 7 : && tree_int_cst_sgn (captures[4]) > 0
749 28 : && (tree_nonzero_bits (captures[0]) & tree_nonzero_bits (captures[3])) == 0
750 : )
751 : {
752 4 : {
753 4 : tree t = type;
754 4 : if (!TYPE_OVERFLOW_WRAPS (t))
755 4 : t = unsigned_type_for (t);
756 4 : wide_int wone = wi::one (TYPE_PRECISION (t));
757 8 : wide_int c = wi::add (wi::lshift (wone, wi::to_wide (captures[2])),
758 8 : wi::lshift (wone, wi::to_wide (captures[4])));
759 4 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail281;
760 4 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail281;
761 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail281;
762 4 : {
763 4 : tree res_op0;
764 4 : {
765 4 : tree _o1[2], _r1;
766 4 : {
767 4 : tree _o2[1], _r2;
768 4 : _o2[0] = captures[1];
769 4 : if (TREE_TYPE (_o2[0]) != t)
770 : {
771 4 : _r2 = fold_build1_loc (loc, NOP_EXPR, t, _o2[0]);
772 : }
773 : else
774 : _r2 = _o2[0];
775 4 : _o1[0] = _r2;
776 : }
777 4 : _o1[1] = wide_int_to_tree (t,c);
778 4 : _r1 = fold_build2_loc (loc, MULT_EXPR, t, _o1[0], _o1[1]);
779 4 : res_op0 = _r1;
780 : }
781 4 : tree _r;
782 4 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
783 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 204, __FILE__, __LINE__, true);
784 4 : return _r;
785 : }
786 0 : next_after_fail281:;
787 4 : }
788 : }
789 : return NULL_TREE;
790 : }
791 :
792 : tree
793 7 : generic_simplify_152 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
794 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
795 : {
796 7 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
797 7 : if (type_has_mode_precision_p (type)
798 0 : && tree_fits_uhwi_p (captures[1])
799 0 : && tree_fits_uhwi_p (captures[2])
800 0 : && tree_fits_uhwi_p (captures[4])
801 0 : && (((((HOST_WIDE_INT_1U << tree_to_uhwi (captures[1])) - 1)) & tree_to_uhwi (captures[2])) == 0)
802 0 : && (tree_to_uhwi (captures[1]) + tree_to_uhwi (captures[4])) == TYPE_PRECISION (type)
803 0 : && TYPE_UNSIGNED (type)
804 7 : && captures[0] == captures[3]
805 : )
806 : {
807 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail287;
808 0 : {
809 0 : tree res_op0;
810 0 : {
811 0 : tree _o1[2], _r1;
812 0 : _o1[0] = captures[0];
813 0 : _o1[1] = captures[4];
814 0 : _r1 = fold_build2_loc (loc, RROTATE_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
815 0 : res_op0 = _r1;
816 : }
817 0 : tree res_op1;
818 0 : res_op1 = captures[2];
819 0 : tree _r;
820 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
821 0 : if (TREE_SIDE_EFFECTS (captures[1]))
822 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
823 0 : if (TREE_SIDE_EFFECTS (captures[3]))
824 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
825 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 209, __FILE__, __LINE__, true);
826 0 : return _r;
827 : }
828 0 : next_after_fail287:;
829 : }
830 : return NULL_TREE;
831 : }
832 :
833 : tree
834 0 : generic_simplify_161 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
835 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
836 : {
837 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
838 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail296;
839 0 : {
840 0 : tree res_op0;
841 0 : res_op0 = captures[0];
842 0 : tree res_op1;
843 0 : res_op1 = captures[1];
844 0 : tree _r;
845 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
846 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 218, __FILE__, __LINE__, true);
847 : return _r;
848 : }
849 0 : next_after_fail296:;
850 0 : return NULL_TREE;
851 : }
852 :
853 : tree
854 10 : generic_simplify_165 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
855 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
856 : {
857 10 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
858 10 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[0]))
859 10 : && element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
860 : )
861 : {
862 10 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail300;
863 10 : {
864 10 : tree res_op0;
865 10 : {
866 10 : tree _o1[1], _r1;
867 10 : _o1[0] = captures[0];
868 10 : if (TREE_TYPE (_o1[0]) != type)
869 : {
870 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
871 : }
872 : else
873 : _r1 = _o1[0];
874 10 : res_op0 = _r1;
875 : }
876 10 : tree res_op1;
877 10 : {
878 10 : tree _o1[1], _r1;
879 10 : _o1[0] = captures[1];
880 10 : if (TREE_TYPE (_o1[0]) != type)
881 : {
882 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
883 : }
884 : else
885 : _r1 = _o1[0];
886 10 : res_op1 = _r1;
887 : }
888 10 : tree _r;
889 10 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
890 10 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 222, __FILE__, __LINE__, true);
891 10 : return _r;
892 : }
893 0 : next_after_fail300:;
894 : }
895 : return NULL_TREE;
896 : }
897 :
898 : tree
899 0 : generic_simplify_176 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
900 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
901 : const combined_fn ARG_UNUSED (COPYSIGN_ALL))
902 : {
903 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
904 0 : if (!tree_expr_maybe_nan_p (captures[0]) && !HONOR_SIGNED_ZEROS (type)
905 : )
906 : {
907 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail313;
908 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail313;
909 0 : {
910 0 : tree res_op0;
911 0 : res_op0 = captures[0];
912 0 : tree _r;
913 0 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
914 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 234, __FILE__, __LINE__, true);
915 0 : return _r;
916 : }
917 : next_after_fail313:;
918 : }
919 : return NULL_TREE;
920 : }
921 :
922 : tree
923 3125 : generic_simplify_182 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
924 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
925 : {
926 3125 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
927 3125 : if (! FLOAT_TYPE_P (type)
928 6250 : && tree_nop_conversion_p (type, TREE_TYPE (captures[1]))
929 : )
930 : {
931 3124 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail319;
932 3124 : {
933 3124 : tree res_op0;
934 3124 : res_op0 = captures[0];
935 3124 : tree res_op1;
936 3124 : res_op1 = captures[2];
937 3124 : tree _r;
938 3124 : _r = fold_build2_loc (loc, LSHIFT_EXPR, type, res_op0, res_op1);
939 3124 : if (TREE_SIDE_EFFECTS (captures[1]))
940 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
941 3124 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 238, __FILE__, __LINE__, true);
942 3124 : return _r;
943 : }
944 0 : next_after_fail319:;
945 : }
946 : return NULL_TREE;
947 : }
948 :
949 : tree
950 5762 : generic_simplify_193 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
951 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
952 : const enum tree_code ARG_UNUSED (op))
953 : {
954 5762 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
955 5762 : {
956 5762 : poly_widest_int factor;
957 5762 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[2]))
958 5731 : && tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[2]))
959 11493 : && multiple_p (wi::to_poly_widest (captures[3]), wi::to_widest (captures[1]), &factor)
960 : )
961 : {
962 5682 : {
963 5682 : wi::overflow_type overflow;
964 5682 : wide_int mul;
965 5682 : if (types_match (type, TREE_TYPE (captures[2]))
966 5636 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[2]))
967 0 : && TREE_CODE (captures[2]) == INTEGER_CST
968 0 : && TREE_CODE (captures[3]) == INTEGER_CST
969 5682 : && (mul = wi::mul (wi::to_wide (captures[2]), wi::to_wide (captures[3]),
970 0 : TYPE_SIGN (type), &overflow),
971 0 : !overflow)
972 5682 : && (TYPE_UNSIGNED (type)
973 5682 : || known_eq (factor, 1)
974 0 : || (get_range_pos_neg (captures[0])
975 0 : | (((op == PLUS_EXPR) ^ (tree_int_cst_sgn (captures[2]) < 0))
976 0 : ? 1 : 2)) != 3)
977 : )
978 : {
979 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail332;
980 0 : {
981 0 : tree res_op0;
982 0 : {
983 0 : tree _o1[2], _r1;
984 0 : _o1[0] = captures[0];
985 0 : _o1[1] = wide_int_to_tree (type, factor);
986 0 : _r1 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
987 0 : res_op0 = _r1;
988 : }
989 0 : tree res_op1;
990 0 : res_op1 = wide_int_to_tree (type, mul);
991 0 : tree _r;
992 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
993 0 : if (TREE_SIDE_EFFECTS (captures[1]))
994 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
995 0 : if (TREE_SIDE_EFFECTS (captures[2]))
996 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
997 0 : if (TREE_SIDE_EFFECTS (captures[3]))
998 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
999 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 247, __FILE__, __LINE__, true);
1000 0 : return _r;
1001 : }
1002 0 : next_after_fail332:;
1003 : }
1004 : else
1005 : {
1006 5682 : {
1007 5682 : tree utype = unsigned_type_for (type);
1008 5682 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail333;
1009 5682 : {
1010 5682 : tree res_op0;
1011 5682 : {
1012 5682 : tree _o1[2], _r1;
1013 5682 : {
1014 5682 : tree _o2[2], _r2;
1015 5682 : {
1016 5682 : tree _o3[1], _r3;
1017 5682 : _o3[0] = captures[0];
1018 5682 : if (TREE_TYPE (_o3[0]) != utype)
1019 : {
1020 5682 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
1021 : }
1022 : else
1023 : _r3 = _o3[0];
1024 5682 : _o2[0] = _r3;
1025 : }
1026 5682 : _o2[1] = wide_int_to_tree (utype, factor);
1027 5682 : _r2 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
1028 5682 : _o1[0] = _r2;
1029 : }
1030 5682 : {
1031 5682 : tree _o2[2], _r2;
1032 5682 : {
1033 5682 : tree _o3[1], _r3;
1034 5682 : _o3[0] = captures[3];
1035 5682 : if (TREE_TYPE (_o3[0]) != utype)
1036 : {
1037 14 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
1038 : }
1039 : else
1040 : _r3 = _o3[0];
1041 5682 : _o2[0] = _r3;
1042 : }
1043 5682 : {
1044 5682 : tree _o3[1], _r3;
1045 5682 : _o3[0] = captures[2];
1046 5682 : if (TREE_TYPE (_o3[0]) != utype)
1047 : {
1048 46 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
1049 : }
1050 : else
1051 : _r3 = _o3[0];
1052 5682 : _o2[1] = _r3;
1053 : }
1054 5682 : _r2 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
1055 5682 : _o1[1] = _r2;
1056 : }
1057 5682 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1058 5682 : res_op0 = _r1;
1059 : }
1060 5682 : tree _r;
1061 5682 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1062 5682 : if (TREE_SIDE_EFFECTS (captures[1]))
1063 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1064 5682 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 248, __FILE__, __LINE__, true);
1065 5682 : return _r;
1066 : }
1067 0 : next_after_fail333:;
1068 : }
1069 : }
1070 0 : }
1071 : }
1072 5762 : }
1073 80 : return NULL_TREE;
1074 : }
1075 :
1076 : tree
1077 3 : generic_simplify_224 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1078 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1079 : const enum tree_code ARG_UNUSED (cmp))
1080 : {
1081 3 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1082 3 : if (TREE_INT_CST_LOW (captures[1]) & 1
1083 : )
1084 : {
1085 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail380;
1086 2 : {
1087 2 : tree _r;
1088 2 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1089 2 : if (TREE_SIDE_EFFECTS (captures[0]))
1090 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1091 2 : if (TREE_SIDE_EFFECTS (captures[1]))
1092 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1093 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 293, __FILE__, __LINE__, true);
1094 2 : return _r;
1095 : }
1096 0 : next_after_fail380:;
1097 : }
1098 : return NULL_TREE;
1099 : }
1100 :
1101 : tree
1102 45 : generic_simplify_230 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1103 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1104 : const enum tree_code ARG_UNUSED (cmp))
1105 : {
1106 45 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1107 45 : if (TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1108 : )
1109 : {
1110 0 : {
1111 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[0]));
1112 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail388;
1113 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail388;
1114 0 : {
1115 0 : tree res_op0;
1116 0 : {
1117 0 : tree _o1[2], _r1;
1118 0 : {
1119 0 : tree _o2[1], _r2;
1120 0 : _o2[0] = captures[0];
1121 0 : if (TREE_TYPE (_o2[0]) != utype)
1122 : {
1123 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
1124 : }
1125 : else
1126 : _r2 = _o2[0];
1127 0 : _o1[0] = _r2;
1128 : }
1129 0 : {
1130 0 : tree _o2[1], _r2;
1131 0 : _o2[0] = captures[1];
1132 0 : if (TREE_TYPE (_o2[0]) != utype)
1133 : {
1134 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
1135 : }
1136 : else
1137 : _r2 = _o2[0];
1138 0 : _o1[1] = _r2;
1139 : }
1140 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1141 0 : res_op0 = _r1;
1142 : }
1143 0 : tree res_op1;
1144 0 : res_op1 = build_zero_cst (utype);
1145 0 : tree _r;
1146 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1147 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 301, __FILE__, __LINE__, true);
1148 0 : return _r;
1149 : }
1150 : next_after_fail388:;
1151 : }
1152 : }
1153 : return NULL_TREE;
1154 : }
1155 :
1156 : tree
1157 391 : generic_simplify_239 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1158 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1159 : const enum tree_code ARG_UNUSED (rotate),
1160 : const enum tree_code ARG_UNUSED (invrot),
1161 : const enum tree_code ARG_UNUSED (cmp))
1162 : {
1163 391 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1164 391 : if (integer_zerop (captures[2]) || integer_all_onesp (captures[2])
1165 : )
1166 : {
1167 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail407;
1168 0 : {
1169 0 : tree res_op0;
1170 0 : res_op0 = captures[0];
1171 0 : tree res_op1;
1172 0 : res_op1 = captures[2];
1173 0 : tree _r;
1174 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1175 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1176 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1177 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 320, __FILE__, __LINE__, true);
1178 0 : return _r;
1179 : }
1180 0 : next_after_fail407:;
1181 : }
1182 : return NULL_TREE;
1183 : }
1184 :
1185 : tree
1186 91427 : generic_simplify_245 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1187 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1188 : const enum tree_code ARG_UNUSED (cmp))
1189 : {
1190 91427 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1191 91427 : if (single_use (captures[0])
1192 : )
1193 : {
1194 91427 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail414;
1195 91427 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail414;
1196 91427 : {
1197 91427 : tree res_op0;
1198 91427 : res_op0 = captures[1];
1199 91427 : tree res_op1;
1200 91427 : res_op1 = captures[2];
1201 91427 : tree _r;
1202 91427 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1203 91427 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 327, __FILE__, __LINE__, true);
1204 91427 : return _r;
1205 : }
1206 : next_after_fail414:;
1207 : }
1208 : return NULL_TREE;
1209 : }
1210 :
1211 : tree
1212 0 : generic_simplify_251 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1213 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1214 : const enum tree_code ARG_UNUSED (cmp))
1215 : {
1216 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1217 0 : if (single_use (captures[1]) && single_use (captures[3])
1218 : )
1219 : {
1220 0 : {
1221 0 : tree otype = TREE_TYPE (captures[0]);
1222 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail425;
1223 0 : {
1224 0 : tree res_op0;
1225 0 : {
1226 0 : tree _o1[1], _r1;
1227 0 : _o1[0] = captures[4];
1228 0 : if (TREE_TYPE (_o1[0]) != otype)
1229 : {
1230 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, otype, _o1[0]);
1231 : }
1232 : else
1233 : _r1 = _o1[0];
1234 0 : res_op0 = _r1;
1235 : }
1236 0 : tree res_op1;
1237 0 : {
1238 0 : tree _o1[1], _r1;
1239 0 : _o1[0] = captures[2];
1240 0 : if (TREE_TYPE (_o1[0]) != otype)
1241 : {
1242 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, otype, _o1[0]);
1243 : }
1244 : else
1245 : _r1 = _o1[0];
1246 0 : res_op1 = _r1;
1247 : }
1248 0 : tree _r;
1249 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1250 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 337, __FILE__, __LINE__, true);
1251 0 : return _r;
1252 : }
1253 0 : next_after_fail425:;
1254 : }
1255 : }
1256 0 : return NULL_TREE;
1257 : }
1258 :
1259 : tree
1260 22 : generic_simplify_257 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1261 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1262 : const combined_fn ARG_UNUSED (sq),
1263 : const enum tree_code ARG_UNUSED (cmp))
1264 : {
1265 22 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1266 22 : if (flag_unsafe_math_optimizations && ! flag_errno_math
1267 : )
1268 : {
1269 20 : if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (captures[1]))
1270 : )
1271 : {
1272 2 : if (cmp == EQ_EXPR || cmp == LT_EXPR || cmp == LE_EXPR
1273 : )
1274 : {
1275 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail445;
1276 1 : {
1277 1 : tree _r;
1278 1 : _r = constant_boolean_node (false, type);
1279 1 : if (TREE_SIDE_EFFECTS (captures[0]))
1280 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1281 1 : if (TREE_SIDE_EFFECTS (captures[1]))
1282 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1283 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 356, __FILE__, __LINE__, true);
1284 1 : return _r;
1285 : }
1286 0 : next_after_fail445:;
1287 0 : }
1288 : else
1289 : {
1290 1 : if (cmp == NE_EXPR || !HONOR_NANS (captures[0])
1291 : )
1292 : {
1293 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail446;
1294 1 : {
1295 1 : tree _r;
1296 1 : _r = constant_boolean_node (true, type);
1297 1 : if (TREE_SIDE_EFFECTS (captures[0]))
1298 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1299 1 : if (TREE_SIDE_EFFECTS (captures[1]))
1300 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1301 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 357, __FILE__, __LINE__, true);
1302 1 : return _r;
1303 : }
1304 0 : next_after_fail446:;
1305 : }
1306 : else
1307 : {
1308 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail447;
1309 0 : {
1310 0 : tree res_op0;
1311 0 : res_op0 = captures[0];
1312 0 : tree res_op1;
1313 0 : res_op1 = build_real (TREE_TYPE (captures[0]), dconst0);
1314 0 : tree _r;
1315 0 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
1316 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1317 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1318 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 358, __FILE__, __LINE__, true);
1319 0 : return _r;
1320 : }
1321 0 : next_after_fail447:;
1322 : }
1323 : }
1324 : }
1325 : else
1326 : {
1327 18 : if (real_equal (TREE_REAL_CST_PTR (captures[1]), &dconst0)
1328 : )
1329 : {
1330 0 : if (cmp == LT_EXPR
1331 : )
1332 : {
1333 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail448;
1334 0 : {
1335 0 : tree _r;
1336 0 : _r = constant_boolean_node (false, type);
1337 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1338 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1339 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1340 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1341 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 359, __FILE__, __LINE__, true);
1342 0 : return _r;
1343 : }
1344 0 : next_after_fail448:;
1345 : }
1346 : else
1347 : {
1348 0 : if (cmp == GE_EXPR && !HONOR_NANS (captures[0])
1349 : )
1350 : {
1351 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail449;
1352 0 : {
1353 0 : tree _r;
1354 0 : _r = constant_boolean_node (true, type);
1355 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1356 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1357 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1358 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1359 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 360, __FILE__, __LINE__, true);
1360 0 : return _r;
1361 : }
1362 0 : next_after_fail449:;
1363 : }
1364 : else
1365 : {
1366 0 : if (cmp == LE_EXPR
1367 : )
1368 : {
1369 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail450;
1370 0 : {
1371 0 : tree res_op0;
1372 0 : res_op0 = captures[0];
1373 0 : tree res_op1;
1374 0 : res_op1 = captures[1];
1375 0 : tree _r;
1376 0 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
1377 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 361, __FILE__, __LINE__, true);
1378 0 : return _r;
1379 : }
1380 0 : next_after_fail450:;
1381 : }
1382 : else
1383 : {
1384 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail451;
1385 0 : {
1386 0 : tree res_op0;
1387 0 : res_op0 = captures[0];
1388 0 : tree res_op1;
1389 0 : res_op1 = captures[1];
1390 0 : tree _r;
1391 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1392 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 362, __FILE__, __LINE__, true);
1393 0 : return _r;
1394 : }
1395 0 : next_after_fail451:;
1396 : }
1397 : }
1398 : }
1399 : }
1400 : else
1401 : {
1402 18 : if ((cmp == LT_EXPR
1403 : || cmp == LE_EXPR
1404 : || cmp == GT_EXPR
1405 18 : || cmp == GE_EXPR)
1406 16 : && !REAL_VALUE_ISNAN (TREE_REAL_CST (captures[1]))
1407 34 : && !HONOR_SIGN_DEPENDENT_ROUNDING (TREE_TYPE (captures[0]))
1408 : )
1409 : {
1410 16 : {
1411 16 : REAL_VALUE_TYPE c2;
1412 16 : enum tree_code ncmp = cmp;
1413 16 : const real_format *fmt
1414 16 : = REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (captures[0])));
1415 32 : real_arithmetic (&c2, MULT_EXPR,
1416 16 : &TREE_REAL_CST (captures[1]), &TREE_REAL_CST (captures[1]));
1417 16 : real_convert (&c2, fmt, &c2);
1418 16 : if (!REAL_VALUE_ISINF (c2))
1419 : {
1420 13 : tree c3 = fold_const_call (CFN_SQRT, TREE_TYPE (captures[0]),
1421 13 : build_real (TREE_TYPE (captures[0]), c2));
1422 13 : if (c3 == NULL_TREE || TREE_CODE (c3) != REAL_CST)
1423 : ncmp = ERROR_MARK;
1424 13 : else if ((cmp == LT_EXPR || cmp == GE_EXPR)
1425 13 : && real_less (&TREE_REAL_CST (c3), &TREE_REAL_CST (captures[1])))
1426 4 : ncmp = cmp == LT_EXPR ? LE_EXPR : GT_EXPR;
1427 9 : else if ((cmp == LE_EXPR || cmp == GT_EXPR)
1428 13 : && real_less (&TREE_REAL_CST (captures[1]), &TREE_REAL_CST (c3)))
1429 1 : ncmp = cmp == LE_EXPR ? LT_EXPR : GE_EXPR;
1430 : else
1431 : {
1432 8 : REAL_VALUE_TYPE c2alt, tow;
1433 8 : if (cmp == LT_EXPR || cmp == GE_EXPR)
1434 5 : tow = dconst0;
1435 : else
1436 3 : tow = dconstinf;
1437 8 : real_nextafter (&c2alt, fmt, &c2, &tow);
1438 8 : real_convert (&c2alt, fmt, &c2alt);
1439 8 : if (REAL_VALUE_ISINF (c2alt))
1440 : ncmp = ERROR_MARK;
1441 : else
1442 : {
1443 8 : c3 = fold_const_call (CFN_SQRT, TREE_TYPE (captures[0]),
1444 8 : build_real (TREE_TYPE (captures[0]), c2alt));
1445 8 : if (c3 == NULL_TREE || TREE_CODE (c3) != REAL_CST)
1446 : ncmp = ERROR_MARK;
1447 8 : else if (real_equal (&TREE_REAL_CST (c3),
1448 8 : &TREE_REAL_CST (captures[1])))
1449 8 : c2 = c2alt;
1450 : }
1451 : }
1452 : }
1453 12 : if (cmp == GT_EXPR || cmp == GE_EXPR
1454 : )
1455 : {
1456 5 : if (REAL_VALUE_ISINF (c2)
1457 : )
1458 : {
1459 1 : if (HONOR_INFINITIES (captures[0])
1460 : )
1461 : {
1462 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail452;
1463 0 : {
1464 0 : tree res_op0;
1465 0 : res_op0 = captures[0];
1466 0 : tree res_op1;
1467 0 : res_op1 = build_real (TREE_TYPE (captures[0]), c2);
1468 0 : tree _r;
1469 0 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
1470 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1471 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1472 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 363, __FILE__, __LINE__, true);
1473 14 : return _r;
1474 : }
1475 0 : next_after_fail452:;
1476 : }
1477 : else
1478 : {
1479 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail453;
1480 1 : {
1481 1 : tree _r;
1482 1 : _r = constant_boolean_node (false, type);
1483 1 : if (TREE_SIDE_EFFECTS (captures[0]))
1484 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1485 1 : if (TREE_SIDE_EFFECTS (captures[1]))
1486 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1487 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 364, __FILE__, __LINE__, true);
1488 1 : return _r;
1489 : }
1490 0 : next_after_fail453:;
1491 : }
1492 : }
1493 : else
1494 : {
1495 4 : if (ncmp != ERROR_MARK
1496 : )
1497 : {
1498 4 : if (ncmp == GE_EXPR
1499 : )
1500 : {
1501 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail454;
1502 1 : {
1503 1 : tree res_op0;
1504 1 : res_op0 = captures[0];
1505 1 : tree res_op1;
1506 1 : res_op1 = build_real (TREE_TYPE (captures[0]), c2);
1507 1 : tree _r;
1508 1 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
1509 1 : if (TREE_SIDE_EFFECTS (captures[1]))
1510 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1511 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 365, __FILE__, __LINE__, true);
1512 1 : return _r;
1513 : }
1514 0 : next_after_fail454:;
1515 : }
1516 : else
1517 : {
1518 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail455;
1519 3 : {
1520 3 : tree res_op0;
1521 3 : res_op0 = captures[0];
1522 3 : tree res_op1;
1523 3 : res_op1 = build_real (TREE_TYPE (captures[0]), c2);
1524 3 : tree _r;
1525 3 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
1526 3 : if (TREE_SIDE_EFFECTS (captures[1]))
1527 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1528 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 366, __FILE__, __LINE__, true);
1529 3 : return _r;
1530 : }
1531 0 : next_after_fail455:;
1532 : }
1533 : }
1534 : }
1535 : }
1536 : else
1537 : {
1538 11 : if (REAL_VALUE_ISINF (c2)
1539 : )
1540 : {
1541 2 : if (! HONOR_NANS (captures[0]) && ! HONOR_INFINITIES (captures[0])
1542 : )
1543 : {
1544 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail456;
1545 1 : {
1546 1 : tree _r;
1547 1 : _r = constant_boolean_node (true, type);
1548 1 : if (TREE_SIDE_EFFECTS (captures[0]))
1549 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1550 1 : if (TREE_SIDE_EFFECTS (captures[1]))
1551 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1552 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 367, __FILE__, __LINE__, true);
1553 1 : return _r;
1554 : }
1555 0 : next_after_fail456:;
1556 : }
1557 : else
1558 : {
1559 1 : if (! HONOR_NANS (captures[0])
1560 : )
1561 : {
1562 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail457;
1563 0 : {
1564 0 : tree res_op0;
1565 0 : res_op0 = captures[0];
1566 0 : tree res_op1;
1567 0 : res_op1 = build_real (TREE_TYPE (captures[0]), c2);
1568 0 : tree _r;
1569 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
1570 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1571 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1572 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 368, __FILE__, __LINE__, true);
1573 0 : return _r;
1574 : }
1575 0 : next_after_fail457:;
1576 : }
1577 : else
1578 : {
1579 1 : if (! HONOR_INFINITIES (captures[0])
1580 : )
1581 : {
1582 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail458;
1583 0 : {
1584 0 : tree res_op0;
1585 0 : res_op0 = captures[0];
1586 0 : tree res_op1;
1587 0 : res_op1 = build_real (TREE_TYPE (captures[0]), dconst0);
1588 0 : tree _r;
1589 0 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
1590 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1591 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1592 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 369, __FILE__, __LINE__, true);
1593 0 : return _r;
1594 : }
1595 0 : next_after_fail458:;
1596 : }
1597 : else
1598 : {
1599 1 : if (1
1600 : )
1601 : {
1602 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail459;
1603 1 : {
1604 1 : if (! tree_invariant_p (captures[0])) goto next_after_fail459;
1605 0 : tree res_op0;
1606 0 : {
1607 0 : tree _o1[2], _r1;
1608 0 : _o1[0] = unshare_expr (captures[0]);
1609 0 : _o1[1] = build_real (TREE_TYPE (captures[0]), dconst0);
1610 0 : _r1 = fold_build2_loc (loc, GE_EXPR, type, _o1[0], _o1[1]);
1611 0 : res_op0 = _r1;
1612 : }
1613 0 : tree res_op1;
1614 0 : {
1615 0 : tree _o1[2], _r1;
1616 0 : _o1[0] = captures[0];
1617 0 : _o1[1] = build_real (TREE_TYPE (captures[0]), c2);
1618 0 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
1619 0 : res_op1 = _r1;
1620 : }
1621 0 : tree _r;
1622 0 : _r = fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type, res_op0, res_op1);
1623 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1624 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1625 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 370, __FILE__, __LINE__, true);
1626 0 : return _r;
1627 : }
1628 2 : next_after_fail459:;
1629 : }
1630 : }
1631 : }
1632 : }
1633 : }
1634 : else
1635 : {
1636 9 : if (ncmp != ERROR_MARK && ! HONOR_NANS (captures[0])
1637 : )
1638 : {
1639 8 : if (ncmp == LT_EXPR
1640 : )
1641 : {
1642 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail460;
1643 4 : {
1644 4 : tree res_op0;
1645 4 : res_op0 = captures[0];
1646 4 : tree res_op1;
1647 4 : res_op1 = build_real (TREE_TYPE (captures[0]), c2);
1648 4 : tree _r;
1649 4 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
1650 4 : if (TREE_SIDE_EFFECTS (captures[1]))
1651 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1652 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 371, __FILE__, __LINE__, true);
1653 4 : return _r;
1654 : }
1655 0 : next_after_fail460:;
1656 : }
1657 : else
1658 : {
1659 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail461;
1660 4 : {
1661 4 : tree res_op0;
1662 4 : res_op0 = captures[0];
1663 4 : tree res_op1;
1664 4 : res_op1 = build_real (TREE_TYPE (captures[0]), c2);
1665 4 : tree _r;
1666 4 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1667 4 : if (TREE_SIDE_EFFECTS (captures[1]))
1668 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1669 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 372, __FILE__, __LINE__, true);
1670 4 : return _r;
1671 : }
1672 0 : next_after_fail461:;
1673 : }
1674 : }
1675 : else
1676 : {
1677 1 : if (ncmp != ERROR_MARK &&
1678 : 1
1679 : )
1680 : {
1681 1 : if (ncmp == LT_EXPR
1682 : )
1683 : {
1684 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail462;
1685 1 : {
1686 1 : if (! tree_invariant_p (captures[0])) goto next_after_fail462;
1687 0 : tree res_op0;
1688 0 : {
1689 0 : tree _o1[2], _r1;
1690 0 : _o1[0] = unshare_expr (captures[0]);
1691 0 : _o1[1] = build_real (TREE_TYPE (captures[0]), dconst0);
1692 0 : _r1 = fold_build2_loc (loc, GE_EXPR, type, _o1[0], _o1[1]);
1693 0 : res_op0 = _r1;
1694 : }
1695 0 : tree res_op1;
1696 0 : {
1697 0 : tree _o1[2], _r1;
1698 0 : _o1[0] = captures[0];
1699 0 : _o1[1] = build_real (TREE_TYPE (captures[0]), c2);
1700 0 : _r1 = fold_build2_loc (loc, LT_EXPR, type, _o1[0], _o1[1]);
1701 0 : res_op1 = _r1;
1702 : }
1703 0 : tree _r;
1704 0 : _r = fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type, res_op0, res_op1);
1705 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1706 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1707 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 373, __FILE__, __LINE__, true);
1708 0 : return _r;
1709 : }
1710 2 : next_after_fail462:;
1711 : }
1712 : else
1713 : {
1714 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail463;
1715 0 : {
1716 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail463;
1717 0 : tree res_op0;
1718 0 : {
1719 0 : tree _o1[2], _r1;
1720 0 : _o1[0] = unshare_expr (captures[0]);
1721 0 : _o1[1] = build_real (TREE_TYPE (captures[0]), dconst0);
1722 0 : _r1 = fold_build2_loc (loc, GE_EXPR, type, _o1[0], _o1[1]);
1723 0 : res_op0 = _r1;
1724 : }
1725 0 : tree res_op1;
1726 0 : {
1727 0 : tree _o1[2], _r1;
1728 0 : _o1[0] = captures[0];
1729 0 : _o1[1] = build_real (TREE_TYPE (captures[0]), c2);
1730 0 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
1731 0 : res_op1 = _r1;
1732 : }
1733 0 : tree _r;
1734 0 : _r = fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type, res_op0, res_op1);
1735 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1736 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1737 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 374, __FILE__, __LINE__, true);
1738 0 : return _r;
1739 : }
1740 2 : next_after_fail463:;
1741 : }
1742 : }
1743 : }
1744 : }
1745 : }
1746 : }
1747 : }
1748 : }
1749 : }
1750 : }
1751 : return NULL_TREE;
1752 : }
1753 :
1754 : tree
1755 6 : generic_simplify_332 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1756 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1757 : const combined_fn ARG_UNUSED (SIN),
1758 : const combined_fn ARG_UNUSED (TAN),
1759 : const combined_fn ARG_UNUSED (COS))
1760 : {
1761 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1762 6 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1763 : )
1764 : {
1765 6 : if (! HONOR_NANS (captures[1])
1766 6 : && ! HONOR_INFINITIES (captures[1])
1767 : )
1768 : {
1769 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail601;
1770 6 : {
1771 6 : tree res_op0;
1772 6 : res_op0 = captures[1];
1773 6 : tree _r;
1774 6 : _r = maybe_build_call_expr_loc (loc, COS, type, 1, res_op0);
1775 6 : if (!_r)
1776 0 : goto next_after_fail601;
1777 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 493, __FILE__, __LINE__, true);
1778 6 : return _r;
1779 : }
1780 : next_after_fail601:;
1781 : }
1782 : }
1783 : return NULL_TREE;
1784 : }
1785 :
1786 : tree
1787 7400 : generic_simplify_341 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1788 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1789 : const enum tree_code ARG_UNUSED (cmp),
1790 : const enum tree_code ARG_UNUSED (op))
1791 : {
1792 7400 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1793 7400 : {
1794 7400 : tree from_type = TREE_TYPE (captures[0]), to_type = TREE_TYPE (captures[1]);
1795 7400 : if (types_match (from_type, to_type)
1796 7400 : || (TYPE_UNSIGNED (from_type)
1797 37 : && !TYPE_UNSIGNED (to_type)
1798 37 : && TYPE_PRECISION (from_type) == TYPE_PRECISION (to_type)
1799 37 : && integer_zerop (captures[1])
1800 31 : && (cmp == LT_EXPR || cmp == GE_EXPR))
1801 : )
1802 : {
1803 7370 : {
1804 7370 : wi::overflow_type overflow = wi::OVF_NONE;
1805 7370 : enum tree_code code, cmp_code = cmp;
1806 7370 : wide_int real_c1;
1807 7370 : wide_int c1 = wi::to_wide (captures[1]);
1808 7370 : wide_int c2 = wi::to_wide (captures[2]);
1809 7370 : wide_int c3 = wi::to_wide (captures[3]);
1810 7370 : signop sgn = TYPE_SIGN (from_type);
1811 7370 : if (!types_match (from_type, to_type))
1812 : {
1813 7 : if (cmp_code == LT_EXPR)
1814 : cmp_code = GT_EXPR;
1815 0 : if (cmp_code == GE_EXPR)
1816 0 : cmp_code = LE_EXPR;
1817 7 : c1 = wi::max_value (to_type);
1818 : }
1819 7370 : if (op == PLUS_EXPR)
1820 7370 : real_c1 = wi::sub (c3, c2, sgn, &overflow);
1821 : else
1822 0 : real_c1 = wi::add (c3, c2, sgn, &overflow);
1823 7370 : code = cmp_code;
1824 7370 : if (!overflow || !TYPE_OVERFLOW_UNDEFINED (from_type))
1825 : {
1826 14740 : if (!wi::cmp (wi::sub (real_c1, 1, sgn, &overflow), c1, sgn)
1827 7370 : && !overflow)
1828 : {
1829 631 : if (cmp_code == LE_EXPR)
1830 : code = LT_EXPR;
1831 631 : if (cmp_code == GT_EXPR)
1832 7370 : code = GE_EXPR;
1833 : }
1834 14740 : if (!wi::cmp (wi::add (real_c1, 1, sgn, &overflow), c1, sgn)
1835 7370 : && !overflow)
1836 : {
1837 6309 : if (cmp_code == LT_EXPR)
1838 : code = LE_EXPR;
1839 6309 : if (cmp_code == GE_EXPR)
1840 : code = GT_EXPR;
1841 : }
1842 1078 : if (code != cmp_code || !wi::cmp (real_c1, c1, sgn))
1843 : {
1844 7147 : if (cmp_code == LT_EXPR || cmp_code == LE_EXPR)
1845 : code = MIN_EXPR;
1846 7147 : if (cmp_code == GT_EXPR || cmp_code == GE_EXPR)
1847 : code = MAX_EXPR;
1848 : }
1849 : }
1850 223 : if (code == MAX_EXPR
1851 : )
1852 : {
1853 7147 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail612;
1854 7147 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail612;
1855 7147 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail612;
1856 7147 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail612;
1857 7147 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail612;
1858 7147 : {
1859 7147 : tree res_op0;
1860 7147 : {
1861 7147 : tree _o1[2], _r1;
1862 7147 : _o1[0] = captures[0];
1863 7147 : _o1[1] = wide_int_to_tree (from_type, real_c1);
1864 7147 : _r1 = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1865 7147 : res_op0 = _r1;
1866 : }
1867 7147 : tree res_op1;
1868 7147 : res_op1 = wide_int_to_tree (from_type, c2);
1869 7147 : tree _r;
1870 7147 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1871 7147 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 504, __FILE__, __LINE__, true);
1872 7147 : return _r;
1873 : }
1874 223 : next_after_fail612:;
1875 : }
1876 : else
1877 : {
1878 223 : if (code == MIN_EXPR
1879 : )
1880 : {
1881 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail613;
1882 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail613;
1883 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail613;
1884 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail613;
1885 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail613;
1886 0 : {
1887 0 : tree res_op0;
1888 0 : {
1889 0 : tree _o1[2], _r1;
1890 0 : _o1[0] = captures[0];
1891 0 : _o1[1] = wide_int_to_tree (from_type, real_c1);
1892 0 : _r1 = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1893 0 : res_op0 = _r1;
1894 : }
1895 0 : tree res_op1;
1896 0 : res_op1 = wide_int_to_tree (from_type, c2);
1897 0 : tree _r;
1898 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1899 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 505, __FILE__, __LINE__, true);
1900 0 : return _r;
1901 : }
1902 223 : next_after_fail613:;
1903 : }
1904 : }
1905 7370 : }
1906 : }
1907 : }
1908 : return NULL_TREE;
1909 : }
1910 :
1911 : tree
1912 104 : generic_simplify_371 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1913 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1914 : const enum tree_code ARG_UNUSED (cmp))
1915 : {
1916 104 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1917 104 : if (TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1918 : )
1919 : {
1920 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail650;
1921 0 : {
1922 0 : tree _r;
1923 0 : _r = constant_boolean_node (cmp == LT_EXPR, type);
1924 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1925 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1926 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1927 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1928 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 540, __FILE__, __LINE__, true);
1929 0 : return _r;
1930 : }
1931 0 : next_after_fail650:;
1932 : }
1933 : return NULL_TREE;
1934 : }
1935 :
1936 : tree
1937 435 : generic_simplify_377 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1938 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1939 : const enum tree_code ARG_UNUSED (op))
1940 : {
1941 435 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1942 870 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1943 870 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
1944 : )
1945 : {
1946 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail657;
1947 0 : {
1948 0 : tree res_op0;
1949 0 : res_op0 = captures[2];
1950 0 : tree res_op1;
1951 0 : res_op1 = captures[1];
1952 0 : tree _r;
1953 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1954 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1955 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1956 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 547, __FILE__, __LINE__, true);
1957 0 : return _r;
1958 : }
1959 0 : next_after_fail657:;
1960 : }
1961 : return NULL_TREE;
1962 : }
1963 :
1964 : tree
1965 0 : generic_simplify_384 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1966 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1967 : const enum tree_code ARG_UNUSED (cmp),
1968 : const enum tree_code ARG_UNUSED (cmp2))
1969 : {
1970 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1971 0 : if (tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[2]))
1972 0 : && TYPE_UNSIGNED (TREE_TYPE (captures[2])) && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1973 0 : && wi::gt_p (wi::to_wide (captures[1]), 0, TYPE_SIGN (TREE_TYPE (captures[1])))
1974 : )
1975 : {
1976 0 : {
1977 0 : tree utype = TREE_TYPE (captures[2]);
1978 0 : wide_int denom = wi::to_wide (captures[1]);
1979 0 : wide_int right = wi::to_wide (captures[2]);
1980 0 : wide_int smax = wi::sdiv_trunc (wi::max_value (TREE_TYPE (captures[0])), denom);
1981 0 : wide_int smin = wi::sdiv_trunc (wi::min_value (TREE_TYPE (captures[0])), denom);
1982 0 : bool small = wi::leu_p (right, smax);
1983 0 : bool large = wi::geu_p (right, smin);
1984 0 : if (small || large
1985 : )
1986 : {
1987 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail666;
1988 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail666;
1989 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail666;
1990 0 : {
1991 0 : tree res_op0;
1992 0 : {
1993 0 : tree _o1[1], _r1;
1994 0 : _o1[0] = captures[0];
1995 0 : if (TREE_TYPE (_o1[0]) != utype)
1996 : {
1997 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, utype, _o1[0]);
1998 : }
1999 : else
2000 : _r1 = _o1[0];
2001 0 : res_op0 = _r1;
2002 : }
2003 0 : tree res_op1;
2004 0 : {
2005 0 : tree _o1[2], _r1;
2006 0 : _o1[0] = captures[2];
2007 0 : {
2008 0 : tree _o2[1], _r2;
2009 0 : _o2[0] = captures[1];
2010 0 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (res_op0))
2011 : {
2012 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o2[0]);
2013 : }
2014 : else
2015 : _r2 = _o2[0];
2016 0 : _o1[1] = _r2;
2017 : }
2018 0 : _r1 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2019 0 : res_op1 = _r1;
2020 : }
2021 0 : tree _r;
2022 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2023 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 556, __FILE__, __LINE__, true);
2024 0 : return _r;
2025 : }
2026 0 : next_after_fail666:;
2027 : }
2028 : else
2029 : {
2030 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail667;
2031 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail667;
2032 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail667;
2033 0 : {
2034 0 : tree res_op0;
2035 0 : res_op0 = captures[0];
2036 0 : tree res_op1;
2037 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
2038 0 : tree _r;
2039 0 : _r = fold_build2_loc (loc, cmp2, type, res_op0, res_op1);
2040 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 557, __FILE__, __LINE__, true);
2041 0 : return _r;
2042 : }
2043 0 : next_after_fail667:;
2044 : }
2045 0 : }
2046 : }
2047 : return NULL_TREE;
2048 : }
2049 :
2050 : tree
2051 0 : generic_simplify_400 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2052 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2053 : const enum tree_code ARG_UNUSED (cmp))
2054 : {
2055 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2056 0 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2057 0 : && TYPE_UNSIGNED (TREE_TYPE (captures[0]))
2058 : )
2059 : {
2060 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail720;
2061 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail720;
2062 0 : {
2063 0 : tree res_op0;
2064 0 : res_op0 = captures[1];
2065 0 : tree res_op1;
2066 0 : res_op1 = captures[0];
2067 0 : tree _r;
2068 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2069 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 575, __FILE__, __LINE__, true);
2070 0 : return _r;
2071 : }
2072 : next_after_fail720:;
2073 : }
2074 : return NULL_TREE;
2075 : }
2076 :
2077 : tree
2078 0 : generic_simplify_404 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2079 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2080 : const combined_fn ARG_UNUSED (logs),
2081 : const combined_fn ARG_UNUSED (exps),
2082 : const enum tree_code ARG_UNUSED (cmp))
2083 : {
2084 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2085 0 : if (flag_unsafe_math_optimizations
2086 : )
2087 : {
2088 0 : if (! HONOR_SIGN_DEPENDENT_ROUNDING (type)
2089 0 : && ! HONOR_NANS (type) && ! HONOR_INFINITIES (type)
2090 0 : && ! flag_trapping_math
2091 0 : && ! flag_errno_math
2092 : )
2093 : {
2094 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail724;
2095 0 : {
2096 0 : tree res_op0;
2097 0 : res_op0 = captures[1];
2098 0 : tree res_op1;
2099 0 : {
2100 0 : tree _o1[1], _r1;
2101 0 : _o1[0] = captures[2];
2102 0 : _r1 = maybe_build_call_expr_loc (loc, exps, TREE_TYPE (_o1[0]), 1, _o1[0]);
2103 0 : if (!_r1)
2104 0 : goto next_after_fail724;
2105 0 : if (EXPR_P (_r1))
2106 0 : goto next_after_fail724;
2107 0 : res_op1 = _r1;
2108 : }
2109 0 : tree _r;
2110 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2111 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 593, __FILE__, __LINE__, true);
2112 0 : return _r;
2113 : }
2114 : next_after_fail724:;
2115 : }
2116 : }
2117 : return NULL_TREE;
2118 : }
2119 :
2120 : tree
2121 2029793 : generic_simplify_409 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2122 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2123 : const enum tree_code ARG_UNUSED (shift))
2124 : {
2125 2029793 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2126 2029793 : if ((
2127 :
2128 2029793 : || !sanitize_flags_p (SANITIZE_SHIFT_EXPONENT))
2129 2027852 : && (TYPE_UNSIGNED (type)
2130 382563 : || shift == LSHIFT_EXPR
2131 189576 : || tree_expr_nonnegative_p (captures[0]))
2132 3870063 : && wi::ges_p (wi::to_wide (uniform_integer_cst_p (captures[1])),
2133 3868841 : element_precision (type))
2134 : )
2135 : {
2136 1222 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail733;
2137 1222 : {
2138 1222 : tree _r;
2139 1222 : _r = build_zero_cst (type);
2140 1222 : if (TREE_SIDE_EFFECTS (captures[0]))
2141 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2142 1222 : if (TREE_SIDE_EFFECTS (captures[1]))
2143 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2144 1222 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 602, __FILE__, __LINE__, true);
2145 1222 : return _r;
2146 : }
2147 0 : next_after_fail733:;
2148 : }
2149 : return NULL_TREE;
2150 : }
2151 :
2152 : tree
2153 67 : generic_simplify_418 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2154 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2155 : {
2156 67 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2157 67 : if (wi::ltu_p (wi::to_wide (captures[1]), element_precision (type))
2158 : )
2159 : {
2160 67 : if (TYPE_UNSIGNED (type)
2161 : )
2162 : {
2163 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail745;
2164 2 : {
2165 2 : tree res_op0;
2166 2 : {
2167 2 : tree _o1[1], _r1;
2168 2 : _o1[0] = captures[0];
2169 2 : if (TREE_TYPE (_o1[0]) != type)
2170 : {
2171 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2172 : }
2173 : else
2174 : _r1 = _o1[0];
2175 2 : res_op0 = _r1;
2176 : }
2177 2 : tree res_op1;
2178 2 : {
2179 2 : tree _o1[2], _r1;
2180 2 : _o1[0] = build_minus_one_cst (type);
2181 2 : _o1[1] = captures[1];
2182 2 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2183 2 : res_op1 = _r1;
2184 : }
2185 2 : tree _r;
2186 2 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2187 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 612, __FILE__, __LINE__, true);
2188 2 : return _r;
2189 : }
2190 0 : next_after_fail745:;
2191 : }
2192 : else
2193 : {
2194 65 : if (INTEGRAL_TYPE_P (type)
2195 : )
2196 : {
2197 65 : {
2198 65 : int width = element_precision (type) - tree_to_uhwi (captures[1]);
2199 65 : tree stype = NULL_TREE;
2200 130 : if (width <= MAX_FIXED_MODE_SIZE)
2201 65 : stype = build_nonstandard_integer_type (width, 0);
2202 65 : if (stype && (width == 1 || type_has_mode_precision_p (stype))
2203 : )
2204 : {
2205 25 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail746;
2206 25 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail746;
2207 25 : {
2208 25 : tree res_op0;
2209 25 : {
2210 25 : tree _o1[1], _r1;
2211 25 : _o1[0] = captures[0];
2212 25 : if (TREE_TYPE (_o1[0]) != stype)
2213 : {
2214 25 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
2215 : }
2216 : else
2217 : _r1 = _o1[0];
2218 25 : res_op0 = _r1;
2219 : }
2220 25 : tree _r;
2221 25 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2222 25 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 613, __FILE__, __LINE__, true);
2223 25 : return _r;
2224 : }
2225 : next_after_fail746:;
2226 : }
2227 : }
2228 : }
2229 : }
2230 : }
2231 : return NULL_TREE;
2232 : }
2233 :
2234 : tree
2235 9343684 : generic_simplify_425 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2236 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2237 : const enum tree_code ARG_UNUSED (op))
2238 : {
2239 9343684 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2240 9343684 : if (INTEGRAL_TYPE_P (type)
2241 8484843 : && op != MULT_EXPR
2242 8484843 : && op != RDIV_EXPR
2243 4062651 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2244 3659410 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2245 3659410 : && type_has_mode_precision_p (TREE_TYPE (captures[2]))
2246 3552591 : && type_has_mode_precision_p (TREE_TYPE (captures[4]))
2247 3552583 : && type_has_mode_precision_p (type)
2248 3544130 : && TYPE_PRECISION (TREE_TYPE (captures[1])) > TYPE_PRECISION (TREE_TYPE (captures[2]))
2249 1129660 : && types_match (captures[2], type)
2250 9358576 : && (types_match (captures[2], captures[4])
2251 14892 : || poly_int_tree_p (captures[3]))
2252 : )
2253 : {
2254 10988 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))
2255 : )
2256 : {
2257 6020 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail761;
2258 6020 : {
2259 6020 : tree res_op0;
2260 6020 : res_op0 = captures[2];
2261 6020 : tree res_op1;
2262 6020 : {
2263 6020 : tree _o1[1], _r1;
2264 6020 : _o1[0] = captures[4];
2265 6020 : if (TREE_TYPE (_o1[0]) != type)
2266 : {
2267 6020 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2268 : }
2269 : else
2270 : _r1 = _o1[0];
2271 6020 : res_op1 = _r1;
2272 : }
2273 6020 : tree _r;
2274 6020 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2275 6020 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 624, __FILE__, __LINE__, true);
2276 6020 : return _r;
2277 : }
2278 0 : next_after_fail761:;
2279 : }
2280 : else
2281 : {
2282 4968 : {
2283 4968 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
2284 4968 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail762;
2285 4968 : {
2286 4968 : tree res_op0;
2287 4968 : {
2288 4968 : tree _o1[2], _r1;
2289 4968 : {
2290 4968 : tree _o2[1], _r2;
2291 4968 : _o2[0] = captures[2];
2292 4968 : if (TREE_TYPE (_o2[0]) != utype)
2293 : {
2294 4968 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2295 : }
2296 : else
2297 : _r2 = _o2[0];
2298 4968 : _o1[0] = _r2;
2299 : }
2300 4968 : {
2301 4968 : tree _o2[1], _r2;
2302 4968 : _o2[0] = captures[4];
2303 4968 : if (TREE_TYPE (_o2[0]) != utype)
2304 : {
2305 4968 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2306 : }
2307 : else
2308 : _r2 = _o2[0];
2309 4968 : _o1[1] = _r2;
2310 : }
2311 4968 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2312 4968 : res_op0 = _r1;
2313 : }
2314 4968 : tree _r;
2315 4968 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2316 4968 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 625, __FILE__, __LINE__, true);
2317 4968 : return _r;
2318 : }
2319 0 : next_after_fail762:;
2320 : }
2321 : }
2322 : }
2323 : else
2324 : {
2325 9300993 : if (FLOAT_TYPE_P (type)
2326 9364399 : && DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
2327 31703 : == DECIMAL_FLOAT_TYPE_P (type)
2328 : )
2329 : {
2330 31677 : {
2331 31677 : tree arg0 = strip_float_extensions (captures[2]);
2332 31677 : tree arg1 = strip_float_extensions (captures[4]);
2333 31677 : tree itype = TREE_TYPE (captures[0]);
2334 31677 : tree ty1 = TREE_TYPE (arg0);
2335 31677 : tree ty2 = TREE_TYPE (arg1);
2336 31677 : enum tree_code code = TREE_CODE (itype);
2337 0 : if (FLOAT_TYPE_P (ty1)
2338 31677 : && FLOAT_TYPE_P (ty2)
2339 : )
2340 : {
2341 31677 : {
2342 31677 : tree newtype = type;
2343 31677 : if (TYPE_MODE (ty1) == SDmode
2344 31415 : || TYPE_MODE (ty2) == SDmode
2345 63092 : || TYPE_MODE (type) == SDmode)
2346 262 : newtype = dfloat32_type_node;
2347 31677 : if (TYPE_MODE (ty1) == DDmode
2348 31545 : || TYPE_MODE (ty2) == DDmode
2349 63095 : || TYPE_MODE (type) == DDmode)
2350 259 : newtype = dfloat64_type_node;
2351 31677 : if (TYPE_MODE (ty1) == TDmode
2352 31677 : || TYPE_MODE (ty2) == TDmode
2353 63102 : || TYPE_MODE (type) == TDmode)
2354 267 : newtype = dfloat128_type_node;
2355 31677 : if ((newtype == dfloat32_type_node
2356 31677 : || newtype == dfloat64_type_node
2357 31550 : || newtype == dfloat128_type_node)
2358 394 : && newtype == type
2359 31683 : && types_match (newtype, type)
2360 : )
2361 : {
2362 6 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail763;
2363 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail763;
2364 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail763;
2365 0 : {
2366 0 : tree res_op0;
2367 0 : {
2368 0 : tree _o1[1], _r1;
2369 0 : _o1[0] = captures[2];
2370 0 : if (TREE_TYPE (_o1[0]) != newtype)
2371 : {
2372 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
2373 : }
2374 : else
2375 : _r1 = _o1[0];
2376 0 : res_op0 = _r1;
2377 : }
2378 0 : tree res_op1;
2379 0 : {
2380 0 : tree _o1[1], _r1;
2381 0 : _o1[0] = captures[4];
2382 0 : if (TREE_TYPE (_o1[0]) != newtype)
2383 : {
2384 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
2385 : }
2386 : else
2387 : _r1 = _o1[0];
2388 0 : res_op1 = _r1;
2389 : }
2390 0 : tree _r;
2391 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2392 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 626, __FILE__, __LINE__, true);
2393 0 : return _r;
2394 : }
2395 : next_after_fail763:;
2396 : }
2397 : else
2398 : {
2399 31671 : {
2400 31671 : if (element_precision (ty1) > element_precision (newtype))
2401 14 : newtype = ty1;
2402 31671 : if (element_precision (ty2) > element_precision (newtype))
2403 3960 : newtype = ty2;
2404 31671 : if (element_precision (newtype) < element_precision (itype)
2405 14961 : && (!VECTOR_MODE_P (TYPE_MODE (newtype))
2406 0 : || target_supports_op_p (newtype, op, optab_default))
2407 14961 : && (flag_unsafe_math_optimizations
2408 14936 : || (element_precision (newtype) == element_precision (type)
2409 14912 : && real_can_shorten_arithmetic (element_mode (itype),
2410 : element_mode (type))
2411 6459 : && !excess_precision_type (newtype)))
2412 34936 : && !types_match (itype, newtype)
2413 : )
2414 : {
2415 3265 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail764;
2416 3264 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail764;
2417 3256 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail764;
2418 3256 : {
2419 3256 : tree res_op0;
2420 3256 : {
2421 3256 : tree _o1[2], _r1;
2422 3256 : {
2423 3256 : tree _o2[1], _r2;
2424 3256 : _o2[0] = captures[2];
2425 3256 : if (TREE_TYPE (_o2[0]) != newtype)
2426 : {
2427 3 : _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
2428 : }
2429 : else
2430 : _r2 = _o2[0];
2431 3256 : _o1[0] = _r2;
2432 : }
2433 3256 : {
2434 3256 : tree _o2[1], _r2;
2435 3256 : _o2[0] = captures[4];
2436 3256 : if (TREE_TYPE (_o2[0]) != newtype)
2437 : {
2438 3256 : _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
2439 : }
2440 : else
2441 : _r2 = _o2[0];
2442 3256 : _o1[1] = _r2;
2443 : }
2444 3256 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2445 3256 : res_op0 = _r1;
2446 : }
2447 3256 : tree _r;
2448 3256 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2449 3256 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 627, __FILE__, __LINE__, true);
2450 3256 : return _r;
2451 : }
2452 : next_after_fail764:;
2453 : }
2454 : }
2455 : }
2456 : }
2457 : }
2458 : }
2459 : }
2460 : }
2461 : return NULL_TREE;
2462 : }
2463 :
2464 : tree
2465 2 : generic_simplify_456 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2466 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2467 : {
2468 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2469 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail801;
2470 2 : {
2471 2 : tree res_op0;
2472 2 : {
2473 2 : tree _o1[2], _r1;
2474 2 : _o1[0] = captures[1];
2475 2 : _o1[1] = captures[2];
2476 2 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2477 2 : res_op0 = _r1;
2478 : }
2479 2 : tree _r;
2480 2 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
2481 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 655, __FILE__, __LINE__, true);
2482 : return _r;
2483 : }
2484 0 : next_after_fail801:;
2485 0 : return NULL_TREE;
2486 : }
2487 :
2488 : tree
2489 8 : generic_simplify_462 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2490 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2491 : const enum tree_code ARG_UNUSED (eqne))
2492 : {
2493 8 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2494 8 : if (eqne == EQ_EXPR
2495 : )
2496 : {
2497 4 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail807;
2498 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail807;
2499 4 : {
2500 4 : tree _r;
2501 4 : _r = constant_boolean_node (false, type);
2502 4 : if (TREE_SIDE_EFFECTS (captures[2]))
2503 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2504 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 660, __FILE__, __LINE__, true);
2505 4 : return _r;
2506 : }
2507 : next_after_fail807:;
2508 : }
2509 : else
2510 : {
2511 4 : if (eqne == NE_EXPR
2512 : )
2513 : {
2514 4 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail808;
2515 4 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail808;
2516 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail808;
2517 4 : {
2518 4 : tree _r;
2519 4 : _r = captures[0];
2520 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 661, __FILE__, __LINE__, true);
2521 4 : return _r;
2522 : }
2523 : next_after_fail808:;
2524 : }
2525 : }
2526 : return NULL_TREE;
2527 : }
2528 :
2529 : tree
2530 213 : generic_simplify_472 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2531 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2532 : const enum tree_code ARG_UNUSED (code2),
2533 : const enum tree_code ARG_UNUSED (code1))
2534 : {
2535 213 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2536 213 : if ((TREE_CODE (captures[2]) == INTEGER_CST
2537 6 : && TREE_CODE (captures[5]) == INTEGER_CST)
2538 213 : || ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2539 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[2]))
2540 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, code2))
2541 0 : || POINTER_TYPE_P (TREE_TYPE (captures[2])))
2542 207 : && bitwise_equal_p (captures[2], captures[5]))
2543 : )
2544 : {
2545 6 : {
2546 6 : bool one_before = false;
2547 6 : bool one_after = false;
2548 6 : int cmp = 0;
2549 6 : bool allbits = true;
2550 6 : if (TREE_CODE (captures[2]) == INTEGER_CST
2551 6 : && TREE_CODE (captures[5]) == INTEGER_CST)
2552 : {
2553 6 : allbits = TYPE_PRECISION (TREE_TYPE (captures[2])) <= TYPE_PRECISION (TREE_TYPE (captures[5]));
2554 6 : auto t1 = wi::to_wide (fold_convert (TREE_TYPE (captures[5]), captures[2]));
2555 6 : auto t2 = wi::to_wide (captures[5]);
2556 6 : cmp = wi::cmp (t1, t2, TYPE_SIGN (TREE_TYPE (captures[5])));
2557 6 : if (cmp < 0
2558 6 : && t1 == t2 - 1)
2559 : one_before = true;
2560 6 : if (cmp > 0
2561 6 : && t1 == t2 + 1)
2562 : one_after = true;
2563 : }
2564 6 : bool val;
2565 6 : switch (code2)
2566 : {
2567 0 : case EQ_EXPR: val = (cmp == 0); break;
2568 2 : case NE_EXPR: val = (cmp != 0); break;
2569 0 : case LT_EXPR: val = (cmp < 0); break;
2570 4 : case GT_EXPR: val = (cmp > 0); break;
2571 0 : case LE_EXPR: val = (cmp <= 0); break;
2572 0 : case GE_EXPR: val = (cmp >= 0); break;
2573 0 : default: gcc_unreachable ();
2574 : }
2575 6 : if (code1 == EQ_EXPR && val
2576 : )
2577 : {
2578 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail845;
2579 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail845;
2580 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail845;
2581 0 : {
2582 0 : tree _r;
2583 0 : _r = captures[0];
2584 0 : if (TREE_SIDE_EFFECTS (captures[4]))
2585 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
2586 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 664, __FILE__, __LINE__, true);
2587 0 : return _r;
2588 : }
2589 : next_after_fail845:;
2590 : }
2591 : else
2592 : {
2593 6 : if (code1 == EQ_EXPR && !val
2594 : )
2595 : {
2596 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail846;
2597 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail846;
2598 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail846;
2599 0 : {
2600 0 : tree _r;
2601 0 : _r = constant_boolean_node (false, type);
2602 0 : if (TREE_SIDE_EFFECTS (captures[4]))
2603 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
2604 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 665, __FILE__, __LINE__, true);
2605 0 : return _r;
2606 : }
2607 : next_after_fail846:;
2608 : }
2609 : else
2610 : {
2611 6 : if (code1 == NE_EXPR && !val && allbits
2612 : )
2613 : {
2614 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail847;
2615 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail847;
2616 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail847;
2617 0 : {
2618 0 : tree _r;
2619 0 : _r = captures[3];
2620 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 666, __FILE__, __LINE__, true);
2621 0 : return _r;
2622 : }
2623 : next_after_fail847:;
2624 : }
2625 : else
2626 : {
2627 6 : if ((code1 == NE_EXPR
2628 6 : && code2 == GE_EXPR
2629 0 : && cmp == 0
2630 0 : && allbits)
2631 6 : && ((VECTOR_BOOLEAN_TYPE_P (type)
2632 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GT_EXPR))
2633 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
2634 : )
2635 : {
2636 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail848;
2637 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail848;
2638 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail848;
2639 0 : {
2640 0 : tree res_op0;
2641 0 : res_op0 = captures[4];
2642 0 : tree res_op1;
2643 0 : {
2644 0 : tree _o1[1], _r1;
2645 0 : _o1[0] = captures[2];
2646 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
2647 : {
2648 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
2649 : }
2650 : else
2651 : _r1 = _o1[0];
2652 0 : res_op1 = _r1;
2653 : }
2654 0 : tree _r;
2655 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
2656 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 667, __FILE__, __LINE__, true);
2657 0 : return _r;
2658 : }
2659 : next_after_fail848:;
2660 : }
2661 : else
2662 : {
2663 6 : if ((code1 == NE_EXPR
2664 6 : && code2 == LE_EXPR
2665 0 : && cmp == 0
2666 0 : && allbits)
2667 6 : && ((VECTOR_BOOLEAN_TYPE_P (type)
2668 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LT_EXPR))
2669 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
2670 : )
2671 : {
2672 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail849;
2673 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail849;
2674 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail849;
2675 0 : {
2676 0 : tree res_op0;
2677 0 : res_op0 = captures[4];
2678 0 : tree res_op1;
2679 0 : {
2680 0 : tree _o1[1], _r1;
2681 0 : _o1[0] = captures[2];
2682 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
2683 : {
2684 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
2685 : }
2686 : else
2687 : _r1 = _o1[0];
2688 0 : res_op1 = _r1;
2689 : }
2690 0 : tree _r;
2691 0 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
2692 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 668, __FILE__, __LINE__, true);
2693 0 : return _r;
2694 : }
2695 : next_after_fail849:;
2696 : }
2697 : else
2698 : {
2699 6 : if ((code1 == NE_EXPR
2700 6 : && code2 == GT_EXPR
2701 : && one_after
2702 4 : && allbits)
2703 6 : && ((VECTOR_BOOLEAN_TYPE_P (type)
2704 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GT_EXPR))
2705 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
2706 : )
2707 : {
2708 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail850;
2709 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail850;
2710 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail850;
2711 0 : {
2712 0 : tree res_op0;
2713 0 : res_op0 = captures[4];
2714 0 : tree res_op1;
2715 0 : {
2716 0 : tree _o1[1], _r1;
2717 0 : _o1[0] = captures[2];
2718 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
2719 : {
2720 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
2721 : }
2722 : else
2723 : _r1 = _o1[0];
2724 0 : res_op1 = _r1;
2725 : }
2726 0 : tree _r;
2727 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
2728 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 669, __FILE__, __LINE__, true);
2729 0 : return _r;
2730 : }
2731 : next_after_fail850:;
2732 : }
2733 : else
2734 : {
2735 6 : if ((code1 == NE_EXPR
2736 6 : && code2 == LT_EXPR
2737 : && one_before
2738 0 : && allbits)
2739 6 : && ((VECTOR_BOOLEAN_TYPE_P (type)
2740 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LT_EXPR))
2741 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
2742 : )
2743 : {
2744 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail851;
2745 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail851;
2746 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail851;
2747 0 : {
2748 0 : tree res_op0;
2749 0 : res_op0 = captures[4];
2750 0 : tree res_op1;
2751 0 : {
2752 0 : tree _o1[1], _r1;
2753 0 : _o1[0] = captures[2];
2754 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
2755 : {
2756 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
2757 : }
2758 : else
2759 : _r1 = _o1[0];
2760 0 : res_op1 = _r1;
2761 : }
2762 0 : tree _r;
2763 0 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
2764 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 670, __FILE__, __LINE__, true);
2765 0 : return _r;
2766 : }
2767 : next_after_fail851:;
2768 : }
2769 : }
2770 : }
2771 : }
2772 : }
2773 : }
2774 : }
2775 : }
2776 : }
2777 : return NULL_TREE;
2778 : }
2779 :
2780 : tree
2781 147 : generic_simplify_505 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2782 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2783 : {
2784 147 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2785 147 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail895;
2786 147 : {
2787 147 : tree res_op0;
2788 147 : {
2789 147 : tree _o1[1], _r1;
2790 147 : _o1[0] = captures[0];
2791 147 : if (TREE_TYPE (_o1[0]) != type)
2792 : {
2793 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
2794 : }
2795 : else
2796 : _r1 = _o1[0];
2797 147 : res_op0 = _r1;
2798 : }
2799 147 : tree res_op1;
2800 147 : res_op1 = build_each_one_cst (type);
2801 147 : tree _r;
2802 147 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
2803 147 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 708, __FILE__, __LINE__, true);
2804 : return _r;
2805 : }
2806 0 : next_after_fail895:;
2807 0 : return NULL_TREE;
2808 : }
2809 :
2810 : tree
2811 0 : generic_simplify_512 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2812 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2813 : const enum tree_code ARG_UNUSED (minmax))
2814 : {
2815 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2816 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail903;
2817 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail903;
2818 0 : {
2819 0 : tree _r;
2820 0 : _r = captures[0];
2821 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 715, __FILE__, __LINE__, true);
2822 : return _r;
2823 : }
2824 : next_after_fail903:;
2825 : return NULL_TREE;
2826 : }
2827 :
2828 : tree
2829 2 : generic_simplify_520 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2830 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2831 : const enum tree_code ARG_UNUSED (op),
2832 : const enum tree_code ARG_UNUSED (logic))
2833 : {
2834 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2835 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail923;
2836 2 : {
2837 2 : tree res_op0;
2838 2 : res_op0 = captures[0];
2839 2 : tree res_op1;
2840 2 : res_op1 = captures[1];
2841 2 : tree _r;
2842 2 : _r = fold_build2_loc (loc, logic, type, res_op0, res_op1);
2843 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 723, __FILE__, __LINE__, true);
2844 : return _r;
2845 : }
2846 0 : next_after_fail923:;
2847 0 : return NULL_TREE;
2848 : }
2849 :
2850 : tree
2851 0 : generic_simplify_524 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2852 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2853 : const combined_fn ARG_UNUSED (minmax))
2854 : {
2855 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2856 0 : if (real_isnan (TREE_REAL_CST_PTR (captures[1]))
2857 0 : && (!HONOR_SNANS (captures[1]) || !TREE_REAL_CST (captures[1]).signalling)
2858 0 : && !tree_expr_maybe_signaling_nan_p (captures[0])
2859 : )
2860 : {
2861 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail927;
2862 0 : {
2863 0 : tree _r;
2864 0 : _r = captures[0];
2865 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2866 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2867 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 727, __FILE__, __LINE__, true);
2868 0 : return _r;
2869 : }
2870 0 : next_after_fail927:;
2871 : }
2872 : return NULL_TREE;
2873 : }
2874 :
2875 : tree
2876 0 : generic_simplify_532 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2877 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2878 : const combined_fn ARG_UNUSED (bswap))
2879 : {
2880 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2881 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail938;
2882 0 : {
2883 0 : tree res_op0;
2884 0 : res_op0 = captures[0];
2885 0 : tree _r;
2886 0 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
2887 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 738, __FILE__, __LINE__, true);
2888 : return _r;
2889 : }
2890 0 : next_after_fail938:;
2891 0 : return NULL_TREE;
2892 : }
2893 :
2894 : tree
2895 12 : generic_simplify_536 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2896 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
2897 : const enum tree_code ARG_UNUSED (op))
2898 : {
2899 12 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2900 12 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail942;
2901 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail942;
2902 12 : {
2903 12 : tree _r;
2904 12 : _r = captures[2];
2905 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 520, __FILE__, __LINE__, true);
2906 : return _r;
2907 : }
2908 : next_after_fail942:;
2909 : return NULL_TREE;
2910 : }
2911 :
2912 : tree
2913 0 : generic_simplify_544 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2914 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
2915 : const combined_fn ARG_UNUSED (cond_len_op))
2916 : {
2917 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2918 0 : {
2919 0 : tree op_type = TREE_TYPE (captures[5]);
2920 0 : if (inverse_conditions_p (captures[0], captures[2])
2921 0 : && element_precision (type) == element_precision (op_type)
2922 : )
2923 : {
2924 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail950;
2925 0 : {
2926 0 : tree res_op0;
2927 0 : {
2928 0 : tree _o1[6], _r1;
2929 0 : _o1[0] = captures[2];
2930 0 : _o1[1] = captures[3];
2931 0 : _o1[2] = captures[4];
2932 0 : {
2933 0 : tree _o2[1], _r2;
2934 0 : _o2[0] = captures[1];
2935 0 : if (TREE_TYPE (_o2[0]) != op_type)
2936 : {
2937 0 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
2938 : }
2939 : else
2940 : _r2 = _o2[0];
2941 0 : _o1[3] = _r2;
2942 : }
2943 0 : _o1[4] = captures[6];
2944 0 : _o1[5] = captures[7];
2945 0 : _r1 = maybe_build_call_expr_loc (loc, cond_len_op, TREE_TYPE (_o1[1]), 6, _o1[0], _o1[1], _o1[2], _o1[3], _o1[4], _o1[5]);
2946 0 : if (!_r1)
2947 0 : goto next_after_fail950;
2948 0 : res_op0 = _r1;
2949 : }
2950 0 : tree _r;
2951 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
2952 0 : if (TREE_SIDE_EFFECTS (captures[0]))
2953 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2954 0 : if (TREE_SIDE_EFFECTS (captures[5]))
2955 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
2956 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 745, __FILE__, __LINE__, true);
2957 0 : return _r;
2958 : }
2959 : next_after_fail950:;
2960 : }
2961 : }
2962 : return NULL_TREE;
2963 : }
2964 :
2965 : tree
2966 0 : generic_simplify_555 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2967 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2968 : const combined_fn ARG_UNUSED (logs))
2969 : {
2970 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2971 0 : if (flag_unsafe_math_optimizations
2972 : )
2973 : {
2974 0 : if (! HONOR_SIGN_DEPENDENT_ROUNDING (type)
2975 0 : && ! HONOR_NANS (type) && ! HONOR_INFINITIES (type)
2976 0 : && ! flag_trapping_math
2977 0 : && ! flag_errno_math
2978 : )
2979 : {
2980 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail961;
2981 0 : {
2982 0 : tree res_op0;
2983 0 : {
2984 0 : tree _o1[1], _r1;
2985 0 : _o1[0] = captures[1];
2986 0 : _r1 = maybe_build_call_expr_loc (loc, logs, TREE_TYPE (_o1[0]), 1, _o1[0]);
2987 0 : if (!_r1)
2988 0 : goto next_after_fail961;
2989 0 : if (EXPR_P (_r1))
2990 0 : goto next_after_fail961;
2991 0 : res_op0 = _r1;
2992 : }
2993 0 : tree res_op1;
2994 0 : {
2995 0 : tree _o1[1], _r1;
2996 0 : _o1[0] = captures[2];
2997 0 : _r1 = maybe_build_call_expr_loc (loc, logs, TREE_TYPE (_o1[0]), 1, _o1[0]);
2998 0 : if (!_r1)
2999 0 : goto next_after_fail961;
3000 0 : res_op1 = _r1;
3001 : }
3002 0 : tree _r;
3003 0 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
3004 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 756, __FILE__, __LINE__, true);
3005 0 : return _r;
3006 : }
3007 : next_after_fail961:;
3008 : }
3009 : }
3010 : return NULL_TREE;
3011 : }
3012 :
3013 : tree
3014 0 : generic_simplify_569 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3015 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3016 : const combined_fn ARG_UNUSED (floors))
3017 : {
3018 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3019 0 : if (canonicalize_math_p ()
3020 : )
3021 : {
3022 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail975;
3023 0 : {
3024 0 : tree res_op0;
3025 0 : res_op0 = captures[0];
3026 0 : tree _r;
3027 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3028 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 770, __FILE__, __LINE__, true);
3029 0 : return _r;
3030 : }
3031 0 : next_after_fail975:;
3032 : }
3033 : return NULL_TREE;
3034 : }
3035 :
3036 : tree
3037 0 : generic_simplify_578 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3038 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
3039 : const combined_fn ARG_UNUSED (fmas))
3040 : {
3041 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3042 0 : if (canonicalize_math_after_vectorization_p ()
3043 : )
3044 : {
3045 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail984;
3046 : {
3047 : tree res_op0;
3048 : res_op0 = captures[0];
3049 : tree res_op1;
3050 : res_op1 = captures[1];
3051 : tree res_op2;
3052 : res_op2 = captures[2];
3053 : tree _r;
3054 : _r = maybe_build_call_expr_loc (loc, CFN_FMS, type, 3, res_op0, res_op1, res_op2);
3055 : if (!_r)
3056 : goto next_after_fail984;
3057 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 779, __FILE__, __LINE__, true);
3058 : return _r;
3059 : }
3060 0 : next_after_fail984:;
3061 : }
3062 0 : return NULL_TREE;
3063 : }
3064 :
3065 : tree
3066 0 : generic_simplify_588 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3067 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree ARG_UNUSED (_p3), tree ARG_UNUSED (_p4), tree *ARG_UNUSED (captures))
3068 : {
3069 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3070 0 : if (canonicalize_math_after_vectorization_p ()
3071 : )
3072 : {
3073 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail994;
3074 : {
3075 : tree res_op0;
3076 : res_op0 = captures[0];
3077 : tree res_op1;
3078 : res_op1 = captures[1];
3079 : tree res_op2;
3080 : res_op2 = captures[2];
3081 : tree res_op3;
3082 : res_op3 = captures[3];
3083 : tree res_op4;
3084 : res_op4 = captures[4];
3085 : tree _r;
3086 : _r = maybe_build_call_expr_loc (loc, CFN_COND_FNMA, type, 5, res_op0, res_op1, res_op2, res_op3, res_op4);
3087 : if (!_r)
3088 : goto next_after_fail994;
3089 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 789, __FILE__, __LINE__, true);
3090 : return _r;
3091 : }
3092 0 : next_after_fail994:;
3093 : }
3094 0 : return NULL_TREE;
3095 : }
3096 :
3097 : tree
3098 0 : generic_simplify_598 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3099 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3100 : const enum tree_code ARG_UNUSED (rot),
3101 : const combined_fn ARG_UNUSED (popcount))
3102 : {
3103 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3104 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3105 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
3106 0 : && (
3107 :
3108 0 : || !TREE_SIDE_EFFECTS (captures[3]))
3109 : )
3110 : {
3111 0 : {
3112 0 : tree type0 = TREE_TYPE (captures[0]);
3113 0 : tree type1 = TREE_TYPE (captures[1]);
3114 0 : unsigned int prec0 = TYPE_PRECISION (type0);
3115 0 : unsigned int prec1 = TYPE_PRECISION (type1);
3116 0 : if (prec0 == prec1 || (prec0 > prec1 && TYPE_UNSIGNED (type1))
3117 : )
3118 : {
3119 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1004;
3120 0 : {
3121 0 : tree res_op0;
3122 0 : {
3123 0 : tree _o1[1], _r1;
3124 0 : _o1[0] = captures[2];
3125 0 : if (TREE_TYPE (_o1[0]) != type0)
3126 : {
3127 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type0, _o1[0]);
3128 : }
3129 : else
3130 : _r1 = _o1[0];
3131 0 : res_op0 = _r1;
3132 : }
3133 0 : tree _r;
3134 0 : _r = maybe_build_call_expr_loc (loc, popcount, type, 1, res_op0);
3135 0 : if (!_r)
3136 0 : goto next_after_fail1004;
3137 0 : if (TREE_SIDE_EFFECTS (captures[3]))
3138 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
3139 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 796, __FILE__, __LINE__, true);
3140 0 : return _r;
3141 : }
3142 : next_after_fail1004:;
3143 : }
3144 : }
3145 : }
3146 : return NULL_TREE;
3147 : }
3148 :
3149 : tree
3150 0 : generic_simplify_608 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3151 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3152 : const combined_fn ARG_UNUSED (reduc))
3153 : {
3154 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3155 0 : {
3156 0 : int i = single_nonzero_element (captures[1]);
3157 0 : if (i >= 0
3158 : )
3159 : {
3160 0 : {
3161 0 : tree elt = vector_cst_elt (captures[1], i);
3162 0 : tree elt_type = TREE_TYPE (elt);
3163 0 : unsigned int elt_bits = tree_to_uhwi (TYPE_SIZE (elt_type));
3164 0 : tree size = bitsize_int (elt_bits);
3165 0 : tree pos = bitsize_int (elt_bits * i);
3166 0 : if (compare_tree_int (TYPE_SIZE (type), elt_bits) == 0
3167 : )
3168 : {
3169 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1015;
3170 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1015;
3171 0 : {
3172 0 : tree res_op0;
3173 0 : {
3174 0 : tree _o1[2], _r1;
3175 0 : {
3176 0 : tree _o2[3], _r2;
3177 0 : _o2[0] = captures[0];
3178 0 : _o2[1] = size;
3179 0 : _o2[2] = pos;
3180 0 : _r2 = fold_build3_loc (loc, BIT_FIELD_REF, elt_type, _o2[0], _o2[1], _o2[2]);
3181 0 : _o1[0] = _r2;
3182 : }
3183 0 : _o1[1] = elt;
3184 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, elt_type, _o1[0], _o1[1]);
3185 0 : res_op0 = _r1;
3186 : }
3187 0 : tree _r;
3188 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3189 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 803, __FILE__, __LINE__, true);
3190 0 : return _r;
3191 : }
3192 : next_after_fail1015:;
3193 : }
3194 : }
3195 : }
3196 : }
3197 : return NULL_TREE;
3198 : }
3199 :
3200 : tree
3201 492783 : generic_simplify_FIX_TRUNC_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0)
3202 : {
3203 492783 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3204 492783 : {
3205 492783 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3206 985566 : if ((
3207 :
3208 : && useless_type_conversion_p (type, TREE_TYPE (captures[0])))
3209 : || (
3210 : 1
3211 492783 : && type == TREE_TYPE (captures[0]))
3212 : )
3213 : {
3214 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1098;
3215 0 : {
3216 0 : tree _r;
3217 0 : _r = captures[0];
3218 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 818, __FILE__, __LINE__, true);
3219 0 : return _r;
3220 : }
3221 0 : next_after_fail1098:;
3222 : }
3223 : }
3224 492783 : switch (TREE_CODE (_p0))
3225 : {
3226 14978 : CASE_CONVERT:
3227 14978 : {
3228 14978 : tree _q20 = TREE_OPERAND (_p0, 0);
3229 14978 : {
3230 14978 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3231 14978 : {
3232 14978 : tree inside_type = TREE_TYPE (captures[1]);
3233 14978 : tree inter_type = TREE_TYPE (captures[0]);
3234 14978 : int inside_int = INTEGRAL_TYPE_P (inside_type);
3235 14978 : int inside_ptr = POINTER_TYPE_P (inside_type);
3236 14978 : int inside_float = FLOAT_TYPE_P (inside_type);
3237 14978 : int inside_vec = VECTOR_TYPE_P (inside_type);
3238 14978 : unsigned int inside_prec = element_precision (inside_type);
3239 14978 : int inside_unsignedp = TYPE_UNSIGNED (inside_type);
3240 14978 : int inter_int = INTEGRAL_TYPE_P (inter_type);
3241 14978 : int inter_ptr = POINTER_TYPE_P (inter_type);
3242 14978 : int inter_float = FLOAT_TYPE_P (inter_type);
3243 14978 : int inter_vec = VECTOR_TYPE_P (inter_type);
3244 14978 : unsigned int inter_prec = element_precision (inter_type);
3245 14978 : int inter_unsignedp = TYPE_UNSIGNED (inter_type);
3246 14978 : int final_int = INTEGRAL_TYPE_P (type);
3247 14978 : int final_ptr = POINTER_TYPE_P (type);
3248 14978 : int final_float = FLOAT_TYPE_P (type);
3249 14978 : int final_vec = VECTOR_TYPE_P (type);
3250 14978 : unsigned int final_prec = element_precision (type);
3251 14978 : int final_unsignedp = TYPE_UNSIGNED (type);
3252 14978 : if (((
3253 :
3254 : && useless_type_conversion_p (type, inside_type))
3255 : || (
3256 : 1
3257 14978 : && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
3258 0 : && (((inter_int || inter_ptr) && final_int)
3259 0 : || (inter_float && final_float))
3260 14978 : && inter_prec >= final_prec
3261 : )
3262 : {
3263 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1099;
3264 0 : {
3265 0 : tree res_op0;
3266 0 : res_op0 = captures[1];
3267 0 : tree _r;
3268 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3269 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 819, __FILE__, __LINE__, true);
3270 0 : return _r;
3271 : }
3272 0 : next_after_fail1099:;
3273 : }
3274 : else
3275 : {
3276 14978 : if (((inter_int && inside_int) || (inter_float && inside_float))
3277 14978 : && (final_int || final_float)
3278 14978 : && inter_prec >= inside_prec
3279 14760 : && (inter_float || inter_unsignedp == inside_unsignedp)
3280 : )
3281 : {
3282 14760 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1100;
3283 14760 : {
3284 14760 : tree res_op0;
3285 14760 : res_op0 = captures[1];
3286 14760 : tree _r;
3287 14760 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3288 14760 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 820, __FILE__, __LINE__, true);
3289 14760 : return _r;
3290 : }
3291 0 : next_after_fail1100:;
3292 0 : }
3293 : else
3294 : {
3295 218 : if (inside_int && inter_int && final_int
3296 0 : && ((inside_prec < inter_prec && inter_prec < final_prec
3297 0 : && inside_unsignedp && !inter_unsignedp)
3298 0 : || final_prec == inter_prec
3299 0 : || (inside_prec < inter_prec && inter_prec > final_prec
3300 0 : && !inside_unsignedp && inter_unsignedp))
3301 : )
3302 : {
3303 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1101;
3304 0 : {
3305 0 : tree res_op0;
3306 0 : res_op0 = captures[1];
3307 0 : tree _r;
3308 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3309 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 821, __FILE__, __LINE__, true);
3310 0 : return _r;
3311 : }
3312 0 : next_after_fail1101:;
3313 0 : }
3314 : else
3315 : {
3316 218 : if (! inside_float && ! inter_float && ! final_float
3317 : && ! inside_vec && ! inter_vec && ! final_vec
3318 0 : && (inter_prec >= inside_prec || inter_prec >= final_prec)
3319 0 : && ! (inside_int && inter_int
3320 0 : && inter_unsignedp != inside_unsignedp
3321 0 : && inter_prec < final_prec)
3322 0 : && ((inter_unsignedp && inter_prec > inside_prec)
3323 0 : == (final_unsignedp && final_prec > inter_prec))
3324 0 : && ! (inside_ptr && inter_prec != final_prec)
3325 0 : && ! (final_ptr && inside_prec != inter_prec)
3326 : )
3327 : {
3328 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1102;
3329 0 : {
3330 0 : tree res_op0;
3331 0 : res_op0 = captures[1];
3332 0 : tree _r;
3333 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3334 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 822, __FILE__, __LINE__, true);
3335 0 : return _r;
3336 : }
3337 0 : next_after_fail1102:;
3338 0 : }
3339 : else
3340 : {
3341 218 : if (inside_int && inter_int && final_int
3342 0 : && final_prec <= inside_prec
3343 0 : && inter_prec >= inside_prec
3344 : )
3345 : {
3346 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1103;
3347 0 : {
3348 0 : tree res_op0;
3349 0 : res_op0 = captures[1];
3350 0 : tree _r;
3351 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3352 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 823, __FILE__, __LINE__, true);
3353 0 : return _r;
3354 : }
3355 0 : next_after_fail1103:;
3356 0 : }
3357 : else
3358 : {
3359 : if (0
3360 : && final_int && inter_int && inside_int
3361 : && final_prec >= inside_prec
3362 : && inside_prec > inter_prec
3363 : && inter_unsignedp
3364 : )
3365 : {
3366 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1104;
3367 : {
3368 : tree res_op0;
3369 : {
3370 : tree _o1[2], _r1;
3371 : _o1[0] = captures[1];
3372 : _o1[1] = wide_int_to_tree
3373 : (inside_type,
3374 : wi::mask (inter_prec, false,
3375 : TYPE_PRECISION (inside_type)));
3376 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3377 : res_op0 = _r1;
3378 : }
3379 : tree _r;
3380 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3381 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 824, __FILE__, __LINE__, true);
3382 : return _r;
3383 : }
3384 : next_after_fail1104:;
3385 : }
3386 : else
3387 : {
3388 : if (0
3389 : && inside_int && inter_float && final_int &&
3390 : (unsigned) significand_size (TYPE_MODE (inter_type))
3391 : >= inside_prec - !inside_unsignedp
3392 : )
3393 : {
3394 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1105;
3395 : {
3396 : tree res_op0;
3397 : res_op0 = captures[1];
3398 : tree _r;
3399 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3400 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 825, __FILE__, __LINE__, true);
3401 : return _r;
3402 : }
3403 : next_after_fail1105:;
3404 : }
3405 : }
3406 : }
3407 : }
3408 : }
3409 : }
3410 : }
3411 : }
3412 : }
3413 218 : break;
3414 : }
3415 589 : case FLOAT_EXPR:
3416 589 : {
3417 589 : tree _q20 = TREE_OPERAND (_p0, 0);
3418 589 : {
3419 589 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3420 589 : {
3421 589 : tree inside_type = TREE_TYPE (captures[1]);
3422 589 : tree inter_type = TREE_TYPE (captures[0]);
3423 589 : int inside_int = INTEGRAL_TYPE_P (inside_type);
3424 589 : int inside_ptr = POINTER_TYPE_P (inside_type);
3425 589 : int inside_float = FLOAT_TYPE_P (inside_type);
3426 589 : int inside_vec = VECTOR_TYPE_P (inside_type);
3427 589 : unsigned int inside_prec = element_precision (inside_type);
3428 589 : int inside_unsignedp = TYPE_UNSIGNED (inside_type);
3429 589 : int inter_int = INTEGRAL_TYPE_P (inter_type);
3430 589 : int inter_ptr = POINTER_TYPE_P (inter_type);
3431 589 : int inter_float = FLOAT_TYPE_P (inter_type);
3432 589 : int inter_vec = VECTOR_TYPE_P (inter_type);
3433 589 : unsigned int inter_prec = element_precision (inter_type);
3434 589 : int inter_unsignedp = TYPE_UNSIGNED (inter_type);
3435 589 : int final_int = INTEGRAL_TYPE_P (type);
3436 589 : int final_ptr = POINTER_TYPE_P (type);
3437 589 : int final_float = FLOAT_TYPE_P (type);
3438 589 : int final_vec = VECTOR_TYPE_P (type);
3439 589 : unsigned int final_prec = element_precision (type);
3440 589 : int final_unsignedp = TYPE_UNSIGNED (type);
3441 589 : if (((
3442 :
3443 : && useless_type_conversion_p (type, inside_type))
3444 : || (
3445 : 1
3446 589 : && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
3447 44 : && (((inter_int || inter_ptr) && final_int)
3448 44 : || (inter_float && final_float))
3449 589 : && inter_prec >= final_prec
3450 : )
3451 : {
3452 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1106;
3453 0 : {
3454 0 : tree res_op0;
3455 0 : res_op0 = captures[1];
3456 0 : tree _r;
3457 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3458 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 819, __FILE__, __LINE__, true);
3459 0 : return _r;
3460 : }
3461 0 : next_after_fail1106:;
3462 : }
3463 : else
3464 : {
3465 589 : if (((inter_int && inside_int) || (inter_float && inside_float))
3466 0 : && (final_int || final_float)
3467 0 : && inter_prec >= inside_prec
3468 0 : && (inter_float || inter_unsignedp == inside_unsignedp)
3469 : )
3470 : {
3471 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1107;
3472 0 : {
3473 0 : tree res_op0;
3474 0 : res_op0 = captures[1];
3475 0 : tree _r;
3476 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3477 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 820, __FILE__, __LINE__, true);
3478 0 : return _r;
3479 : }
3480 0 : next_after_fail1107:;
3481 0 : }
3482 : else
3483 : {
3484 589 : if (inside_int && inter_int && final_int
3485 0 : && ((inside_prec < inter_prec && inter_prec < final_prec
3486 0 : && inside_unsignedp && !inter_unsignedp)
3487 0 : || final_prec == inter_prec
3488 0 : || (inside_prec < inter_prec && inter_prec > final_prec
3489 0 : && !inside_unsignedp && inter_unsignedp))
3490 : )
3491 : {
3492 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1108;
3493 0 : {
3494 0 : tree res_op0;
3495 0 : res_op0 = captures[1];
3496 0 : tree _r;
3497 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3498 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 821, __FILE__, __LINE__, true);
3499 0 : return _r;
3500 : }
3501 0 : next_after_fail1108:;
3502 0 : }
3503 : else
3504 : {
3505 589 : if (! inside_float && ! inter_float && ! final_float
3506 : && ! inside_vec && ! inter_vec && ! final_vec
3507 0 : && (inter_prec >= inside_prec || inter_prec >= final_prec)
3508 0 : && ! (inside_int && inter_int
3509 0 : && inter_unsignedp != inside_unsignedp
3510 0 : && inter_prec < final_prec)
3511 0 : && ((inter_unsignedp && inter_prec > inside_prec)
3512 0 : == (final_unsignedp && final_prec > inter_prec))
3513 0 : && ! (inside_ptr && inter_prec != final_prec)
3514 0 : && ! (final_ptr && inside_prec != inter_prec)
3515 : )
3516 : {
3517 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1109;
3518 0 : {
3519 0 : tree res_op0;
3520 0 : res_op0 = captures[1];
3521 0 : tree _r;
3522 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3523 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 822, __FILE__, __LINE__, true);
3524 0 : return _r;
3525 : }
3526 0 : next_after_fail1109:;
3527 0 : }
3528 : else
3529 : {
3530 589 : if (inside_int && inter_int && final_int
3531 0 : && final_prec <= inside_prec
3532 0 : && inter_prec >= inside_prec
3533 : )
3534 : {
3535 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1110;
3536 0 : {
3537 0 : tree res_op0;
3538 0 : res_op0 = captures[1];
3539 0 : tree _r;
3540 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3541 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 823, __FILE__, __LINE__, true);
3542 0 : return _r;
3543 : }
3544 0 : next_after_fail1110:;
3545 0 : }
3546 : else
3547 : {
3548 : if (0
3549 : && final_int && inter_int && inside_int
3550 : && final_prec >= inside_prec
3551 : && inside_prec > inter_prec
3552 : && inter_unsignedp
3553 : )
3554 : {
3555 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1111;
3556 : {
3557 : tree res_op0;
3558 : {
3559 : tree _o1[2], _r1;
3560 : _o1[0] = captures[1];
3561 : _o1[1] = wide_int_to_tree
3562 : (inside_type,
3563 : wi::mask (inter_prec, false,
3564 : TYPE_PRECISION (inside_type)));
3565 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3566 : res_op0 = _r1;
3567 : }
3568 : tree _r;
3569 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3570 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 824, __FILE__, __LINE__, true);
3571 : return _r;
3572 : }
3573 : next_after_fail1111:;
3574 : }
3575 : else
3576 : {
3577 : if (0
3578 : && inside_int && inter_float && final_int &&
3579 : (unsigned) significand_size (TYPE_MODE (inter_type))
3580 : >= inside_prec - !inside_unsignedp
3581 : )
3582 : {
3583 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1112;
3584 : {
3585 : tree res_op0;
3586 : res_op0 = captures[1];
3587 : tree _r;
3588 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3589 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 825, __FILE__, __LINE__, true);
3590 : return _r;
3591 : }
3592 : next_after_fail1112:;
3593 : }
3594 : }
3595 : }
3596 : }
3597 : }
3598 : }
3599 : }
3600 : }
3601 : }
3602 589 : break;
3603 : }
3604 : default:;
3605 : }
3606 : return NULL_TREE;
3607 : }
3608 :
3609 : tree
3610 980029 : generic_simplify_BIT_XOR_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
3611 : {
3612 980029 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3613 980029 : if (integer_zerop (_p1))
3614 : {
3615 543 : {
3616 543 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3617 543 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1275;
3618 543 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1275;
3619 543 : {
3620 543 : tree res_op0;
3621 543 : res_op0 = captures[0];
3622 543 : tree _r;
3623 543 : _r = non_lvalue_loc (loc, res_op0);
3624 543 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 869, __FILE__, __LINE__, true);
3625 543 : return _r;
3626 : }
3627 : next_after_fail1275:;
3628 : }
3629 : }
3630 979486 : switch (TREE_CODE (_p0))
3631 : {
3632 2964 : case LSHIFT_EXPR:
3633 2964 : {
3634 2964 : tree _q20 = TREE_OPERAND (_p0, 0);
3635 2964 : tree _q21 = TREE_OPERAND (_p0, 1);
3636 2964 : switch (TREE_CODE (_p1))
3637 : {
3638 10 : case LSHIFT_EXPR:
3639 10 : {
3640 10 : tree _q50 = TREE_OPERAND (_p1, 0);
3641 10 : tree _q51 = TREE_OPERAND (_p1, 1);
3642 10 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
3643 : {
3644 1 : {
3645 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
3646 1 : tree res = generic_simplify_65 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3647 1 : if (res) return res;
3648 : }
3649 : }
3650 : break;
3651 : }
3652 : default:;
3653 : }
3654 : break;
3655 : }
3656 22242 : case RSHIFT_EXPR:
3657 22242 : {
3658 22242 : tree _q20 = TREE_OPERAND (_p0, 0);
3659 22242 : tree _q21 = TREE_OPERAND (_p0, 1);
3660 22242 : switch (TREE_CODE (_p1))
3661 : {
3662 20 : case RSHIFT_EXPR:
3663 20 : {
3664 20 : tree _q50 = TREE_OPERAND (_p1, 0);
3665 20 : tree _q51 = TREE_OPERAND (_p1, 1);
3666 20 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
3667 : {
3668 10 : {
3669 10 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
3670 10 : tree res = generic_simplify_66 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3671 10 : if (res) return res;
3672 : }
3673 : }
3674 : break;
3675 : }
3676 : default:;
3677 : }
3678 : break;
3679 : }
3680 2857 : case BIT_AND_EXPR:
3681 2857 : {
3682 2857 : tree _q20 = TREE_OPERAND (_p0, 0);
3683 2857 : tree _q21 = TREE_OPERAND (_p0, 1);
3684 2857 : switch (TREE_CODE (_p1))
3685 : {
3686 354 : case BIT_AND_EXPR:
3687 354 : {
3688 354 : tree _q50 = TREE_OPERAND (_p1, 0);
3689 354 : tree _q51 = TREE_OPERAND (_p1, 1);
3690 354 : {
3691 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51 };
3692 354 : tree res = generic_simplify_7 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3693 354 : if (res) return res;
3694 : }
3695 354 : {
3696 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q51, _q50 };
3697 354 : tree res = generic_simplify_7 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3698 354 : if (res) return res;
3699 : }
3700 354 : {
3701 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q50, _q51 };
3702 354 : tree res = generic_simplify_7 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3703 354 : if (res) return res;
3704 : }
3705 354 : {
3706 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q51, _q50 };
3707 354 : tree res = generic_simplify_7 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3708 354 : if (res) return res;
3709 : }
3710 354 : break;
3711 : }
3712 2857 : default:;
3713 : }
3714 2857 : switch (TREE_CODE (_q21))
3715 : {
3716 41 : case BIT_NOT_EXPR:
3717 41 : {
3718 41 : tree _q40 = TREE_OPERAND (_q21, 0);
3719 41 : switch (TREE_CODE (_p1))
3720 : {
3721 0 : case BIT_NOT_EXPR:
3722 0 : {
3723 0 : tree _q60 = TREE_OPERAND (_p1, 0);
3724 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
3725 : {
3726 0 : {
3727 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
3728 0 : tree res = generic_simplify_153 (loc, type, _p0, _p1, captures);
3729 0 : if (res) return res;
3730 : }
3731 : }
3732 : break;
3733 : }
3734 : default:;
3735 : }
3736 : break;
3737 : }
3738 2857 : default:;
3739 : }
3740 2857 : switch (TREE_CODE (_q20))
3741 : {
3742 90 : case BIT_NOT_EXPR:
3743 90 : {
3744 90 : tree _q30 = TREE_OPERAND (_q20, 0);
3745 90 : switch (TREE_CODE (_p1))
3746 : {
3747 0 : case BIT_NOT_EXPR:
3748 0 : {
3749 0 : tree _q60 = TREE_OPERAND (_p1, 0);
3750 0 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
3751 : {
3752 0 : {
3753 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q30 };
3754 0 : tree res = generic_simplify_153 (loc, type, _p0, _p1, captures);
3755 0 : if (res) return res;
3756 : }
3757 : }
3758 : break;
3759 : }
3760 90 : default:;
3761 : }
3762 90 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
3763 : {
3764 0 : {
3765 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q21 };
3766 0 : tree res = generic_simplify_154 (loc, type, _p0, _p1, captures);
3767 0 : if (res) return res;
3768 : }
3769 : }
3770 : break;
3771 : }
3772 2857 : default:;
3773 : }
3774 2857 : switch (TREE_CODE (_q21))
3775 : {
3776 41 : case BIT_NOT_EXPR:
3777 41 : {
3778 41 : tree _q40 = TREE_OPERAND (_q21, 0);
3779 41 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
3780 : {
3781 0 : {
3782 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q20 };
3783 0 : tree res = generic_simplify_154 (loc, type, _p0, _p1, captures);
3784 0 : if (res) return res;
3785 : }
3786 : }
3787 : break;
3788 : }
3789 : default:;
3790 : }
3791 : break;
3792 : }
3793 505 : case BIT_NOT_EXPR:
3794 505 : {
3795 505 : tree _q20 = TREE_OPERAND (_p0, 0);
3796 505 : switch (TREE_CODE (_p1))
3797 : {
3798 51 : case BIT_AND_EXPR:
3799 51 : {
3800 51 : tree _q40 = TREE_OPERAND (_p1, 0);
3801 51 : tree _q41 = TREE_OPERAND (_p1, 1);
3802 51 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
3803 : {
3804 0 : switch (TREE_CODE (_q41))
3805 : {
3806 0 : case BIT_NOT_EXPR:
3807 0 : {
3808 0 : tree _q60 = TREE_OPERAND (_q41, 0);
3809 0 : {
3810 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q20, _q60 };
3811 0 : tree res = generic_simplify_153 (loc, type, _p0, _p1, captures);
3812 0 : if (res) return res;
3813 : }
3814 0 : break;
3815 : }
3816 : default:;
3817 : }
3818 : }
3819 51 : switch (TREE_CODE (_q40))
3820 : {
3821 7 : case BIT_NOT_EXPR:
3822 7 : {
3823 7 : tree _q50 = TREE_OPERAND (_q40, 0);
3824 7 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
3825 : {
3826 0 : {
3827 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q20, _q50 };
3828 0 : tree res = generic_simplify_153 (loc, type, _p0, _p1, captures);
3829 0 : if (res) return res;
3830 : }
3831 : }
3832 : break;
3833 : }
3834 : default:;
3835 : }
3836 : break;
3837 : }
3838 : default:;
3839 : }
3840 : break;
3841 : }
3842 979475 : default:;
3843 : }
3844 979475 : switch (TREE_CODE (_p1))
3845 : {
3846 707 : case BIT_AND_EXPR:
3847 707 : {
3848 707 : tree _q30 = TREE_OPERAND (_p1, 0);
3849 707 : tree _q31 = TREE_OPERAND (_p1, 1);
3850 707 : switch (TREE_CODE (_q30))
3851 : {
3852 57 : case BIT_NOT_EXPR:
3853 57 : {
3854 57 : tree _q40 = TREE_OPERAND (_q30, 0);
3855 57 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
3856 : {
3857 0 : {
3858 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q31 };
3859 0 : tree res = generic_simplify_154 (loc, type, _p0, _p1, captures);
3860 0 : if (res) return res;
3861 : }
3862 : }
3863 : break;
3864 : }
3865 707 : default:;
3866 : }
3867 707 : switch (TREE_CODE (_q31))
3868 : {
3869 8 : case BIT_NOT_EXPR:
3870 8 : {
3871 8 : tree _q50 = TREE_OPERAND (_q31, 0);
3872 8 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
3873 : {
3874 0 : {
3875 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q30 };
3876 0 : tree res = generic_simplify_154 (loc, type, _p0, _p1, captures);
3877 0 : if (res) return res;
3878 : }
3879 : }
3880 : break;
3881 : }
3882 : default:;
3883 : }
3884 : break;
3885 : }
3886 979475 : default:;
3887 : }
3888 979475 : switch (TREE_CODE (_p0))
3889 : {
3890 21368 : case PLUS_EXPR:
3891 21368 : {
3892 21368 : tree _q20 = TREE_OPERAND (_p0, 0);
3893 21368 : tree _q21 = TREE_OPERAND (_p0, 1);
3894 21368 : if (integer_minus_onep (_q21))
3895 : {
3896 10422 : switch (TREE_CODE (_p1))
3897 : {
3898 11 : case NEGATE_EXPR:
3899 11 : {
3900 11 : tree _q50 = TREE_OPERAND (_p1, 0);
3901 11 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
3902 : {
3903 11 : {
3904 11 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3905 11 : tree res = generic_simplify_75 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3906 11 : if (res) return res;
3907 : }
3908 : }
3909 : break;
3910 : }
3911 : default:;
3912 : }
3913 : }
3914 : break;
3915 : }
3916 142 : case NEGATE_EXPR:
3917 142 : {
3918 142 : tree _q20 = TREE_OPERAND (_p0, 0);
3919 142 : switch (TREE_CODE (_p1))
3920 : {
3921 0 : case PLUS_EXPR:
3922 0 : {
3923 0 : tree _q40 = TREE_OPERAND (_p1, 0);
3924 0 : tree _q41 = TREE_OPERAND (_p1, 1);
3925 0 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
3926 : {
3927 0 : if (integer_minus_onep (_q41))
3928 : {
3929 0 : {
3930 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3931 0 : tree res = generic_simplify_76 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3932 0 : if (res) return res;
3933 : }
3934 : }
3935 : }
3936 : break;
3937 : }
3938 0 : case MINUS_EXPR:
3939 0 : {
3940 0 : tree _q40 = TREE_OPERAND (_p1, 0);
3941 0 : tree _q41 = TREE_OPERAND (_p1, 1);
3942 0 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
3943 : {
3944 0 : if (integer_onep (_q41))
3945 : {
3946 0 : {
3947 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3948 0 : tree res = generic_simplify_77 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3949 0 : if (res) return res;
3950 : }
3951 : }
3952 : }
3953 : break;
3954 : }
3955 : default:;
3956 : }
3957 : break;
3958 : }
3959 102 : case MINUS_EXPR:
3960 102 : {
3961 102 : tree _q20 = TREE_OPERAND (_p0, 0);
3962 102 : tree _q21 = TREE_OPERAND (_p0, 1);
3963 102 : if (integer_onep (_q21))
3964 : {
3965 0 : switch (TREE_CODE (_p1))
3966 : {
3967 0 : case NEGATE_EXPR:
3968 0 : {
3969 0 : tree _q50 = TREE_OPERAND (_p1, 0);
3970 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
3971 : {
3972 0 : {
3973 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3974 0 : tree res = generic_simplify_78 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3975 0 : if (res) return res;
3976 : }
3977 : }
3978 : break;
3979 : }
3980 : default:;
3981 : }
3982 : }
3983 : break;
3984 : }
3985 1310 : case BIT_IOR_EXPR:
3986 1310 : {
3987 1310 : tree _q20 = TREE_OPERAND (_p0, 0);
3988 1310 : tree _q21 = TREE_OPERAND (_p0, 1);
3989 1310 : switch (TREE_CODE (_q20))
3990 : {
3991 481 : case BIT_NOT_EXPR:
3992 481 : {
3993 481 : tree _q30 = TREE_OPERAND (_q20, 0);
3994 481 : {
3995 481 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _p1 };
3996 481 : tree res = generic_simplify_155 (loc, type, _p0, _p1, captures);
3997 481 : if (res) return res;
3998 : }
3999 480 : break;
4000 : }
4001 1309 : default:;
4002 : }
4003 1309 : switch (TREE_CODE (_q21))
4004 : {
4005 62 : case BIT_NOT_EXPR:
4006 62 : {
4007 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4008 62 : {
4009 62 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20, _p1 };
4010 62 : tree res = generic_simplify_155 (loc, type, _p0, _p1, captures);
4011 62 : if (res) return res;
4012 : }
4013 62 : break;
4014 : }
4015 : default:;
4016 : }
4017 : break;
4018 : }
4019 979463 : default:;
4020 : }
4021 979463 : switch (TREE_CODE (_p1))
4022 : {
4023 521 : case BIT_IOR_EXPR:
4024 521 : {
4025 521 : tree _q30 = TREE_OPERAND (_p1, 0);
4026 521 : tree _q31 = TREE_OPERAND (_p1, 1);
4027 521 : switch (TREE_CODE (_q30))
4028 : {
4029 21 : case BIT_NOT_EXPR:
4030 21 : {
4031 21 : tree _q40 = TREE_OPERAND (_q30, 0);
4032 21 : {
4033 21 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _q31, _p0 };
4034 21 : tree res = generic_simplify_155 (loc, type, _p0, _p1, captures);
4035 21 : if (res) return res;
4036 : }
4037 21 : break;
4038 : }
4039 521 : default:;
4040 : }
4041 521 : switch (TREE_CODE (_q31))
4042 : {
4043 25 : case BIT_NOT_EXPR:
4044 25 : {
4045 25 : tree _q50 = TREE_OPERAND (_q31, 0);
4046 25 : {
4047 25 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q31, _q50, _q30, _p0 };
4048 25 : tree res = generic_simplify_155 (loc, type, _p0, _p1, captures);
4049 25 : if (res) return res;
4050 : }
4051 25 : break;
4052 : }
4053 : default:;
4054 : }
4055 : break;
4056 : }
4057 979463 : default:;
4058 : }
4059 979463 : switch (TREE_CODE (_p0))
4060 : {
4061 2857 : case BIT_AND_EXPR:
4062 2857 : {
4063 2857 : tree _q20 = TREE_OPERAND (_p0, 0);
4064 2857 : tree _q21 = TREE_OPERAND (_p0, 1);
4065 2857 : switch (TREE_CODE (_q20))
4066 : {
4067 90 : case BIT_NOT_EXPR:
4068 90 : {
4069 90 : tree _q30 = TREE_OPERAND (_q20, 0);
4070 90 : {
4071 90 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _p1 };
4072 90 : tree res = generic_simplify_156 (loc, type, _p0, _p1, captures);
4073 90 : if (res) return res;
4074 : }
4075 89 : break;
4076 : }
4077 2856 : default:;
4078 : }
4079 2856 : switch (TREE_CODE (_q21))
4080 : {
4081 41 : case BIT_NOT_EXPR:
4082 41 : {
4083 41 : tree _q40 = TREE_OPERAND (_q21, 0);
4084 41 : {
4085 41 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20, _p1 };
4086 41 : tree res = generic_simplify_156 (loc, type, _p0, _p1, captures);
4087 41 : if (res) return res;
4088 : }
4089 41 : break;
4090 : }
4091 : default:;
4092 : }
4093 : break;
4094 : }
4095 979462 : default:;
4096 : }
4097 979462 : switch (TREE_CODE (_p1))
4098 : {
4099 707 : case BIT_AND_EXPR:
4100 707 : {
4101 707 : tree _q30 = TREE_OPERAND (_p1, 0);
4102 707 : tree _q31 = TREE_OPERAND (_p1, 1);
4103 707 : switch (TREE_CODE (_q30))
4104 : {
4105 57 : case BIT_NOT_EXPR:
4106 57 : {
4107 57 : tree _q40 = TREE_OPERAND (_q30, 0);
4108 57 : {
4109 57 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _q31, _p0 };
4110 57 : tree res = generic_simplify_156 (loc, type, _p0, _p1, captures);
4111 57 : if (res) return res;
4112 : }
4113 57 : break;
4114 : }
4115 707 : default:;
4116 : }
4117 707 : switch (TREE_CODE (_q31))
4118 : {
4119 8 : case BIT_NOT_EXPR:
4120 8 : {
4121 8 : tree _q50 = TREE_OPERAND (_q31, 0);
4122 8 : {
4123 8 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q31, _q50, _q30, _p0 };
4124 8 : tree res = generic_simplify_156 (loc, type, _p0, _p1, captures);
4125 8 : if (res) return res;
4126 : }
4127 8 : break;
4128 : }
4129 : default:;
4130 : }
4131 : break;
4132 : }
4133 979462 : default:;
4134 : }
4135 979462 : switch (TREE_CODE (_p0))
4136 : {
4137 625379 : CASE_CONVERT:
4138 625379 : {
4139 625379 : tree _q20 = TREE_OPERAND (_p0, 0);
4140 625379 : switch (TREE_CODE (_p1))
4141 : {
4142 621211 : CASE_CONVERT:
4143 621211 : {
4144 621211 : tree _q40 = TREE_OPERAND (_p1, 0);
4145 621211 : {
4146 621211 : tree _q40_pops[1];
4147 621211 : if (tree_maybe_bit_not (_q40, _q40_pops))
4148 : {
4149 0 : tree _q50 = _q40_pops[0];
4150 0 : {
4151 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
4152 0 : tree res = generic_simplify_88 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4153 0 : if (res) return res;
4154 : }
4155 : }
4156 : }
4157 621211 : break;
4158 : }
4159 625379 : default:;
4160 : }
4161 625379 : {
4162 625379 : tree _q20_pops[1];
4163 625379 : if (tree_maybe_bit_not (_q20, _q20_pops))
4164 : {
4165 59140 : tree _q30 = _q20_pops[0];
4166 59140 : switch (TREE_CODE (_p1))
4167 : {
4168 59090 : CASE_CONVERT:
4169 59090 : {
4170 59090 : tree _q50 = TREE_OPERAND (_p1, 0);
4171 59090 : {
4172 59090 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
4173 59090 : tree res = generic_simplify_88 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4174 59090 : if (res) return res;
4175 : }
4176 59090 : break;
4177 : }
4178 : default:;
4179 : }
4180 : }
4181 : }
4182 625379 : break;
4183 : }
4184 979462 : default:;
4185 : }
4186 979462 : {
4187 979462 : tree _p1_pops[1];
4188 979462 : if (tree_maybe_bit_not (_p1, _p1_pops))
4189 : {
4190 8727 : tree _q30 = _p1_pops[0];
4191 8727 : {
4192 8727 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
4193 8727 : tree res = generic_simplify_88 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4194 8727 : if (res) return res;
4195 : }
4196 : }
4197 : }
4198 979462 : {
4199 979462 : tree _p0_pops[1];
4200 979462 : if (tree_maybe_bit_not (_p0, _p0_pops))
4201 : {
4202 1051 : tree _q20 = _p0_pops[0];
4203 1051 : {
4204 1051 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _q20 };
4205 1051 : tree res = generic_simplify_88 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4206 1051 : if (res) return res;
4207 : }
4208 : }
4209 : }
4210 979441 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
4211 : {
4212 149 : {
4213 149 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4214 149 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1276;
4215 149 : {
4216 149 : tree _r;
4217 149 : _r = build_zero_cst (type);
4218 149 : if (TREE_SIDE_EFFECTS (captures[0]))
4219 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4220 149 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
4221 149 : return _r;
4222 : }
4223 0 : next_after_fail1276:;
4224 : }
4225 : }
4226 979292 : if (integer_all_onesp (_p1))
4227 : {
4228 1067 : {
4229 1067 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4230 1067 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1277;
4231 1067 : {
4232 1067 : tree res_op0;
4233 1067 : res_op0 = captures[0];
4234 1067 : tree _r;
4235 1067 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
4236 1067 : if (TREE_SIDE_EFFECTS (captures[1]))
4237 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4238 1067 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 925, __FILE__, __LINE__, true);
4239 1067 : return _r;
4240 : }
4241 0 : next_after_fail1277:;
4242 : }
4243 : }
4244 978225 : switch (TREE_CODE (_p0))
4245 : {
4246 1302 : case BIT_IOR_EXPR:
4247 1302 : {
4248 1302 : tree _q20 = TREE_OPERAND (_p0, 0);
4249 1302 : tree _q21 = TREE_OPERAND (_p0, 1);
4250 1302 : switch (TREE_CODE (_p1))
4251 : {
4252 179 : case BIT_IOR_EXPR:
4253 179 : {
4254 179 : tree _q50 = TREE_OPERAND (_p1, 0);
4255 179 : tree _q51 = TREE_OPERAND (_p1, 1);
4256 179 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4257 : {
4258 0 : switch (TREE_CODE (_q51))
4259 : {
4260 0 : case BIT_NOT_EXPR:
4261 0 : {
4262 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4263 0 : if ((_q70 == _q21 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q21, 0) && types_match (_q70, _q21)))
4264 : {
4265 0 : {
4266 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4267 0 : tree res = generic_simplify_157 (loc, type, _p0, _p1, captures);
4268 0 : if (res) return res;
4269 : }
4270 : }
4271 : break;
4272 : }
4273 : default:;
4274 : }
4275 : }
4276 179 : switch (TREE_CODE (_q50))
4277 : {
4278 20 : case BIT_NOT_EXPR:
4279 20 : {
4280 20 : tree _q60 = TREE_OPERAND (_q50, 0);
4281 20 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
4282 : {
4283 2 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4284 : {
4285 1 : {
4286 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4287 1 : tree res = generic_simplify_157 (loc, type, _p0, _p1, captures);
4288 1 : if (res) return res;
4289 : }
4290 : }
4291 : }
4292 19 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4293 : {
4294 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4295 : {
4296 0 : {
4297 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
4298 0 : tree res = generic_simplify_157 (loc, type, _p0, _p1, captures);
4299 0 : if (res) return res;
4300 : }
4301 : }
4302 : }
4303 : break;
4304 : }
4305 178 : default:;
4306 : }
4307 178 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4308 : {
4309 0 : switch (TREE_CODE (_q51))
4310 : {
4311 0 : case BIT_NOT_EXPR:
4312 0 : {
4313 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4314 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4315 : {
4316 0 : {
4317 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
4318 0 : tree res = generic_simplify_157 (loc, type, _p0, _p1, captures);
4319 0 : if (res) return res;
4320 : }
4321 : }
4322 : break;
4323 : }
4324 : default:;
4325 : }
4326 : }
4327 : break;
4328 : }
4329 1301 : default:;
4330 : }
4331 1301 : switch (TREE_CODE (_q21))
4332 : {
4333 62 : case BIT_NOT_EXPR:
4334 62 : {
4335 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4336 62 : switch (TREE_CODE (_p1))
4337 : {
4338 9 : case BIT_IOR_EXPR:
4339 9 : {
4340 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4341 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4342 9 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4343 : {
4344 0 : if ((_q61 == _q40 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q40, 0) && types_match (_q61, _q40)))
4345 : {
4346 0 : {
4347 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
4348 0 : tree res = generic_simplify_157 (loc, type, _p0, _p1, captures);
4349 0 : if (res) return res;
4350 : }
4351 : }
4352 : }
4353 : break;
4354 : }
4355 : default:;
4356 : }
4357 : break;
4358 : }
4359 1301 : default:;
4360 : }
4361 1301 : switch (TREE_CODE (_q20))
4362 : {
4363 480 : case BIT_NOT_EXPR:
4364 480 : {
4365 480 : tree _q30 = TREE_OPERAND (_q20, 0);
4366 480 : switch (TREE_CODE (_p1))
4367 : {
4368 28 : case BIT_IOR_EXPR:
4369 28 : {
4370 28 : tree _q60 = TREE_OPERAND (_p1, 0);
4371 28 : tree _q61 = TREE_OPERAND (_p1, 1);
4372 28 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
4373 : {
4374 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
4375 : {
4376 0 : {
4377 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q30 };
4378 0 : tree res = generic_simplify_157 (loc, type, _p0, _p1, captures);
4379 0 : if (res) return res;
4380 : }
4381 : }
4382 : }
4383 28 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
4384 : {
4385 9 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
4386 : {
4387 0 : {
4388 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q30 };
4389 0 : tree res = generic_simplify_157 (loc, type, _p0, _p1, captures);
4390 0 : if (res) return res;
4391 : }
4392 : }
4393 9 : switch (TREE_CODE (_q61))
4394 : {
4395 0 : case BIT_NOT_EXPR:
4396 0 : {
4397 0 : tree _q80 = TREE_OPERAND (_q61, 0);
4398 0 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
4399 : {
4400 0 : {
4401 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q21 };
4402 0 : tree res = generic_simplify_158 (loc, type, _p0, _p1, captures);
4403 0 : if (res) return res;
4404 : }
4405 : }
4406 : break;
4407 : }
4408 : default:;
4409 : }
4410 : }
4411 28 : switch (TREE_CODE (_q60))
4412 : {
4413 1 : case BIT_NOT_EXPR:
4414 1 : {
4415 1 : tree _q70 = TREE_OPERAND (_q60, 0);
4416 1 : if ((_q70 == _q21 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q21, 0) && types_match (_q70, _q21)))
4417 : {
4418 1 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
4419 : {
4420 1 : {
4421 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q21 };
4422 1 : tree res = generic_simplify_158 (loc, type, _p0, _p1, captures);
4423 1 : if (res) return res;
4424 : }
4425 : }
4426 : }
4427 : break;
4428 : }
4429 : default:;
4430 : }
4431 : break;
4432 : }
4433 9 : case BIT_XOR_EXPR:
4434 9 : {
4435 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4436 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4437 9 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
4438 : {
4439 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
4440 : {
4441 0 : {
4442 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q21, _p1 };
4443 0 : tree res = generic_simplify_159 (loc, type, _p0, _p1, captures);
4444 0 : if (res) return res;
4445 : }
4446 : }
4447 : }
4448 : break;
4449 : }
4450 479 : default:;
4451 : }
4452 479 : {
4453 479 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q21, _p1 };
4454 479 : tree res = generic_simplify_160 (loc, type, _p0, _p1, captures);
4455 479 : if (res) return res;
4456 : }
4457 431 : break;
4458 : }
4459 1252 : default:;
4460 : }
4461 1252 : switch (TREE_CODE (_q21))
4462 : {
4463 62 : case BIT_NOT_EXPR:
4464 62 : {
4465 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4466 62 : switch (TREE_CODE (_p1))
4467 : {
4468 9 : case BIT_IOR_EXPR:
4469 9 : {
4470 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4471 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4472 9 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
4473 : {
4474 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
4475 : {
4476 0 : {
4477 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
4478 0 : tree res = generic_simplify_157 (loc, type, _p0, _p1, captures);
4479 0 : if (res) return res;
4480 : }
4481 : }
4482 : }
4483 : break;
4484 : }
4485 9 : case BIT_XOR_EXPR:
4486 9 : {
4487 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4488 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4489 9 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
4490 : {
4491 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
4492 : {
4493 0 : {
4494 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q40, _q20, _p1 };
4495 0 : tree res = generic_simplify_159 (loc, type, _p0, _p1, captures);
4496 0 : if (res) return res;
4497 : }
4498 : }
4499 : }
4500 : break;
4501 : }
4502 : default:;
4503 : }
4504 : break;
4505 : }
4506 1252 : default:;
4507 : }
4508 1252 : switch (TREE_CODE (_p1))
4509 : {
4510 65 : case BIT_AND_EXPR:
4511 65 : {
4512 65 : tree _q50 = TREE_OPERAND (_p1, 0);
4513 65 : tree _q51 = TREE_OPERAND (_p1, 1);
4514 65 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4515 : {
4516 6 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4517 : {
4518 0 : {
4519 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4520 0 : tree res = generic_simplify_161 (loc, type, _p0, _p1, captures);
4521 0 : if (res) return res;
4522 : }
4523 : }
4524 : }
4525 : break;
4526 : }
4527 36 : case BIT_XOR_EXPR:
4528 36 : {
4529 36 : tree _q50 = TREE_OPERAND (_p1, 0);
4530 36 : tree _q51 = TREE_OPERAND (_p1, 1);
4531 36 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4532 : {
4533 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4534 : {
4535 0 : {
4536 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4537 0 : tree res = generic_simplify_162 (loc, type, _p0, _p1, captures);
4538 0 : if (res) return res;
4539 : }
4540 : }
4541 : }
4542 : break;
4543 : }
4544 1252 : default:;
4545 : }
4546 1252 : switch (TREE_CODE (_q21))
4547 : {
4548 62 : case BIT_NOT_EXPR:
4549 62 : {
4550 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4551 62 : switch (TREE_CODE (_p1))
4552 : {
4553 9 : case BIT_IOR_EXPR:
4554 9 : {
4555 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4556 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4557 9 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
4558 : {
4559 0 : switch (TREE_CODE (_q61))
4560 : {
4561 0 : case BIT_NOT_EXPR:
4562 0 : {
4563 0 : tree _q80 = TREE_OPERAND (_q61, 0);
4564 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
4565 : {
4566 0 : {
4567 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
4568 0 : tree res = generic_simplify_158 (loc, type, _p0, _p1, captures);
4569 0 : if (res) return res;
4570 : }
4571 : }
4572 : break;
4573 : }
4574 : default:;
4575 : }
4576 : }
4577 9 : switch (TREE_CODE (_q60))
4578 : {
4579 0 : case BIT_NOT_EXPR:
4580 0 : {
4581 0 : tree _q70 = TREE_OPERAND (_q60, 0);
4582 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4583 : {
4584 0 : if ((_q61 == _q40 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q40, 0) && types_match (_q61, _q40)))
4585 : {
4586 0 : {
4587 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
4588 0 : tree res = generic_simplify_158 (loc, type, _p0, _p1, captures);
4589 0 : if (res) return res;
4590 : }
4591 : }
4592 : }
4593 : break;
4594 : }
4595 : default:;
4596 : }
4597 : break;
4598 : }
4599 : default:;
4600 : }
4601 : break;
4602 : }
4603 1252 : default:;
4604 : }
4605 1252 : switch (TREE_CODE (_p1))
4606 : {
4607 24 : CASE_CONVERT:
4608 24 : {
4609 24 : tree _q50 = TREE_OPERAND (_p1, 0);
4610 24 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
4611 : {
4612 0 : {
4613 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q20 };
4614 0 : tree res = generic_simplify_163 (loc, type, _p0, _p1, captures);
4615 0 : if (res) return res;
4616 : }
4617 : }
4618 24 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q21, 0))
4619 : {
4620 0 : {
4621 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q21 };
4622 0 : tree res = generic_simplify_163 (loc, type, _p0, _p1, captures);
4623 0 : if (res) return res;
4624 : }
4625 : }
4626 : break;
4627 : }
4628 1252 : default:;
4629 : }
4630 1252 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q20, 0))
4631 : {
4632 3 : {
4633 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q20 };
4634 3 : tree res = generic_simplify_163 (loc, type, _p0, _p1, captures);
4635 3 : if (res) return res;
4636 : }
4637 : }
4638 1249 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q21, 0))
4639 : {
4640 3 : {
4641 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q21 };
4642 3 : tree res = generic_simplify_163 (loc, type, _p0, _p1, captures);
4643 3 : if (res) return res;
4644 : }
4645 : }
4646 1246 : {
4647 1246 : tree _q20_pops[1];
4648 1246 : if (tree_nop_convert (_q20, _q20_pops))
4649 : {
4650 8 : tree _q30 = _q20_pops[0];
4651 8 : switch (TREE_CODE (_q30))
4652 : {
4653 8 : case BIT_NOT_EXPR:
4654 8 : {
4655 8 : tree _q40 = TREE_OPERAND (_q30, 0);
4656 8 : {
4657 8 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q21, _p1 };
4658 8 : tree res = generic_simplify_160 (loc, type, _p0, _p1, captures);
4659 8 : if (res) return res;
4660 : }
4661 0 : break;
4662 : }
4663 : default:;
4664 : }
4665 : }
4666 : }
4667 1238 : switch (TREE_CODE (_q21))
4668 : {
4669 62 : case BIT_NOT_EXPR:
4670 62 : {
4671 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4672 62 : {
4673 62 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q20, _p1 };
4674 62 : tree res = generic_simplify_160 (loc, type, _p0, _p1, captures);
4675 62 : if (res) return res;
4676 : }
4677 54 : break;
4678 : }
4679 1230 : default:;
4680 : }
4681 1230 : {
4682 1230 : tree _q21_pops[1];
4683 1230 : if (tree_nop_convert (_q21, _q21_pops))
4684 : {
4685 0 : tree _q40 = _q21_pops[0];
4686 0 : switch (TREE_CODE (_q40))
4687 : {
4688 0 : case BIT_NOT_EXPR:
4689 0 : {
4690 0 : tree _q50 = TREE_OPERAND (_q40, 0);
4691 0 : {
4692 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q20, _p1 };
4693 0 : tree res = generic_simplify_160 (loc, type, _p0, _p1, captures);
4694 0 : if (res) return res;
4695 : }
4696 0 : break;
4697 : }
4698 : default:;
4699 : }
4700 : }
4701 : }
4702 1230 : break;
4703 : }
4704 3908 : case BIT_XOR_EXPR:
4705 3908 : {
4706 3908 : tree _q20 = TREE_OPERAND (_p0, 0);
4707 3908 : tree _q21 = TREE_OPERAND (_p0, 1);
4708 3908 : switch (TREE_CODE (_p1))
4709 : {
4710 203 : case BIT_IOR_EXPR:
4711 203 : {
4712 203 : tree _q50 = TREE_OPERAND (_p1, 0);
4713 203 : tree _q51 = TREE_OPERAND (_p1, 1);
4714 203 : switch (TREE_CODE (_q50))
4715 : {
4716 1 : case BIT_NOT_EXPR:
4717 1 : {
4718 1 : tree _q60 = TREE_OPERAND (_q50, 0);
4719 1 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4720 : {
4721 1 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4722 : {
4723 1 : {
4724 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q20, _q21, _p0 };
4725 1 : tree res = generic_simplify_159 (loc, type, _p0, _p1, captures);
4726 1 : if (res) return res;
4727 : }
4728 : }
4729 : }
4730 : break;
4731 : }
4732 202 : default:;
4733 : }
4734 202 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4735 : {
4736 0 : switch (TREE_CODE (_q51))
4737 : {
4738 0 : case BIT_NOT_EXPR:
4739 0 : {
4740 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4741 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4742 : {
4743 0 : {
4744 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q20, _q21, _p0 };
4745 0 : tree res = generic_simplify_159 (loc, type, _p0, _p1, captures);
4746 0 : if (res) return res;
4747 : }
4748 : }
4749 : break;
4750 : }
4751 : default:;
4752 : }
4753 : }
4754 202 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4755 : {
4756 1 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4757 : {
4758 0 : {
4759 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4760 0 : tree res = generic_simplify_162 (loc, type, _p0, _p1, captures);
4761 0 : if (res) return res;
4762 : }
4763 : }
4764 : }
4765 : break;
4766 : }
4767 41 : case BIT_AND_EXPR:
4768 41 : {
4769 41 : tree _q50 = TREE_OPERAND (_p1, 0);
4770 41 : tree _q51 = TREE_OPERAND (_p1, 1);
4771 41 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4772 : {
4773 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4774 : {
4775 0 : {
4776 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4777 0 : tree res = generic_simplify_9 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4778 0 : if (res) return res;
4779 : }
4780 : }
4781 : }
4782 : break;
4783 : }
4784 198 : CASE_CONVERT:
4785 198 : {
4786 198 : tree _q50 = TREE_OPERAND (_p1, 0);
4787 198 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q21, 0))
4788 : {
4789 0 : {
4790 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q21 };
4791 0 : tree res = generic_simplify_164 (loc, type, _p0, _p1, captures);
4792 0 : if (res) return res;
4793 : }
4794 : }
4795 198 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
4796 : {
4797 0 : {
4798 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q20 };
4799 0 : tree res = generic_simplify_164 (loc, type, _p0, _p1, captures);
4800 0 : if (res) return res;
4801 : }
4802 : }
4803 : break;
4804 : }
4805 3907 : default:;
4806 : }
4807 3907 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q21, 0))
4808 : {
4809 0 : {
4810 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q21 };
4811 0 : tree res = generic_simplify_164 (loc, type, _p0, _p1, captures);
4812 0 : if (res) return res;
4813 : }
4814 : }
4815 3907 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q20, 0))
4816 : {
4817 11 : {
4818 11 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q20 };
4819 11 : tree res = generic_simplify_164 (loc, type, _p0, _p1, captures);
4820 11 : if (res) return res;
4821 : }
4822 : }
4823 : break;
4824 : }
4825 2856 : case BIT_AND_EXPR:
4826 2856 : {
4827 2856 : tree _q20 = TREE_OPERAND (_p0, 0);
4828 2856 : tree _q21 = TREE_OPERAND (_p0, 1);
4829 2856 : switch (TREE_CODE (_p1))
4830 : {
4831 74 : case BIT_IOR_EXPR:
4832 74 : {
4833 74 : tree _q50 = TREE_OPERAND (_p1, 0);
4834 74 : tree _q51 = TREE_OPERAND (_p1, 1);
4835 74 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4836 : {
4837 18 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4838 : {
4839 0 : {
4840 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4841 0 : tree res = generic_simplify_161 (loc, type, _p0, _p1, captures);
4842 0 : if (res) return res;
4843 : }
4844 : }
4845 : }
4846 : break;
4847 : }
4848 30 : case BIT_XOR_EXPR:
4849 30 : {
4850 30 : tree _q50 = TREE_OPERAND (_p1, 0);
4851 30 : tree _q51 = TREE_OPERAND (_p1, 1);
4852 30 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4853 : {
4854 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4855 : {
4856 0 : {
4857 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4858 0 : tree res = generic_simplify_9 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4859 0 : if (res) return res;
4860 : }
4861 : }
4862 : }
4863 : break;
4864 : }
4865 2856 : default:;
4866 : }
4867 2856 : switch (TREE_CODE (_q21))
4868 : {
4869 1031 : case INTEGER_CST:
4870 1031 : {
4871 1031 : switch (TREE_CODE (_p1))
4872 : {
4873 15 : CASE_CONVERT:
4874 15 : {
4875 15 : tree _q50 = TREE_OPERAND (_p1, 0);
4876 15 : switch (TREE_CODE (_q50))
4877 : {
4878 0 : case BIT_AND_EXPR:
4879 0 : {
4880 0 : tree _q60 = TREE_OPERAND (_q50, 0);
4881 0 : tree _q61 = TREE_OPERAND (_q50, 1);
4882 0 : switch (TREE_CODE (_q61))
4883 : {
4884 0 : case INTEGER_CST:
4885 0 : {
4886 0 : {
4887 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50, _q60, _q61 };
4888 0 : tree res = generic_simplify_11 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4889 0 : if (res) return res;
4890 : }
4891 0 : break;
4892 : }
4893 : default:;
4894 : }
4895 : break;
4896 : }
4897 : default:;
4898 : }
4899 : break;
4900 : }
4901 210 : case BIT_AND_EXPR:
4902 210 : {
4903 210 : tree _q50 = TREE_OPERAND (_p1, 0);
4904 210 : tree _q51 = TREE_OPERAND (_p1, 1);
4905 210 : switch (TREE_CODE (_q51))
4906 : {
4907 210 : case INTEGER_CST:
4908 210 : {
4909 210 : {
4910 210 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50, _q51 };
4911 210 : tree res = generic_simplify_11 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4912 210 : if (res) return res;
4913 : }
4914 209 : break;
4915 : }
4916 : default:;
4917 : }
4918 : break;
4919 : }
4920 : default:;
4921 : }
4922 : break;
4923 : }
4924 : default:;
4925 : }
4926 : break;
4927 : }
4928 625222 : CASE_CONVERT:
4929 625222 : {
4930 625222 : tree _q20 = TREE_OPERAND (_p0, 0);
4931 625222 : switch (TREE_CODE (_q20))
4932 : {
4933 24 : case BIT_AND_EXPR:
4934 24 : {
4935 24 : tree _q30 = TREE_OPERAND (_q20, 0);
4936 24 : tree _q31 = TREE_OPERAND (_q20, 1);
4937 24 : switch (TREE_CODE (_q31))
4938 : {
4939 0 : case INTEGER_CST:
4940 0 : {
4941 0 : switch (TREE_CODE (_p1))
4942 : {
4943 0 : CASE_CONVERT:
4944 0 : {
4945 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4946 0 : switch (TREE_CODE (_q60))
4947 : {
4948 0 : case BIT_AND_EXPR:
4949 0 : {
4950 0 : tree _q70 = TREE_OPERAND (_q60, 0);
4951 0 : tree _q71 = TREE_OPERAND (_q60, 1);
4952 0 : switch (TREE_CODE (_q71))
4953 : {
4954 0 : case INTEGER_CST:
4955 0 : {
4956 0 : {
4957 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q60, _q70, _q71 };
4958 0 : tree res = generic_simplify_11 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4959 0 : if (res) return res;
4960 : }
4961 0 : break;
4962 : }
4963 : default:;
4964 : }
4965 : break;
4966 : }
4967 : default:;
4968 : }
4969 : break;
4970 : }
4971 0 : case BIT_AND_EXPR:
4972 0 : {
4973 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4974 0 : tree _q61 = TREE_OPERAND (_p1, 1);
4975 0 : switch (TREE_CODE (_q61))
4976 : {
4977 0 : case INTEGER_CST:
4978 0 : {
4979 0 : {
4980 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _p1, _q60, _q61 };
4981 0 : tree res = generic_simplify_11 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4982 0 : if (res) return res;
4983 : }
4984 0 : break;
4985 : }
4986 : default:;
4987 : }
4988 : break;
4989 : }
4990 : default:;
4991 : }
4992 : break;
4993 : }
4994 : default:;
4995 : }
4996 : break;
4997 : }
4998 24 : case BIT_IOR_EXPR:
4999 24 : {
5000 24 : tree _q30 = TREE_OPERAND (_q20, 0);
5001 24 : tree _q31 = TREE_OPERAND (_q20, 1);
5002 24 : switch (TREE_CODE (_p1))
5003 : {
5004 16 : CASE_CONVERT:
5005 16 : {
5006 16 : tree _q60 = TREE_OPERAND (_p1, 0);
5007 16 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q30, 0))
5008 : {
5009 0 : {
5010 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q30 };
5011 0 : tree res = generic_simplify_163 (loc, type, _p0, _p1, captures);
5012 0 : if (res) return res;
5013 : }
5014 : }
5015 16 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q31, 0))
5016 : {
5017 0 : {
5018 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q31 };
5019 0 : tree res = generic_simplify_163 (loc, type, _p0, _p1, captures);
5020 0 : if (res) return res;
5021 : }
5022 : }
5023 : break;
5024 : }
5025 24 : default:;
5026 : }
5027 24 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q30, 0))
5028 : {
5029 0 : {
5030 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q30 };
5031 0 : tree res = generic_simplify_163 (loc, type, _p0, _p1, captures);
5032 0 : if (res) return res;
5033 : }
5034 : }
5035 24 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q31, 0))
5036 : {
5037 0 : {
5038 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q31 };
5039 0 : tree res = generic_simplify_163 (loc, type, _p0, _p1, captures);
5040 0 : if (res) return res;
5041 : }
5042 : }
5043 : break;
5044 : }
5045 625222 : default:;
5046 : }
5047 625222 : switch (TREE_CODE (_p1))
5048 : {
5049 621204 : CASE_CONVERT:
5050 621204 : {
5051 621204 : tree _q40 = TREE_OPERAND (_p1, 0);
5052 621204 : switch (TREE_CODE (_q40))
5053 : {
5054 0 : case BIT_IOR_EXPR:
5055 0 : {
5056 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5057 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5058 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
5059 : {
5060 0 : {
5061 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
5062 0 : tree res = generic_simplify_163 (loc, type, _p0, _p1, captures);
5063 0 : if (res) return res;
5064 : }
5065 : }
5066 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
5067 : {
5068 0 : {
5069 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q50, _q20 };
5070 0 : tree res = generic_simplify_163 (loc, type, _p0, _p1, captures);
5071 0 : if (res) return res;
5072 : }
5073 : }
5074 : break;
5075 : }
5076 : default:;
5077 : }
5078 : break;
5079 : }
5080 26 : case BIT_IOR_EXPR:
5081 26 : {
5082 26 : tree _q40 = TREE_OPERAND (_p1, 0);
5083 26 : tree _q41 = TREE_OPERAND (_p1, 1);
5084 26 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _q20, 0))
5085 : {
5086 0 : {
5087 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q20 };
5088 0 : tree res = generic_simplify_163 (loc, type, _p0, _p1, captures);
5089 0 : if (res) return res;
5090 : }
5091 : }
5092 26 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _q20, 0))
5093 : {
5094 0 : {
5095 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q20 };
5096 0 : tree res = generic_simplify_163 (loc, type, _p0, _p1, captures);
5097 0 : if (res) return res;
5098 : }
5099 : }
5100 : break;
5101 : }
5102 : default:;
5103 : }
5104 : break;
5105 : }
5106 978140 : default:;
5107 : }
5108 978140 : switch (TREE_CODE (_p1))
5109 : {
5110 747900 : CASE_CONVERT:
5111 747900 : {
5112 747900 : tree _q30 = TREE_OPERAND (_p1, 0);
5113 747900 : switch (TREE_CODE (_q30))
5114 : {
5115 6 : case BIT_IOR_EXPR:
5116 6 : {
5117 6 : tree _q40 = TREE_OPERAND (_q30, 0);
5118 6 : tree _q41 = TREE_OPERAND (_q30, 1);
5119 6 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _p0, 0))
5120 : {
5121 0 : {
5122 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _p0 };
5123 0 : tree res = generic_simplify_163 (loc, type, _p0, _p1, captures);
5124 0 : if (res) return res;
5125 : }
5126 : }
5127 6 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _p0, 0))
5128 : {
5129 0 : {
5130 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _p0 };
5131 0 : tree res = generic_simplify_163 (loc, type, _p0, _p1, captures);
5132 0 : if (res) return res;
5133 : }
5134 : }
5135 : break;
5136 : }
5137 : default:;
5138 : }
5139 : break;
5140 : }
5141 518 : case BIT_IOR_EXPR:
5142 518 : {
5143 518 : tree _q30 = TREE_OPERAND (_p1, 0);
5144 518 : tree _q31 = TREE_OPERAND (_p1, 1);
5145 518 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || operand_equal_p (_q30, _p0, 0))
5146 : {
5147 1 : {
5148 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
5149 1 : tree res = generic_simplify_163 (loc, type, _p0, _p1, captures);
5150 1 : if (res) return res;
5151 : }
5152 : }
5153 517 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || operand_equal_p (_q31, _p0, 0))
5154 : {
5155 1 : {
5156 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _p0 };
5157 1 : tree res = generic_simplify_163 (loc, type, _p0, _p1, captures);
5158 1 : if (res) return res;
5159 : }
5160 : }
5161 : break;
5162 : }
5163 978138 : default:;
5164 : }
5165 978138 : {
5166 978138 : tree _p0_pops[1];
5167 978138 : if (tree_nop_convert (_p0, _p0_pops))
5168 : {
5169 500983 : tree _q20 = _p0_pops[0];
5170 500983 : switch (TREE_CODE (_q20))
5171 : {
5172 16 : case BIT_IOR_EXPR:
5173 16 : {
5174 16 : tree _q30 = TREE_OPERAND (_q20, 0);
5175 16 : tree _q31 = TREE_OPERAND (_q20, 1);
5176 16 : {
5177 16 : tree _q30_pops[1];
5178 16 : if (tree_nop_convert (_q30, _q30_pops))
5179 : {
5180 0 : tree _q40 = _q30_pops[0];
5181 0 : switch (TREE_CODE (_q40))
5182 : {
5183 0 : case BIT_NOT_EXPR:
5184 0 : {
5185 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5186 0 : {
5187 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q31, _p1 };
5188 0 : tree res = generic_simplify_160 (loc, type, _p0, _p1, captures);
5189 0 : if (res) return res;
5190 : }
5191 0 : break;
5192 : }
5193 : default:;
5194 : }
5195 : }
5196 : }
5197 16 : {
5198 16 : tree _q31_pops[1];
5199 16 : if (tree_nop_convert (_q31, _q31_pops))
5200 : {
5201 0 : tree _q50 = _q31_pops[0];
5202 0 : switch (TREE_CODE (_q50))
5203 : {
5204 0 : case BIT_NOT_EXPR:
5205 0 : {
5206 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5207 0 : {
5208 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q30, _p1 };
5209 0 : tree res = generic_simplify_160 (loc, type, _p0, _p1, captures);
5210 0 : if (res) return res;
5211 : }
5212 0 : break;
5213 : }
5214 : default:;
5215 : }
5216 : }
5217 : }
5218 16 : switch (TREE_CODE (_q30))
5219 : {
5220 16 : case BIT_NOT_EXPR:
5221 16 : {
5222 16 : tree _q40 = TREE_OPERAND (_q30, 0);
5223 16 : {
5224 16 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q31, _p1 };
5225 16 : tree res = generic_simplify_160 (loc, type, _p0, _p1, captures);
5226 16 : if (res) return res;
5227 : }
5228 0 : break;
5229 : }
5230 0 : default:;
5231 : }
5232 0 : switch (TREE_CODE (_q31))
5233 : {
5234 0 : case BIT_NOT_EXPR:
5235 0 : {
5236 0 : tree _q50 = TREE_OPERAND (_q31, 0);
5237 0 : {
5238 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q30, _p1 };
5239 0 : tree res = generic_simplify_160 (loc, type, _p0, _p1, captures);
5240 0 : if (res) return res;
5241 : }
5242 0 : break;
5243 : }
5244 : default:;
5245 : }
5246 : break;
5247 : }
5248 : default:;
5249 : }
5250 : }
5251 : }
5252 978122 : switch (TREE_CODE (_p1))
5253 : {
5254 516 : case BIT_IOR_EXPR:
5255 516 : {
5256 516 : tree _q30 = TREE_OPERAND (_p1, 0);
5257 516 : tree _q31 = TREE_OPERAND (_p1, 1);
5258 516 : {
5259 516 : tree _q30_pops[1];
5260 516 : if (tree_nop_convert (_q30, _q30_pops))
5261 : {
5262 2 : tree _q40 = _q30_pops[0];
5263 2 : switch (TREE_CODE (_q40))
5264 : {
5265 0 : case BIT_NOT_EXPR:
5266 0 : {
5267 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5268 0 : {
5269 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q31, _p0 };
5270 0 : tree res = generic_simplify_160 (loc, type, _p0, _p1, captures);
5271 0 : if (res) return res;
5272 : }
5273 0 : break;
5274 : }
5275 : default:;
5276 : }
5277 : }
5278 : }
5279 516 : {
5280 516 : tree _q31_pops[1];
5281 516 : if (tree_nop_convert (_q31, _q31_pops))
5282 : {
5283 2 : tree _q50 = _q31_pops[0];
5284 2 : switch (TREE_CODE (_q50))
5285 : {
5286 0 : case BIT_NOT_EXPR:
5287 0 : {
5288 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5289 0 : {
5290 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q30, _p0 };
5291 0 : tree res = generic_simplify_160 (loc, type, _p0, _p1, captures);
5292 0 : if (res) return res;
5293 : }
5294 0 : break;
5295 : }
5296 : default:;
5297 : }
5298 : }
5299 : }
5300 516 : switch (TREE_CODE (_q30))
5301 : {
5302 18 : case BIT_NOT_EXPR:
5303 18 : {
5304 18 : tree _q40 = TREE_OPERAND (_q30, 0);
5305 18 : {
5306 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q31, _p0 };
5307 18 : tree res = generic_simplify_160 (loc, type, _p0, _p1, captures);
5308 18 : if (res) return res;
5309 : }
5310 18 : break;
5311 : }
5312 516 : default:;
5313 : }
5314 516 : switch (TREE_CODE (_q31))
5315 : {
5316 25 : case BIT_NOT_EXPR:
5317 25 : {
5318 25 : tree _q50 = TREE_OPERAND (_q31, 0);
5319 25 : {
5320 25 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q30, _p0 };
5321 25 : tree res = generic_simplify_160 (loc, type, _p0, _p1, captures);
5322 25 : if (res) return res;
5323 : }
5324 17 : break;
5325 : }
5326 : default:;
5327 : }
5328 : break;
5329 : }
5330 978114 : default:;
5331 : }
5332 978114 : {
5333 978114 : tree _p1_pops[1];
5334 978114 : if (tree_nop_convert (_p1, _p1_pops))
5335 : {
5336 626211 : tree _q30 = _p1_pops[0];
5337 626211 : switch (TREE_CODE (_q30))
5338 : {
5339 0 : case BIT_IOR_EXPR:
5340 0 : {
5341 0 : tree _q40 = TREE_OPERAND (_q30, 0);
5342 0 : tree _q41 = TREE_OPERAND (_q30, 1);
5343 0 : {
5344 0 : tree _q40_pops[1];
5345 0 : if (tree_nop_convert (_q40, _q40_pops))
5346 : {
5347 0 : tree _q50 = _q40_pops[0];
5348 0 : switch (TREE_CODE (_q50))
5349 : {
5350 0 : case BIT_NOT_EXPR:
5351 0 : {
5352 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5353 0 : {
5354 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q41, _p0 };
5355 0 : tree res = generic_simplify_160 (loc, type, _p0, _p1, captures);
5356 0 : if (res) return res;
5357 : }
5358 0 : break;
5359 : }
5360 : default:;
5361 : }
5362 : }
5363 : }
5364 0 : {
5365 0 : tree _q41_pops[1];
5366 0 : if (tree_nop_convert (_q41, _q41_pops))
5367 : {
5368 0 : tree _q60 = _q41_pops[0];
5369 0 : switch (TREE_CODE (_q60))
5370 : {
5371 0 : case BIT_NOT_EXPR:
5372 0 : {
5373 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5374 0 : {
5375 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q70, _q40, _p0 };
5376 0 : tree res = generic_simplify_160 (loc, type, _p0, _p1, captures);
5377 0 : if (res) return res;
5378 : }
5379 0 : break;
5380 : }
5381 : default:;
5382 : }
5383 : }
5384 : }
5385 0 : switch (TREE_CODE (_q40))
5386 : {
5387 0 : case BIT_NOT_EXPR:
5388 0 : {
5389 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5390 0 : {
5391 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q41, _p0 };
5392 0 : tree res = generic_simplify_160 (loc, type, _p0, _p1, captures);
5393 0 : if (res) return res;
5394 : }
5395 0 : break;
5396 : }
5397 0 : default:;
5398 : }
5399 0 : switch (TREE_CODE (_q41))
5400 : {
5401 0 : case BIT_NOT_EXPR:
5402 0 : {
5403 0 : tree _q60 = TREE_OPERAND (_q41, 0);
5404 0 : {
5405 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q40, _p0 };
5406 0 : tree res = generic_simplify_160 (loc, type, _p0, _p1, captures);
5407 0 : if (res) return res;
5408 : }
5409 0 : break;
5410 : }
5411 : default:;
5412 : }
5413 : break;
5414 : }
5415 : default:;
5416 : }
5417 : }
5418 : }
5419 978114 : switch (TREE_CODE (_p0))
5420 : {
5421 625198 : CASE_CONVERT:
5422 625198 : {
5423 625198 : tree _q20 = TREE_OPERAND (_p0, 0);
5424 625198 : switch (TREE_CODE (_q20))
5425 : {
5426 50 : case BIT_NOT_EXPR:
5427 50 : {
5428 50 : tree _q30 = TREE_OPERAND (_q20, 0);
5429 50 : switch (TREE_CODE (_p1))
5430 : {
5431 0 : CASE_CONVERT:
5432 0 : {
5433 0 : tree _q50 = TREE_OPERAND (_p1, 0);
5434 0 : switch (TREE_CODE (_q50))
5435 : {
5436 0 : case BIT_NOT_EXPR:
5437 0 : {
5438 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5439 0 : {
5440 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q60 };
5441 0 : tree res = generic_simplify_165 (loc, type, _p0, _p1, captures);
5442 0 : if (res) return res;
5443 : }
5444 0 : break;
5445 : }
5446 : default:;
5447 : }
5448 : break;
5449 : }
5450 0 : case BIT_NOT_EXPR:
5451 0 : {
5452 0 : tree _q50 = TREE_OPERAND (_p1, 0);
5453 0 : {
5454 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q50 };
5455 0 : tree res = generic_simplify_165 (loc, type, _p0, _p1, captures);
5456 0 : if (res) return res;
5457 : }
5458 0 : break;
5459 : }
5460 26 : case INTEGER_CST:
5461 26 : {
5462 26 : {
5463 26 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p1 };
5464 26 : tree res = generic_simplify_166 (loc, type, _p0, _p1, captures);
5465 26 : if (res) return res;
5466 : }
5467 24 : break;
5468 : }
5469 : default:;
5470 : }
5471 : break;
5472 : }
5473 : default:;
5474 : }
5475 : break;
5476 : }
5477 484 : case BIT_NOT_EXPR:
5478 484 : {
5479 484 : tree _q20 = TREE_OPERAND (_p0, 0);
5480 484 : switch (TREE_CODE (_p1))
5481 : {
5482 18 : CASE_CONVERT:
5483 18 : {
5484 18 : tree _q40 = TREE_OPERAND (_p1, 0);
5485 18 : switch (TREE_CODE (_q40))
5486 : {
5487 0 : case BIT_NOT_EXPR:
5488 0 : {
5489 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5490 0 : {
5491 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
5492 0 : tree res = generic_simplify_165 (loc, type, _p0, _p1, captures);
5493 0 : if (res) return res;
5494 : }
5495 0 : break;
5496 : }
5497 : default:;
5498 : }
5499 : break;
5500 : }
5501 10 : case BIT_NOT_EXPR:
5502 10 : {
5503 10 : tree _q40 = TREE_OPERAND (_p1, 0);
5504 10 : {
5505 10 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
5506 10 : tree res = generic_simplify_165 (loc, type, _p0, _p1, captures);
5507 10 : if (res) return res;
5508 : }
5509 0 : break;
5510 : }
5511 31 : case INTEGER_CST:
5512 31 : {
5513 31 : {
5514 31 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
5515 31 : tree res = generic_simplify_166 (loc, type, _p0, _p1, captures);
5516 31 : if (res) return res;
5517 : }
5518 0 : break;
5519 : }
5520 443 : default:;
5521 : }
5522 443 : {
5523 443 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _p1 };
5524 443 : tree res = generic_simplify_167 (loc, type, _p0, _p1, captures);
5525 443 : if (res) return res;
5526 : }
5527 0 : break;
5528 : }
5529 2853 : case BIT_AND_EXPR:
5530 2853 : {
5531 2853 : tree _q20 = TREE_OPERAND (_p0, 0);
5532 2853 : tree _q21 = TREE_OPERAND (_p0, 1);
5533 2853 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5534 : {
5535 75 : {
5536 75 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
5537 75 : tree res = generic_simplify_168 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5538 75 : if (res) return res;
5539 : }
5540 : }
5541 2778 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5542 : {
5543 3 : {
5544 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
5545 3 : tree res = generic_simplify_168 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5546 3 : if (res) return res;
5547 : }
5548 : }
5549 2775 : switch (TREE_CODE (_p1))
5550 : {
5551 353 : case BIT_AND_EXPR:
5552 353 : {
5553 353 : tree _q50 = TREE_OPERAND (_p1, 0);
5554 353 : tree _q51 = TREE_OPERAND (_p1, 1);
5555 353 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
5556 : {
5557 21 : {
5558 21 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q51, _q20 };
5559 21 : tree res = generic_simplify_96 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5560 21 : if (res) return res;
5561 : }
5562 : }
5563 332 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
5564 : {
5565 0 : {
5566 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q20 };
5567 0 : tree res = generic_simplify_96 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5568 0 : if (res) return res;
5569 : }
5570 : }
5571 332 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q21, 0))
5572 : {
5573 0 : {
5574 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q51, _q21 };
5575 0 : tree res = generic_simplify_96 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5576 0 : if (res) return res;
5577 : }
5578 : }
5579 332 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q21, 0))
5580 : {
5581 201 : {
5582 201 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q50, _q21 };
5583 201 : tree res = generic_simplify_96 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5584 201 : if (res) return res;
5585 : }
5586 : }
5587 : break;
5588 : }
5589 : default:;
5590 : }
5591 : break;
5592 : }
5593 977328 : default:;
5594 : }
5595 977328 : switch (TREE_CODE (_p1))
5596 : {
5597 431 : case BIT_AND_EXPR:
5598 431 : {
5599 431 : tree _q30 = TREE_OPERAND (_p1, 0);
5600 431 : tree _q31 = TREE_OPERAND (_p1, 1);
5601 431 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5602 : {
5603 0 : {
5604 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
5605 0 : tree res = generic_simplify_168 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5606 0 : if (res) return res;
5607 : }
5608 : }
5609 431 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5610 : {
5611 0 : {
5612 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q31, _p0 };
5613 0 : tree res = generic_simplify_168 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5614 0 : if (res) return res;
5615 : }
5616 : }
5617 : break;
5618 : }
5619 977328 : default:;
5620 : }
5621 977328 : switch (TREE_CODE (_p0))
5622 : {
5623 625196 : CASE_CONVERT:
5624 625196 : {
5625 625196 : tree _q20 = TREE_OPERAND (_p0, 0);
5626 625196 : switch (TREE_CODE (_q20))
5627 : {
5628 24 : case BIT_AND_EXPR:
5629 24 : {
5630 24 : tree _q30 = TREE_OPERAND (_q20, 0);
5631 24 : tree _q31 = TREE_OPERAND (_q20, 1);
5632 24 : switch (TREE_CODE (_p1))
5633 : {
5634 8 : CASE_CONVERT:
5635 8 : {
5636 8 : tree _q60 = TREE_OPERAND (_p1, 0);
5637 8 : switch (TREE_CODE (_q60))
5638 : {
5639 0 : case BIT_AND_EXPR:
5640 0 : {
5641 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5642 0 : tree _q71 = TREE_OPERAND (_q60, 1);
5643 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || operand_equal_p (_q70, _q30, 0))
5644 : {
5645 0 : {
5646 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q71, _q30 };
5647 0 : tree res = generic_simplify_96 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5648 0 : if (res) return res;
5649 : }
5650 : }
5651 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || operand_equal_p (_q71, _q30, 0))
5652 : {
5653 0 : {
5654 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q70, _q30 };
5655 0 : tree res = generic_simplify_96 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5656 0 : if (res) return res;
5657 : }
5658 : }
5659 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || operand_equal_p (_q70, _q31, 0))
5660 : {
5661 0 : {
5662 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q31, _q30, _q71, _q31 };
5663 0 : tree res = generic_simplify_96 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5664 0 : if (res) return res;
5665 : }
5666 : }
5667 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || operand_equal_p (_q71, _q31, 0))
5668 : {
5669 0 : {
5670 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q31, _q30, _q70, _q31 };
5671 0 : tree res = generic_simplify_96 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5672 0 : if (res) return res;
5673 : }
5674 : }
5675 : break;
5676 : }
5677 : default:;
5678 : }
5679 : break;
5680 : }
5681 : default:;
5682 : }
5683 : break;
5684 : }
5685 59203 : case BIT_XOR_EXPR:
5686 59203 : {
5687 59203 : tree _q30 = TREE_OPERAND (_q20, 0);
5688 59203 : tree _q31 = TREE_OPERAND (_q20, 1);
5689 59203 : switch (TREE_CODE (_p1))
5690 : {
5691 59138 : CASE_CONVERT:
5692 59138 : {
5693 59138 : tree _q60 = TREE_OPERAND (_p1, 0);
5694 59138 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q31, 0))
5695 : {
5696 0 : {
5697 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q31 };
5698 0 : tree res = generic_simplify_164 (loc, type, _p0, _p1, captures);
5699 0 : if (res) return res;
5700 : }
5701 : }
5702 59138 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q30, 0))
5703 : {
5704 0 : {
5705 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q30 };
5706 0 : tree res = generic_simplify_164 (loc, type, _p0, _p1, captures);
5707 0 : if (res) return res;
5708 : }
5709 : }
5710 : break;
5711 : }
5712 59203 : default:;
5713 : }
5714 59203 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q31, 0))
5715 : {
5716 0 : {
5717 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q31 };
5718 0 : tree res = generic_simplify_164 (loc, type, _p0, _p1, captures);
5719 0 : if (res) return res;
5720 : }
5721 : }
5722 59203 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q30, 0))
5723 : {
5724 0 : {
5725 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q30 };
5726 0 : tree res = generic_simplify_164 (loc, type, _p0, _p1, captures);
5727 0 : if (res) return res;
5728 : }
5729 : }
5730 : break;
5731 : }
5732 625196 : default:;
5733 : }
5734 625196 : switch (TREE_CODE (_p1))
5735 : {
5736 621188 : CASE_CONVERT:
5737 621188 : {
5738 621188 : tree _q40 = TREE_OPERAND (_p1, 0);
5739 621188 : switch (TREE_CODE (_q40))
5740 : {
5741 0 : case BIT_XOR_EXPR:
5742 0 : {
5743 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5744 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5745 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
5746 : {
5747 0 : {
5748 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
5749 0 : tree res = generic_simplify_164 (loc, type, _p0, _p1, captures);
5750 0 : if (res) return res;
5751 : }
5752 : }
5753 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
5754 : {
5755 0 : {
5756 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q50, _q20 };
5757 0 : tree res = generic_simplify_164 (loc, type, _p0, _p1, captures);
5758 0 : if (res) return res;
5759 : }
5760 : }
5761 : break;
5762 : }
5763 : default:;
5764 : }
5765 : break;
5766 : }
5767 2 : case BIT_XOR_EXPR:
5768 2 : {
5769 2 : tree _q40 = TREE_OPERAND (_p1, 0);
5770 2 : tree _q41 = TREE_OPERAND (_p1, 1);
5771 2 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _q20, 0))
5772 : {
5773 0 : {
5774 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q20 };
5775 0 : tree res = generic_simplify_164 (loc, type, _p0, _p1, captures);
5776 0 : if (res) return res;
5777 : }
5778 : }
5779 2 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _q20, 0))
5780 : {
5781 0 : {
5782 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q20 };
5783 0 : tree res = generic_simplify_164 (loc, type, _p0, _p1, captures);
5784 0 : if (res) return res;
5785 : }
5786 : }
5787 : break;
5788 : }
5789 : default:;
5790 : }
5791 : break;
5792 : }
5793 977328 : default:;
5794 : }
5795 977328 : switch (TREE_CODE (_p1))
5796 : {
5797 747866 : CASE_CONVERT:
5798 747866 : {
5799 747866 : tree _q30 = TREE_OPERAND (_p1, 0);
5800 747866 : switch (TREE_CODE (_q30))
5801 : {
5802 8 : case BIT_XOR_EXPR:
5803 8 : {
5804 8 : tree _q40 = TREE_OPERAND (_q30, 0);
5805 8 : tree _q41 = TREE_OPERAND (_q30, 1);
5806 8 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _p0, 0))
5807 : {
5808 0 : {
5809 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _p0 };
5810 0 : tree res = generic_simplify_164 (loc, type, _p0, _p1, captures);
5811 0 : if (res) return res;
5812 : }
5813 : }
5814 8 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _p0, 0))
5815 : {
5816 0 : {
5817 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _p0 };
5818 0 : tree res = generic_simplify_164 (loc, type, _p0, _p1, captures);
5819 0 : if (res) return res;
5820 : }
5821 : }
5822 : break;
5823 : }
5824 : default:;
5825 : }
5826 : break;
5827 : }
5828 78 : case BIT_XOR_EXPR:
5829 78 : {
5830 78 : tree _q30 = TREE_OPERAND (_p1, 0);
5831 78 : tree _q31 = TREE_OPERAND (_p1, 1);
5832 78 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || operand_equal_p (_q31, _p0, 0))
5833 : {
5834 0 : {
5835 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
5836 0 : tree res = generic_simplify_164 (loc, type, _p0, _p1, captures);
5837 0 : if (res) return res;
5838 : }
5839 : }
5840 78 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || operand_equal_p (_q30, _p0, 0))
5841 : {
5842 0 : {
5843 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _p0 };
5844 0 : tree res = generic_simplify_164 (loc, type, _p0, _p1, captures);
5845 0 : if (res) return res;
5846 : }
5847 : }
5848 : break;
5849 : }
5850 977328 : default:;
5851 : }
5852 977328 : switch (TREE_CODE (_p0))
5853 : {
5854 625196 : CASE_CONVERT:
5855 625196 : {
5856 625196 : tree _q20 = TREE_OPERAND (_p0, 0);
5857 625196 : switch (TREE_CODE (_q20))
5858 : {
5859 59203 : case BIT_XOR_EXPR:
5860 59203 : {
5861 59203 : tree _q30 = TREE_OPERAND (_q20, 0);
5862 59203 : tree _q31 = TREE_OPERAND (_q20, 1);
5863 59203 : switch (TREE_CODE (_p1))
5864 : {
5865 59138 : CASE_CONVERT:
5866 59138 : {
5867 59138 : tree _q60 = TREE_OPERAND (_p1, 0);
5868 59138 : switch (TREE_CODE (_q60))
5869 : {
5870 0 : case BIT_XOR_EXPR:
5871 0 : {
5872 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5873 0 : tree _q71 = TREE_OPERAND (_q60, 1);
5874 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
5875 : {
5876 0 : {
5877 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q71 };
5878 0 : tree res = generic_simplify_169 (loc, type, _p0, _p1, captures);
5879 0 : if (res) return res;
5880 : }
5881 : }
5882 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
5883 : {
5884 0 : {
5885 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q70 };
5886 0 : tree res = generic_simplify_169 (loc, type, _p0, _p1, captures);
5887 0 : if (res) return res;
5888 : }
5889 : }
5890 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
5891 : {
5892 0 : {
5893 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q71 };
5894 0 : tree res = generic_simplify_169 (loc, type, _p0, _p1, captures);
5895 0 : if (res) return res;
5896 : }
5897 : }
5898 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
5899 : {
5900 0 : {
5901 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q70 };
5902 0 : tree res = generic_simplify_169 (loc, type, _p0, _p1, captures);
5903 0 : if (res) return res;
5904 : }
5905 : }
5906 : break;
5907 : }
5908 : default:;
5909 : }
5910 : break;
5911 : }
5912 0 : case BIT_XOR_EXPR:
5913 0 : {
5914 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5915 0 : tree _q61 = TREE_OPERAND (_p1, 1);
5916 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
5917 : {
5918 0 : {
5919 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q61 };
5920 0 : tree res = generic_simplify_169 (loc, type, _p0, _p1, captures);
5921 0 : if (res) return res;
5922 : }
5923 : }
5924 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
5925 : {
5926 0 : {
5927 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q60 };
5928 0 : tree res = generic_simplify_169 (loc, type, _p0, _p1, captures);
5929 0 : if (res) return res;
5930 : }
5931 : }
5932 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
5933 : {
5934 0 : {
5935 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q61 };
5936 0 : tree res = generic_simplify_169 (loc, type, _p0, _p1, captures);
5937 0 : if (res) return res;
5938 : }
5939 : }
5940 0 : if ((_q61 == _q31 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q31, 0) && types_match (_q61, _q31)))
5941 : {
5942 0 : {
5943 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q60 };
5944 0 : tree res = generic_simplify_169 (loc, type, _p0, _p1, captures);
5945 0 : if (res) return res;
5946 : }
5947 : }
5948 : break;
5949 : }
5950 : default:;
5951 : }
5952 : break;
5953 : }
5954 625196 : default:;
5955 : }
5956 625196 : switch (TREE_CODE (_p1))
5957 : {
5958 621188 : CASE_CONVERT:
5959 621188 : {
5960 621188 : tree _q40 = TREE_OPERAND (_p1, 0);
5961 621188 : {
5962 621188 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
5963 621188 : tree res = generic_simplify_103 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5964 621188 : if (res) return res;
5965 : }
5966 535565 : break;
5967 : }
5968 539573 : default:;
5969 : }
5970 539573 : {
5971 539573 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
5972 539573 : tree res = generic_simplify_104 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5973 539573 : if (res) return res;
5974 : }
5975 539465 : break;
5976 : }
5977 3896 : case BIT_XOR_EXPR:
5978 3896 : {
5979 3896 : tree _q20 = TREE_OPERAND (_p0, 0);
5980 3896 : tree _q21 = TREE_OPERAND (_p0, 1);
5981 3896 : switch (TREE_CODE (_p1))
5982 : {
5983 198 : CASE_CONVERT:
5984 198 : {
5985 198 : tree _q50 = TREE_OPERAND (_p1, 0);
5986 198 : switch (TREE_CODE (_q50))
5987 : {
5988 0 : case BIT_XOR_EXPR:
5989 0 : {
5990 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5991 0 : tree _q61 = TREE_OPERAND (_q50, 1);
5992 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
5993 : {
5994 0 : {
5995 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q61 };
5996 0 : tree res = generic_simplify_169 (loc, type, _p0, _p1, captures);
5997 0 : if (res) return res;
5998 : }
5999 : }
6000 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
6001 : {
6002 0 : {
6003 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q60 };
6004 0 : tree res = generic_simplify_169 (loc, type, _p0, _p1, captures);
6005 0 : if (res) return res;
6006 : }
6007 : }
6008 0 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
6009 : {
6010 0 : {
6011 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q61 };
6012 0 : tree res = generic_simplify_169 (loc, type, _p0, _p1, captures);
6013 0 : if (res) return res;
6014 : }
6015 : }
6016 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
6017 : {
6018 0 : {
6019 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q60 };
6020 0 : tree res = generic_simplify_169 (loc, type, _p0, _p1, captures);
6021 0 : if (res) return res;
6022 : }
6023 : }
6024 : break;
6025 : }
6026 : default:;
6027 : }
6028 : break;
6029 : }
6030 10 : case BIT_XOR_EXPR:
6031 10 : {
6032 10 : tree _q50 = TREE_OPERAND (_p1, 0);
6033 10 : tree _q51 = TREE_OPERAND (_p1, 1);
6034 10 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6035 : {
6036 0 : {
6037 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
6038 0 : tree res = generic_simplify_169 (loc, type, _p0, _p1, captures);
6039 0 : if (res) return res;
6040 : }
6041 : }
6042 10 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6043 : {
6044 0 : {
6045 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
6046 0 : tree res = generic_simplify_169 (loc, type, _p0, _p1, captures);
6047 0 : if (res) return res;
6048 : }
6049 : }
6050 10 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6051 : {
6052 0 : {
6053 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
6054 0 : tree res = generic_simplify_169 (loc, type, _p0, _p1, captures);
6055 0 : if (res) return res;
6056 : }
6057 : }
6058 10 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6059 : {
6060 0 : {
6061 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
6062 0 : tree res = generic_simplify_169 (loc, type, _p0, _p1, captures);
6063 0 : if (res) return res;
6064 : }
6065 : }
6066 : break;
6067 : }
6068 3896 : default:;
6069 : }
6070 3896 : if (CONSTANT_CLASS_P (_q21))
6071 : {
6072 49 : if (CONSTANT_CLASS_P (_p1))
6073 : {
6074 30 : {
6075 30 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6076 30 : tree res = generic_simplify_119 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
6077 30 : if (res) return res;
6078 : }
6079 : }
6080 : }
6081 : break;
6082 : }
6083 70 : case COND_EXPR:
6084 70 : {
6085 70 : tree _q20 = TREE_OPERAND (_p0, 0);
6086 70 : tree _q21 = TREE_OPERAND (_p0, 1);
6087 70 : tree _q22 = TREE_OPERAND (_p0, 2);
6088 70 : if (integer_zerop (_q22))
6089 : {
6090 70 : switch (TREE_CODE (_p1))
6091 : {
6092 4 : case COND_EXPR:
6093 4 : {
6094 4 : tree _q60 = TREE_OPERAND (_p1, 0);
6095 4 : tree _q61 = TREE_OPERAND (_p1, 1);
6096 4 : tree _q62 = TREE_OPERAND (_p1, 2);
6097 4 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6098 : {
6099 0 : if (integer_zerop (_q61))
6100 : {
6101 0 : {
6102 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q62 };
6103 0 : const enum tree_code op = BIT_XOR_EXPR;
6104 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1278;
6105 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1278;
6106 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1278;
6107 0 : {
6108 0 : tree res_op0;
6109 0 : res_op0 = captures[1];
6110 0 : tree res_op1;
6111 0 : res_op1 = captures[2];
6112 0 : tree res_op2;
6113 0 : res_op2 = captures[4];
6114 0 : tree _r;
6115 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
6116 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 871, __FILE__, __LINE__, true);
6117 0 : return _r;
6118 : }
6119 0 : next_after_fail1278:;
6120 : }
6121 : }
6122 : }
6123 : break;
6124 : }
6125 : default:;
6126 : }
6127 : }
6128 70 : if (integer_zerop (_q21))
6129 : {
6130 0 : switch (TREE_CODE (_p1))
6131 : {
6132 0 : case COND_EXPR:
6133 0 : {
6134 0 : tree _q60 = TREE_OPERAND (_p1, 0);
6135 0 : tree _q61 = TREE_OPERAND (_p1, 1);
6136 0 : tree _q62 = TREE_OPERAND (_p1, 2);
6137 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6138 : {
6139 0 : if (integer_zerop (_q62))
6140 : {
6141 0 : {
6142 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q20, _q61, _p0, _q22 };
6143 0 : const enum tree_code op = BIT_XOR_EXPR;
6144 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1279;
6145 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1279;
6146 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1279;
6147 0 : {
6148 0 : tree res_op0;
6149 0 : res_op0 = captures[1];
6150 0 : tree res_op1;
6151 0 : res_op1 = captures[2];
6152 0 : tree res_op2;
6153 0 : res_op2 = captures[4];
6154 0 : tree _r;
6155 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
6156 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 871, __FILE__, __LINE__, true);
6157 0 : return _r;
6158 : }
6159 0 : next_after_fail1279:;
6160 : }
6161 : }
6162 : }
6163 : break;
6164 : }
6165 : default:;
6166 : }
6167 : }
6168 70 : switch (TREE_CODE (_q20))
6169 : {
6170 0 : case LT_EXPR:
6171 0 : {
6172 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6173 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6174 0 : if (zerop (_q22))
6175 : {
6176 0 : switch (TREE_CODE (_p1))
6177 : {
6178 0 : case COND_EXPR:
6179 0 : {
6180 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6181 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6182 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6183 0 : switch (TREE_CODE (_q80))
6184 : {
6185 0 : case GE_EXPR:
6186 0 : {
6187 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6188 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6189 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6190 : {
6191 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6192 : {
6193 0 : if (zerop (_q82))
6194 : {
6195 0 : {
6196 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6197 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LT_EXPR, GE_EXPR);
6198 0 : if (res) return res;
6199 : }
6200 : }
6201 : }
6202 : }
6203 : break;
6204 : }
6205 : default:;
6206 : }
6207 : break;
6208 : }
6209 : default:;
6210 : }
6211 : }
6212 : break;
6213 : }
6214 38 : case LE_EXPR:
6215 38 : {
6216 38 : tree _q30 = TREE_OPERAND (_q20, 0);
6217 38 : tree _q31 = TREE_OPERAND (_q20, 1);
6218 38 : if (zerop (_q22))
6219 : {
6220 38 : switch (TREE_CODE (_p1))
6221 : {
6222 0 : case COND_EXPR:
6223 0 : {
6224 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6225 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6226 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6227 0 : switch (TREE_CODE (_q80))
6228 : {
6229 0 : case GT_EXPR:
6230 0 : {
6231 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6232 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6233 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6234 : {
6235 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6236 : {
6237 0 : if (zerop (_q82))
6238 : {
6239 0 : {
6240 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6241 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LE_EXPR, GT_EXPR);
6242 0 : if (res) return res;
6243 : }
6244 : }
6245 : }
6246 : }
6247 : break;
6248 : }
6249 : default:;
6250 : }
6251 : break;
6252 : }
6253 : default:;
6254 : }
6255 : }
6256 : break;
6257 : }
6258 0 : case EQ_EXPR:
6259 0 : {
6260 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6261 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6262 0 : if (zerop (_q22))
6263 : {
6264 0 : switch (TREE_CODE (_p1))
6265 : {
6266 0 : case COND_EXPR:
6267 0 : {
6268 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6269 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6270 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6271 0 : switch (TREE_CODE (_q80))
6272 : {
6273 0 : case NE_EXPR:
6274 0 : {
6275 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6276 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6277 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6278 : {
6279 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6280 : {
6281 0 : if (zerop (_q82))
6282 : {
6283 0 : {
6284 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6285 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, EQ_EXPR, NE_EXPR);
6286 0 : if (res) return res;
6287 : }
6288 : }
6289 : }
6290 : }
6291 : break;
6292 : }
6293 : default:;
6294 : }
6295 : break;
6296 : }
6297 : default:;
6298 : }
6299 : }
6300 : break;
6301 : }
6302 32 : case NE_EXPR:
6303 32 : {
6304 32 : tree _q30 = TREE_OPERAND (_q20, 0);
6305 32 : tree _q31 = TREE_OPERAND (_q20, 1);
6306 32 : if (zerop (_q22))
6307 : {
6308 32 : switch (TREE_CODE (_p1))
6309 : {
6310 4 : case COND_EXPR:
6311 4 : {
6312 4 : tree _q80 = TREE_OPERAND (_p1, 0);
6313 4 : tree _q81 = TREE_OPERAND (_p1, 1);
6314 4 : tree _q82 = TREE_OPERAND (_p1, 2);
6315 4 : switch (TREE_CODE (_q80))
6316 : {
6317 0 : case EQ_EXPR:
6318 0 : {
6319 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6320 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6321 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6322 : {
6323 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6324 : {
6325 0 : if (zerop (_q82))
6326 : {
6327 0 : {
6328 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6329 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, NE_EXPR, EQ_EXPR);
6330 0 : if (res) return res;
6331 : }
6332 : }
6333 : }
6334 : }
6335 : break;
6336 : }
6337 : default:;
6338 : }
6339 : break;
6340 : }
6341 : default:;
6342 : }
6343 : }
6344 : break;
6345 : }
6346 0 : case GE_EXPR:
6347 0 : {
6348 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6349 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6350 0 : if (zerop (_q22))
6351 : {
6352 0 : switch (TREE_CODE (_p1))
6353 : {
6354 0 : case COND_EXPR:
6355 0 : {
6356 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6357 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6358 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6359 0 : switch (TREE_CODE (_q80))
6360 : {
6361 0 : case LT_EXPR:
6362 0 : {
6363 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6364 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6365 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6366 : {
6367 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6368 : {
6369 0 : if (zerop (_q82))
6370 : {
6371 0 : {
6372 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6373 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GE_EXPR, LT_EXPR);
6374 0 : if (res) return res;
6375 : }
6376 : }
6377 : }
6378 : }
6379 : break;
6380 : }
6381 : default:;
6382 : }
6383 : break;
6384 : }
6385 : default:;
6386 : }
6387 : }
6388 : break;
6389 : }
6390 0 : case GT_EXPR:
6391 0 : {
6392 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6393 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6394 0 : if (zerop (_q22))
6395 : {
6396 0 : switch (TREE_CODE (_p1))
6397 : {
6398 0 : case COND_EXPR:
6399 0 : {
6400 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6401 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6402 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6403 0 : switch (TREE_CODE (_q80))
6404 : {
6405 0 : case LE_EXPR:
6406 0 : {
6407 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6408 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6409 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6410 : {
6411 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6412 : {
6413 0 : if (zerop (_q82))
6414 : {
6415 0 : {
6416 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6417 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GT_EXPR, LE_EXPR);
6418 0 : if (res) return res;
6419 : }
6420 : }
6421 : }
6422 : }
6423 : break;
6424 : }
6425 : default:;
6426 : }
6427 : break;
6428 : }
6429 : default:;
6430 : }
6431 : }
6432 : break;
6433 : }
6434 0 : case UNORDERED_EXPR:
6435 0 : {
6436 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6437 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6438 0 : if (zerop (_q22))
6439 : {
6440 0 : switch (TREE_CODE (_p1))
6441 : {
6442 0 : case COND_EXPR:
6443 0 : {
6444 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6445 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6446 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6447 0 : switch (TREE_CODE (_q80))
6448 : {
6449 0 : case ORDERED_EXPR:
6450 0 : {
6451 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6452 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6453 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6454 : {
6455 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6456 : {
6457 0 : if (zerop (_q82))
6458 : {
6459 0 : {
6460 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6461 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNORDERED_EXPR, ORDERED_EXPR);
6462 0 : if (res) return res;
6463 : }
6464 : }
6465 : }
6466 : }
6467 : break;
6468 : }
6469 : default:;
6470 : }
6471 : break;
6472 : }
6473 : default:;
6474 : }
6475 : }
6476 : break;
6477 : }
6478 0 : case ORDERED_EXPR:
6479 0 : {
6480 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6481 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6482 0 : if (zerop (_q22))
6483 : {
6484 0 : switch (TREE_CODE (_p1))
6485 : {
6486 0 : case COND_EXPR:
6487 0 : {
6488 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6489 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6490 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6491 0 : switch (TREE_CODE (_q80))
6492 : {
6493 0 : case UNORDERED_EXPR:
6494 0 : {
6495 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6496 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6497 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6498 : {
6499 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6500 : {
6501 0 : if (zerop (_q82))
6502 : {
6503 0 : {
6504 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6505 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, ORDERED_EXPR, UNORDERED_EXPR);
6506 0 : if (res) return res;
6507 : }
6508 : }
6509 : }
6510 : }
6511 : break;
6512 : }
6513 : default:;
6514 : }
6515 : break;
6516 : }
6517 : default:;
6518 : }
6519 : }
6520 : break;
6521 : }
6522 0 : case UNLT_EXPR:
6523 0 : {
6524 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6525 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6526 0 : if (zerop (_q22))
6527 : {
6528 0 : switch (TREE_CODE (_p1))
6529 : {
6530 0 : case COND_EXPR:
6531 0 : {
6532 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6533 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6534 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6535 0 : switch (TREE_CODE (_q80))
6536 : {
6537 0 : case GE_EXPR:
6538 0 : {
6539 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6540 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6541 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6542 : {
6543 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6544 : {
6545 0 : if (zerop (_q82))
6546 : {
6547 0 : {
6548 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6549 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLT_EXPR, GE_EXPR);
6550 0 : if (res) return res;
6551 : }
6552 : }
6553 : }
6554 : }
6555 : break;
6556 : }
6557 : default:;
6558 : }
6559 : break;
6560 : }
6561 : default:;
6562 : }
6563 : }
6564 : break;
6565 : }
6566 0 : case UNLE_EXPR:
6567 0 : {
6568 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6569 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6570 0 : if (zerop (_q22))
6571 : {
6572 0 : switch (TREE_CODE (_p1))
6573 : {
6574 0 : case COND_EXPR:
6575 0 : {
6576 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6577 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6578 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6579 0 : switch (TREE_CODE (_q80))
6580 : {
6581 0 : case GT_EXPR:
6582 0 : {
6583 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6584 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6585 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6586 : {
6587 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6588 : {
6589 0 : if (zerop (_q82))
6590 : {
6591 0 : {
6592 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6593 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLE_EXPR, GT_EXPR);
6594 0 : if (res) return res;
6595 : }
6596 : }
6597 : }
6598 : }
6599 : break;
6600 : }
6601 : default:;
6602 : }
6603 : break;
6604 : }
6605 : default:;
6606 : }
6607 : }
6608 : break;
6609 : }
6610 0 : case UNGT_EXPR:
6611 0 : {
6612 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6613 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6614 0 : if (zerop (_q22))
6615 : {
6616 0 : switch (TREE_CODE (_p1))
6617 : {
6618 0 : case COND_EXPR:
6619 0 : {
6620 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6621 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6622 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6623 0 : switch (TREE_CODE (_q80))
6624 : {
6625 0 : case LE_EXPR:
6626 0 : {
6627 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6628 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6629 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6630 : {
6631 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6632 : {
6633 0 : if (zerop (_q82))
6634 : {
6635 0 : {
6636 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6637 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGT_EXPR, LE_EXPR);
6638 0 : if (res) return res;
6639 : }
6640 : }
6641 : }
6642 : }
6643 : break;
6644 : }
6645 : default:;
6646 : }
6647 : break;
6648 : }
6649 : default:;
6650 : }
6651 : }
6652 : break;
6653 : }
6654 0 : case UNGE_EXPR:
6655 0 : {
6656 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6657 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6658 0 : if (zerop (_q22))
6659 : {
6660 0 : switch (TREE_CODE (_p1))
6661 : {
6662 0 : case COND_EXPR:
6663 0 : {
6664 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6665 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6666 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6667 0 : switch (TREE_CODE (_q80))
6668 : {
6669 0 : case LT_EXPR:
6670 0 : {
6671 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6672 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6673 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6674 : {
6675 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6676 : {
6677 0 : if (zerop (_q82))
6678 : {
6679 0 : {
6680 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6681 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGE_EXPR, LT_EXPR);
6682 0 : if (res) return res;
6683 : }
6684 : }
6685 : }
6686 : }
6687 : break;
6688 : }
6689 : default:;
6690 : }
6691 : break;
6692 : }
6693 : default:;
6694 : }
6695 : }
6696 : break;
6697 : }
6698 0 : case UNEQ_EXPR:
6699 0 : {
6700 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6701 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6702 0 : if (zerop (_q22))
6703 : {
6704 0 : switch (TREE_CODE (_p1))
6705 : {
6706 0 : case COND_EXPR:
6707 0 : {
6708 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6709 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6710 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6711 0 : switch (TREE_CODE (_q80))
6712 : {
6713 0 : case LTGT_EXPR:
6714 0 : {
6715 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6716 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6717 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6718 : {
6719 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6720 : {
6721 0 : if (zerop (_q82))
6722 : {
6723 0 : {
6724 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6725 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNEQ_EXPR, LTGT_EXPR);
6726 0 : if (res) return res;
6727 : }
6728 : }
6729 : }
6730 : }
6731 : break;
6732 : }
6733 : default:;
6734 : }
6735 : break;
6736 : }
6737 : default:;
6738 : }
6739 : }
6740 : break;
6741 : }
6742 0 : case LTGT_EXPR:
6743 0 : {
6744 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6745 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6746 0 : if (zerop (_q22))
6747 : {
6748 0 : switch (TREE_CODE (_p1))
6749 : {
6750 0 : case COND_EXPR:
6751 0 : {
6752 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6753 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6754 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6755 0 : switch (TREE_CODE (_q80))
6756 : {
6757 0 : case UNEQ_EXPR:
6758 0 : {
6759 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6760 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6761 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6762 : {
6763 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6764 : {
6765 0 : if (zerop (_q82))
6766 : {
6767 0 : {
6768 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6769 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LTGT_EXPR, UNEQ_EXPR);
6770 0 : if (res) return res;
6771 : }
6772 : }
6773 : }
6774 : }
6775 : break;
6776 : }
6777 : default:;
6778 : }
6779 : break;
6780 : }
6781 : default:;
6782 : }
6783 : }
6784 : break;
6785 : }
6786 : default:;
6787 : }
6788 : break;
6789 : }
6790 1 : case VEC_COND_EXPR:
6791 1 : {
6792 1 : tree _q20 = TREE_OPERAND (_p0, 0);
6793 1 : tree _q21 = TREE_OPERAND (_p0, 1);
6794 1 : tree _q22 = TREE_OPERAND (_p0, 2);
6795 1 : if (integer_zerop (_q22))
6796 : {
6797 1 : switch (TREE_CODE (_p1))
6798 : {
6799 0 : case VEC_COND_EXPR:
6800 0 : {
6801 0 : tree _q60 = TREE_OPERAND (_p1, 0);
6802 0 : tree _q61 = TREE_OPERAND (_p1, 1);
6803 0 : tree _q62 = TREE_OPERAND (_p1, 2);
6804 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6805 : {
6806 0 : if (integer_zerop (_q61))
6807 : {
6808 0 : {
6809 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q62 };
6810 0 : const enum tree_code op = BIT_XOR_EXPR;
6811 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1280;
6812 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1280;
6813 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1280;
6814 0 : {
6815 0 : tree res_op0;
6816 0 : res_op0 = captures[1];
6817 0 : tree res_op1;
6818 0 : res_op1 = captures[2];
6819 0 : tree res_op2;
6820 0 : res_op2 = captures[4];
6821 0 : tree _r;
6822 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
6823 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 871, __FILE__, __LINE__, true);
6824 0 : return _r;
6825 : }
6826 0 : next_after_fail1280:;
6827 : }
6828 : }
6829 : }
6830 : break;
6831 : }
6832 : default:;
6833 : }
6834 : }
6835 1 : if (integer_zerop (_q21))
6836 : {
6837 0 : switch (TREE_CODE (_p1))
6838 : {
6839 0 : case VEC_COND_EXPR:
6840 0 : {
6841 0 : tree _q60 = TREE_OPERAND (_p1, 0);
6842 0 : tree _q61 = TREE_OPERAND (_p1, 1);
6843 0 : tree _q62 = TREE_OPERAND (_p1, 2);
6844 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6845 : {
6846 0 : if (integer_zerop (_q62))
6847 : {
6848 0 : {
6849 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q20, _q61, _p0, _q22 };
6850 0 : const enum tree_code op = BIT_XOR_EXPR;
6851 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1281;
6852 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1281;
6853 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1281;
6854 0 : {
6855 0 : tree res_op0;
6856 0 : res_op0 = captures[1];
6857 0 : tree res_op1;
6858 0 : res_op1 = captures[2];
6859 0 : tree res_op2;
6860 0 : res_op2 = captures[4];
6861 0 : tree _r;
6862 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
6863 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 871, __FILE__, __LINE__, true);
6864 0 : return _r;
6865 : }
6866 0 : next_after_fail1281:;
6867 : }
6868 : }
6869 : }
6870 : break;
6871 : }
6872 : default:;
6873 : }
6874 : }
6875 1 : switch (TREE_CODE (_q20))
6876 : {
6877 0 : case LT_EXPR:
6878 0 : {
6879 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6880 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6881 0 : if (integer_zerop (_q22))
6882 : {
6883 0 : switch (TREE_CODE (_p1))
6884 : {
6885 0 : case VEC_COND_EXPR:
6886 0 : {
6887 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6888 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6889 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6890 0 : switch (TREE_CODE (_q80))
6891 : {
6892 0 : case GE_EXPR:
6893 0 : {
6894 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6895 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6896 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6897 : {
6898 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6899 : {
6900 0 : if (integer_zerop (_q82))
6901 : {
6902 0 : {
6903 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
6904 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LT_EXPR, GE_EXPR);
6905 0 : if (res) return res;
6906 : }
6907 : }
6908 : }
6909 : }
6910 : break;
6911 : }
6912 : default:;
6913 : }
6914 : break;
6915 : }
6916 : default:;
6917 : }
6918 : }
6919 : break;
6920 : }
6921 0 : case LE_EXPR:
6922 0 : {
6923 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6924 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6925 0 : if (integer_zerop (_q22))
6926 : {
6927 0 : switch (TREE_CODE (_p1))
6928 : {
6929 0 : case VEC_COND_EXPR:
6930 0 : {
6931 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6932 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6933 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6934 0 : switch (TREE_CODE (_q80))
6935 : {
6936 0 : case GT_EXPR:
6937 0 : {
6938 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6939 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6940 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6941 : {
6942 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6943 : {
6944 0 : if (integer_zerop (_q82))
6945 : {
6946 0 : {
6947 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
6948 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LE_EXPR, GT_EXPR);
6949 0 : if (res) return res;
6950 : }
6951 : }
6952 : }
6953 : }
6954 : break;
6955 : }
6956 : default:;
6957 : }
6958 : break;
6959 : }
6960 : default:;
6961 : }
6962 : }
6963 : break;
6964 : }
6965 0 : case EQ_EXPR:
6966 0 : {
6967 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6968 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6969 0 : if (integer_zerop (_q22))
6970 : {
6971 0 : switch (TREE_CODE (_p1))
6972 : {
6973 0 : case VEC_COND_EXPR:
6974 0 : {
6975 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6976 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6977 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6978 0 : switch (TREE_CODE (_q80))
6979 : {
6980 0 : case NE_EXPR:
6981 0 : {
6982 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6983 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6984 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6985 : {
6986 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6987 : {
6988 0 : if (integer_zerop (_q82))
6989 : {
6990 0 : {
6991 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
6992 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, EQ_EXPR, NE_EXPR);
6993 0 : if (res) return res;
6994 : }
6995 : }
6996 : }
6997 : }
6998 : break;
6999 : }
7000 : default:;
7001 : }
7002 : break;
7003 : }
7004 : default:;
7005 : }
7006 : }
7007 : break;
7008 : }
7009 1 : case NE_EXPR:
7010 1 : {
7011 1 : tree _q30 = TREE_OPERAND (_q20, 0);
7012 1 : tree _q31 = TREE_OPERAND (_q20, 1);
7013 1 : if (integer_zerop (_q22))
7014 : {
7015 1 : switch (TREE_CODE (_p1))
7016 : {
7017 0 : case VEC_COND_EXPR:
7018 0 : {
7019 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7020 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7021 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7022 0 : switch (TREE_CODE (_q80))
7023 : {
7024 0 : case EQ_EXPR:
7025 0 : {
7026 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7027 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7028 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7029 : {
7030 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7031 : {
7032 0 : if (integer_zerop (_q82))
7033 : {
7034 0 : {
7035 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7036 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, NE_EXPR, EQ_EXPR);
7037 0 : if (res) return res;
7038 : }
7039 : }
7040 : }
7041 : }
7042 : break;
7043 : }
7044 : default:;
7045 : }
7046 : break;
7047 : }
7048 : default:;
7049 : }
7050 : }
7051 : break;
7052 : }
7053 0 : case GE_EXPR:
7054 0 : {
7055 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7056 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7057 0 : if (integer_zerop (_q22))
7058 : {
7059 0 : switch (TREE_CODE (_p1))
7060 : {
7061 0 : case VEC_COND_EXPR:
7062 0 : {
7063 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7064 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7065 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7066 0 : switch (TREE_CODE (_q80))
7067 : {
7068 0 : case LT_EXPR:
7069 0 : {
7070 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7071 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7072 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7073 : {
7074 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7075 : {
7076 0 : if (integer_zerop (_q82))
7077 : {
7078 0 : {
7079 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7080 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GE_EXPR, LT_EXPR);
7081 0 : if (res) return res;
7082 : }
7083 : }
7084 : }
7085 : }
7086 : break;
7087 : }
7088 : default:;
7089 : }
7090 : break;
7091 : }
7092 : default:;
7093 : }
7094 : }
7095 : break;
7096 : }
7097 0 : case GT_EXPR:
7098 0 : {
7099 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7100 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7101 0 : if (integer_zerop (_q22))
7102 : {
7103 0 : switch (TREE_CODE (_p1))
7104 : {
7105 0 : case VEC_COND_EXPR:
7106 0 : {
7107 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7108 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7109 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7110 0 : switch (TREE_CODE (_q80))
7111 : {
7112 0 : case LE_EXPR:
7113 0 : {
7114 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7115 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7116 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7117 : {
7118 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7119 : {
7120 0 : if (integer_zerop (_q82))
7121 : {
7122 0 : {
7123 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7124 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GT_EXPR, LE_EXPR);
7125 0 : if (res) return res;
7126 : }
7127 : }
7128 : }
7129 : }
7130 : break;
7131 : }
7132 : default:;
7133 : }
7134 : break;
7135 : }
7136 : default:;
7137 : }
7138 : }
7139 : break;
7140 : }
7141 0 : case UNORDERED_EXPR:
7142 0 : {
7143 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7144 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7145 0 : if (integer_zerop (_q22))
7146 : {
7147 0 : switch (TREE_CODE (_p1))
7148 : {
7149 0 : case VEC_COND_EXPR:
7150 0 : {
7151 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7152 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7153 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7154 0 : switch (TREE_CODE (_q80))
7155 : {
7156 0 : case ORDERED_EXPR:
7157 0 : {
7158 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7159 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7160 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7161 : {
7162 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7163 : {
7164 0 : if (integer_zerop (_q82))
7165 : {
7166 0 : {
7167 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7168 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNORDERED_EXPR, ORDERED_EXPR);
7169 0 : if (res) return res;
7170 : }
7171 : }
7172 : }
7173 : }
7174 : break;
7175 : }
7176 : default:;
7177 : }
7178 : break;
7179 : }
7180 : default:;
7181 : }
7182 : }
7183 : break;
7184 : }
7185 0 : case ORDERED_EXPR:
7186 0 : {
7187 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7188 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7189 0 : if (integer_zerop (_q22))
7190 : {
7191 0 : switch (TREE_CODE (_p1))
7192 : {
7193 0 : case VEC_COND_EXPR:
7194 0 : {
7195 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7196 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7197 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7198 0 : switch (TREE_CODE (_q80))
7199 : {
7200 0 : case UNORDERED_EXPR:
7201 0 : {
7202 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7203 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7204 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7205 : {
7206 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7207 : {
7208 0 : if (integer_zerop (_q82))
7209 : {
7210 0 : {
7211 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7212 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, ORDERED_EXPR, UNORDERED_EXPR);
7213 0 : if (res) return res;
7214 : }
7215 : }
7216 : }
7217 : }
7218 : break;
7219 : }
7220 : default:;
7221 : }
7222 : break;
7223 : }
7224 : default:;
7225 : }
7226 : }
7227 : break;
7228 : }
7229 0 : case UNLT_EXPR:
7230 0 : {
7231 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7232 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7233 0 : if (integer_zerop (_q22))
7234 : {
7235 0 : switch (TREE_CODE (_p1))
7236 : {
7237 0 : case VEC_COND_EXPR:
7238 0 : {
7239 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7240 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7241 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7242 0 : switch (TREE_CODE (_q80))
7243 : {
7244 0 : case GE_EXPR:
7245 0 : {
7246 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7247 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7248 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7249 : {
7250 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7251 : {
7252 0 : if (integer_zerop (_q82))
7253 : {
7254 0 : {
7255 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7256 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLT_EXPR, GE_EXPR);
7257 0 : if (res) return res;
7258 : }
7259 : }
7260 : }
7261 : }
7262 : break;
7263 : }
7264 : default:;
7265 : }
7266 : break;
7267 : }
7268 : default:;
7269 : }
7270 : }
7271 : break;
7272 : }
7273 0 : case UNLE_EXPR:
7274 0 : {
7275 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7276 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7277 0 : if (integer_zerop (_q22))
7278 : {
7279 0 : switch (TREE_CODE (_p1))
7280 : {
7281 0 : case VEC_COND_EXPR:
7282 0 : {
7283 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7284 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7285 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7286 0 : switch (TREE_CODE (_q80))
7287 : {
7288 0 : case GT_EXPR:
7289 0 : {
7290 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7291 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7292 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7293 : {
7294 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7295 : {
7296 0 : if (integer_zerop (_q82))
7297 : {
7298 0 : {
7299 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7300 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLE_EXPR, GT_EXPR);
7301 0 : if (res) return res;
7302 : }
7303 : }
7304 : }
7305 : }
7306 : break;
7307 : }
7308 : default:;
7309 : }
7310 : break;
7311 : }
7312 : default:;
7313 : }
7314 : }
7315 : break;
7316 : }
7317 0 : case UNGT_EXPR:
7318 0 : {
7319 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7320 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7321 0 : if (integer_zerop (_q22))
7322 : {
7323 0 : switch (TREE_CODE (_p1))
7324 : {
7325 0 : case VEC_COND_EXPR:
7326 0 : {
7327 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7328 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7329 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7330 0 : switch (TREE_CODE (_q80))
7331 : {
7332 0 : case LE_EXPR:
7333 0 : {
7334 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7335 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7336 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7337 : {
7338 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7339 : {
7340 0 : if (integer_zerop (_q82))
7341 : {
7342 0 : {
7343 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7344 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGT_EXPR, LE_EXPR);
7345 0 : if (res) return res;
7346 : }
7347 : }
7348 : }
7349 : }
7350 : break;
7351 : }
7352 : default:;
7353 : }
7354 : break;
7355 : }
7356 : default:;
7357 : }
7358 : }
7359 : break;
7360 : }
7361 0 : case UNGE_EXPR:
7362 0 : {
7363 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7364 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7365 0 : if (integer_zerop (_q22))
7366 : {
7367 0 : switch (TREE_CODE (_p1))
7368 : {
7369 0 : case VEC_COND_EXPR:
7370 0 : {
7371 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7372 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7373 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7374 0 : switch (TREE_CODE (_q80))
7375 : {
7376 0 : case LT_EXPR:
7377 0 : {
7378 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7379 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7380 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7381 : {
7382 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7383 : {
7384 0 : if (integer_zerop (_q82))
7385 : {
7386 0 : {
7387 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7388 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGE_EXPR, LT_EXPR);
7389 0 : if (res) return res;
7390 : }
7391 : }
7392 : }
7393 : }
7394 : break;
7395 : }
7396 : default:;
7397 : }
7398 : break;
7399 : }
7400 : default:;
7401 : }
7402 : }
7403 : break;
7404 : }
7405 0 : case UNEQ_EXPR:
7406 0 : {
7407 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7408 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7409 0 : if (integer_zerop (_q22))
7410 : {
7411 0 : switch (TREE_CODE (_p1))
7412 : {
7413 0 : case VEC_COND_EXPR:
7414 0 : {
7415 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7416 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7417 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7418 0 : switch (TREE_CODE (_q80))
7419 : {
7420 0 : case LTGT_EXPR:
7421 0 : {
7422 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7423 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7424 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7425 : {
7426 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7427 : {
7428 0 : if (integer_zerop (_q82))
7429 : {
7430 0 : {
7431 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7432 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNEQ_EXPR, LTGT_EXPR);
7433 0 : if (res) return res;
7434 : }
7435 : }
7436 : }
7437 : }
7438 : break;
7439 : }
7440 : default:;
7441 : }
7442 : break;
7443 : }
7444 : default:;
7445 : }
7446 : }
7447 : break;
7448 : }
7449 0 : case LTGT_EXPR:
7450 0 : {
7451 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7452 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7453 0 : if (integer_zerop (_q22))
7454 : {
7455 0 : switch (TREE_CODE (_p1))
7456 : {
7457 0 : case VEC_COND_EXPR:
7458 0 : {
7459 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7460 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7461 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7462 0 : switch (TREE_CODE (_q80))
7463 : {
7464 0 : case UNEQ_EXPR:
7465 0 : {
7466 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7467 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7468 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7469 : {
7470 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7471 : {
7472 0 : if (integer_zerop (_q82))
7473 : {
7474 0 : {
7475 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7476 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LTGT_EXPR, UNEQ_EXPR);
7477 0 : if (res) return res;
7478 : }
7479 : }
7480 : }
7481 : }
7482 : break;
7483 : }
7484 : default:;
7485 : }
7486 : break;
7487 : }
7488 : default:;
7489 : }
7490 : }
7491 : break;
7492 : }
7493 : default:;
7494 : }
7495 : break;
7496 : }
7497 2553 : case BIT_AND_EXPR:
7498 2553 : {
7499 2553 : tree _q20 = TREE_OPERAND (_p0, 0);
7500 2553 : tree _q21 = TREE_OPERAND (_p0, 1);
7501 2553 : if (tree_truth_valued_p (_q20))
7502 : {
7503 0 : if (tree_truth_valued_p (_q21))
7504 : {
7505 0 : switch (TREE_CODE (_p1))
7506 : {
7507 0 : case EQ_EXPR:
7508 0 : {
7509 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7510 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7511 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7512 : {
7513 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7514 : {
7515 0 : {
7516 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7517 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1282;
7518 0 : {
7519 0 : tree res_op0;
7520 0 : {
7521 0 : tree _o1[2], _r1;
7522 0 : _o1[0] = captures[0];
7523 0 : _o1[1] = captures[1];
7524 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
7525 0 : res_op0 = _r1;
7526 : }
7527 0 : tree _r;
7528 0 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
7529 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 926, __FILE__, __LINE__, true);
7530 0 : return _r;
7531 : }
7532 0 : next_after_fail1282:;
7533 : }
7534 : }
7535 : }
7536 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7537 : {
7538 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7539 : {
7540 0 : {
7541 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
7542 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1283;
7543 0 : {
7544 0 : tree res_op0;
7545 0 : {
7546 0 : tree _o1[2], _r1;
7547 0 : _o1[0] = captures[0];
7548 0 : _o1[1] = captures[1];
7549 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
7550 0 : res_op0 = _r1;
7551 : }
7552 0 : tree _r;
7553 0 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
7554 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 926, __FILE__, __LINE__, true);
7555 0 : return _r;
7556 : }
7557 0 : next_after_fail1283:;
7558 : }
7559 : }
7560 : }
7561 : break;
7562 : }
7563 : default:;
7564 : }
7565 : }
7566 : }
7567 : break;
7568 : }
7569 118 : case EQ_EXPR:
7570 118 : {
7571 118 : tree _q20 = TREE_OPERAND (_p0, 0);
7572 118 : tree _q21 = TREE_OPERAND (_p0, 1);
7573 118 : switch (TREE_CODE (_p1))
7574 : {
7575 0 : case BIT_AND_EXPR:
7576 0 : {
7577 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7578 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7579 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7580 : {
7581 0 : if (tree_truth_valued_p (_q50))
7582 : {
7583 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7584 : {
7585 0 : if (tree_truth_valued_p (_q51))
7586 : {
7587 0 : {
7588 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7589 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1284;
7590 0 : {
7591 0 : tree res_op0;
7592 0 : {
7593 0 : tree _o1[2], _r1;
7594 0 : _o1[0] = captures[0];
7595 0 : _o1[1] = captures[1];
7596 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
7597 0 : res_op0 = _r1;
7598 : }
7599 0 : tree _r;
7600 0 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
7601 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 926, __FILE__, __LINE__, true);
7602 0 : return _r;
7603 : }
7604 0 : next_after_fail1284:;
7605 : }
7606 : }
7607 : }
7608 : }
7609 : }
7610 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7611 : {
7612 0 : if (tree_truth_valued_p (_q50))
7613 : {
7614 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7615 : {
7616 0 : if (tree_truth_valued_p (_q51))
7617 : {
7618 0 : {
7619 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7620 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1285;
7621 0 : {
7622 0 : tree res_op0;
7623 0 : {
7624 0 : tree _o1[2], _r1;
7625 0 : _o1[0] = captures[0];
7626 0 : _o1[1] = captures[1];
7627 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
7628 0 : res_op0 = _r1;
7629 : }
7630 0 : tree _r;
7631 0 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
7632 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 926, __FILE__, __LINE__, true);
7633 0 : return _r;
7634 : }
7635 0 : next_after_fail1285:;
7636 : }
7637 : }
7638 : }
7639 : }
7640 : }
7641 : break;
7642 : }
7643 : default:;
7644 : }
7645 : break;
7646 : }
7647 891567 : default:;
7648 : }
7649 891567 : {
7650 891567 : tree _p0_pops[1];
7651 891567 : if (tree_logical_inverted_value (_p0, _p0_pops))
7652 : {
7653 45 : tree _q20 = _p0_pops[0];
7654 45 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
7655 : {
7656 4 : if (tree_truth_valued_p (_p1))
7657 : {
7658 4 : {
7659 4 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
7660 4 : tree res = generic_simplify_120 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
7661 4 : if (res) return res;
7662 : }
7663 : }
7664 : }
7665 : }
7666 : }
7667 891563 : {
7668 891563 : tree _p0_pops[1];
7669 891563 : if (tree_nop_convert (_p0, _p0_pops))
7670 : {
7671 500965 : tree _q20 = _p0_pops[0];
7672 500965 : switch (TREE_CODE (_q20))
7673 : {
7674 24 : case BIT_NOT_EXPR:
7675 24 : {
7676 24 : tree _q30 = TREE_OPERAND (_q20, 0);
7677 24 : {
7678 24 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _p1 };
7679 24 : tree res = generic_simplify_170 (loc, type, _p0, _p1, captures);
7680 24 : if (res) return res;
7681 : }
7682 0 : break;
7683 : }
7684 20 : case MULT_EXPR:
7685 20 : {
7686 20 : tree _q30 = TREE_OPERAND (_q20, 0);
7687 20 : tree _q31 = TREE_OPERAND (_q20, 1);
7688 20 : {
7689 20 : tree _q30_pops[1];
7690 20 : if (tree_nop_convert (_q30, _q30_pops))
7691 : {
7692 0 : tree _q40 = _q30_pops[0];
7693 0 : switch (TREE_CODE (_q31))
7694 : {
7695 0 : case INTEGER_CST:
7696 0 : {
7697 0 : switch (TREE_CODE (_p1))
7698 : {
7699 0 : case LSHIFT_EXPR:
7700 0 : {
7701 0 : tree _q70 = TREE_OPERAND (_p1, 0);
7702 0 : tree _q71 = TREE_OPERAND (_p1, 1);
7703 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
7704 : {
7705 0 : switch (TREE_CODE (_q71))
7706 : {
7707 0 : case INTEGER_CST:
7708 0 : {
7709 0 : {
7710 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31, _p1, _q71 };
7711 0 : tree res = generic_simplify_117 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
7712 0 : if (res) return res;
7713 : }
7714 0 : break;
7715 : }
7716 : default:;
7717 : }
7718 : }
7719 : break;
7720 : }
7721 0 : default:;
7722 : }
7723 0 : {
7724 0 : tree _p1_pops[1];
7725 0 : if (tree_nop_convert (_p1, _p1_pops))
7726 : {
7727 0 : tree _q70 = _p1_pops[0];
7728 0 : switch (TREE_CODE (_q70))
7729 : {
7730 0 : case MULT_EXPR:
7731 0 : {
7732 0 : tree _q80 = TREE_OPERAND (_q70, 0);
7733 0 : tree _q81 = TREE_OPERAND (_q70, 1);
7734 0 : {
7735 0 : tree _q80_pops[1];
7736 0 : if (tree_nop_convert (_q80, _q80_pops))
7737 : {
7738 0 : tree _q90 = _q80_pops[0];
7739 0 : switch (TREE_CODE (_q81))
7740 : {
7741 0 : case INTEGER_CST:
7742 0 : {
7743 0 : {
7744 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31, _p1, _q70, _q90, _q81 };
7745 0 : tree res = generic_simplify_116 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
7746 0 : if (res) return res;
7747 : }
7748 0 : break;
7749 : }
7750 : default:;
7751 : }
7752 : }
7753 : }
7754 0 : break;
7755 : }
7756 : default:;
7757 : }
7758 : }
7759 : }
7760 0 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
7761 : {
7762 0 : {
7763 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31 };
7764 0 : tree res = generic_simplify_118 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
7765 0 : if (res) return res;
7766 : }
7767 : }
7768 : break;
7769 : }
7770 : default:;
7771 : }
7772 : }
7773 : }
7774 20 : break;
7775 : }
7776 : default:;
7777 : }
7778 : }
7779 : }
7780 891539 : if (tree_truth_valued_p (_p0))
7781 : {
7782 132542 : {
7783 132542 : tree _p1_pops[1];
7784 132542 : if (tree_logical_inverted_value (_p1, _p1_pops))
7785 : {
7786 7 : tree _q30 = _p1_pops[0];
7787 7 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
7788 : {
7789 0 : {
7790 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
7791 0 : tree res = generic_simplify_120 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
7792 0 : if (res) return res;
7793 : }
7794 : }
7795 : }
7796 : }
7797 : }
7798 891539 : switch (TREE_CODE (_p1))
7799 : {
7800 288 : case BIT_NOT_EXPR:
7801 288 : {
7802 288 : tree _q30 = TREE_OPERAND (_p1, 0);
7803 288 : {
7804 288 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0 };
7805 288 : tree res = generic_simplify_167 (loc, type, _p0, _p1, captures);
7806 288 : if (res) return res;
7807 : }
7808 0 : break;
7809 : }
7810 891251 : default:;
7811 : }
7812 891251 : {
7813 891251 : tree _p1_pops[1];
7814 891251 : if (tree_nop_convert (_p1, _p1_pops))
7815 : {
7816 626202 : tree _q30 = _p1_pops[0];
7817 626202 : switch (TREE_CODE (_q30))
7818 : {
7819 0 : case BIT_NOT_EXPR:
7820 0 : {
7821 0 : tree _q40 = TREE_OPERAND (_q30, 0);
7822 0 : {
7823 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0 };
7824 0 : tree res = generic_simplify_170 (loc, type, _p0, _p1, captures);
7825 0 : if (res) return res;
7826 : }
7827 0 : break;
7828 : }
7829 : default:;
7830 : }
7831 : }
7832 : }
7833 891251 : switch (TREE_CODE (_p0))
7834 : {
7835 1131 : case BIT_IOR_EXPR:
7836 1131 : {
7837 1131 : tree _q20 = TREE_OPERAND (_p0, 0);
7838 1131 : tree _q21 = TREE_OPERAND (_p0, 1);
7839 1131 : switch (TREE_CODE (_q21))
7840 : {
7841 23 : case INTEGER_CST:
7842 23 : {
7843 23 : switch (TREE_CODE (_p1))
7844 : {
7845 23 : case INTEGER_CST:
7846 23 : {
7847 23 : {
7848 23 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
7849 23 : tree res = generic_simplify_124 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_XOR_EXPR);
7850 23 : if (res) return res;
7851 : }
7852 23 : break;
7853 : }
7854 : default:;
7855 : }
7856 : break;
7857 : }
7858 : default:;
7859 : }
7860 : break;
7861 : }
7862 90 : case LT_EXPR:
7863 90 : {
7864 90 : tree _q20 = TREE_OPERAND (_p0, 0);
7865 90 : tree _q21 = TREE_OPERAND (_p0, 1);
7866 90 : switch (TREE_CODE (_p1))
7867 : {
7868 0 : case GT_EXPR:
7869 0 : {
7870 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7871 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7872 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7873 : {
7874 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7875 : {
7876 0 : {
7877 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7878 0 : const enum tree_code cmp1 = LT_EXPR;
7879 0 : const enum tree_code cmp2 = GT_EXPR;
7880 0 : const enum tree_code rcmp = NE_EXPR;
7881 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
7882 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
7883 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
7884 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
7885 : )
7886 : {
7887 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1286;
7888 0 : {
7889 0 : tree res_op0;
7890 0 : res_op0 = captures[0];
7891 0 : tree res_op1;
7892 0 : res_op1 = captures[1];
7893 0 : tree _r;
7894 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
7895 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
7896 0 : return _r;
7897 : }
7898 0 : next_after_fail1286:;
7899 : }
7900 : }
7901 : }
7902 : }
7903 : break;
7904 : }
7905 0 : case EQ_EXPR:
7906 0 : {
7907 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7908 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7909 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7910 : {
7911 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7912 : {
7913 0 : {
7914 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7915 0 : const enum tree_code cmp1 = LT_EXPR;
7916 0 : const enum tree_code cmp2 = EQ_EXPR;
7917 0 : const enum tree_code rcmp = LE_EXPR;
7918 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
7919 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
7920 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
7921 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
7922 : )
7923 : {
7924 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1287;
7925 0 : {
7926 0 : tree res_op0;
7927 0 : res_op0 = captures[0];
7928 0 : tree res_op1;
7929 0 : res_op1 = captures[1];
7930 0 : tree _r;
7931 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
7932 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
7933 0 : return _r;
7934 : }
7935 0 : next_after_fail1287:;
7936 : }
7937 : }
7938 : }
7939 : }
7940 : break;
7941 : }
7942 0 : case NE_EXPR:
7943 0 : {
7944 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7945 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7946 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7947 : {
7948 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7949 : {
7950 0 : {
7951 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7952 0 : const enum tree_code cmp1 = LT_EXPR;
7953 0 : const enum tree_code cmp2 = NE_EXPR;
7954 0 : const enum tree_code rcmp = GT_EXPR;
7955 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
7956 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
7957 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
7958 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
7959 : )
7960 : {
7961 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1288;
7962 0 : {
7963 0 : tree res_op0;
7964 0 : res_op0 = captures[0];
7965 0 : tree res_op1;
7966 0 : res_op1 = captures[1];
7967 0 : tree _r;
7968 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
7969 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
7970 0 : return _r;
7971 : }
7972 0 : next_after_fail1288:;
7973 : }
7974 : }
7975 : }
7976 : }
7977 : break;
7978 : }
7979 : default:;
7980 : }
7981 : break;
7982 : }
7983 85 : case LE_EXPR:
7984 85 : {
7985 85 : tree _q20 = TREE_OPERAND (_p0, 0);
7986 85 : tree _q21 = TREE_OPERAND (_p0, 1);
7987 85 : switch (TREE_CODE (_p1))
7988 : {
7989 0 : case GE_EXPR:
7990 0 : {
7991 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7992 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7993 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7994 : {
7995 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7996 : {
7997 0 : {
7998 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7999 0 : const enum tree_code cmp1 = LE_EXPR;
8000 0 : const enum tree_code cmp2 = GE_EXPR;
8001 0 : const enum tree_code rcmp = NE_EXPR;
8002 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8003 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8004 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8005 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8006 : )
8007 : {
8008 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1289;
8009 0 : {
8010 0 : tree res_op0;
8011 0 : res_op0 = captures[0];
8012 0 : tree res_op1;
8013 0 : res_op1 = captures[1];
8014 0 : tree _r;
8015 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8016 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8017 0 : return _r;
8018 : }
8019 0 : next_after_fail1289:;
8020 : }
8021 : }
8022 : }
8023 : }
8024 : break;
8025 : }
8026 0 : case EQ_EXPR:
8027 0 : {
8028 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8029 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8030 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8031 : {
8032 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8033 : {
8034 0 : {
8035 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8036 0 : const enum tree_code cmp1 = LE_EXPR;
8037 0 : const enum tree_code cmp2 = EQ_EXPR;
8038 0 : const enum tree_code rcmp = LT_EXPR;
8039 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8040 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8041 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8042 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8043 : )
8044 : {
8045 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1290;
8046 0 : {
8047 0 : tree res_op0;
8048 0 : res_op0 = captures[0];
8049 0 : tree res_op1;
8050 0 : res_op1 = captures[1];
8051 0 : tree _r;
8052 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8053 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8054 0 : return _r;
8055 : }
8056 0 : next_after_fail1290:;
8057 : }
8058 : }
8059 : }
8060 : }
8061 : break;
8062 : }
8063 0 : case NE_EXPR:
8064 0 : {
8065 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8066 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8067 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8068 : {
8069 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8070 : {
8071 0 : {
8072 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8073 0 : const enum tree_code cmp1 = LE_EXPR;
8074 0 : const enum tree_code cmp2 = NE_EXPR;
8075 0 : const enum tree_code rcmp = GE_EXPR;
8076 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8077 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8078 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8079 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8080 : )
8081 : {
8082 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1291;
8083 0 : {
8084 0 : tree res_op0;
8085 0 : res_op0 = captures[0];
8086 0 : tree res_op1;
8087 0 : res_op1 = captures[1];
8088 0 : tree _r;
8089 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8090 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8091 0 : return _r;
8092 : }
8093 0 : next_after_fail1291:;
8094 : }
8095 : }
8096 : }
8097 : }
8098 : break;
8099 : }
8100 : default:;
8101 : }
8102 : break;
8103 : }
8104 100 : case GT_EXPR:
8105 100 : {
8106 100 : tree _q20 = TREE_OPERAND (_p0, 0);
8107 100 : tree _q21 = TREE_OPERAND (_p0, 1);
8108 100 : switch (TREE_CODE (_p1))
8109 : {
8110 0 : case GT_EXPR:
8111 0 : {
8112 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8113 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8114 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8115 : {
8116 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8117 : {
8118 0 : {
8119 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8120 0 : const enum tree_code cmp1 = LT_EXPR;
8121 0 : const enum tree_code cmp2 = GT_EXPR;
8122 0 : const enum tree_code rcmp = NE_EXPR;
8123 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8124 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8125 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8126 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8127 : )
8128 : {
8129 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1292;
8130 0 : {
8131 0 : tree res_op0;
8132 0 : res_op0 = captures[0];
8133 0 : tree res_op1;
8134 0 : res_op1 = captures[1];
8135 0 : tree _r;
8136 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8137 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8138 0 : return _r;
8139 : }
8140 0 : next_after_fail1292:;
8141 : }
8142 : }
8143 0 : {
8144 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8145 0 : const enum tree_code cmp1 = LT_EXPR;
8146 0 : const enum tree_code cmp2 = GT_EXPR;
8147 0 : const enum tree_code rcmp = NE_EXPR;
8148 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8149 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8150 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8151 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8152 : )
8153 : {
8154 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1293;
8155 0 : {
8156 0 : tree res_op0;
8157 0 : res_op0 = captures[0];
8158 0 : tree res_op1;
8159 0 : res_op1 = captures[1];
8160 0 : tree _r;
8161 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8162 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8163 0 : return _r;
8164 : }
8165 0 : next_after_fail1293:;
8166 : }
8167 : }
8168 : }
8169 : }
8170 : break;
8171 : }
8172 0 : case EQ_EXPR:
8173 0 : {
8174 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8175 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8176 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8177 : {
8178 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8179 : {
8180 0 : {
8181 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8182 0 : const enum tree_code cmp1 = LT_EXPR;
8183 0 : const enum tree_code cmp2 = EQ_EXPR;
8184 0 : const enum tree_code rcmp = LE_EXPR;
8185 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8186 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8187 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8188 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8189 : )
8190 : {
8191 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1294;
8192 0 : {
8193 0 : tree res_op0;
8194 0 : res_op0 = captures[0];
8195 0 : tree res_op1;
8196 0 : res_op1 = captures[1];
8197 0 : tree _r;
8198 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8199 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8200 0 : return _r;
8201 : }
8202 0 : next_after_fail1294:;
8203 : }
8204 : }
8205 : }
8206 : }
8207 : break;
8208 : }
8209 12 : case NE_EXPR:
8210 12 : {
8211 12 : tree _q50 = TREE_OPERAND (_p1, 0);
8212 12 : tree _q51 = TREE_OPERAND (_p1, 1);
8213 12 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8214 : {
8215 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8216 : {
8217 0 : {
8218 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8219 0 : const enum tree_code cmp1 = LT_EXPR;
8220 0 : const enum tree_code cmp2 = NE_EXPR;
8221 0 : const enum tree_code rcmp = GT_EXPR;
8222 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8223 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8224 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8225 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8226 : )
8227 : {
8228 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1295;
8229 0 : {
8230 0 : tree res_op0;
8231 0 : res_op0 = captures[0];
8232 0 : tree res_op1;
8233 0 : res_op1 = captures[1];
8234 0 : tree _r;
8235 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8236 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8237 0 : return _r;
8238 : }
8239 0 : next_after_fail1295:;
8240 : }
8241 : }
8242 : }
8243 : }
8244 : break;
8245 : }
8246 0 : case LT_EXPR:
8247 0 : {
8248 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8249 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8250 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8251 : {
8252 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8253 : {
8254 0 : {
8255 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8256 0 : const enum tree_code cmp1 = LT_EXPR;
8257 0 : const enum tree_code cmp2 = GT_EXPR;
8258 0 : const enum tree_code rcmp = NE_EXPR;
8259 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8260 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8261 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8262 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8263 : )
8264 : {
8265 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1296;
8266 0 : {
8267 0 : tree res_op0;
8268 0 : res_op0 = captures[0];
8269 0 : tree res_op1;
8270 0 : res_op1 = captures[1];
8271 0 : tree _r;
8272 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8273 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8274 0 : return _r;
8275 : }
8276 0 : next_after_fail1296:;
8277 : }
8278 : }
8279 : }
8280 : }
8281 : break;
8282 : }
8283 : default:;
8284 : }
8285 : break;
8286 : }
8287 62 : case GE_EXPR:
8288 62 : {
8289 62 : tree _q20 = TREE_OPERAND (_p0, 0);
8290 62 : tree _q21 = TREE_OPERAND (_p0, 1);
8291 62 : switch (TREE_CODE (_p1))
8292 : {
8293 1 : case GE_EXPR:
8294 1 : {
8295 1 : tree _q50 = TREE_OPERAND (_p1, 0);
8296 1 : tree _q51 = TREE_OPERAND (_p1, 1);
8297 1 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8298 : {
8299 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8300 : {
8301 0 : {
8302 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8303 0 : const enum tree_code cmp1 = LE_EXPR;
8304 0 : const enum tree_code cmp2 = GE_EXPR;
8305 0 : const enum tree_code rcmp = NE_EXPR;
8306 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8307 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8308 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8309 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8310 : )
8311 : {
8312 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1297;
8313 0 : {
8314 0 : tree res_op0;
8315 0 : res_op0 = captures[0];
8316 0 : tree res_op1;
8317 0 : res_op1 = captures[1];
8318 0 : tree _r;
8319 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8320 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8321 0 : return _r;
8322 : }
8323 0 : next_after_fail1297:;
8324 : }
8325 : }
8326 0 : {
8327 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8328 0 : const enum tree_code cmp1 = LE_EXPR;
8329 0 : const enum tree_code cmp2 = GE_EXPR;
8330 0 : const enum tree_code rcmp = NE_EXPR;
8331 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8332 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8333 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8334 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8335 : )
8336 : {
8337 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1298;
8338 0 : {
8339 0 : tree res_op0;
8340 0 : res_op0 = captures[0];
8341 0 : tree res_op1;
8342 0 : res_op1 = captures[1];
8343 0 : tree _r;
8344 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8345 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8346 0 : return _r;
8347 : }
8348 0 : next_after_fail1298:;
8349 : }
8350 : }
8351 : }
8352 : }
8353 : break;
8354 : }
8355 0 : case EQ_EXPR:
8356 0 : {
8357 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8358 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8359 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8360 : {
8361 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8362 : {
8363 0 : {
8364 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8365 0 : const enum tree_code cmp1 = LE_EXPR;
8366 0 : const enum tree_code cmp2 = EQ_EXPR;
8367 0 : const enum tree_code rcmp = LT_EXPR;
8368 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8369 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8370 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8371 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8372 : )
8373 : {
8374 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1299;
8375 0 : {
8376 0 : tree res_op0;
8377 0 : res_op0 = captures[0];
8378 0 : tree res_op1;
8379 0 : res_op1 = captures[1];
8380 0 : tree _r;
8381 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8382 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8383 0 : return _r;
8384 : }
8385 0 : next_after_fail1299:;
8386 : }
8387 : }
8388 : }
8389 : }
8390 : break;
8391 : }
8392 8 : case NE_EXPR:
8393 8 : {
8394 8 : tree _q50 = TREE_OPERAND (_p1, 0);
8395 8 : tree _q51 = TREE_OPERAND (_p1, 1);
8396 8 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8397 : {
8398 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8399 : {
8400 0 : {
8401 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8402 0 : const enum tree_code cmp1 = LE_EXPR;
8403 0 : const enum tree_code cmp2 = NE_EXPR;
8404 0 : const enum tree_code rcmp = GE_EXPR;
8405 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8406 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8407 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8408 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8409 : )
8410 : {
8411 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1300;
8412 0 : {
8413 0 : tree res_op0;
8414 0 : res_op0 = captures[0];
8415 0 : tree res_op1;
8416 0 : res_op1 = captures[1];
8417 0 : tree _r;
8418 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8419 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8420 0 : return _r;
8421 : }
8422 0 : next_after_fail1300:;
8423 : }
8424 : }
8425 : }
8426 : }
8427 : break;
8428 : }
8429 0 : case LE_EXPR:
8430 0 : {
8431 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8432 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8433 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8434 : {
8435 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8436 : {
8437 0 : {
8438 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8439 0 : const enum tree_code cmp1 = LE_EXPR;
8440 0 : const enum tree_code cmp2 = GE_EXPR;
8441 0 : const enum tree_code rcmp = NE_EXPR;
8442 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8443 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8444 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8445 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8446 : )
8447 : {
8448 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1301;
8449 0 : {
8450 0 : tree res_op0;
8451 0 : res_op0 = captures[0];
8452 0 : tree res_op1;
8453 0 : res_op1 = captures[1];
8454 0 : tree _r;
8455 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8456 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8457 0 : return _r;
8458 : }
8459 0 : next_after_fail1301:;
8460 : }
8461 : }
8462 : }
8463 : }
8464 : break;
8465 : }
8466 : default:;
8467 : }
8468 : break;
8469 : }
8470 118 : case EQ_EXPR:
8471 118 : {
8472 118 : tree _q20 = TREE_OPERAND (_p0, 0);
8473 118 : tree _q21 = TREE_OPERAND (_p0, 1);
8474 118 : switch (TREE_CODE (_p1))
8475 : {
8476 0 : case LT_EXPR:
8477 0 : {
8478 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8479 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8480 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8481 : {
8482 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8483 : {
8484 0 : {
8485 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8486 0 : const enum tree_code cmp1 = LT_EXPR;
8487 0 : const enum tree_code cmp2 = EQ_EXPR;
8488 0 : const enum tree_code rcmp = LE_EXPR;
8489 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8490 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8491 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8492 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8493 : )
8494 : {
8495 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1302;
8496 0 : {
8497 0 : tree res_op0;
8498 0 : res_op0 = captures[0];
8499 0 : tree res_op1;
8500 0 : res_op1 = captures[1];
8501 0 : tree _r;
8502 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8503 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8504 0 : return _r;
8505 : }
8506 0 : next_after_fail1302:;
8507 : }
8508 : }
8509 : }
8510 : }
8511 : break;
8512 : }
8513 0 : case LE_EXPR:
8514 0 : {
8515 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8516 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8517 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8518 : {
8519 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8520 : {
8521 0 : {
8522 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8523 0 : const enum tree_code cmp1 = LE_EXPR;
8524 0 : const enum tree_code cmp2 = EQ_EXPR;
8525 0 : const enum tree_code rcmp = LT_EXPR;
8526 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8527 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8528 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8529 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8530 : )
8531 : {
8532 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1303;
8533 0 : {
8534 0 : tree res_op0;
8535 0 : res_op0 = captures[0];
8536 0 : tree res_op1;
8537 0 : res_op1 = captures[1];
8538 0 : tree _r;
8539 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8540 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8541 0 : return _r;
8542 : }
8543 0 : next_after_fail1303:;
8544 : }
8545 : }
8546 : }
8547 : }
8548 : break;
8549 : }
8550 0 : case GT_EXPR:
8551 0 : {
8552 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8553 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8554 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8555 : {
8556 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8557 : {
8558 0 : {
8559 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8560 0 : const enum tree_code cmp1 = LT_EXPR;
8561 0 : const enum tree_code cmp2 = EQ_EXPR;
8562 0 : const enum tree_code rcmp = LE_EXPR;
8563 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8564 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8565 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8566 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8567 : )
8568 : {
8569 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1304;
8570 0 : {
8571 0 : tree res_op0;
8572 0 : res_op0 = captures[0];
8573 0 : tree res_op1;
8574 0 : res_op1 = captures[1];
8575 0 : tree _r;
8576 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8577 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8578 0 : return _r;
8579 : }
8580 0 : next_after_fail1304:;
8581 : }
8582 : }
8583 : }
8584 : }
8585 : break;
8586 : }
8587 8 : case GE_EXPR:
8588 8 : {
8589 8 : tree _q50 = TREE_OPERAND (_p1, 0);
8590 8 : tree _q51 = TREE_OPERAND (_p1, 1);
8591 8 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8592 : {
8593 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8594 : {
8595 0 : {
8596 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8597 0 : const enum tree_code cmp1 = LE_EXPR;
8598 0 : const enum tree_code cmp2 = EQ_EXPR;
8599 0 : const enum tree_code rcmp = LT_EXPR;
8600 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8601 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8602 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8603 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8604 : )
8605 : {
8606 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1305;
8607 0 : {
8608 0 : tree res_op0;
8609 0 : res_op0 = captures[0];
8610 0 : tree res_op1;
8611 0 : res_op1 = captures[1];
8612 0 : tree _r;
8613 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8614 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8615 0 : return _r;
8616 : }
8617 0 : next_after_fail1305:;
8618 : }
8619 : }
8620 : }
8621 : }
8622 : break;
8623 : }
8624 : default:;
8625 : }
8626 : break;
8627 : }
8628 113 : case NE_EXPR:
8629 113 : {
8630 113 : tree _q20 = TREE_OPERAND (_p0, 0);
8631 113 : tree _q21 = TREE_OPERAND (_p0, 1);
8632 113 : switch (TREE_CODE (_p1))
8633 : {
8634 0 : case LT_EXPR:
8635 0 : {
8636 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8637 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8638 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8639 : {
8640 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8641 : {
8642 0 : {
8643 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8644 0 : const enum tree_code cmp1 = LT_EXPR;
8645 0 : const enum tree_code cmp2 = NE_EXPR;
8646 0 : const enum tree_code rcmp = GT_EXPR;
8647 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8648 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8649 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8650 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8651 : )
8652 : {
8653 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1306;
8654 0 : {
8655 0 : tree res_op0;
8656 0 : res_op0 = captures[0];
8657 0 : tree res_op1;
8658 0 : res_op1 = captures[1];
8659 0 : tree _r;
8660 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8661 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8662 0 : return _r;
8663 : }
8664 0 : next_after_fail1306:;
8665 : }
8666 : }
8667 : }
8668 : }
8669 : break;
8670 : }
8671 0 : case LE_EXPR:
8672 0 : {
8673 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8674 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8675 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8676 : {
8677 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8678 : {
8679 0 : {
8680 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8681 0 : const enum tree_code cmp1 = LE_EXPR;
8682 0 : const enum tree_code cmp2 = NE_EXPR;
8683 0 : const enum tree_code rcmp = GE_EXPR;
8684 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8685 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8686 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8687 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8688 : )
8689 : {
8690 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1307;
8691 0 : {
8692 0 : tree res_op0;
8693 0 : res_op0 = captures[0];
8694 0 : tree res_op1;
8695 0 : res_op1 = captures[1];
8696 0 : tree _r;
8697 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8698 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8699 0 : return _r;
8700 : }
8701 0 : next_after_fail1307:;
8702 : }
8703 : }
8704 : }
8705 : }
8706 : break;
8707 : }
8708 0 : case GT_EXPR:
8709 0 : {
8710 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8711 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8712 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8713 : {
8714 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8715 : {
8716 0 : {
8717 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8718 0 : const enum tree_code cmp1 = LT_EXPR;
8719 0 : const enum tree_code cmp2 = NE_EXPR;
8720 0 : const enum tree_code rcmp = GT_EXPR;
8721 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8722 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8723 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8724 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8725 : )
8726 : {
8727 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1308;
8728 0 : {
8729 0 : tree res_op0;
8730 0 : res_op0 = captures[0];
8731 0 : tree res_op1;
8732 0 : res_op1 = captures[1];
8733 0 : tree _r;
8734 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8735 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8736 0 : return _r;
8737 : }
8738 0 : next_after_fail1308:;
8739 : }
8740 : }
8741 : }
8742 : }
8743 : break;
8744 : }
8745 6 : case GE_EXPR:
8746 6 : {
8747 6 : tree _q50 = TREE_OPERAND (_p1, 0);
8748 6 : tree _q51 = TREE_OPERAND (_p1, 1);
8749 6 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8750 : {
8751 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8752 : {
8753 0 : {
8754 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8755 0 : const enum tree_code cmp1 = LE_EXPR;
8756 0 : const enum tree_code cmp2 = NE_EXPR;
8757 0 : const enum tree_code rcmp = GE_EXPR;
8758 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8759 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8760 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8761 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8762 : )
8763 : {
8764 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1309;
8765 0 : {
8766 0 : tree res_op0;
8767 0 : res_op0 = captures[0];
8768 0 : tree res_op1;
8769 0 : res_op1 = captures[1];
8770 0 : tree _r;
8771 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8772 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
8773 0 : return _r;
8774 : }
8775 0 : next_after_fail1309:;
8776 : }
8777 : }
8778 : }
8779 : }
8780 : break;
8781 : }
8782 : default:;
8783 : }
8784 : break;
8785 : }
8786 523 : case MULT_EXPR:
8787 523 : {
8788 523 : tree _q20 = TREE_OPERAND (_p0, 0);
8789 523 : tree _q21 = TREE_OPERAND (_p0, 1);
8790 523 : switch (TREE_CODE (_q21))
8791 : {
8792 498 : case INTEGER_CST:
8793 498 : {
8794 498 : switch (TREE_CODE (_p1))
8795 : {
8796 12 : case MULT_EXPR:
8797 12 : {
8798 12 : tree _q50 = TREE_OPERAND (_p1, 0);
8799 12 : tree _q51 = TREE_OPERAND (_p1, 1);
8800 12 : switch (TREE_CODE (_q51))
8801 : {
8802 12 : case INTEGER_CST:
8803 12 : {
8804 12 : {
8805 12 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1, _p1, _q50, _q51 };
8806 12 : tree res = generic_simplify_143 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
8807 12 : if (res) return res;
8808 : }
8809 12 : break;
8810 : }
8811 : default:;
8812 : }
8813 : break;
8814 : }
8815 0 : case LSHIFT_EXPR:
8816 0 : {
8817 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8818 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8819 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8820 : {
8821 0 : switch (TREE_CODE (_q51))
8822 : {
8823 0 : case INTEGER_CST:
8824 0 : {
8825 0 : {
8826 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1, _q51 };
8827 0 : tree res = generic_simplify_144 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
8828 0 : if (res) return res;
8829 : }
8830 0 : break;
8831 : }
8832 : default:;
8833 : }
8834 : }
8835 : break;
8836 : }
8837 498 : default:;
8838 : }
8839 498 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
8840 : {
8841 18 : {
8842 18 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
8843 18 : tree res = generic_simplify_145 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
8844 18 : if (res) return res;
8845 : }
8846 : }
8847 : break;
8848 : }
8849 523 : default:;
8850 : }
8851 523 : switch (TREE_CODE (_q20))
8852 : {
8853 0 : case BIT_XOR_EXPR:
8854 0 : {
8855 0 : tree _q30 = TREE_OPERAND (_q20, 0);
8856 0 : tree _q31 = TREE_OPERAND (_q20, 1);
8857 0 : if (tree_zero_one_valued_p (_q21))
8858 : {
8859 0 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
8860 : {
8861 0 : {
8862 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q21 };
8863 0 : tree res = generic_simplify_171 (loc, type, _p0, _p1, captures);
8864 0 : if (res) return res;
8865 : }
8866 : }
8867 0 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
8868 : {
8869 0 : {
8870 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q21 };
8871 0 : tree res = generic_simplify_171 (loc, type, _p0, _p1, captures);
8872 0 : if (res) return res;
8873 : }
8874 : }
8875 : }
8876 : break;
8877 : }
8878 523 : default:;
8879 : }
8880 523 : if (tree_zero_one_valued_p (_q20))
8881 : {
8882 8 : switch (TREE_CODE (_q21))
8883 : {
8884 2 : case BIT_XOR_EXPR:
8885 2 : {
8886 2 : tree _q40 = TREE_OPERAND (_q21, 0);
8887 2 : tree _q41 = TREE_OPERAND (_q21, 1);
8888 2 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
8889 : {
8890 2 : {
8891 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q20 };
8892 2 : tree res = generic_simplify_171 (loc, type, _p0, _p1, captures);
8893 2 : if (res) return res;
8894 : }
8895 : }
8896 0 : if ((_p1 == _q41 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q41, 0) && types_match (_p1, _q41)))
8897 : {
8898 0 : {
8899 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q20 };
8900 0 : tree res = generic_simplify_171 (loc, type, _p0, _p1, captures);
8901 0 : if (res) return res;
8902 : }
8903 : }
8904 : break;
8905 : }
8906 : default:;
8907 : }
8908 : }
8909 : break;
8910 : }
8911 2503 : case LSHIFT_EXPR:
8912 2503 : {
8913 2503 : tree _q20 = TREE_OPERAND (_p0, 0);
8914 2503 : tree _q21 = TREE_OPERAND (_p0, 1);
8915 2503 : switch (TREE_CODE (_q21))
8916 : {
8917 1122 : case INTEGER_CST:
8918 1122 : {
8919 1122 : switch (TREE_CODE (_p1))
8920 : {
8921 0 : case MULT_EXPR:
8922 0 : {
8923 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8924 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8925 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8926 : {
8927 0 : switch (TREE_CODE (_q51))
8928 : {
8929 0 : case INTEGER_CST:
8930 0 : {
8931 0 : {
8932 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _p1, _q20, _q51, _p0, _q21 };
8933 0 : tree res = generic_simplify_144 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
8934 0 : if (res) return res;
8935 : }
8936 0 : break;
8937 : }
8938 : default:;
8939 : }
8940 : }
8941 : break;
8942 : }
8943 1122 : default:;
8944 : }
8945 1122 : {
8946 1122 : tree _p1_pops[1];
8947 1122 : if (tree_nop_convert (_p1, _p1_pops))
8948 : {
8949 23 : tree _q50 = _p1_pops[0];
8950 23 : switch (TREE_CODE (_q50))
8951 : {
8952 0 : case MULT_EXPR:
8953 0 : {
8954 0 : tree _q60 = TREE_OPERAND (_q50, 0);
8955 0 : tree _q61 = TREE_OPERAND (_q50, 1);
8956 0 : {
8957 0 : tree _q60_pops[1];
8958 0 : if (tree_nop_convert (_q60, _q60_pops))
8959 : {
8960 0 : tree _q70 = _q60_pops[0];
8961 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
8962 : {
8963 0 : switch (TREE_CODE (_q61))
8964 : {
8965 0 : case INTEGER_CST:
8966 0 : {
8967 0 : {
8968 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _q50, _q20, _q61, _p0, _q21 };
8969 0 : tree res = generic_simplify_117 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
8970 0 : if (res) return res;
8971 : }
8972 0 : break;
8973 : }
8974 : default:;
8975 : }
8976 : }
8977 : }
8978 : }
8979 0 : break;
8980 : }
8981 : default:;
8982 : }
8983 : }
8984 : }
8985 1122 : break;
8986 : }
8987 : default:;
8988 : }
8989 : break;
8990 : }
8991 891249 : default:;
8992 : }
8993 891249 : switch (TREE_CODE (_p1))
8994 : {
8995 243 : case MULT_EXPR:
8996 243 : {
8997 243 : tree _q30 = TREE_OPERAND (_p1, 0);
8998 243 : tree _q31 = TREE_OPERAND (_p1, 1);
8999 243 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9000 : {
9001 0 : switch (TREE_CODE (_q31))
9002 : {
9003 0 : case INTEGER_CST:
9004 0 : {
9005 0 : {
9006 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _p0, _q31 };
9007 0 : tree res = generic_simplify_145 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9008 0 : if (res) return res;
9009 : }
9010 0 : break;
9011 : }
9012 : default:;
9013 : }
9014 : }
9015 : break;
9016 : }
9017 891249 : default:;
9018 : }
9019 891249 : {
9020 891249 : tree _p1_pops[1];
9021 891249 : if (tree_nop_convert (_p1, _p1_pops))
9022 : {
9023 626202 : tree _q30 = _p1_pops[0];
9024 626202 : switch (TREE_CODE (_q30))
9025 : {
9026 17 : case MULT_EXPR:
9027 17 : {
9028 17 : tree _q40 = TREE_OPERAND (_q30, 0);
9029 17 : tree _q41 = TREE_OPERAND (_q30, 1);
9030 17 : {
9031 17 : tree _q40_pops[1];
9032 17 : if (tree_nop_convert (_q40, _q40_pops))
9033 : {
9034 0 : tree _q50 = _q40_pops[0];
9035 0 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
9036 : {
9037 0 : switch (TREE_CODE (_q41))
9038 : {
9039 0 : case INTEGER_CST:
9040 0 : {
9041 0 : {
9042 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _p0, _q41 };
9043 0 : tree res = generic_simplify_118 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9044 0 : if (res) return res;
9045 : }
9046 0 : break;
9047 : }
9048 : default:;
9049 : }
9050 : }
9051 : }
9052 : }
9053 17 : break;
9054 : }
9055 : default:;
9056 : }
9057 : }
9058 : }
9059 891249 : switch (TREE_CODE (_p0))
9060 : {
9061 2503 : case LSHIFT_EXPR:
9062 2503 : {
9063 2503 : tree _q20 = TREE_OPERAND (_p0, 0);
9064 2503 : tree _q21 = TREE_OPERAND (_p0, 1);
9065 2503 : switch (TREE_CODE (_q21))
9066 : {
9067 1122 : case INTEGER_CST:
9068 1122 : {
9069 1122 : switch (TREE_CODE (_p1))
9070 : {
9071 9 : case LSHIFT_EXPR:
9072 9 : {
9073 9 : tree _q50 = TREE_OPERAND (_p1, 0);
9074 9 : tree _q51 = TREE_OPERAND (_p1, 1);
9075 9 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9076 : {
9077 3 : switch (TREE_CODE (_q51))
9078 : {
9079 3 : case INTEGER_CST:
9080 3 : {
9081 3 : {
9082 3 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
9083 3 : tree res = generic_simplify_146 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9084 3 : if (res) return res;
9085 : }
9086 1 : break;
9087 : }
9088 : default:;
9089 : }
9090 : }
9091 : break;
9092 : }
9093 1120 : default:;
9094 : }
9095 1120 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9096 : {
9097 57 : {
9098 57 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
9099 57 : tree res = generic_simplify_147 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9100 57 : if (res) return res;
9101 : }
9102 : }
9103 : break;
9104 : }
9105 : default:;
9106 : }
9107 : break;
9108 : }
9109 891247 : default:;
9110 : }
9111 891247 : switch (TREE_CODE (_p1))
9112 : {
9113 1982 : case LSHIFT_EXPR:
9114 1982 : {
9115 1982 : tree _q30 = TREE_OPERAND (_p1, 0);
9116 1982 : tree _q31 = TREE_OPERAND (_p1, 1);
9117 1982 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9118 : {
9119 3 : switch (TREE_CODE (_q31))
9120 : {
9121 3 : case INTEGER_CST:
9122 3 : {
9123 3 : {
9124 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q31 };
9125 3 : tree res = generic_simplify_147 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9126 3 : if (res) return res;
9127 : }
9128 0 : break;
9129 : }
9130 : default:;
9131 : }
9132 : }
9133 : break;
9134 : }
9135 891244 : default:;
9136 : }
9137 891244 : switch (TREE_CODE (_p0))
9138 : {
9139 0 : case MIN_EXPR:
9140 0 : {
9141 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9142 0 : tree _q21 = TREE_OPERAND (_p0, 1);
9143 0 : switch (TREE_CODE (_p1))
9144 : {
9145 0 : case MAX_EXPR:
9146 0 : {
9147 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9148 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9149 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9150 : {
9151 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9152 : {
9153 0 : {
9154 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9155 0 : if (!HONOR_NANS (captures[0])
9156 : )
9157 : {
9158 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1310;
9159 0 : {
9160 0 : tree res_op0;
9161 0 : res_op0 = captures[0];
9162 0 : tree res_op1;
9163 0 : res_op1 = captures[1];
9164 0 : tree _r;
9165 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
9166 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
9167 0 : return _r;
9168 : }
9169 0 : next_after_fail1310:;
9170 : }
9171 : }
9172 : }
9173 : }
9174 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9175 : {
9176 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9177 : {
9178 0 : {
9179 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9180 0 : if (!HONOR_NANS (captures[0])
9181 : )
9182 : {
9183 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1311;
9184 0 : {
9185 0 : tree res_op0;
9186 0 : res_op0 = captures[0];
9187 0 : tree res_op1;
9188 0 : res_op1 = captures[1];
9189 0 : tree _r;
9190 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
9191 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
9192 0 : return _r;
9193 : }
9194 0 : next_after_fail1311:;
9195 : }
9196 : }
9197 : }
9198 : }
9199 : break;
9200 : }
9201 : default:;
9202 : }
9203 : break;
9204 : }
9205 0 : case MAX_EXPR:
9206 0 : {
9207 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9208 0 : tree _q21 = TREE_OPERAND (_p0, 1);
9209 0 : switch (TREE_CODE (_p1))
9210 : {
9211 0 : case MIN_EXPR:
9212 0 : {
9213 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9214 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9215 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9216 : {
9217 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9218 : {
9219 0 : {
9220 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9221 0 : if (!HONOR_NANS (captures[0])
9222 : )
9223 : {
9224 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1312;
9225 0 : {
9226 0 : tree res_op0;
9227 0 : res_op0 = captures[0];
9228 0 : tree res_op1;
9229 0 : res_op1 = captures[1];
9230 0 : tree _r;
9231 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
9232 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
9233 0 : return _r;
9234 : }
9235 0 : next_after_fail1312:;
9236 : }
9237 : }
9238 : }
9239 : }
9240 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9241 : {
9242 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9243 : {
9244 0 : {
9245 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9246 0 : if (!HONOR_NANS (captures[0])
9247 : )
9248 : {
9249 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1313;
9250 0 : {
9251 0 : tree res_op0;
9252 0 : res_op0 = captures[0];
9253 0 : tree res_op1;
9254 0 : res_op1 = captures[1];
9255 0 : tree _r;
9256 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
9257 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
9258 0 : return _r;
9259 : }
9260 0 : next_after_fail1313:;
9261 : }
9262 : }
9263 : }
9264 : }
9265 : break;
9266 : }
9267 : default:;
9268 : }
9269 : break;
9270 : }
9271 891244 : default:;
9272 : }
9273 891244 : switch (TREE_CODE (_p1))
9274 : {
9275 243 : case MULT_EXPR:
9276 243 : {
9277 243 : tree _q30 = TREE_OPERAND (_p1, 0);
9278 243 : tree _q31 = TREE_OPERAND (_p1, 1);
9279 243 : switch (TREE_CODE (_q30))
9280 : {
9281 0 : case BIT_XOR_EXPR:
9282 0 : {
9283 0 : tree _q40 = TREE_OPERAND (_q30, 0);
9284 0 : tree _q41 = TREE_OPERAND (_q30, 1);
9285 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
9286 : {
9287 0 : if (tree_zero_one_valued_p (_q31))
9288 : {
9289 0 : {
9290 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q31 };
9291 0 : tree res = generic_simplify_171 (loc, type, _p0, _p1, captures);
9292 0 : if (res) return res;
9293 : }
9294 : }
9295 : }
9296 0 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
9297 : {
9298 0 : if (tree_zero_one_valued_p (_q31))
9299 : {
9300 0 : {
9301 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q31 };
9302 0 : tree res = generic_simplify_171 (loc, type, _p0, _p1, captures);
9303 0 : if (res) return res;
9304 : }
9305 : }
9306 : }
9307 : break;
9308 : }
9309 243 : default:;
9310 : }
9311 243 : if (tree_zero_one_valued_p (_q30))
9312 : {
9313 17 : switch (TREE_CODE (_q31))
9314 : {
9315 0 : case BIT_XOR_EXPR:
9316 0 : {
9317 0 : tree _q50 = TREE_OPERAND (_q31, 0);
9318 0 : tree _q51 = TREE_OPERAND (_q31, 1);
9319 0 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
9320 : {
9321 0 : {
9322 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q51, _q30 };
9323 0 : tree res = generic_simplify_171 (loc, type, _p0, _p1, captures);
9324 0 : if (res) return res;
9325 : }
9326 : }
9327 0 : if ((_q51 == _p0 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _p0, 0) && types_match (_q51, _p0)))
9328 : {
9329 0 : {
9330 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q50, _q30 };
9331 0 : tree res = generic_simplify_171 (loc, type, _p0, _p1, captures);
9332 0 : if (res) return res;
9333 : }
9334 : }
9335 : break;
9336 : }
9337 : default:;
9338 : }
9339 : }
9340 : break;
9341 : }
9342 891244 : default:;
9343 : }
9344 891244 : switch (TREE_CODE (_p0))
9345 : {
9346 1 : case VEC_COND_EXPR:
9347 1 : {
9348 1 : tree _q20 = TREE_OPERAND (_p0, 0);
9349 1 : tree _q21 = TREE_OPERAND (_p0, 1);
9350 1 : tree _q22 = TREE_OPERAND (_p0, 2);
9351 1 : switch (TREE_CODE (_p1))
9352 : {
9353 0 : case VEC_COND_EXPR:
9354 0 : {
9355 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9356 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9357 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9358 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9359 : {
9360 0 : {
9361 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
9362 0 : if (VECTOR_TYPE_P (type)
9363 0 : && (TREE_CODE_CLASS (BIT_XOR_EXPR) != tcc_comparison
9364 : || types_match (type, TREE_TYPE (captures[2]))
9365 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9366 : || (optimize_vectors_before_lowering_p ()
9367 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9368 : )
9369 : {
9370 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1314;
9371 0 : {
9372 0 : tree res_op0;
9373 0 : res_op0 = captures[1];
9374 0 : tree res_op1;
9375 0 : {
9376 0 : tree _o1[2], _r1;
9377 0 : _o1[0] = captures[2];
9378 0 : _o1[1] = captures[5];
9379 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
9380 0 : if (EXPR_P (_r1))
9381 0 : goto next_after_fail1314;
9382 0 : res_op1 = _r1;
9383 : }
9384 0 : tree res_op2;
9385 0 : {
9386 0 : tree _o1[2], _r1;
9387 0 : _o1[0] = captures[3];
9388 0 : _o1[1] = captures[6];
9389 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
9390 0 : if (EXPR_P (_r1))
9391 0 : goto next_after_fail1314;
9392 0 : res_op2 = _r1;
9393 : }
9394 0 : tree _r;
9395 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9396 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 876, __FILE__, __LINE__, true);
9397 0 : return _r;
9398 : }
9399 0 : next_after_fail1314:;
9400 : }
9401 : }
9402 : }
9403 : break;
9404 : }
9405 1 : default:;
9406 : }
9407 1 : if (integer_minus_onep (_q21))
9408 : {
9409 1 : if (integer_zerop (_q22))
9410 : {
9411 1 : switch (TREE_CODE (_p1))
9412 : {
9413 0 : case VEC_COND_EXPR:
9414 0 : {
9415 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9416 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9417 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9418 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
9419 : {
9420 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
9421 : {
9422 0 : {
9423 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9424 0 : const enum tree_code lop = BIT_XOR_EXPR;
9425 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9426 : )
9427 : {
9428 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1315;
9429 0 : {
9430 0 : tree res_op0;
9431 0 : {
9432 0 : tree _o1[2], _r1;
9433 0 : _o1[0] = captures[0];
9434 0 : _o1[1] = captures[3];
9435 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9436 0 : res_op0 = _r1;
9437 : }
9438 0 : tree res_op1;
9439 0 : res_op1 = captures[1];
9440 0 : tree res_op2;
9441 0 : res_op2 = captures[2];
9442 0 : tree _r;
9443 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9444 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9445 0 : return _r;
9446 : }
9447 0 : next_after_fail1315:;
9448 : }
9449 : }
9450 0 : {
9451 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9452 0 : const enum tree_code lop = BIT_XOR_EXPR;
9453 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9454 : )
9455 : {
9456 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1316;
9457 0 : {
9458 0 : tree res_op0;
9459 0 : {
9460 0 : tree _o1[2], _r1;
9461 0 : _o1[0] = captures[0];
9462 0 : _o1[1] = captures[3];
9463 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9464 0 : res_op0 = _r1;
9465 : }
9466 0 : tree res_op1;
9467 0 : res_op1 = captures[1];
9468 0 : tree res_op2;
9469 0 : res_op2 = captures[2];
9470 0 : tree _r;
9471 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9472 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9473 0 : return _r;
9474 : }
9475 0 : next_after_fail1316:;
9476 : }
9477 : }
9478 0 : {
9479 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9480 0 : const enum tree_code lop = BIT_XOR_EXPR;
9481 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9482 : )
9483 : {
9484 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1317;
9485 0 : {
9486 0 : tree res_op0;
9487 0 : {
9488 0 : tree _o1[2], _r1;
9489 0 : _o1[0] = captures[0];
9490 0 : _o1[1] = captures[3];
9491 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9492 0 : res_op0 = _r1;
9493 : }
9494 0 : tree res_op1;
9495 0 : res_op1 = captures[1];
9496 0 : tree res_op2;
9497 0 : res_op2 = captures[2];
9498 0 : tree _r;
9499 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9500 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9501 0 : return _r;
9502 : }
9503 0 : next_after_fail1317:;
9504 : }
9505 : }
9506 0 : {
9507 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9508 0 : const enum tree_code lop = BIT_XOR_EXPR;
9509 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9510 : )
9511 : {
9512 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1318;
9513 0 : {
9514 0 : tree res_op0;
9515 0 : {
9516 0 : tree _o1[2], _r1;
9517 0 : _o1[0] = captures[0];
9518 0 : _o1[1] = captures[3];
9519 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9520 0 : res_op0 = _r1;
9521 : }
9522 0 : tree res_op1;
9523 0 : res_op1 = captures[1];
9524 0 : tree res_op2;
9525 0 : res_op2 = captures[2];
9526 0 : tree _r;
9527 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9528 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9529 0 : return _r;
9530 : }
9531 0 : next_after_fail1318:;
9532 : }
9533 : }
9534 0 : {
9535 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9536 0 : const enum tree_code lop = BIT_XOR_EXPR;
9537 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9538 : )
9539 : {
9540 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1319;
9541 0 : {
9542 0 : tree res_op0;
9543 0 : {
9544 0 : tree _o1[2], _r1;
9545 0 : _o1[0] = captures[0];
9546 0 : _o1[1] = captures[3];
9547 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9548 0 : res_op0 = _r1;
9549 : }
9550 0 : tree res_op1;
9551 0 : res_op1 = captures[1];
9552 0 : tree res_op2;
9553 0 : res_op2 = captures[2];
9554 0 : tree _r;
9555 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9556 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9557 0 : return _r;
9558 : }
9559 0 : next_after_fail1319:;
9560 : }
9561 : }
9562 0 : {
9563 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9564 0 : const enum tree_code lop = BIT_XOR_EXPR;
9565 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9566 : )
9567 : {
9568 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1320;
9569 0 : {
9570 0 : tree res_op0;
9571 0 : {
9572 0 : tree _o1[2], _r1;
9573 0 : _o1[0] = captures[0];
9574 0 : _o1[1] = captures[3];
9575 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9576 0 : res_op0 = _r1;
9577 : }
9578 0 : tree res_op1;
9579 0 : res_op1 = captures[1];
9580 0 : tree res_op2;
9581 0 : res_op2 = captures[2];
9582 0 : tree _r;
9583 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9584 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9585 0 : return _r;
9586 : }
9587 0 : next_after_fail1320:;
9588 : }
9589 : }
9590 0 : {
9591 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9592 0 : const enum tree_code lop = BIT_XOR_EXPR;
9593 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9594 : )
9595 : {
9596 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1321;
9597 0 : {
9598 0 : tree res_op0;
9599 0 : {
9600 0 : tree _o1[2], _r1;
9601 0 : _o1[0] = captures[0];
9602 0 : _o1[1] = captures[3];
9603 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9604 0 : res_op0 = _r1;
9605 : }
9606 0 : tree res_op1;
9607 0 : res_op1 = captures[1];
9608 0 : tree res_op2;
9609 0 : res_op2 = captures[2];
9610 0 : tree _r;
9611 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9612 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9613 0 : return _r;
9614 : }
9615 0 : next_after_fail1321:;
9616 : }
9617 : }
9618 0 : {
9619 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9620 0 : const enum tree_code lop = BIT_XOR_EXPR;
9621 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9622 : )
9623 : {
9624 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1322;
9625 0 : {
9626 0 : tree res_op0;
9627 0 : {
9628 0 : tree _o1[2], _r1;
9629 0 : _o1[0] = captures[0];
9630 0 : _o1[1] = captures[3];
9631 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9632 0 : res_op0 = _r1;
9633 : }
9634 0 : tree res_op1;
9635 0 : res_op1 = captures[1];
9636 0 : tree res_op2;
9637 0 : res_op2 = captures[2];
9638 0 : tree _r;
9639 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9640 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9641 0 : return _r;
9642 : }
9643 0 : next_after_fail1322:;
9644 : }
9645 : }
9646 0 : {
9647 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9648 0 : const enum tree_code lop = BIT_XOR_EXPR;
9649 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9650 : )
9651 : {
9652 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1323;
9653 0 : {
9654 0 : tree res_op0;
9655 0 : {
9656 0 : tree _o1[2], _r1;
9657 0 : _o1[0] = captures[0];
9658 0 : _o1[1] = captures[3];
9659 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9660 0 : res_op0 = _r1;
9661 : }
9662 0 : tree res_op1;
9663 0 : res_op1 = captures[1];
9664 0 : tree res_op2;
9665 0 : res_op2 = captures[2];
9666 0 : tree _r;
9667 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9668 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9669 0 : return _r;
9670 : }
9671 0 : next_after_fail1323:;
9672 : }
9673 : }
9674 0 : {
9675 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9676 0 : const enum tree_code lop = BIT_XOR_EXPR;
9677 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9678 : )
9679 : {
9680 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1324;
9681 0 : {
9682 0 : tree res_op0;
9683 0 : {
9684 0 : tree _o1[2], _r1;
9685 0 : _o1[0] = captures[0];
9686 0 : _o1[1] = captures[3];
9687 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9688 0 : res_op0 = _r1;
9689 : }
9690 0 : tree res_op1;
9691 0 : res_op1 = captures[1];
9692 0 : tree res_op2;
9693 0 : res_op2 = captures[2];
9694 0 : tree _r;
9695 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9696 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9697 0 : return _r;
9698 : }
9699 0 : next_after_fail1324:;
9700 : }
9701 : }
9702 0 : {
9703 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9704 0 : const enum tree_code lop = BIT_XOR_EXPR;
9705 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9706 : )
9707 : {
9708 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1325;
9709 0 : {
9710 0 : tree res_op0;
9711 0 : {
9712 0 : tree _o1[2], _r1;
9713 0 : _o1[0] = captures[0];
9714 0 : _o1[1] = captures[3];
9715 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9716 0 : res_op0 = _r1;
9717 : }
9718 0 : tree res_op1;
9719 0 : res_op1 = captures[1];
9720 0 : tree res_op2;
9721 0 : res_op2 = captures[2];
9722 0 : tree _r;
9723 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9724 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9725 0 : return _r;
9726 : }
9727 0 : next_after_fail1325:;
9728 : }
9729 : }
9730 0 : {
9731 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9732 0 : const enum tree_code lop = BIT_XOR_EXPR;
9733 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9734 : )
9735 : {
9736 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1326;
9737 0 : {
9738 0 : tree res_op0;
9739 0 : {
9740 0 : tree _o1[2], _r1;
9741 0 : _o1[0] = captures[0];
9742 0 : _o1[1] = captures[3];
9743 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9744 0 : res_op0 = _r1;
9745 : }
9746 0 : tree res_op1;
9747 0 : res_op1 = captures[1];
9748 0 : tree res_op2;
9749 0 : res_op2 = captures[2];
9750 0 : tree _r;
9751 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9752 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9753 0 : return _r;
9754 : }
9755 0 : next_after_fail1326:;
9756 : }
9757 : }
9758 0 : {
9759 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9760 0 : const enum tree_code lop = BIT_XOR_EXPR;
9761 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9762 : )
9763 : {
9764 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1327;
9765 0 : {
9766 0 : tree res_op0;
9767 0 : {
9768 0 : tree _o1[2], _r1;
9769 0 : _o1[0] = captures[0];
9770 0 : _o1[1] = captures[3];
9771 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9772 0 : res_op0 = _r1;
9773 : }
9774 0 : tree res_op1;
9775 0 : res_op1 = captures[1];
9776 0 : tree res_op2;
9777 0 : res_op2 = captures[2];
9778 0 : tree _r;
9779 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9780 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9781 0 : return _r;
9782 : }
9783 0 : next_after_fail1327:;
9784 : }
9785 : }
9786 0 : {
9787 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9788 0 : const enum tree_code lop = BIT_XOR_EXPR;
9789 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9790 : )
9791 : {
9792 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1328;
9793 0 : {
9794 0 : tree res_op0;
9795 0 : {
9796 0 : tree _o1[2], _r1;
9797 0 : _o1[0] = captures[0];
9798 0 : _o1[1] = captures[3];
9799 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9800 0 : res_op0 = _r1;
9801 : }
9802 0 : tree res_op1;
9803 0 : res_op1 = captures[1];
9804 0 : tree res_op2;
9805 0 : res_op2 = captures[2];
9806 0 : tree _r;
9807 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9808 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9809 0 : return _r;
9810 : }
9811 0 : next_after_fail1328:;
9812 : }
9813 : }
9814 0 : {
9815 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9816 0 : const enum tree_code lop = BIT_XOR_EXPR;
9817 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9818 : )
9819 : {
9820 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1329;
9821 0 : {
9822 0 : tree res_op0;
9823 0 : {
9824 0 : tree _o1[2], _r1;
9825 0 : _o1[0] = captures[0];
9826 0 : _o1[1] = captures[3];
9827 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9828 0 : res_op0 = _r1;
9829 : }
9830 0 : tree res_op1;
9831 0 : res_op1 = captures[1];
9832 0 : tree res_op2;
9833 0 : res_op2 = captures[2];
9834 0 : tree _r;
9835 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9836 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9837 0 : return _r;
9838 : }
9839 0 : next_after_fail1329:;
9840 : }
9841 : }
9842 0 : {
9843 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9844 0 : const enum tree_code lop = BIT_XOR_EXPR;
9845 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9846 : )
9847 : {
9848 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1330;
9849 0 : {
9850 0 : tree res_op0;
9851 0 : {
9852 0 : tree _o1[2], _r1;
9853 0 : _o1[0] = captures[0];
9854 0 : _o1[1] = captures[3];
9855 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9856 0 : res_op0 = _r1;
9857 : }
9858 0 : tree res_op1;
9859 0 : res_op1 = captures[1];
9860 0 : tree res_op2;
9861 0 : res_op2 = captures[2];
9862 0 : tree _r;
9863 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9864 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9865 0 : return _r;
9866 : }
9867 0 : next_after_fail1330:;
9868 : }
9869 : }
9870 0 : {
9871 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9872 0 : const enum tree_code lop = BIT_XOR_EXPR;
9873 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9874 : )
9875 : {
9876 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1331;
9877 0 : {
9878 0 : tree res_op0;
9879 0 : {
9880 0 : tree _o1[2], _r1;
9881 0 : _o1[0] = captures[0];
9882 0 : _o1[1] = captures[3];
9883 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9884 0 : res_op0 = _r1;
9885 : }
9886 0 : tree res_op1;
9887 0 : res_op1 = captures[1];
9888 0 : tree res_op2;
9889 0 : res_op2 = captures[2];
9890 0 : tree _r;
9891 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9892 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9893 0 : return _r;
9894 : }
9895 0 : next_after_fail1331:;
9896 : }
9897 : }
9898 0 : {
9899 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9900 0 : const enum tree_code lop = BIT_XOR_EXPR;
9901 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9902 : )
9903 : {
9904 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1332;
9905 0 : {
9906 0 : tree res_op0;
9907 0 : {
9908 0 : tree _o1[2], _r1;
9909 0 : _o1[0] = captures[0];
9910 0 : _o1[1] = captures[3];
9911 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9912 0 : res_op0 = _r1;
9913 : }
9914 0 : tree res_op1;
9915 0 : res_op1 = captures[1];
9916 0 : tree res_op2;
9917 0 : res_op2 = captures[2];
9918 0 : tree _r;
9919 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9920 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9921 0 : return _r;
9922 : }
9923 0 : next_after_fail1332:;
9924 : }
9925 : }
9926 0 : {
9927 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9928 0 : const enum tree_code lop = BIT_XOR_EXPR;
9929 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9930 : )
9931 : {
9932 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1333;
9933 0 : {
9934 0 : tree res_op0;
9935 0 : {
9936 0 : tree _o1[2], _r1;
9937 0 : _o1[0] = captures[0];
9938 0 : _o1[1] = captures[3];
9939 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9940 0 : res_op0 = _r1;
9941 : }
9942 0 : tree res_op1;
9943 0 : res_op1 = captures[1];
9944 0 : tree res_op2;
9945 0 : res_op2 = captures[2];
9946 0 : tree _r;
9947 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9948 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9949 0 : return _r;
9950 : }
9951 0 : next_after_fail1333:;
9952 : }
9953 : }
9954 0 : {
9955 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9956 0 : const enum tree_code lop = BIT_XOR_EXPR;
9957 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9958 : )
9959 : {
9960 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1334;
9961 0 : {
9962 0 : tree res_op0;
9963 0 : {
9964 0 : tree _o1[2], _r1;
9965 0 : _o1[0] = captures[0];
9966 0 : _o1[1] = captures[3];
9967 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9968 0 : res_op0 = _r1;
9969 : }
9970 0 : tree res_op1;
9971 0 : res_op1 = captures[1];
9972 0 : tree res_op2;
9973 0 : res_op2 = captures[2];
9974 0 : tree _r;
9975 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9976 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
9977 0 : return _r;
9978 : }
9979 0 : next_after_fail1334:;
9980 : }
9981 : }
9982 0 : {
9983 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9984 0 : const enum tree_code lop = BIT_XOR_EXPR;
9985 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9986 : )
9987 : {
9988 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1335;
9989 0 : {
9990 0 : tree res_op0;
9991 0 : {
9992 0 : tree _o1[2], _r1;
9993 0 : _o1[0] = captures[0];
9994 0 : _o1[1] = captures[3];
9995 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9996 0 : res_op0 = _r1;
9997 : }
9998 0 : tree res_op1;
9999 0 : res_op1 = captures[1];
10000 0 : tree res_op2;
10001 0 : res_op2 = captures[2];
10002 0 : tree _r;
10003 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10004 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
10005 0 : return _r;
10006 : }
10007 0 : next_after_fail1335:;
10008 : }
10009 : }
10010 0 : {
10011 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10012 0 : const enum tree_code lop = BIT_XOR_EXPR;
10013 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10014 : )
10015 : {
10016 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1336;
10017 0 : {
10018 0 : tree res_op0;
10019 0 : {
10020 0 : tree _o1[2], _r1;
10021 0 : _o1[0] = captures[0];
10022 0 : _o1[1] = captures[3];
10023 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10024 0 : res_op0 = _r1;
10025 : }
10026 0 : tree res_op1;
10027 0 : res_op1 = captures[1];
10028 0 : tree res_op2;
10029 0 : res_op2 = captures[2];
10030 0 : tree _r;
10031 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10032 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
10033 0 : return _r;
10034 : }
10035 0 : next_after_fail1336:;
10036 : }
10037 : }
10038 0 : {
10039 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10040 0 : const enum tree_code lop = BIT_XOR_EXPR;
10041 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10042 : )
10043 : {
10044 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1337;
10045 0 : {
10046 0 : tree res_op0;
10047 0 : {
10048 0 : tree _o1[2], _r1;
10049 0 : _o1[0] = captures[0];
10050 0 : _o1[1] = captures[3];
10051 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10052 0 : res_op0 = _r1;
10053 : }
10054 0 : tree res_op1;
10055 0 : res_op1 = captures[1];
10056 0 : tree res_op2;
10057 0 : res_op2 = captures[2];
10058 0 : tree _r;
10059 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10060 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
10061 0 : return _r;
10062 : }
10063 0 : next_after_fail1337:;
10064 : }
10065 : }
10066 0 : {
10067 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10068 0 : const enum tree_code lop = BIT_XOR_EXPR;
10069 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10070 : )
10071 : {
10072 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1338;
10073 0 : {
10074 0 : tree res_op0;
10075 0 : {
10076 0 : tree _o1[2], _r1;
10077 0 : _o1[0] = captures[0];
10078 0 : _o1[1] = captures[3];
10079 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10080 0 : res_op0 = _r1;
10081 : }
10082 0 : tree res_op1;
10083 0 : res_op1 = captures[1];
10084 0 : tree res_op2;
10085 0 : res_op2 = captures[2];
10086 0 : tree _r;
10087 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10088 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
10089 0 : return _r;
10090 : }
10091 0 : next_after_fail1338:;
10092 : }
10093 : }
10094 0 : {
10095 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10096 0 : const enum tree_code lop = BIT_XOR_EXPR;
10097 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10098 : )
10099 : {
10100 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1339;
10101 0 : {
10102 0 : tree res_op0;
10103 0 : {
10104 0 : tree _o1[2], _r1;
10105 0 : _o1[0] = captures[0];
10106 0 : _o1[1] = captures[3];
10107 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10108 0 : res_op0 = _r1;
10109 : }
10110 0 : tree res_op1;
10111 0 : res_op1 = captures[1];
10112 0 : tree res_op2;
10113 0 : res_op2 = captures[2];
10114 0 : tree _r;
10115 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10116 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
10117 0 : return _r;
10118 : }
10119 0 : next_after_fail1339:;
10120 : }
10121 : }
10122 0 : {
10123 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10124 0 : const enum tree_code lop = BIT_XOR_EXPR;
10125 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10126 : )
10127 : {
10128 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1340;
10129 0 : {
10130 0 : tree res_op0;
10131 0 : {
10132 0 : tree _o1[2], _r1;
10133 0 : _o1[0] = captures[0];
10134 0 : _o1[1] = captures[3];
10135 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10136 0 : res_op0 = _r1;
10137 : }
10138 0 : tree res_op1;
10139 0 : res_op1 = captures[1];
10140 0 : tree res_op2;
10141 0 : res_op2 = captures[2];
10142 0 : tree _r;
10143 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10144 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
10145 0 : return _r;
10146 : }
10147 0 : next_after_fail1340:;
10148 : }
10149 : }
10150 0 : {
10151 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10152 0 : const enum tree_code lop = BIT_XOR_EXPR;
10153 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10154 : )
10155 : {
10156 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1341;
10157 0 : {
10158 0 : tree res_op0;
10159 0 : {
10160 0 : tree _o1[2], _r1;
10161 0 : _o1[0] = captures[0];
10162 0 : _o1[1] = captures[3];
10163 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10164 0 : res_op0 = _r1;
10165 : }
10166 0 : tree res_op1;
10167 0 : res_op1 = captures[1];
10168 0 : tree res_op2;
10169 0 : res_op2 = captures[2];
10170 0 : tree _r;
10171 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10172 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
10173 0 : return _r;
10174 : }
10175 0 : next_after_fail1341:;
10176 : }
10177 : }
10178 0 : {
10179 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10180 0 : const enum tree_code lop = BIT_XOR_EXPR;
10181 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10182 : )
10183 : {
10184 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1342;
10185 0 : {
10186 0 : tree res_op0;
10187 0 : {
10188 0 : tree _o1[2], _r1;
10189 0 : _o1[0] = captures[0];
10190 0 : _o1[1] = captures[3];
10191 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10192 0 : res_op0 = _r1;
10193 : }
10194 0 : tree res_op1;
10195 0 : res_op1 = captures[1];
10196 0 : tree res_op2;
10197 0 : res_op2 = captures[2];
10198 0 : tree _r;
10199 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10200 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
10201 0 : return _r;
10202 : }
10203 0 : next_after_fail1342:;
10204 : }
10205 : }
10206 0 : {
10207 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10208 0 : const enum tree_code lop = BIT_XOR_EXPR;
10209 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10210 : )
10211 : {
10212 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1343;
10213 0 : {
10214 0 : tree res_op0;
10215 0 : {
10216 0 : tree _o1[2], _r1;
10217 0 : _o1[0] = captures[0];
10218 0 : _o1[1] = captures[3];
10219 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10220 0 : res_op0 = _r1;
10221 : }
10222 0 : tree res_op1;
10223 0 : res_op1 = captures[1];
10224 0 : tree res_op2;
10225 0 : res_op2 = captures[2];
10226 0 : tree _r;
10227 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10228 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
10229 0 : return _r;
10230 : }
10231 0 : next_after_fail1343:;
10232 : }
10233 : }
10234 0 : {
10235 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10236 0 : const enum tree_code lop = BIT_XOR_EXPR;
10237 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10238 : )
10239 : {
10240 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1344;
10241 0 : {
10242 0 : tree res_op0;
10243 0 : {
10244 0 : tree _o1[2], _r1;
10245 0 : _o1[0] = captures[0];
10246 0 : _o1[1] = captures[3];
10247 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10248 0 : res_op0 = _r1;
10249 : }
10250 0 : tree res_op1;
10251 0 : res_op1 = captures[1];
10252 0 : tree res_op2;
10253 0 : res_op2 = captures[2];
10254 0 : tree _r;
10255 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10256 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
10257 0 : return _r;
10258 : }
10259 0 : next_after_fail1344:;
10260 : }
10261 : }
10262 0 : {
10263 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10264 0 : const enum tree_code lop = BIT_XOR_EXPR;
10265 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10266 : )
10267 : {
10268 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1345;
10269 0 : {
10270 0 : tree res_op0;
10271 0 : {
10272 0 : tree _o1[2], _r1;
10273 0 : _o1[0] = captures[0];
10274 0 : _o1[1] = captures[3];
10275 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10276 0 : res_op0 = _r1;
10277 : }
10278 0 : tree res_op1;
10279 0 : res_op1 = captures[1];
10280 0 : tree res_op2;
10281 0 : res_op2 = captures[2];
10282 0 : tree _r;
10283 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10284 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
10285 0 : return _r;
10286 : }
10287 0 : next_after_fail1345:;
10288 : }
10289 : }
10290 0 : {
10291 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10292 0 : const enum tree_code lop = BIT_XOR_EXPR;
10293 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10294 : )
10295 : {
10296 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1346;
10297 0 : {
10298 0 : tree res_op0;
10299 0 : {
10300 0 : tree _o1[2], _r1;
10301 0 : _o1[0] = captures[0];
10302 0 : _o1[1] = captures[3];
10303 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10304 0 : res_op0 = _r1;
10305 : }
10306 0 : tree res_op1;
10307 0 : res_op1 = captures[1];
10308 0 : tree res_op2;
10309 0 : res_op2 = captures[2];
10310 0 : tree _r;
10311 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10312 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
10313 0 : return _r;
10314 : }
10315 0 : next_after_fail1346:;
10316 : }
10317 : }
10318 0 : {
10319 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10320 0 : const enum tree_code lop = BIT_XOR_EXPR;
10321 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10322 : )
10323 : {
10324 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1347;
10325 0 : {
10326 0 : tree res_op0;
10327 0 : {
10328 0 : tree _o1[2], _r1;
10329 0 : _o1[0] = captures[0];
10330 0 : _o1[1] = captures[3];
10331 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10332 0 : res_op0 = _r1;
10333 : }
10334 0 : tree res_op1;
10335 0 : res_op1 = captures[1];
10336 0 : tree res_op2;
10337 0 : res_op2 = captures[2];
10338 0 : tree _r;
10339 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10340 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
10341 0 : return _r;
10342 : }
10343 0 : next_after_fail1347:;
10344 : }
10345 : }
10346 0 : {
10347 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10348 0 : const enum tree_code lop = BIT_XOR_EXPR;
10349 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10350 : )
10351 : {
10352 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1348;
10353 0 : {
10354 0 : tree res_op0;
10355 0 : {
10356 0 : tree _o1[2], _r1;
10357 0 : _o1[0] = captures[0];
10358 0 : _o1[1] = captures[3];
10359 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10360 0 : res_op0 = _r1;
10361 : }
10362 0 : tree res_op1;
10363 0 : res_op1 = captures[1];
10364 0 : tree res_op2;
10365 0 : res_op2 = captures[2];
10366 0 : tree _r;
10367 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10368 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
10369 0 : return _r;
10370 : }
10371 0 : next_after_fail1348:;
10372 : }
10373 : }
10374 : }
10375 : }
10376 : break;
10377 : }
10378 : default:;
10379 : }
10380 : }
10381 : }
10382 1 : {
10383 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
10384 1 : if (VECTOR_TYPE_P (type)
10385 1 : && (TREE_CODE_CLASS (BIT_XOR_EXPR) != tcc_comparison
10386 : || types_match (type, TREE_TYPE (captures[2]))
10387 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10388 : || (optimize_vectors_before_lowering_p ()
10389 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10390 : )
10391 : {
10392 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1349;
10393 1 : {
10394 1 : if (! tree_invariant_p (captures[4])) goto next_after_fail1349;
10395 0 : tree res_op0;
10396 0 : res_op0 = captures[1];
10397 0 : tree res_op1;
10398 0 : {
10399 0 : tree _o1[2], _r1;
10400 0 : _o1[0] = captures[2];
10401 0 : _o1[1] = unshare_expr (captures[4]);
10402 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
10403 0 : if (EXPR_P (_r1))
10404 0 : goto next_after_fail1349;
10405 0 : res_op1 = _r1;
10406 : }
10407 0 : tree res_op2;
10408 0 : {
10409 0 : tree _o1[2], _r1;
10410 0 : _o1[0] = captures[3];
10411 0 : _o1[1] = captures[4];
10412 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
10413 0 : if (EXPR_P (_r1))
10414 0 : goto next_after_fail1349;
10415 0 : res_op2 = _r1;
10416 : }
10417 0 : tree _r;
10418 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10419 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 877, __FILE__, __LINE__, true);
10420 0 : return _r;
10421 : }
10422 1 : next_after_fail1349:;
10423 : }
10424 : }
10425 1 : break;
10426 : }
10427 891244 : default:;
10428 : }
10429 891244 : switch (TREE_CODE (_p1))
10430 : {
10431 0 : case VEC_COND_EXPR:
10432 0 : {
10433 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10434 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10435 0 : tree _q32 = TREE_OPERAND (_p1, 2);
10436 0 : {
10437 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
10438 0 : if (VECTOR_TYPE_P (type)
10439 0 : && (TREE_CODE_CLASS (BIT_XOR_EXPR) != tcc_comparison
10440 : || types_match (type, TREE_TYPE (captures[3]))
10441 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
10442 : || (optimize_vectors_before_lowering_p ()
10443 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
10444 : )
10445 : {
10446 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1350;
10447 0 : {
10448 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1350;
10449 0 : tree res_op0;
10450 0 : res_op0 = captures[2];
10451 0 : tree res_op1;
10452 0 : {
10453 0 : tree _o1[2], _r1;
10454 0 : _o1[0] = unshare_expr (captures[0]);
10455 0 : _o1[1] = captures[3];
10456 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
10457 0 : if (EXPR_P (_r1))
10458 0 : goto next_after_fail1350;
10459 0 : res_op1 = _r1;
10460 : }
10461 0 : tree res_op2;
10462 0 : {
10463 0 : tree _o1[2], _r1;
10464 0 : _o1[0] = captures[0];
10465 0 : _o1[1] = captures[4];
10466 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
10467 0 : if (EXPR_P (_r1))
10468 0 : goto next_after_fail1350;
10469 0 : res_op2 = _r1;
10470 : }
10471 0 : tree _r;
10472 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10473 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 878, __FILE__, __LINE__, true);
10474 0 : return _r;
10475 : }
10476 0 : next_after_fail1350:;
10477 : }
10478 : }
10479 0 : break;
10480 : }
10481 891244 : default:;
10482 : }
10483 891244 : switch (TREE_CODE (_p0))
10484 : {
10485 90 : case LT_EXPR:
10486 90 : {
10487 90 : tree _q20 = TREE_OPERAND (_p0, 0);
10488 90 : tree _q21 = TREE_OPERAND (_p0, 1);
10489 90 : if (integer_truep (_p1))
10490 : {
10491 14 : {
10492 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10493 14 : tree res = generic_simplify_172 (loc, type, _p0, _p1, captures, LT_EXPR, GE_EXPR, UNGE_EXPR);
10494 14 : if (res) return res;
10495 : }
10496 : }
10497 76 : if (integer_zerop (_q21))
10498 : {
10499 24 : switch (TREE_CODE (_p1))
10500 : {
10501 17 : case LT_EXPR:
10502 17 : {
10503 17 : tree _q50 = TREE_OPERAND (_p1, 0);
10504 17 : tree _q51 = TREE_OPERAND (_p1, 1);
10505 17 : if (integer_zerop (_q51))
10506 : {
10507 17 : {
10508 17 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q50 };
10509 17 : tree res = generic_simplify_173 (loc, type, _p0, _p1, captures, LT_EXPR);
10510 17 : if (res) return res;
10511 : }
10512 : }
10513 : break;
10514 : }
10515 0 : case GE_EXPR:
10516 0 : {
10517 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10518 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10519 0 : if (integer_zerop (_q51))
10520 : {
10521 0 : {
10522 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q50 };
10523 0 : tree res = generic_simplify_174 (loc, type, _p0, _p1, captures);
10524 0 : if (res) return res;
10525 : }
10526 : }
10527 : break;
10528 : }
10529 : default:;
10530 : }
10531 : }
10532 : break;
10533 : }
10534 85 : case LE_EXPR:
10535 85 : {
10536 85 : tree _q20 = TREE_OPERAND (_p0, 0);
10537 85 : tree _q21 = TREE_OPERAND (_p0, 1);
10538 85 : if (integer_truep (_p1))
10539 : {
10540 15 : {
10541 15 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10542 15 : tree res = generic_simplify_172 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR, UNGT_EXPR);
10543 15 : if (res) return res;
10544 : }
10545 : }
10546 : break;
10547 : }
10548 118 : case EQ_EXPR:
10549 118 : {
10550 118 : tree _q20 = TREE_OPERAND (_p0, 0);
10551 118 : tree _q21 = TREE_OPERAND (_p0, 1);
10552 118 : if (integer_truep (_p1))
10553 : {
10554 14 : {
10555 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10556 14 : tree res = generic_simplify_172 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR, NE_EXPR);
10557 14 : if (res) return res;
10558 : }
10559 : }
10560 : break;
10561 : }
10562 113 : case NE_EXPR:
10563 113 : {
10564 113 : tree _q20 = TREE_OPERAND (_p0, 0);
10565 113 : tree _q21 = TREE_OPERAND (_p0, 1);
10566 113 : if (integer_truep (_p1))
10567 : {
10568 7 : {
10569 7 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10570 7 : tree res = generic_simplify_172 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR, EQ_EXPR);
10571 7 : if (res) return res;
10572 : }
10573 : }
10574 : break;
10575 : }
10576 62 : case GE_EXPR:
10577 62 : {
10578 62 : tree _q20 = TREE_OPERAND (_p0, 0);
10579 62 : tree _q21 = TREE_OPERAND (_p0, 1);
10580 62 : if (integer_truep (_p1))
10581 : {
10582 0 : {
10583 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10584 0 : tree res = generic_simplify_172 (loc, type, _p0, _p1, captures, GE_EXPR, LT_EXPR, UNLT_EXPR);
10585 0 : if (res) return res;
10586 : }
10587 : }
10588 62 : if (integer_zerop (_q21))
10589 : {
10590 26 : switch (TREE_CODE (_p1))
10591 : {
10592 1 : case GE_EXPR:
10593 1 : {
10594 1 : tree _q50 = TREE_OPERAND (_p1, 0);
10595 1 : tree _q51 = TREE_OPERAND (_p1, 1);
10596 1 : if (integer_zerop (_q51))
10597 : {
10598 1 : {
10599 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q50 };
10600 1 : tree res = generic_simplify_173 (loc, type, _p0, _p1, captures, GE_EXPR);
10601 1 : if (res) return res;
10602 : }
10603 : }
10604 : break;
10605 : }
10606 5 : case LT_EXPR:
10607 5 : {
10608 5 : tree _q50 = TREE_OPERAND (_p1, 0);
10609 5 : tree _q51 = TREE_OPERAND (_p1, 1);
10610 5 : if (integer_zerop (_q51))
10611 : {
10612 5 : {
10613 5 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q50, _p0, _q20 };
10614 5 : tree res = generic_simplify_174 (loc, type, _p0, _p1, captures);
10615 5 : if (res) return res;
10616 : }
10617 : }
10618 : break;
10619 : }
10620 : default:;
10621 : }
10622 : }
10623 : break;
10624 : }
10625 100 : case GT_EXPR:
10626 100 : {
10627 100 : tree _q20 = TREE_OPERAND (_p0, 0);
10628 100 : tree _q21 = TREE_OPERAND (_p0, 1);
10629 100 : if (integer_truep (_p1))
10630 : {
10631 14 : {
10632 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10633 14 : tree res = generic_simplify_172 (loc, type, _p0, _p1, captures, GT_EXPR, LE_EXPR, UNLE_EXPR);
10634 14 : if (res) return res;
10635 : }
10636 : }
10637 : break;
10638 : }
10639 0 : case UNORDERED_EXPR:
10640 0 : {
10641 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10642 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10643 0 : if (integer_truep (_p1))
10644 : {
10645 0 : {
10646 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10647 0 : tree res = generic_simplify_172 (loc, type, _p0, _p1, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR);
10648 0 : if (res) return res;
10649 : }
10650 : }
10651 : break;
10652 : }
10653 0 : case ORDERED_EXPR:
10654 0 : {
10655 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10656 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10657 0 : if (integer_truep (_p1))
10658 : {
10659 0 : {
10660 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10661 0 : tree res = generic_simplify_172 (loc, type, _p0, _p1, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR);
10662 0 : if (res) return res;
10663 : }
10664 : }
10665 : break;
10666 : }
10667 0 : case UNLT_EXPR:
10668 0 : {
10669 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10670 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10671 0 : if (integer_truep (_p1))
10672 : {
10673 0 : {
10674 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10675 0 : tree res = generic_simplify_172 (loc, type, _p0, _p1, captures, UNLT_EXPR, GE_EXPR, GE_EXPR);
10676 0 : if (res) return res;
10677 : }
10678 : }
10679 : break;
10680 : }
10681 0 : case UNLE_EXPR:
10682 0 : {
10683 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10684 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10685 0 : if (integer_truep (_p1))
10686 : {
10687 0 : {
10688 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10689 0 : tree res = generic_simplify_172 (loc, type, _p0, _p1, captures, UNLE_EXPR, GT_EXPR, GT_EXPR);
10690 0 : if (res) return res;
10691 : }
10692 : }
10693 : break;
10694 : }
10695 0 : case UNGT_EXPR:
10696 0 : {
10697 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10698 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10699 0 : if (integer_truep (_p1))
10700 : {
10701 0 : {
10702 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10703 0 : tree res = generic_simplify_172 (loc, type, _p0, _p1, captures, UNGT_EXPR, LE_EXPR, LE_EXPR);
10704 0 : if (res) return res;
10705 : }
10706 : }
10707 : break;
10708 : }
10709 0 : case UNGE_EXPR:
10710 0 : {
10711 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10712 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10713 0 : if (integer_truep (_p1))
10714 : {
10715 0 : {
10716 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10717 0 : tree res = generic_simplify_172 (loc, type, _p0, _p1, captures, UNGE_EXPR, LT_EXPR, LT_EXPR);
10718 0 : if (res) return res;
10719 : }
10720 : }
10721 : break;
10722 : }
10723 0 : case UNEQ_EXPR:
10724 0 : {
10725 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10726 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10727 0 : if (integer_truep (_p1))
10728 : {
10729 0 : {
10730 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10731 0 : tree res = generic_simplify_172 (loc, type, _p0, _p1, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR);
10732 0 : if (res) return res;
10733 : }
10734 : }
10735 : break;
10736 : }
10737 0 : case LTGT_EXPR:
10738 0 : {
10739 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10740 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10741 0 : if (integer_truep (_p1))
10742 : {
10743 0 : {
10744 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10745 0 : tree res = generic_simplify_172 (loc, type, _p0, _p1, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR);
10746 0 : if (res) return res;
10747 : }
10748 : }
10749 : break;
10750 : }
10751 7 : case VEC_PERM_EXPR:
10752 7 : {
10753 7 : tree _q20 = TREE_OPERAND (_p0, 0);
10754 7 : tree _q21 = TREE_OPERAND (_p0, 1);
10755 7 : tree _q22 = TREE_OPERAND (_p0, 2);
10756 7 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
10757 : {
10758 0 : switch (TREE_CODE (_p1))
10759 : {
10760 0 : case VEC_PERM_EXPR:
10761 0 : {
10762 0 : tree _q60 = TREE_OPERAND (_p1, 0);
10763 0 : tree _q61 = TREE_OPERAND (_p1, 1);
10764 0 : tree _q62 = TREE_OPERAND (_p1, 2);
10765 0 : if ((_q61 == _q60 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q60, 0) && types_match (_q61, _q60)))
10766 : {
10767 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
10768 : {
10769 0 : {
10770 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q22, _q60 };
10771 0 : if (VECTOR_INTEGER_TYPE_P (type)
10772 : )
10773 : {
10774 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1351;
10775 0 : {
10776 0 : tree res_op0;
10777 0 : {
10778 0 : tree _o1[2], _r1;
10779 0 : _o1[0] = captures[0];
10780 0 : _o1[1] = captures[2];
10781 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10782 0 : captures[3] = _r1;
10783 : }
10784 0 : res_op0 = unshare_expr (captures[3]);
10785 0 : tree res_op1;
10786 0 : res_op1 = captures[3];
10787 0 : tree res_op2;
10788 0 : res_op2 = captures[1];
10789 0 : tree _r;
10790 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
10791 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 879, __FILE__, __LINE__, true);
10792 0 : return _r;
10793 : }
10794 0 : next_after_fail1351:;
10795 : }
10796 : }
10797 : }
10798 : }
10799 : break;
10800 : }
10801 : default:;
10802 : }
10803 : }
10804 : break;
10805 : }
10806 2903 : case CALL_EXPR:
10807 2903 : switch (get_call_combined_fn (_p0))
10808 : {
10809 1 : case CFN_PARITY:
10810 1 : if (call_expr_nargs (_p0) == 1)
10811 : {
10812 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10813 1 : switch (TREE_CODE (_p1))
10814 : {
10815 1 : case CALL_EXPR:
10816 1 : switch (get_call_combined_fn (_p1))
10817 : {
10818 1 : case CFN_PARITY:
10819 1 : if (call_expr_nargs (_p1) == 1)
10820 : {
10821 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
10822 1 : {
10823 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10824 1 : tree res = generic_simplify_175 (loc, type, _p0, _p1, captures, CFN_PARITY);
10825 1 : if (res) return res;
10826 : }
10827 : }
10828 : break;
10829 : default:;
10830 : }
10831 : break;
10832 : default:;
10833 : }
10834 : }
10835 : break;
10836 1 : case CFN_BUILT_IN_PARITYL:
10837 1 : if (call_expr_nargs (_p0) == 1)
10838 : {
10839 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10840 1 : switch (TREE_CODE (_p1))
10841 : {
10842 1 : case CALL_EXPR:
10843 1 : switch (get_call_combined_fn (_p1))
10844 : {
10845 1 : case CFN_BUILT_IN_PARITYL:
10846 1 : if (call_expr_nargs (_p1) == 1)
10847 : {
10848 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
10849 1 : {
10850 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10851 1 : tree res = generic_simplify_175 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITYL);
10852 1 : if (res) return res;
10853 : }
10854 : }
10855 : break;
10856 : default:;
10857 : }
10858 : break;
10859 : default:;
10860 : }
10861 : }
10862 : break;
10863 0 : case CFN_BUILT_IN_PARITYIMAX:
10864 0 : if (call_expr_nargs (_p0) == 1)
10865 : {
10866 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10867 0 : switch (TREE_CODE (_p1))
10868 : {
10869 0 : case CALL_EXPR:
10870 0 : switch (get_call_combined_fn (_p1))
10871 : {
10872 0 : case CFN_BUILT_IN_PARITYIMAX:
10873 0 : if (call_expr_nargs (_p1) == 1)
10874 : {
10875 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
10876 0 : {
10877 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10878 0 : tree res = generic_simplify_175 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITYIMAX);
10879 0 : if (res) return res;
10880 : }
10881 : }
10882 : break;
10883 : default:;
10884 : }
10885 : break;
10886 : default:;
10887 : }
10888 : }
10889 : break;
10890 1 : case CFN_BUILT_IN_PARITY:
10891 1 : if (call_expr_nargs (_p0) == 1)
10892 : {
10893 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10894 1 : switch (TREE_CODE (_p1))
10895 : {
10896 1 : case CALL_EXPR:
10897 1 : switch (get_call_combined_fn (_p1))
10898 : {
10899 1 : case CFN_BUILT_IN_PARITY:
10900 1 : if (call_expr_nargs (_p1) == 1)
10901 : {
10902 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
10903 1 : {
10904 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10905 1 : tree res = generic_simplify_175 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITY);
10906 1 : if (res) return res;
10907 : }
10908 : }
10909 : break;
10910 : default:;
10911 : }
10912 : break;
10913 : default:;
10914 : }
10915 : }
10916 : break;
10917 8 : case CFN_BUILT_IN_PARITYLL:
10918 8 : if (call_expr_nargs (_p0) == 1)
10919 : {
10920 8 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10921 8 : switch (TREE_CODE (_p1))
10922 : {
10923 8 : case CALL_EXPR:
10924 8 : switch (get_call_combined_fn (_p1))
10925 : {
10926 8 : case CFN_BUILT_IN_PARITYLL:
10927 8 : if (call_expr_nargs (_p1) == 1)
10928 : {
10929 8 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
10930 8 : {
10931 8 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
10932 8 : tree res = generic_simplify_175 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITYLL);
10933 8 : if (res) return res;
10934 : }
10935 : }
10936 : break;
10937 : default:;
10938 : }
10939 : break;
10940 : default:;
10941 : }
10942 : }
10943 : break;
10944 : default:;
10945 : }
10946 : break;
10947 : default:;
10948 : }
10949 : return NULL_TREE;
10950 : }
10951 :
10952 : tree
10953 43470986 : generic_simplify (location_t loc, enum tree_code code, const tree type ATTRIBUTE_UNUSED, tree _p0, tree _p1, tree _p2)
10954 : {
10955 43470986 : switch (code)
10956 : {
10957 14158214 : case COND_EXPR:
10958 14158214 : return generic_simplify_COND_EXPR (loc, code, type, _p0, _p1, _p2);
10959 335226 : case VEC_COND_EXPR:
10960 335226 : return generic_simplify_VEC_COND_EXPR (loc, code, type, _p0, _p1, _p2);
10961 649727 : case BIT_FIELD_REF:
10962 649727 : return generic_simplify_BIT_FIELD_REF (loc, code, type, _p0, _p1, _p2);
10963 14647 : case BIT_INSERT_EXPR:
10964 14647 : return generic_simplify_BIT_INSERT_EXPR (loc, code, type, _p0, _p1, _p2);
10965 743602 : case VEC_PERM_EXPR:
10966 743602 : return generic_simplify_VEC_PERM_EXPR (loc, code, type, _p0, _p1, _p2);
10967 : default:;
10968 : }
10969 : return NULL_TREE;
10970 : }
10971 :
10972 : tree
10973 0 : generic_simplify (location_t, enum tree_code,
10974 : const tree, tree, tree, tree, tree)
10975 : {
10976 0 : return NULL_TREE;
10977 : }
10978 :
10979 : tree
10980 0 : generic_simplify (location_t, enum tree_code,
10981 : const tree, tree, tree, tree, tree, tree)
10982 : {
10983 0 : return NULL_TREE;
10984 : }
10985 :
10986 : tree
10987 0 : generic_simplify (location_t, enum tree_code,
10988 : const tree, tree, tree, tree, tree, tree, tree)
10989 : {
10990 0 : return NULL_TREE;
10991 : }
10992 :
10993 : tree
10994 0 : generic_simplify (location_t, enum tree_code,
10995 : const tree, tree, tree, tree, tree, tree, tree, tree)
10996 : {
10997 0 : return NULL_TREE;
10998 : }
10999 : void
11000 19451 : generic_dump_logs (const char *file1, int line1_id, const char *file2, int line2, bool simplify)
11001 : {
11002 19451 : static int dbg_line_numbers[1091] = {
11003 : /* 0 */ 161, 164, 173, 175, 178, 181, 183, 189, 197, 195,
11004 : /* 10 */ 199, 201, 962, 964, 2146, 2152, 2154, 2157, 2162, 2165,
11005 : /* 20 */ 2408, 2412, 2414, 2416, 2418, 2420, 2422, 2424, 2451, 2467,
11006 : /* 30 */ 2475, 2457, 3051, 3053, 3055, 3062, 3059, 3069, 3071, 3078,
11007 : /* 40 */ 3075, 3286, 3296, 6076, 9425, 9446, 11688, 11691, 11696, 2113,
11008 : /* 50 */ 9245, 256, 283, 284, 495, 1331, 1501, 1837, 1887, 1892,
11009 : /* 60 */ 1996, 1955, 4373, 4311, 2541, 2573, 4416, 4417, 4421, 4422,
11010 : /* 70 */ 4432, 4436, 4440, 4455, 4458, 4462, 4388, 4391, 4396, 4542,
11011 : /* 80 */ 4548, 4554, 4734, 4735, 4764, 4785, 4804, 5147, 5975, 7336,
11012 : /* 90 */ 7421, 7423, 8873, 8948, 10599, 10647, 10661, 11715, 12140, 946,
11013 : /* 100 */ 952, 1481, 1490, 1973, 1964, 1911, 2690, 4324, 4364, 4369,
11014 : /* 110 */ 4370, 4378, 4379, 4382, 4399, 4474, 4477, 4481, 4562, 4584,
11015 : /* 120 */ 4622, 4633, 4672, 4687, 5153, 7346, 8953, 10657, 11719, 1337,
11016 : /* 130 */ 1341, 1467, 1476, 1506, 1511, 1553, 1538, 1545, 1568, 1569,
11017 : /* 140 */ 1573, 1574, 1595, 2050, 1600, 1607, 1627, 1730, 1754, 1844,
11018 : /* 150 */ 1849, 1859, 1869, 1983, 2042, 2070, 2080, 2082, 2305, 2341,
11019 : /* 160 */ 2349, 2354, 2359, 2375, 2365, 2366, 4861, 4874, 4884, 2389,
11020 : /* 170 */ 2400, 2403, 2435, 2524, 2553, 2555, 2560, 2562, 2683, 3128,
11021 : /* 180 */ 3130, 3897, 3912, 3930, 4130, 4131, 4132, 4140, 4148, 4157,
11022 : /* 190 */ 4166, 4198, 4199, 4204, 4205, 4210, 4215, 4219, 4274, 4288,
11023 : /* 200 */ 3902, 3921, 3923, 3907, 4898, 4910, 8009, 9822, 12238, 12253,
11024 : /* 210 */ 1516, 1521, 1632, 1637, 1854, 1944, 1864, 2008, 1874, 1879,
11025 : /* 220 */ 2002, 2054, 2015, 2021, 2664, 2028, 2088, 5159, 7405, 7407,
11026 : /* 230 */ 7472, 7480, 10758, 10764, 463, 469, 501, 1276, 1296, 1301,
11027 : /* 240 */ 2138, 2139, 2176, 2699, 5660, 5961, 5968, 6018, 6021, 6071,
11028 : /* 250 */ 8866, 9280, 9110, 9117, 9274, 9319, 9324, 331, 908, 1349,
11029 : /* 260 */ 2970, 2766, 2772, 2775, 2780, 2440, 2678, 2493, 2717, 2727,
11030 : /* 270 */ 2796, 2798, 2799, 2802, 2804, 2805, 2807, 2809, 2811, 2813,
11031 : /* 280 */ 2815, 2817, 2831, 2832, 2854, 2888, 2976, 3001, 2917, 2944,
11032 : /* 290 */ 2984, 2989, 3014, 3021, 3087, 4246, 5089, 5097, 5100, 5106,
11033 : /* 300 */ 5109, 5136, 5452, 5453, 5487, 5491, 5620, 5460, 5461, 5505,
11034 : /* 310 */ 5508, 5509, 5514, 5517, 5520, 5521, 5473, 5476, 5693, 5697,
11035 : /* 320 */ 5702, 5986, 6138, 6142, 7432, 7448, 7450, 7462, 7492, 7498,
11036 : /* 330 */ 7499, 7514, 7515, 7519, 7537, 7542, 7574, 7582, 7592, 7601,
11037 : /* 340 */ 7605, 7611, 7618, 7634, 7638, 7642, 7649, 7650, 7655, 7656,
11038 : /* 350 */ 7663, 7664, 7666, 7667, 7683, 7694, 7706, 7710, 7712, 7717,
11039 : /* 360 */ 7720, 7723, 7731, 7793, 7794, 7798, 7799, 7806, 7810, 7814,
11040 : /* 370 */ 7817, 7823, 7824, 7828, 7831, 7838, 7858, 7861, 7864, 7867,
11041 : /* 380 */ 7916, 7919, 7923, 7930, 7936, 7944, 7953, 7954, 8052, 8062,
11042 : /* 390 */ 8101, 8107, 8123, 8136, 8138, 8140, 8166, 8208, 8187, 8188,
11043 : /* 400 */ 8195, 8197, 8213, 8219, 8224, 8233, 8239, 8245, 8250, 8255,
11044 : /* 410 */ 8287, 8350, 8269, 8279, 8379, 8398, 8400, 8402, 8404, 8406,
11045 : /* 420 */ 8408, 8412, 8414, 8437, 8460, 8572, 8579, 8580, 8588, 8589,
11046 : /* 430 */ 8786, 9866, 9868, 9946, 9948, 9949, 9955, 9971, 9973, 9975,
11047 : /* 440 */ 9993, 9994, 10384, 10387, 10401, 10410, 10474, 10475, 10529, 10531,
11048 : /* 450 */ 10607, 11030, 11032, 11034, 11468, 7428, 7439, 7441, 7549, 475,
11049 : /* 460 */ 1249, 1270, 9230, 9235, 9240, 535, 536, 547, 552, 559,
11050 : /* 470 */ 568, 576, 585, 631, 634, 843, 997, 1025, 1056, 596,
11051 : /* 480 */ 873, 877, 882, 888, 892, 900, 989, 747, 757, 759,
11052 : /* 490 */ 761, 8860, 9285, 9307, 9290, 9295, 9300, 9314, 9348, 9353,
11053 : /* 500 */ 818, 6754, 6756, 6758, 6858, 6861, 7035, 7037, 7051, 7055,
11054 : /* 510 */ 7078, 7084, 7142, 3858, 5196, 5239, 5252, 6680, 6968, 6972,
11055 : /* 520 */ 6980, 5183, 5203, 5210, 5216, 5222, 5228, 7148, 7280, 9839,
11056 : /* 530 */ 9840, 7290, 10818, 10826, 8303, 8304, 8318, 8319, 830, 833,
11057 : /* 540 */ 1705, 2740, 2743, 2862, 2874, 2959, 2903, 2930, 3042, 3045,
11058 : /* 550 */ 5127, 5119, 7370, 8716, 7966, 7969, 7995, 7996, 8485, 8487,
11059 : /* 560 */ 8489, 8491, 8495, 8497, 8499, 8501, 8505, 8510, 8517, 8522,
11060 : /* 570 */ 8542, 8544, 8546, 8548, 8729, 8737, 8747, 8755, 8765, 8887,
11061 : /* 580 */ 8889, 9880, 9889, 9929, 10452, 10454, 10455, 10510, 10513, 10515,
11062 : /* 590 */ 2756, 7360, 8039, 8961, 8966, 11051, 11053, 11055, 11057, 11061,
11063 : /* 600 */ 935, 971, 1321, 5272, 5342, 5345, 5353, 5421, 5423, 5424,
11064 : /* 610 */ 5425, 5632, 5323, 5332, 6192, 6195, 6196, 6204, 2316, 2326,
11065 : /* 620 */ 2333, 4257, 4262, 5031, 9705, 9707, 9738, 9773, 12084, 1213,
11066 : /* 630 */ 9178, 9199, 1222, 8922, 8928, 9225, 9652, 1236, 1240, 9220,
11067 : /* 640 */ 9403, 1449, 1533, 1581, 1526, 1558, 1589, 1622, 1663, 1674,
11068 : /* 650 */ 1685, 1697, 2585, 1926, 1934, 1939, 2062, 2430, 2705, 3282,
11069 : /* 660 */ 3867, 3869, 3879, 3881, 3988, 3989, 3990, 3998, 4006, 4015,
11070 : /* 670 */ 4024, 4058, 4059, 4064, 4065, 4070, 4075, 4079, 3887, 3892,
11071 : /* 680 */ 3937, 5164, 5591, 5609, 5610, 6163, 6169, 6217, 7564, 8012,
11072 : /* 690 */ 9808, 9810, 10642, 1612, 1617, 2643, 1785, 2648, 5671, 2623,
11073 : /* 700 */ 2654, 2658, 5685, 5074, 7397, 7399, 2183, 2197, 2628, 4349,
11074 : /* 710 */ 2222, 2245, 2246, 10269, 4917, 4921, 4931, 4949, 5014, 5016,
11075 : /* 720 */ 5018, 5020, 5069, 9830, 4935, 4942, 4927, 5041, 5050, 5053,
11076 : /* 730 */ 5259, 5393, 5403, 8815, 8818, 8837, 6114, 6126, 6129, 6133,
11077 : /* 740 */ 11260, 11266, 11274, 11280, 11289, 11295, 11303, 11309, 11355, 11363,
11078 : /* 750 */ 8604, 7557, 7553, 8796, 8803, 8938, 8943, 9044, 9141, 9158,
11079 : /* 760 */ 9190, 9210, 9215, 9466, 9443, 9422, 9251, 9255, 9546, 9556,
11080 : /* 770 */ 9563, 9572, 9590, 9597, 9578, 9845, 9851, 10259, 10265, 10262,
11081 : /* 780 */ 10273, 10279, 10287, 10293, 10301, 10307, 10317, 10323, 10331, 10337,
11082 : /* 790 */ 10345, 10351, 10359, 10365, 10419, 10622, 10637, 10673, 10917, 10920,
11083 : /* 800 */ 10725, 10739, 10752, 11437, 11452, 11543, 11544, 12193, 221, 2094,
11084 : /* 810 */ 2104, 6249, 2122, 1163, 2596, 3263, 5713, 5715, 5725, 5842,
11085 : /* 820 */ 5853, 5866, 5889, 5899, 5908, 5920, 5946, 6259, 6686, 1782,
11086 : /* 830 */ 1796, 1803, 1825, 1832, 2445, 2671, 2099, 2117, 2126, 2192,
11087 : /* 840 */ 2228, 2234, 4336, 7323, 4344, 10327, 10283, 10341, 10355, 10369,
11088 : /* 850 */ 10297, 10311, 5730, 5740, 5749, 5776, 5786, 5792, 6270, 5801,
11089 : /* 860 */ 5798, 6084, 6092, 6100, 6104, 6087, 6095, 6108, 6120, 239,
11090 : /* 870 */ 729, 2509, 4996, 6033, 6039, 6041, 6288, 6308, 6317, 12099,
11091 : /* 880 */ 3135, 3139, 244, 3156, 3160, 3191, 3199, 3172, 3186, 262,
11092 : /* 890 */ 299, 1485, 1791, 1899, 1906, 1916, 1921, 2203, 3207, 3219,
11093 : /* 900 */ 3213, 3225, 2214, 2883, 2911, 2938, 2922, 2949, 4596, 4568,
11094 : /* 910 */ 4643, 4652, 4695, 4706, 6046, 6057, 12065, 12066, 1710, 1715,
11095 : /* 920 */ 6297, 8002, 11414, 11418, 1738, 1743, 2636, 4234, 249, 302,
11096 : /* 930 */ 2892, 2895, 3232, 3239, 3246, 3252, 4605, 3257, 4661, 4715,
11097 : /* 940 */ 6049, 375, 306, 343, 352, 360, 434, 449, 457, 648,
11098 : /* 950 */ 688, 1006, 1201, 1206, 1304, 1307, 1441, 2499, 6062, 8895,
11099 : /* 960 */ 8901, 9092, 9342, 2616, 6476, 6486, 8069, 8636, 8696, 8697,
11100 : /* 970 */ 2606, 8630, 611, 614, 738, 767, 773, 779, 787, 792,
11101 : /* 980 */ 797, 861, 865, 8907, 8913, 8554, 919, 1396, 5288, 1385,
11102 : /* 990 */ 1388, 1420, 1431, 5265, 5337, 5431, 1455, 1644, 1720, 1748,
11103 : /* 1000 */ 2380, 5437, 5438, 8006, 12072, 4956, 4960, 4988, 4989, 5062,
11104 : /* 1010 */ 4967, 4971, 4979, 4980, 5374, 6081, 8612, 8614, 8621, 8623,
11105 : /* 1020 */ 7561, 7155, 5170, 6987, 6992, 7117, 7123, 7132, 7133, 6235,
11106 : /* 1030 */ 6237, 7161, 7164, 7173, 7177, 7182, 7211, 7216, 7277, 7224,
11107 : /* 1040 */ 7229, 7287, 8333, 8335, 7246, 7247, 7248, 7298, 7267, 7268,
11108 : /* 1050 */ 7269, 7310, 7311, 8364, 8369, 7190, 6241, 6243, 6497, 6499,
11109 : /* 1060 */ 10001, 10007, 10012, 10021, 10023, 10043, 10088, 10091, 10092, 10124,
11110 : /* 1070 */ 10130, 10132, 10133, 10189, 10190, 10211, 10216, 10221, 10251, 11568,
11111 : /* 1080 */ 11570, 11605, 11680, 11683, 11768, 11703, 11709, 11837, 11839, 11901, 11903
11112 : };
11113 :
11114 29171 : fprintf (dump_file, "%s %s:%d, %s:%d\n",
11115 : simplify ? "Applying pattern" : "Matching expression", file1, dbg_line_numbers[line1_id], file2, line2);
11116 19451 : }
11117 :
11118 : #pragma GCC diagnostic pop
|
