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 119712218 : tree_maybe_cmp (tree t, tree *res_ops)
11 : {
12 119712218 : const tree type = TREE_TYPE (t);
13 119712218 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 119712218 : if (TREE_SIDE_EFFECTS (t)) return false;
15 119712218 : switch (TREE_CODE (t))
16 : {
17 476684 : case LT_EXPR:
18 476684 : case LE_EXPR:
19 476684 : case EQ_EXPR:
20 476684 : case NE_EXPR:
21 476684 : case GE_EXPR:
22 476684 : case GT_EXPR:
23 476684 : case UNORDERED_EXPR:
24 476684 : case ORDERED_EXPR:
25 476684 : case UNLT_EXPR:
26 476684 : case UNLE_EXPR:
27 476684 : case UNGT_EXPR:
28 476684 : case UNGE_EXPR:
29 476684 : case UNEQ_EXPR:
30 476684 : case LTGT_EXPR:
31 476684 : {
32 476684 : tree _p0 = TREE_OPERAND (t, 0);
33 476684 : tree _p1 = TREE_OPERAND (t, 1);
34 476684 : {
35 476684 : tree captures[3] ATTRIBUTE_UNUSED = { t, _p0, _p1 };
36 476684 : {
37 476684 : res_ops[0] = captures[0];
38 476684 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 5, __FILE__, __LINE__, false);
39 : return true;
40 : }
41 : }
42 26004071 : break;
43 : }
44 26004071 : CASE_CONVERT:
45 26004071 : {
46 26004071 : tree _p0 = TREE_OPERAND (t, 0);
47 26004071 : switch (TREE_CODE (_p0))
48 : {
49 1441 : case LT_EXPR:
50 1441 : case LE_EXPR:
51 1441 : case EQ_EXPR:
52 1441 : case NE_EXPR:
53 1441 : case GE_EXPR:
54 1441 : case GT_EXPR:
55 1441 : case UNORDERED_EXPR:
56 1441 : case ORDERED_EXPR:
57 1441 : case UNLT_EXPR:
58 1441 : case UNLE_EXPR:
59 1441 : case UNGT_EXPR:
60 1441 : case UNGE_EXPR:
61 1441 : case UNEQ_EXPR:
62 1441 : case LTGT_EXPR:
63 1441 : {
64 1441 : tree _q20 = TREE_OPERAND (_p0, 0);
65 1441 : tree _q21 = TREE_OPERAND (_p0, 1);
66 1441 : {
67 1441 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
68 1441 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
69 : )
70 : {
71 777 : {
72 777 : res_ops[0] = captures[0];
73 777 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 6, __FILE__, __LINE__, false);
74 : return true;
75 : }
76 : }
77 : }
78 : break;
79 : }
80 : default:;
81 : }
82 : break;
83 : }
84 192281 : case BIT_XOR_EXPR:
85 192281 : {
86 192281 : tree _p0 = TREE_OPERAND (t, 0);
87 192281 : tree _p1 = TREE_OPERAND (t, 1);
88 192281 : {
89 192281 : tree captures[3] ATTRIBUTE_UNUSED = { t, _p0, _p1 };
90 192281 : if (INTEGRAL_TYPE_P (type)
91 192281 : && TYPE_PRECISION (type) == 1
92 : )
93 : {
94 93785 : {
95 93785 : res_ops[0] = captures[0];
96 93785 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 7, __FILE__, __LINE__, false);
97 : return true;
98 : }
99 : }
100 : }
101 : break;
102 : }
103 : default:;
104 : }
105 : return false;
106 : }
107 :
108 : bool
109 0 : tree_float_value_p (tree t)
110 : {
111 0 : const tree type = TREE_TYPE (t);
112 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
113 0 : if (TREE_SIDE_EFFECTS (t)) return false;
114 0 : {
115 0 : tree captures[1] ATTRIBUTE_UNUSED = { t };
116 0 : if (TYPE_MAIN_VARIANT (TREE_TYPE (captures[0])) == float_type_node
117 : )
118 : {
119 0 : {
120 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 45, __FILE__, __LINE__, false);
121 0 : return true;
122 : }
123 : }
124 : }
125 : return false;
126 : }
127 :
128 : tree
129 29 : generic_simplify_7 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
130 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
131 : const enum tree_code ARG_UNUSED (bit_op))
132 : {
133 29 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
134 29 : if (bit_op == BIT_AND_EXPR
135 : )
136 : {
137 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail78;
138 9 : {
139 9 : tree _r;
140 9 : _r = build_zero_cst (type);
141 9 : if (TREE_SIDE_EFFECTS (captures[0]))
142 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
143 9 : if (TREE_SIDE_EFFECTS (captures[1]))
144 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
145 9 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 55, __FILE__, __LINE__, true);
146 : return _r;
147 : }
148 0 : next_after_fail78:;
149 : }
150 : else
151 : {
152 20 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail79;
153 20 : {
154 20 : tree _r;
155 20 : _r = captures[1];
156 20 : if (TREE_SIDE_EFFECTS (captures[0]))
157 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
158 20 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 56, __FILE__, __LINE__, true);
159 : return _r;
160 : }
161 0 : next_after_fail79:;
162 : }
163 : return NULL_TREE;
164 : }
165 :
166 : tree
167 608 : generic_simplify_17 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
168 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
169 : {
170 608 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
171 608 : if (bitwise_equal_p (captures[0], captures[2])
172 : )
173 : {
174 88 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail91;
175 88 : {
176 88 : tree res_op0;
177 88 : {
178 88 : tree _o1[1], _r1;
179 88 : {
180 88 : tree _o2[2], _r2;
181 88 : _o2[0] = captures[0];
182 88 : {
183 88 : tree _o3[1], _r3;
184 88 : _o3[0] = captures[1];
185 88 : if (TREE_TYPE (_o3[0]) != TREE_TYPE (_o2[0]))
186 : {
187 8 : _r3 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o2[0]), _o3[0]);
188 : }
189 : else
190 : _r3 = _o3[0];
191 88 : _o2[1] = _r3;
192 : }
193 88 : _r2 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
194 88 : _o1[0] = _r2;
195 : }
196 88 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
197 88 : res_op0 = _r1;
198 : }
199 88 : tree _r;
200 88 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
201 88 : if (TREE_SIDE_EFFECTS (captures[2]))
202 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
203 88 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 66, __FILE__, __LINE__, true);
204 : return _r;
205 : }
206 0 : next_after_fail91:;
207 : }
208 : return NULL_TREE;
209 : }
210 :
211 : tree
212 3387045 : generic_simplify_30 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
213 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
214 : const enum tree_code ARG_UNUSED (bitop))
215 : {
216 3387045 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
217 3387045 : if (((TREE_CODE (captures[3]) == INTEGER_CST
218 1064262 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
219 874281 : && (int_fits_type_p (captures[3], TREE_TYPE (captures[1]))
220 12631 : || tree_nop_conversion_p (TREE_TYPE (captures[1]), type)))
221 2523151 : || types_match (captures[1], captures[3]))
222 1303522 : && !POINTER_TYPE_P (TREE_TYPE (captures[1]))
223 1303522 : && !VECTOR_TYPE_P (TREE_TYPE (captures[1]))
224 1303293 : && TREE_CODE (TREE_TYPE (captures[1])) != OFFSET_TYPE
225 1303293 : && (bitop != BIT_AND_EXPR ||
226 :
227 : )
228 3387045 : && (
229 64468 : TYPE_PRECISION (TREE_TYPE (captures[1])) < TYPE_PRECISION (type)
230 : || (
231 :
232 : && TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (type))
233 63210 : || GET_MODE_CLASS (TYPE_MODE (type)) != MODE_INT
234 63210 : || !type_has_mode_precision_p (type)
235 63210 : || (
236 :
237 : && TREE_CODE (captures[3]) != INTEGER_CST
238 : && tree_nop_conversion_p (type, TREE_TYPE (captures[1]))
239 : && single_use (captures[0])
240 : && single_use (captures[2])))
241 : )
242 : {
243 1261 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail104;
244 1261 : {
245 1261 : tree res_op0;
246 1261 : {
247 1261 : tree _o1[2], _r1;
248 1261 : _o1[0] = captures[1];
249 1261 : {
250 1261 : tree _o2[1], _r2;
251 1261 : _o2[0] = captures[3];
252 1261 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
253 : {
254 1261 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
255 : }
256 : else
257 : _r2 = _o2[0];
258 1261 : _o1[1] = _r2;
259 : }
260 1261 : _r1 = fold_build2_loc (loc, bitop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
261 1261 : res_op0 = _r1;
262 : }
263 1261 : tree _r;
264 1261 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
265 1261 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 78, __FILE__, __LINE__, true);
266 : return _r;
267 : }
268 0 : next_after_fail104:;
269 : }
270 : return NULL_TREE;
271 : }
272 :
273 : tree
274 7 : generic_simplify_44 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
275 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
276 : const enum tree_code ARG_UNUSED (op))
277 : {
278 7 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
279 14 : if (INTEGRAL_TYPE_P (type)
280 7 : && tree_int_cst_sgn (captures[2]) > 0
281 7 : && tree_int_cst_sgn (captures[4]) > 0
282 28 : && (tree_nonzero_bits (captures[0]) & tree_nonzero_bits (captures[3])) == 0
283 : )
284 : {
285 4 : {
286 4 : tree t = type;
287 4 : if (!TYPE_OVERFLOW_WRAPS (t))
288 4 : t = unsigned_type_for (t);
289 4 : wide_int wone = wi::one (TYPE_PRECISION (t));
290 8 : wide_int c = wi::add (wi::lshift (wone, wi::to_wide (captures[2])),
291 8 : wi::lshift (wone, wi::to_wide (captures[4])));
292 4 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail121;
293 4 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail121;
294 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail121;
295 4 : {
296 4 : tree res_op0;
297 4 : {
298 4 : tree _o1[2], _r1;
299 4 : {
300 4 : tree _o2[1], _r2;
301 4 : _o2[0] = captures[1];
302 4 : if (TREE_TYPE (_o2[0]) != t)
303 : {
304 4 : _r2 = fold_build1_loc (loc, NOP_EXPR, t, _o2[0]);
305 : }
306 : else
307 : _r2 = _o2[0];
308 4 : _o1[0] = _r2;
309 : }
310 4 : _o1[1] = wide_int_to_tree (t,c);
311 4 : _r1 = fold_build2_loc (loc, MULT_EXPR, t, _o1[0], _o1[1]);
312 4 : res_op0 = _r1;
313 : }
314 4 : tree _r;
315 4 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
316 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 91, __FILE__, __LINE__, true);
317 4 : return _r;
318 : }
319 0 : next_after_fail121:;
320 4 : }
321 : }
322 : return NULL_TREE;
323 : }
324 :
325 : tree
326 5353 : generic_simplify_53 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
327 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
328 : {
329 5353 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
330 5353 : if (fold_real_zero_addition_p (type, captures[0], captures[1], 0)
331 : )
332 : {
333 95 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail132;
334 95 : {
335 95 : tree res_op0;
336 95 : res_op0 = captures[0];
337 95 : tree _r;
338 95 : _r = non_lvalue_loc (loc, res_op0);
339 95 : if (TREE_SIDE_EFFECTS (captures[1]))
340 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
341 95 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 101, __FILE__, __LINE__, true);
342 : return _r;
343 : }
344 0 : next_after_fail132:;
345 : }
346 : return NULL_TREE;
347 : }
348 :
349 : tree
350 53 : generic_simplify_62 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
351 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
352 : {
353 53 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
354 53 : {
355 53 : tree cst = uniform_integer_cst_p (captures[2]);
356 53 : tree etype = TREE_TYPE (cst);
357 53 : wide_int c = wi::to_wide (cst);
358 2 : if (ANY_INTEGRAL_TYPE_P (type)
359 53 : && !TYPE_OVERFLOW_TRAPS (type)
360 52 : && !TYPE_OVERFLOW_SANITIZED (type)
361 157 : && wi::popcount (c + 1) == 1
362 : )
363 : {
364 20 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail142;
365 20 : {
366 20 : tree res_op0;
367 20 : {
368 20 : tree _o1[2], _r1;
369 20 : _o1[0] = captures[0];
370 20 : _o1[1] = captures[2];
371 20 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
372 20 : res_op0 = _r1;
373 : }
374 20 : tree res_op1;
375 20 : res_op1 = build_uniform_cst
376 20 : (type, wide_int_to_tree (etype, wi::bit_not (c)));
377 20 : tree _r;
378 20 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
379 20 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 110, __FILE__, __LINE__, true);
380 20 : return _r;
381 : }
382 0 : next_after_fail142:;
383 : }
384 20 : }
385 33 : return NULL_TREE;
386 : }
387 :
388 : tree
389 764 : generic_simplify_72 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
390 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
391 : {
392 764 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
393 764 : if (!TYPE_SATURATING (type)
394 : )
395 : {
396 764 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
397 1528 : && !FIXED_POINT_TYPE_P (type)
398 : )
399 : {
400 764 : if (!TYPE_OVERFLOW_TRAPS (type)
401 : )
402 : {
403 764 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail160;
404 764 : {
405 764 : tree res_op0;
406 764 : res_op0 = build_all_ones_cst (TREE_TYPE (captures[0]));
407 764 : tree _r;
408 764 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
409 764 : if (TREE_SIDE_EFFECTS (captures[0]))
410 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
411 764 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 128, __FILE__, __LINE__, true);
412 : return _r;
413 : }
414 0 : next_after_fail160:;
415 : }
416 : }
417 : }
418 : return NULL_TREE;
419 : }
420 :
421 : tree
422 0 : generic_simplify_79 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
423 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
424 : {
425 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
426 0 : if (INTEGRAL_TYPE_P (type)
427 0 : && !TYPE_SATURATING (type)
428 0 : && (
429 :
430 0 : || !TREE_SIDE_EFFECTS (captures[0]))
431 : )
432 : {
433 0 : {
434 0 : tree utype = unsigned_type_for (type);
435 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail168;
436 0 : {
437 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail168;
438 0 : tree res_op0;
439 0 : {
440 0 : tree _o1[1], _r1;
441 0 : _o1[0] = captures[1];
442 0 : if (TREE_TYPE (_o1[0]) != boolean_type_node)
443 : {
444 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, boolean_type_node, _o1[0]);
445 : }
446 : else
447 : _r1 = _o1[0];
448 0 : res_op0 = _r1;
449 : }
450 0 : tree res_op1;
451 0 : {
452 0 : tree _o1[1], _r1;
453 0 : {
454 0 : tree _o2[1], _r2;
455 0 : {
456 0 : tree _o3[1], _r3;
457 0 : _o3[0] = unshare_expr (captures[0]);
458 0 : if (TREE_TYPE (_o3[0]) != utype)
459 : {
460 0 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
461 : }
462 : else
463 : _r3 = _o3[0];
464 0 : _o2[0] = _r3;
465 : }
466 0 : _r2 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
467 0 : _o1[0] = _r2;
468 : }
469 0 : if (TREE_TYPE (_o1[0]) != type)
470 : {
471 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
472 : }
473 : else
474 : _r1 = _o1[0];
475 0 : res_op1 = _r1;
476 : }
477 0 : tree res_op2;
478 0 : res_op2 = captures[0];
479 0 : tree _r;
480 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
481 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 136, __FILE__, __LINE__, true);
482 : return _r;
483 : }
484 0 : next_after_fail168:;
485 : }
486 : }
487 : return NULL_TREE;
488 : }
489 :
490 : tree
491 0 : generic_simplify_89 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
492 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
493 : {
494 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
495 0 : if (TREE_CODE (captures[1]) == SSA_NAME && num_imm_uses (captures[1]) == 2
496 : )
497 : {
498 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail179;
499 0 : {
500 0 : if (! tree_invariant_p (captures[2])) goto next_after_fail179;
501 0 : tree res_op0;
502 0 : {
503 0 : tree _o1[2], _r1;
504 0 : {
505 0 : tree _o2[3], _r2;
506 0 : _o2[0] = unshare_expr (captures[2]);
507 0 : _o2[1] = captures[2];
508 0 : _o2[2] = captures[4];
509 0 : _r2 = fold_build3_loc (loc, VEC_PERM_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1], _o2[2]);
510 0 : _o1[0] = _r2;
511 : }
512 0 : _o1[1] = captures[3];
513 0 : _r1 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
514 0 : res_op0 = _r1;
515 : }
516 0 : tree res_op1;
517 0 : res_op1 = captures[5];
518 0 : tree _r;
519 0 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
520 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 147, __FILE__, __LINE__, true);
521 : return _r;
522 : }
523 0 : next_after_fail179:;
524 : }
525 : return NULL_TREE;
526 : }
527 :
528 : tree
529 0 : generic_simplify_96 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
530 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
531 : const enum tree_code ARG_UNUSED (op),
532 : const enum tree_code ARG_UNUSED (rop))
533 : {
534 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
535 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail186;
536 0 : {
537 0 : tree res_op0;
538 0 : res_op0 = captures[0];
539 0 : tree res_op1;
540 0 : res_op1 = captures[1];
541 0 : tree _r;
542 0 : _r = fold_build2_loc (loc, rop, type, res_op0, res_op1);
543 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 154, __FILE__, __LINE__, true);
544 : return _r;
545 : }
546 0 : next_after_fail186:;
547 0 : return NULL_TREE;
548 : }
549 :
550 : tree
551 57881 : generic_simplify_104 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
552 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
553 : {
554 57881 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
555 57881 : if (!TYPE_SATURATING (type)
556 : )
557 : {
558 57881 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
559 115751 : && !FIXED_POINT_TYPE_P (type)
560 : )
561 : {
562 57870 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail194;
563 57870 : {
564 57870 : tree res_op0;
565 57870 : res_op0 = captures[1];
566 57870 : tree _r;
567 57870 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
568 57870 : if (TREE_SIDE_EFFECTS (captures[0]))
569 15 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
570 57870 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 161, __FILE__, __LINE__, true);
571 : return _r;
572 : }
573 0 : next_after_fail194:;
574 : }
575 : }
576 : return NULL_TREE;
577 : }
578 :
579 : tree
580 10778 : generic_simplify_112 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
581 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
582 : {
583 10778 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
584 10778 : if (!TYPE_SATURATING (type)
585 : )
586 : {
587 10778 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
588 21556 : && !FIXED_POINT_TYPE_P (type)
589 : )
590 : {
591 10778 : if (INTEGRAL_TYPE_P (type)
592 10778 : && TYPE_OVERFLOW_UNDEFINED (type)
593 3274 : && TREE_CODE (captures[1]) != INTEGER_CST
594 11990 : && element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
595 : )
596 : {
597 1212 : {
598 1212 : tree utype = unsigned_type_for (type);
599 1212 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail206;
600 1212 : {
601 1212 : tree res_op0;
602 1212 : {
603 1212 : tree _o1[1], _r1;
604 1212 : {
605 1212 : tree _o2[1], _r2;
606 1212 : _o2[0] = captures[1];
607 1212 : if (TREE_TYPE (_o2[0]) != utype)
608 : {
609 1212 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
610 : }
611 : else
612 : _r2 = _o2[0];
613 1212 : _o1[0] = _r2;
614 : }
615 1212 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
616 1212 : res_op0 = _r1;
617 : }
618 1212 : tree _r;
619 1212 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
620 1212 : if (TREE_SIDE_EFFECTS (captures[2]))
621 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
622 1212 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 173, __FILE__, __LINE__, true);
623 : return _r;
624 : }
625 0 : next_after_fail206:;
626 : }
627 : }
628 : else
629 : {
630 9566 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
631 9566 : || (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
632 2329 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1])))
633 : )
634 : {
635 9296 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail207;
636 9296 : {
637 9296 : tree res_op0;
638 9296 : {
639 9296 : tree _o1[1], _r1;
640 9296 : _o1[0] = captures[1];
641 9296 : if (TREE_TYPE (_o1[0]) != type)
642 : {
643 9296 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
644 : }
645 : else
646 : _r1 = _o1[0];
647 9296 : res_op0 = _r1;
648 : }
649 9296 : tree _r;
650 9296 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
651 9296 : if (TREE_SIDE_EFFECTS (captures[2]))
652 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
653 9296 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 174, __FILE__, __LINE__, true);
654 : return _r;
655 : }
656 0 : next_after_fail207:;
657 : }
658 : }
659 : }
660 : }
661 : return NULL_TREE;
662 : }
663 :
664 : tree
665 16 : generic_simplify_126 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
666 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
667 : {
668 16 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
669 16 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail226;
670 16 : {
671 16 : tree res_op0;
672 16 : res_op0 = captures[0];
673 16 : tree res_op1;
674 16 : res_op1 = captures[1];
675 16 : tree _r;
676 16 : _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
677 16 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 191, __FILE__, __LINE__, true);
678 : return _r;
679 : }
680 0 : next_after_fail226:;
681 0 : return NULL_TREE;
682 : }
683 :
684 : tree
685 0 : generic_simplify_129 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
686 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
687 : {
688 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
689 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail229;
690 0 : {
691 0 : tree res_op0;
692 0 : res_op0 = captures[0];
693 0 : tree res_op1;
694 0 : {
695 0 : tree _o1[1], _r1;
696 0 : _o1[0] = captures[2];
697 0 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
698 0 : res_op1 = _r1;
699 : }
700 0 : tree _r;
701 0 : _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
702 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 193, __FILE__, __LINE__, true);
703 : return _r;
704 : }
705 0 : next_after_fail229:;
706 0 : return NULL_TREE;
707 : }
708 :
709 : tree
710 0 : generic_simplify_137 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
711 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
712 : {
713 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
714 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail237;
715 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail237;
716 0 : {
717 0 : tree _r;
718 0 : _r = captures[2];
719 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 199, __FILE__, __LINE__, true);
720 : return _r;
721 : }
722 0 : next_after_fail237:;
723 : return NULL_TREE;
724 : }
725 :
726 : tree
727 0 : generic_simplify_145 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
728 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
729 : {
730 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
731 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail245;
732 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail245;
733 0 : {
734 0 : tree _r;
735 0 : _r = captures[0];
736 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 202, __FILE__, __LINE__, true);
737 : return _r;
738 : }
739 0 : next_after_fail245:;
740 : return NULL_TREE;
741 : }
742 :
743 : tree
744 21 : generic_simplify_152 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
745 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
746 : const enum tree_code ARG_UNUSED (bitop),
747 : const enum tree_code ARG_UNUSED (rbitop))
748 : {
749 21 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
750 21 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail256;
751 21 : {
752 21 : tree _r;
753 21 : _r = captures[0];
754 21 : if (TREE_SIDE_EFFECTS (captures[1]))
755 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
756 21 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 208, __FILE__, __LINE__, true);
757 : return _r;
758 : }
759 0 : next_after_fail256:;
760 0 : return NULL_TREE;
761 : }
762 :
763 : tree
764 2 : generic_simplify_157 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
765 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
766 : const enum tree_code ARG_UNUSED (bitop),
767 : const enum tree_code ARG_UNUSED (rbitop))
768 : {
769 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
770 2 : if (bitop == BIT_AND_EXPR
771 : )
772 : {
773 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail261;
774 1 : {
775 1 : tree _r;
776 1 : _r = build_zero_cst (type);
777 1 : if (TREE_SIDE_EFFECTS (captures[0]))
778 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
779 1 : if (TREE_SIDE_EFFECTS (captures[1]))
780 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
781 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 211, __FILE__, __LINE__, true);
782 : return _r;
783 : }
784 0 : next_after_fail261:;
785 : }
786 : else
787 : {
788 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail262;
789 1 : {
790 1 : tree _r;
791 1 : _r = build_minus_one_cst (type);
792 1 : if (TREE_SIDE_EFFECTS (captures[0]))
793 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
794 1 : if (TREE_SIDE_EFFECTS (captures[1]))
795 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
796 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 212, __FILE__, __LINE__, true);
797 : return _r;
798 : }
799 0 : next_after_fail262:;
800 : }
801 : return NULL_TREE;
802 : }
803 :
804 : tree
805 0 : generic_simplify_167 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
806 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
807 : {
808 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
809 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
810 0 : && TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))
811 : )
812 : {
813 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail275;
814 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail275;
815 0 : {
816 0 : tree res_op0;
817 0 : res_op0 = captures[3];
818 0 : tree res_op1;
819 0 : {
820 0 : tree _o1[2], _r1;
821 0 : _o1[0] = captures[1];
822 0 : _o1[1] = build_int_cst (TREE_TYPE (captures[1]), 1);
823 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
824 0 : res_op1 = _r1;
825 : }
826 0 : tree _r;
827 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
828 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 222, __FILE__, __LINE__, true);
829 : return _r;
830 : }
831 0 : next_after_fail275:;
832 : }
833 : return NULL_TREE;
834 : }
835 :
836 : tree
837 0 : generic_simplify_176 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
838 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
839 : {
840 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
841 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail303;
842 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail303;
843 0 : {
844 0 : tree _r;
845 0 : _r = captures[2];
846 0 : if (TREE_SIDE_EFFECTS (captures[1]))
847 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
848 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 221, __FILE__, __LINE__, true);
849 : return _r;
850 : }
851 0 : next_after_fail303:;
852 : return NULL_TREE;
853 : }
854 :
855 : tree
856 0 : generic_simplify_181 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
857 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
858 : const enum tree_code ARG_UNUSED (cmp),
859 : const enum tree_code ARG_UNUSED (bitop),
860 : const enum tree_code ARG_UNUSED (neeq))
861 : {
862 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
863 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail321;
864 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail321;
865 0 : {
866 0 : tree res_op0;
867 0 : {
868 0 : tree _o1[2], _r1;
869 0 : _o1[0] = build_zero_cst (TREE_TYPE (captures[0]));
870 0 : _o1[1] = captures[2];
871 0 : _r1 = fold_build2_loc (loc, cmp, type, _o1[0], _o1[1]);
872 0 : res_op0 = _r1;
873 : }
874 0 : tree res_op1;
875 0 : res_op1 = captures[3];
876 0 : tree _r;
877 0 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
878 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 240, __FILE__, __LINE__, true);
879 : return _r;
880 : }
881 0 : next_after_fail321:;
882 : return NULL_TREE;
883 : }
884 :
885 : tree
886 0 : generic_simplify_187 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
887 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
888 : const enum tree_code ARG_UNUSED (bitop),
889 : const enum tree_code ARG_UNUSED (op))
890 : {
891 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
892 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail328;
893 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail328;
894 0 : {
895 0 : tree _r;
896 0 : _r = captures[1];
897 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 246, __FILE__, __LINE__, true);
898 : return _r;
899 : }
900 0 : next_after_fail328:;
901 : return NULL_TREE;
902 : }
903 :
904 : tree
905 94 : generic_simplify_189 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
906 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
907 : const enum tree_code ARG_UNUSED (logic),
908 : const enum tree_code ARG_UNUSED (op),
909 : const enum tree_code ARG_UNUSED (ext))
910 : {
911 94 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
912 188 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
913 188 : && TREE_CODE (captures[1]) != INTEGER_CST
914 : )
915 : {
916 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail330;
917 0 : {
918 0 : tree res_op0;
919 0 : res_op0 = captures[1];
920 0 : tree res_op1;
921 0 : {
922 0 : tree _o1[2], _r1;
923 0 : _o1[0] = captures[2];
924 0 : _o1[1] = captures[4];
925 0 : _r1 = fold_build2_loc (loc, ext, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
926 0 : res_op1 = _r1;
927 : }
928 0 : tree _r;
929 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
930 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 247, __FILE__, __LINE__, true);
931 : return _r;
932 : }
933 0 : next_after_fail330:;
934 : }
935 : return NULL_TREE;
936 : }
937 :
938 : tree
939 0 : generic_simplify_194 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
940 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
941 : const combined_fn ARG_UNUSED (COPYSIGN_ALL))
942 : {
943 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
944 0 : if (!tree_expr_maybe_nan_p (captures[0]) && !HONOR_SIGNED_ZEROS (type)
945 : )
946 : {
947 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail335;
948 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail335;
949 0 : {
950 0 : tree res_op0;
951 0 : {
952 0 : tree _o1[1], _r1;
953 0 : _o1[0] = captures[0];
954 0 : _r1 = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
955 0 : res_op0 = _r1;
956 : }
957 0 : tree _r;
958 0 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
959 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 251, __FILE__, __LINE__, true);
960 : return _r;
961 : }
962 0 : next_after_fail335:;
963 : }
964 : return NULL_TREE;
965 : }
966 :
967 : tree
968 0 : generic_simplify_201 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
969 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
970 : {
971 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
972 0 : if (INTEGRAL_TYPE_P (type)
973 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
974 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
975 : )
976 : {
977 0 : if (TYPE_UNSIGNED (type)
978 : )
979 : {
980 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail343;
981 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail343;
982 0 : {
983 0 : tree res_op0;
984 0 : res_op0 = captures[0];
985 0 : tree _r;
986 0 : _r = fold_build1_loc (loc, ABSU_EXPR, type, res_op0);
987 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 256, __FILE__, __LINE__, true);
988 : return _r;
989 : }
990 0 : next_after_fail343:;
991 : }
992 : else
993 : {
994 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail344;
995 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail344;
996 0 : {
997 0 : tree res_op0;
998 0 : res_op0 = captures[0];
999 0 : tree _r;
1000 0 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
1001 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 257, __FILE__, __LINE__, true);
1002 : return _r;
1003 : }
1004 0 : next_after_fail344:;
1005 : }
1006 : }
1007 : return NULL_TREE;
1008 : }
1009 :
1010 : tree
1011 42292 : generic_simplify_207 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1012 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
1013 : {
1014 42292 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1015 42292 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail350;
1016 42292 : {
1017 42292 : tree res_op0;
1018 42292 : res_op0 = captures[0];
1019 42292 : tree _r;
1020 42292 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1021 42292 : if (TREE_SIDE_EFFECTS (captures[2]))
1022 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1023 42292 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 262, __FILE__, __LINE__, true);
1024 : return _r;
1025 : }
1026 0 : next_after_fail350:;
1027 0 : return NULL_TREE;
1028 : }
1029 :
1030 : tree
1031 6 : generic_simplify_213 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1032 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1033 : const combined_fn ARG_UNUSED (LDEXP))
1034 : {
1035 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1036 6 : if (flag_unsafe_math_optimizations
1037 : )
1038 : {
1039 6 : {
1040 6 : HOST_WIDE_INT tmp = 0;
1041 6 : if (real_isinteger (&TREE_REAL_CST (captures[0]), &tmp)
1042 6 : && tmp > 0 && pow2p_hwi (tmp)
1043 : )
1044 : {
1045 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail357;
1046 3 : {
1047 3 : tree res_op0;
1048 3 : res_op0 = captures[1];
1049 3 : tree res_op1;
1050 3 : {
1051 3 : tree _o1[2], _r1;
1052 3 : _o1[0] = build_int_cst (integer_type_node,
1053 6 : exact_log2 (tmp));
1054 3 : _o1[1] = captures[2];
1055 3 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1056 3 : res_op1 = _r1;
1057 : }
1058 3 : tree _r;
1059 3 : _r = maybe_build_call_expr_loc (loc, LDEXP, type, 2, res_op0, res_op1);
1060 3 : if (!_r)
1061 0 : goto next_after_fail357;
1062 3 : if (TREE_SIDE_EFFECTS (captures[0]))
1063 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1064 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 269, __FILE__, __LINE__, true);
1065 3 : return _r;
1066 : }
1067 3 : next_after_fail357:;
1068 : }
1069 : }
1070 : }
1071 : return NULL_TREE;
1072 : }
1073 :
1074 : tree
1075 7 : generic_simplify_224 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1076 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1077 : const enum tree_code ARG_UNUSED (neeq))
1078 : {
1079 7 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1080 7 : if (tree_fits_uhwi_p (captures[1])
1081 7 : && tree_to_uhwi (captures[1]) < TYPE_PRECISION (TREE_TYPE (captures[0]))
1082 : )
1083 : {
1084 7 : if (neeq == NE_EXPR
1085 : )
1086 : {
1087 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail371;
1088 5 : {
1089 5 : tree res_op0;
1090 5 : res_op0 = captures[0];
1091 5 : tree _r;
1092 5 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1093 5 : if (TREE_SIDE_EFFECTS (captures[1]))
1094 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1095 5 : if (TREE_SIDE_EFFECTS (captures[2]))
1096 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1097 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 282, __FILE__, __LINE__, true);
1098 : return _r;
1099 : }
1100 0 : next_after_fail371:;
1101 : }
1102 : else
1103 : {
1104 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail372;
1105 2 : {
1106 2 : tree res_op0;
1107 2 : res_op0 = captures[0];
1108 2 : tree res_op1;
1109 2 : res_op1 = captures[2];
1110 2 : tree _r;
1111 2 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
1112 2 : if (TREE_SIDE_EFFECTS (captures[1]))
1113 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1114 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 283, __FILE__, __LINE__, true);
1115 : return _r;
1116 : }
1117 0 : next_after_fail372:;
1118 : }
1119 : }
1120 : return NULL_TREE;
1121 : }
1122 :
1123 : tree
1124 43 : generic_simplify_234 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1125 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1126 : const enum tree_code ARG_UNUSED (op))
1127 : {
1128 43 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1129 43 : if (!TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[2]))
1130 : )
1131 : {
1132 43 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail395;
1133 43 : {
1134 43 : tree res_op0;
1135 43 : res_op0 = captures[1];
1136 43 : tree res_op1;
1137 43 : res_op1 = captures[3];
1138 43 : tree _r;
1139 43 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1140 43 : if (TREE_SIDE_EFFECTS (captures[2]))
1141 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1142 43 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 306, __FILE__, __LINE__, true);
1143 : return _r;
1144 : }
1145 0 : next_after_fail395:;
1146 : }
1147 : return NULL_TREE;
1148 : }
1149 :
1150 : tree
1151 21 : generic_simplify_242 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1152 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1153 : const enum tree_code ARG_UNUSED (cmp))
1154 : {
1155 21 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1156 21 : if (TREE_INT_CST_LOW (captures[1]) & 1
1157 : )
1158 : {
1159 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail403;
1160 2 : {
1161 2 : tree _r;
1162 2 : _r = constant_boolean_node (cmp == NE_EXPR, type);
1163 2 : if (TREE_SIDE_EFFECTS (captures[0]))
1164 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1165 2 : if (TREE_SIDE_EFFECTS (captures[1]))
1166 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1167 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 313, __FILE__, __LINE__, true);
1168 : return _r;
1169 : }
1170 0 : next_after_fail403:;
1171 : }
1172 : return NULL_TREE;
1173 : }
1174 :
1175 : tree
1176 22 : generic_simplify_250 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1177 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1178 : const enum tree_code ARG_UNUSED (cmp),
1179 : const enum tree_code ARG_UNUSED (icmp))
1180 : {
1181 22 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1182 22 : {
1183 22 : int c1 = wi::clz (wi::to_wide (captures[0]));
1184 22 : int c2 = wi::clz (wi::to_wide (captures[2]));
1185 22 : if (c1 < c2
1186 44 : || !wi::fits_to_tree_p (wi::shwi (c1 - c2, HOST_BITS_PER_INT),
1187 22 : TREE_TYPE (captures[1]))
1188 : )
1189 : {
1190 16 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail413;
1191 16 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail413;
1192 16 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail413;
1193 16 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail413;
1194 16 : {
1195 16 : tree _r;
1196 16 : _r = constant_boolean_node (cmp != NE_EXPR, type);
1197 16 : if (TREE_SIDE_EFFECTS (captures[1]))
1198 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1199 16 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 323, __FILE__, __LINE__, true);
1200 : return _r;
1201 : }
1202 22 : next_after_fail413:;
1203 : }
1204 : else
1205 : {
1206 6 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail414;
1207 6 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail414;
1208 6 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail414;
1209 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail414;
1210 6 : {
1211 6 : tree res_op0;
1212 6 : res_op0 = captures[1];
1213 6 : tree res_op1;
1214 6 : res_op1 = build_int_cst (TREE_TYPE (captures[1]), c1 - c2);
1215 6 : tree _r;
1216 6 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
1217 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 324, __FILE__, __LINE__, true);
1218 : return _r;
1219 : }
1220 22 : next_after_fail414:;
1221 : }
1222 : }
1223 : return NULL_TREE;
1224 : }
1225 :
1226 : tree
1227 58 : generic_simplify_260 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1228 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1229 : const enum tree_code ARG_UNUSED (cmp))
1230 : {
1231 58 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1232 58 : if (TREE_CODE (TREE_TYPE (captures[1])) != COMPLEX_TYPE
1233 58 : && (!VECTOR_MODE_P (TYPE_MODE (TREE_TYPE (captures[1])))
1234 9 : || !target_supports_op_p (TREE_TYPE (captures[1]), TRUNC_DIV_EXPR,
1235 : optab_vector)
1236 0 : || target_supports_op_p (TREE_TYPE (captures[1]), TRUNC_MOD_EXPR,
1237 : optab_vector))
1238 : )
1239 : {
1240 58 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail434;
1241 58 : {
1242 58 : tree res_op0;
1243 58 : {
1244 58 : tree _o1[2], _r1;
1245 58 : _o1[0] = captures[1];
1246 58 : _o1[1] = captures[2];
1247 58 : _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1248 58 : res_op0 = _r1;
1249 : }
1250 58 : tree res_op1;
1251 58 : res_op1 = build_zero_cst (TREE_TYPE (captures[1]));
1252 58 : tree _r;
1253 58 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1254 58 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 344, __FILE__, __LINE__, true);
1255 : return _r;
1256 : }
1257 0 : next_after_fail434:;
1258 : }
1259 : return NULL_TREE;
1260 : }
1261 :
1262 : tree
1263 15255 : generic_simplify_266 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1264 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1265 : const enum tree_code ARG_UNUSED (cmp))
1266 : {
1267 15255 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1268 15255 : if (single_use (captures[0])
1269 : )
1270 : {
1271 15255 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail441;
1272 15255 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail441;
1273 15255 : {
1274 15255 : tree res_op0;
1275 15255 : res_op0 = captures[1];
1276 15255 : tree res_op1;
1277 15255 : res_op1 = captures[2];
1278 15255 : tree _r;
1279 15255 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1280 15255 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 350, __FILE__, __LINE__, true);
1281 : return _r;
1282 : }
1283 15255 : next_after_fail441:;
1284 : }
1285 : return NULL_TREE;
1286 : }
1287 :
1288 : tree
1289 830138 : generic_simplify_272 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1290 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1291 : const enum tree_code ARG_UNUSED (cmp),
1292 : const enum tree_code ARG_UNUSED (scmp))
1293 : {
1294 830138 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1295 830138 : if (single_use (captures[0])
1296 830138 : && (TREE_CODE (captures[2]) == INTEGER_CST || TREE_CODE (captures[2]) == VECTOR_CST)
1297 : )
1298 : {
1299 830138 : {
1300 830138 : tree otype = TREE_TYPE (captures[2]);
1301 830138 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail452;
1302 830138 : {
1303 830138 : tree res_op0;
1304 830138 : {
1305 830138 : tree _o1[1], _r1;
1306 830138 : _o1[0] = captures[1];
1307 830138 : if (TREE_TYPE (_o1[0]) != otype)
1308 : {
1309 439 : _r1 = fold_build1_loc (loc, NOP_EXPR, otype, _o1[0]);
1310 : }
1311 : else
1312 : _r1 = _o1[0];
1313 830138 : res_op0 = _r1;
1314 : }
1315 830138 : tree res_op1;
1316 830138 : {
1317 830138 : tree _o1[1], _r1;
1318 830138 : _o1[0] = captures[2];
1319 830138 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
1320 830138 : res_op1 = _r1;
1321 : }
1322 830138 : tree _r;
1323 830138 : _r = fold_build2_loc (loc, scmp, type, res_op0, res_op1);
1324 830138 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 361, __FILE__, __LINE__, true);
1325 : return _r;
1326 : }
1327 0 : next_after_fail452:;
1328 : }
1329 : }
1330 : return NULL_TREE;
1331 : }
1332 :
1333 : tree
1334 1263 : generic_simplify_279 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1335 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1336 : const enum tree_code ARG_UNUSED (cmp),
1337 : const enum tree_code ARG_UNUSED (icmp))
1338 : {
1339 1263 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1340 1263 : if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1341 1263 : && ! DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1342 : )
1343 : {
1344 1263 : {
1345 1263 : format_helper fmt (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (captures[0]))));
1346 1263 : tree type1 = TREE_TYPE (captures[1]);
1347 1263 : bool type1_signed_p = TYPE_SIGN (type1) == SIGNED;
1348 1263 : bool type1_ok = fmt.can_represent_integral_type_p (type1);
1349 1263 : tree type2 = TREE_TYPE (captures[3]);
1350 1263 : bool type2_signed_p = TYPE_SIGN (type2) == SIGNED;
1351 1263 : bool type2_ok = fmt.can_represent_integral_type_p (type2);
1352 1263 : if (type1_ok && type2_ok
1353 : )
1354 : {
1355 229 : if (cmp == ORDERED_EXPR || cmp == UNORDERED_EXPR
1356 : )
1357 : {
1358 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail491;
1359 0 : {
1360 0 : tree _r;
1361 0 : _r = constant_boolean_node (cmp == ORDERED_EXPR, type);
1362 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1363 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1364 0 : if (TREE_SIDE_EFFECTS (captures[3]))
1365 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
1366 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 399, __FILE__, __LINE__, true);
1367 183 : return _r;
1368 : }
1369 0 : next_after_fail491:;
1370 : }
1371 : else
1372 : {
1373 229 : if (TYPE_PRECISION (type1) > TYPE_PRECISION (type2)
1374 229 : && type1_signed_p >= type2_signed_p
1375 : )
1376 : {
1377 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail492;
1378 0 : {
1379 0 : tree res_op0;
1380 0 : res_op0 = captures[1];
1381 0 : tree res_op1;
1382 0 : {
1383 0 : tree _o1[1], _r1;
1384 0 : _o1[0] = captures[3];
1385 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
1386 : {
1387 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
1388 : }
1389 : else
1390 : _r1 = _o1[0];
1391 0 : res_op1 = _r1;
1392 : }
1393 0 : tree _r;
1394 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
1395 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 400, __FILE__, __LINE__, true);
1396 : return _r;
1397 : }
1398 0 : next_after_fail492:;
1399 : }
1400 : else
1401 : {
1402 229 : if (TYPE_PRECISION (type1) < TYPE_PRECISION (type2)
1403 229 : && type1_signed_p <= type2_signed_p
1404 : )
1405 : {
1406 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail493;
1407 7 : {
1408 7 : tree res_op0;
1409 7 : {
1410 7 : tree _o1[1], _r1;
1411 7 : _o1[0] = captures[1];
1412 7 : if (TREE_TYPE (_o1[0]) != type2)
1413 : {
1414 7 : _r1 = fold_build1_loc (loc, NOP_EXPR, type2, _o1[0]);
1415 : }
1416 : else
1417 : _r1 = _o1[0];
1418 7 : res_op0 = _r1;
1419 : }
1420 7 : tree res_op1;
1421 7 : res_op1 = captures[3];
1422 7 : tree _r;
1423 7 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
1424 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 401, __FILE__, __LINE__, true);
1425 : return _r;
1426 : }
1427 0 : next_after_fail493:;
1428 : }
1429 : else
1430 : {
1431 222 : if (TYPE_PRECISION (type1) == TYPE_PRECISION (type2)
1432 222 : && type1_signed_p == type2_signed_p
1433 : )
1434 : {
1435 176 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail494;
1436 176 : {
1437 176 : tree res_op0;
1438 176 : res_op0 = captures[1];
1439 176 : tree res_op1;
1440 176 : {
1441 176 : tree _o1[1], _r1;
1442 176 : _o1[0] = captures[3];
1443 176 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
1444 : {
1445 1 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
1446 : }
1447 : else
1448 : _r1 = _o1[0];
1449 176 : res_op1 = _r1;
1450 : }
1451 176 : tree _r;
1452 176 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
1453 176 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 402, __FILE__, __LINE__, true);
1454 : return _r;
1455 : }
1456 0 : next_after_fail494:;
1457 : }
1458 : }
1459 : }
1460 : }
1461 : }
1462 : }
1463 : }
1464 : return NULL_TREE;
1465 : }
1466 :
1467 : tree
1468 436 : generic_simplify_292 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1469 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1470 : const enum tree_code ARG_UNUSED (cmp))
1471 : {
1472 436 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1473 436 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail530;
1474 436 : {
1475 436 : tree res_op0;
1476 436 : {
1477 436 : tree _o1[2], _r1;
1478 436 : _o1[0] = captures[0];
1479 436 : {
1480 436 : tree _o2[1], _r2;
1481 436 : _o2[0] = captures[1];
1482 436 : _r2 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
1483 436 : if (EXPR_P (_r2))
1484 428 : goto next_after_fail530;
1485 8 : _o1[1] = _r2;
1486 : }
1487 8 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1488 8 : res_op0 = _r1;
1489 : }
1490 8 : tree res_op1;
1491 8 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
1492 8 : tree _r;
1493 8 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1494 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 430, __FILE__, __LINE__, true);
1495 : return _r;
1496 : }
1497 436 : next_after_fail530:;
1498 : return NULL_TREE;
1499 : }
1500 :
1501 : tree
1502 39521 : generic_simplify_295 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1503 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1504 : const enum tree_code ARG_UNUSED (cmp))
1505 : {
1506 39521 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1507 39521 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail533;
1508 39521 : {
1509 39521 : tree res_op0;
1510 39521 : {
1511 39521 : tree _o1[2], _r1;
1512 39521 : {
1513 39521 : tree _o2[2], _r2;
1514 39521 : _o2[0] = captures[1];
1515 39521 : _o2[1] = captures[4];
1516 39521 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
1517 39521 : _o1[0] = _r2;
1518 : }
1519 39521 : _o1[1] = captures[2];
1520 39521 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1521 39521 : res_op0 = _r1;
1522 : }
1523 39521 : tree res_op1;
1524 39521 : res_op1 = build_zero_cst (TREE_TYPE (captures[2]));
1525 39521 : tree _r;
1526 39521 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1527 39521 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 433, __FILE__, __LINE__, true);
1528 : return _r;
1529 : }
1530 0 : next_after_fail533:;
1531 0 : return NULL_TREE;
1532 : }
1533 :
1534 : tree
1535 112543 : generic_simplify_302 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1536 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1537 : const enum tree_code ARG_UNUSED (cmp),
1538 : const enum tree_code ARG_UNUSED (ncmp))
1539 : {
1540 112543 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1541 224681 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1542 64223 : && type_has_mode_precision_p (TREE_TYPE (captures[1]))
1543 63154 : && element_precision (captures[0]) >= element_precision (captures[1])
1544 225086 : && wi::only_sign_bit_p (wi::to_wide (captures[2]), element_precision (captures[1]))
1545 : )
1546 : {
1547 6443 : {
1548 6443 : tree stype = signed_type_for (TREE_TYPE (captures[1]));
1549 6443 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail540;
1550 6443 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail540;
1551 6443 : {
1552 6443 : tree res_op0;
1553 6443 : {
1554 6443 : tree _o1[1], _r1;
1555 6443 : _o1[0] = captures[1];
1556 6443 : if (TREE_TYPE (_o1[0]) != stype)
1557 : {
1558 5791 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
1559 : }
1560 : else
1561 : _r1 = _o1[0];
1562 6443 : res_op0 = _r1;
1563 : }
1564 6443 : tree res_op1;
1565 6443 : res_op1 = build_zero_cst (stype);
1566 6443 : tree _r;
1567 6443 : _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
1568 6443 : if (TREE_SIDE_EFFECTS (captures[2]))
1569 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1570 6443 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 439, __FILE__, __LINE__, true);
1571 : return _r;
1572 : }
1573 112543 : next_after_fail540:;
1574 : }
1575 : }
1576 : return NULL_TREE;
1577 : }
1578 :
1579 : tree
1580 0 : generic_simplify_309 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1581 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1582 : const enum tree_code ARG_UNUSED (inner),
1583 : const enum tree_code ARG_UNUSED (outer))
1584 : {
1585 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1586 0 : {
1587 0 : bool cst1 = integer_onep (captures[1]);
1588 0 : bool cst0 = integer_zerop (captures[1]);
1589 0 : bool innereq = inner == EQ_EXPR;
1590 0 : bool outereq = outer == EQ_EXPR;
1591 0 : if (innereq ? cst0 : cst1
1592 : )
1593 : {
1594 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail561;
1595 0 : {
1596 0 : tree _r;
1597 0 : _r = constant_boolean_node (!outereq, type);
1598 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1599 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1600 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1601 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1602 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 451, __FILE__, __LINE__, true);
1603 : return _r;
1604 : }
1605 0 : next_after_fail561:;
1606 : }
1607 : else
1608 : {
1609 0 : if (innereq ? cst1 : cst0
1610 : )
1611 : {
1612 0 : {
1613 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[0]));
1614 0 : tree ucst1 = build_one_cst (utype);
1615 0 : if (!outereq
1616 : )
1617 : {
1618 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail562;
1619 0 : {
1620 0 : tree res_op0;
1621 0 : {
1622 0 : tree _o1[1], _r1;
1623 0 : _o1[0] = captures[0];
1624 0 : if (TREE_TYPE (_o1[0]) != utype)
1625 : {
1626 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, utype, _o1[0]);
1627 : }
1628 : else
1629 : _r1 = _o1[0];
1630 0 : res_op0 = _r1;
1631 : }
1632 0 : tree res_op1;
1633 0 : res_op1 = ucst1;
1634 0 : tree _r;
1635 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
1636 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1637 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1638 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 452, __FILE__, __LINE__, true);
1639 : return _r;
1640 : }
1641 0 : next_after_fail562:;
1642 : }
1643 : else
1644 : {
1645 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail563;
1646 0 : {
1647 0 : tree res_op0;
1648 0 : {
1649 0 : tree _o1[1], _r1;
1650 0 : _o1[0] = captures[0];
1651 0 : if (TREE_TYPE (_o1[0]) != utype)
1652 : {
1653 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, utype, _o1[0]);
1654 : }
1655 : else
1656 : _r1 = _o1[0];
1657 0 : res_op0 = _r1;
1658 : }
1659 0 : tree res_op1;
1660 0 : res_op1 = ucst1;
1661 0 : tree _r;
1662 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1663 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1664 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1665 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 453, __FILE__, __LINE__, true);
1666 : return _r;
1667 : }
1668 0 : next_after_fail563:;
1669 : }
1670 : }
1671 : }
1672 : else
1673 : {
1674 0 : {
1675 0 : tree value = build_int_cst (TREE_TYPE (captures[0]), !innereq);
1676 0 : if (outereq
1677 : )
1678 : {
1679 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail564;
1680 0 : {
1681 0 : tree res_op0;
1682 0 : res_op0 = captures[0];
1683 0 : tree res_op1;
1684 0 : res_op1 = value;
1685 0 : tree _r;
1686 0 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
1687 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1688 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1689 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 454, __FILE__, __LINE__, true);
1690 : return _r;
1691 : }
1692 0 : next_after_fail564:;
1693 : }
1694 : else
1695 : {
1696 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail565;
1697 0 : {
1698 0 : tree res_op0;
1699 0 : res_op0 = captures[0];
1700 0 : tree res_op1;
1701 0 : res_op1 = value;
1702 0 : tree _r;
1703 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
1704 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1705 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1706 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 455, __FILE__, __LINE__, true);
1707 : return _r;
1708 : }
1709 0 : next_after_fail565:;
1710 : }
1711 : }
1712 : }
1713 : }
1714 : }
1715 : return NULL_TREE;
1716 : }
1717 :
1718 : tree
1719 296822 : generic_simplify_320 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1720 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1721 : const enum tree_code ARG_UNUSED (cmp),
1722 : const enum tree_code ARG_UNUSED (icmp),
1723 : const enum tree_code ARG_UNUSED (ncmp))
1724 : {
1725 296822 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1726 296822 : if (types_match (type, TREE_TYPE (captures[0]))
1727 : )
1728 : {
1729 47265 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail591;
1730 47265 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail591;
1731 47265 : {
1732 47265 : tree res_op0;
1733 47265 : res_op0 = captures[1];
1734 47265 : tree res_op1;
1735 47265 : res_op1 = captures[2];
1736 47265 : tree _r;
1737 47265 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1738 47265 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 481, __FILE__, __LINE__, true);
1739 : return _r;
1740 : }
1741 296822 : next_after_fail591:;
1742 : }
1743 : return NULL_TREE;
1744 : }
1745 :
1746 : tree
1747 0 : generic_simplify_325 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1748 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1749 : const combined_fn ARG_UNUSED (copysigns))
1750 : {
1751 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1752 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail597;
1753 0 : {
1754 0 : tree res_op0;
1755 0 : res_op0 = captures[0];
1756 0 : tree res_op1;
1757 0 : res_op1 = captures[2];
1758 0 : tree _r;
1759 0 : _r = maybe_build_call_expr_loc (loc, copysigns, type, 2, res_op0, res_op1);
1760 0 : if (!_r)
1761 0 : goto next_after_fail597;
1762 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1763 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1764 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 487, __FILE__, __LINE__, true);
1765 : return _r;
1766 : }
1767 0 : next_after_fail597:;
1768 : return NULL_TREE;
1769 : }
1770 :
1771 : tree
1772 24 : generic_simplify_330 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1773 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1774 : const enum tree_code ARG_UNUSED (div))
1775 : {
1776 24 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1777 32 : if ((TYPE_UNSIGNED (type) || tree_expr_nonnegative_p (captures[0]))
1778 16 : && (!VECTOR_TYPE_P (type)
1779 0 : || target_supports_op_p (type, RSHIFT_EXPR, optab_vector)
1780 0 : || target_supports_op_p (type, RSHIFT_EXPR, optab_scalar))
1781 40 : && (useless_type_conversion_p (type, TREE_TYPE (captures[2]))
1782 7 : || (element_precision (type) >= element_precision (TREE_TYPE (captures[2]))
1783 7 : && (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
1784 14 : || (element_precision (type)
1785 7 : == element_precision (TREE_TYPE (captures[2])))
1786 7 : || (INTEGRAL_TYPE_P (type)
1787 14 : && (tree_nonzero_bits (captures[0])
1788 45 : & wi::mask (element_precision (TREE_TYPE (captures[2])) - 1,
1789 : true,
1790 38 : element_precision (type))) == 0))))
1791 : )
1792 : {
1793 9 : if (!VECTOR_TYPE_P (type)
1794 9 : && useless_type_conversion_p (TREE_TYPE (captures[1]), TREE_TYPE (captures[2]))
1795 18 : && element_precision (TREE_TYPE (captures[1])) < element_precision (type)
1796 : )
1797 : {
1798 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail603;
1799 0 : {
1800 0 : tree res_op0;
1801 0 : {
1802 0 : tree _o1[2], _r1;
1803 0 : _o1[0] = captures[1];
1804 0 : _o1[1] = captures[3];
1805 0 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1806 0 : res_op0 = _r1;
1807 : }
1808 0 : tree _r;
1809 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1810 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1811 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1812 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 491, __FILE__, __LINE__, true);
1813 : return _r;
1814 : }
1815 0 : next_after_fail603:;
1816 : }
1817 : else
1818 : {
1819 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail604;
1820 9 : {
1821 9 : tree res_op0;
1822 9 : res_op0 = captures[0];
1823 9 : tree res_op1;
1824 9 : res_op1 = captures[3];
1825 9 : tree _r;
1826 9 : _r = fold_build2_loc (loc, RSHIFT_EXPR, type, res_op0, res_op1);
1827 9 : if (TREE_SIDE_EFFECTS (captures[2]))
1828 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1829 9 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 492, __FILE__, __LINE__, true);
1830 : return _r;
1831 : }
1832 0 : next_after_fail604:;
1833 : }
1834 : }
1835 : return NULL_TREE;
1836 : }
1837 :
1838 : tree
1839 230 : generic_simplify_346 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1840 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1841 : const enum tree_code ARG_UNUSED (mod))
1842 : {
1843 230 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1844 230 : if (!integer_zerop (captures[0])
1845 : )
1846 : {
1847 93 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail621;
1848 93 : {
1849 93 : tree _r;
1850 93 : _r = build_zero_cst (type);
1851 93 : if (TREE_SIDE_EFFECTS (captures[0]))
1852 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1853 93 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 509, __FILE__, __LINE__, true);
1854 : return _r;
1855 : }
1856 0 : next_after_fail621:;
1857 : }
1858 : return NULL_TREE;
1859 : }
1860 :
1861 : tree
1862 5 : generic_simplify_356 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1863 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1864 : const combined_fn ARG_UNUSED (SINH),
1865 : const combined_fn ARG_UNUSED (COSH),
1866 : const combined_fn ARG_UNUSED (TANH))
1867 : {
1868 5 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1869 5 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1870 : )
1871 : {
1872 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail633;
1873 3 : {
1874 3 : tree res_op0;
1875 3 : res_op0 = captures[1];
1876 3 : tree _r;
1877 3 : _r = maybe_build_call_expr_loc (loc, TANH, type, 1, res_op0);
1878 3 : if (!_r)
1879 0 : goto next_after_fail633;
1880 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 521, __FILE__, __LINE__, true);
1881 : return _r;
1882 : }
1883 5 : next_after_fail633:;
1884 : }
1885 : return NULL_TREE;
1886 : }
1887 :
1888 : tree
1889 170314 : generic_simplify_363 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1890 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1891 : const enum tree_code ARG_UNUSED (cmp))
1892 : {
1893 170314 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1894 170314 : {
1895 170314 : tree from_type = TREE_TYPE (captures[0]);
1896 170314 : tree c1_type = TREE_TYPE (captures[1]), c2_type = TREE_TYPE (captures[2]);
1897 170314 : enum tree_code code = ERROR_MARK;
1898 170314 : if (integer_zerop (captures[1])
1899 70436 : && INTEGRAL_TYPE_P (from_type)
1900 67731 : && (cmp == GE_EXPR || cmp == LT_EXPR)
1901 17897 : && TYPE_UNSIGNED (from_type)
1902 1809 : && !TYPE_UNSIGNED (c1_type)
1903 1809 : && TYPE_PRECISION (from_type) == TYPE_PRECISION (c1_type)
1904 603 : && int_fits_type_p (captures[2], from_type)
1905 170917 : && (types_match (c2_type, from_type)
1906 16 : || (TYPE_PRECISION (c2_type) > TYPE_PRECISION (from_type)
1907 16 : && (TYPE_UNSIGNED (from_type)
1908 0 : || TYPE_SIGN (c2_type) == TYPE_SIGN (from_type)))))
1909 : {
1910 603 : tree_code ncmp = cmp == GE_EXPR ? LE_EXPR : GT_EXPR;
1911 603 : widest_int c1 = wi::mask<widest_int>(TYPE_PRECISION (c1_type) - 1, 0);
1912 603 : code = minmax_from_comparison (ncmp, captures[0], c1, wi::to_widest (captures[2]));
1913 603 : }
1914 603 : if (code == ERROR_MARK
1915 170309 : && INTEGRAL_TYPE_P (from_type)
1916 167604 : && int_fits_type_p (captures[2], from_type)
1917 167603 : && (types_match (c1_type, from_type)
1918 7216 : || (TYPE_PRECISION (c1_type) > TYPE_PRECISION (from_type)
1919 0 : && (TYPE_UNSIGNED (from_type)
1920 0 : || TYPE_SIGN (c1_type) == TYPE_SIGN (from_type))))
1921 160990 : && (types_match (c2_type, from_type)
1922 63569 : || (TYPE_PRECISION (c2_type) > TYPE_PRECISION (from_type)
1923 19620 : && (TYPE_UNSIGNED (from_type)
1924 729 : || TYPE_SIGN (c2_type) == TYPE_SIGN (from_type)))))
1925 : {
1926 115790 : if (cmp != EQ_EXPR)
1927 115778 : code = minmax_from_comparison (cmp, captures[0], captures[1], captures[0], captures[2]);
1928 12 : else if (int_fits_type_p (captures[1], from_type))
1929 : code = EQ_EXPR;
1930 : }
1931 170302 : if (code == MAX_EXPR
1932 : )
1933 : {
1934 20275 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail640;
1935 20275 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail640;
1936 20275 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail640;
1937 20275 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail640;
1938 20275 : {
1939 20275 : tree res_op0;
1940 20275 : {
1941 20275 : tree _o1[2], _r1;
1942 20275 : _o1[0] = captures[0];
1943 20275 : {
1944 20275 : tree _o2[1], _r2;
1945 20275 : _o2[0] = captures[2];
1946 20275 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
1947 : {
1948 315 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
1949 : }
1950 : else
1951 : _r2 = _o2[0];
1952 20275 : _o1[1] = _r2;
1953 : }
1954 20275 : _r1 = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1955 20275 : res_op0 = _r1;
1956 : }
1957 20275 : tree _r;
1958 20275 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1959 20275 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 528, __FILE__, __LINE__, true);
1960 : return _r;
1961 : }
1962 170314 : next_after_fail640:;
1963 : }
1964 : else
1965 : {
1966 150039 : if (code == MIN_EXPR
1967 : )
1968 : {
1969 260 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail641;
1970 260 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail641;
1971 260 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail641;
1972 260 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail641;
1973 260 : {
1974 260 : tree res_op0;
1975 260 : {
1976 260 : tree _o1[2], _r1;
1977 260 : _o1[0] = captures[0];
1978 260 : {
1979 260 : tree _o2[1], _r2;
1980 260 : _o2[0] = captures[2];
1981 260 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
1982 : {
1983 100 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
1984 : }
1985 : else
1986 : _r2 = _o2[0];
1987 260 : _o1[1] = _r2;
1988 : }
1989 260 : _r1 = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1990 260 : res_op0 = _r1;
1991 : }
1992 260 : tree _r;
1993 260 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1994 260 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 529, __FILE__, __LINE__, true);
1995 : return _r;
1996 : }
1997 170314 : next_after_fail641:;
1998 : }
1999 : else
2000 : {
2001 149779 : if (code == EQ_EXPR
2002 : )
2003 : {
2004 12 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail642;
2005 12 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail642;
2006 12 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail642;
2007 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail642;
2008 12 : {
2009 12 : if (! tree_invariant_p (captures[1])) goto next_after_fail642;
2010 12 : tree res_op0;
2011 12 : {
2012 12 : tree _o1[3], _r1;
2013 12 : {
2014 12 : tree _o2[2], _r2;
2015 12 : _o2[0] = captures[0];
2016 12 : {
2017 12 : tree _o3[1], _r3;
2018 12 : _o3[0] = unshare_expr (captures[1]);
2019 12 : if (TREE_TYPE (_o3[0]) != TREE_TYPE (_o2[0]))
2020 : {
2021 0 : _r3 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o2[0]), _o3[0]);
2022 : }
2023 : else
2024 : _r3 = _o3[0];
2025 12 : _o2[1] = _r3;
2026 : }
2027 12 : _r2 = fold_build2_loc (loc, EQ_EXPR, boolean_type_node, _o2[0], _o2[1]);
2028 12 : _o1[0] = _r2;
2029 : }
2030 12 : {
2031 12 : tree _o2[1], _r2;
2032 12 : _o2[0] = captures[1];
2033 12 : if (TREE_TYPE (_o2[0]) != from_type)
2034 : {
2035 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, from_type, _o2[0]);
2036 : }
2037 : else
2038 : _r2 = _o2[0];
2039 12 : _o1[1] = _r2;
2040 : }
2041 12 : {
2042 12 : tree _o2[1], _r2;
2043 12 : _o2[0] = captures[2];
2044 12 : if (TREE_TYPE (_o2[0]) != from_type)
2045 : {
2046 7 : _r2 = fold_build1_loc (loc, NOP_EXPR, from_type, _o2[0]);
2047 : }
2048 : else
2049 : _r2 = _o2[0];
2050 12 : _o1[2] = _r2;
2051 : }
2052 12 : _r1 = fold_build3_loc (loc, COND_EXPR, TREE_TYPE (_o1[1]), _o1[0], _o1[1], _o1[2]);
2053 12 : res_op0 = _r1;
2054 : }
2055 12 : tree _r;
2056 12 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2057 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 530, __FILE__, __LINE__, true);
2058 : return _r;
2059 : }
2060 170314 : next_after_fail642:;
2061 : }
2062 : }
2063 : }
2064 : }
2065 : return NULL_TREE;
2066 : }
2067 :
2068 : tree
2069 5312 : generic_simplify_406 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2070 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2071 : const enum tree_code ARG_UNUSED (cmp),
2072 : const enum tree_code ARG_UNUSED (bitop))
2073 : {
2074 5312 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2075 5312 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2076 : )
2077 : {
2078 5312 : if (bitop == BIT_AND_EXPR || tree_expr_nonnegative_p (captures[1])
2079 : )
2080 : {
2081 5312 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail698;
2082 5312 : {
2083 5312 : tree _r;
2084 5312 : _r = constant_boolean_node (cmp == GE_EXPR || cmp == LE_EXPR, type);
2085 5312 : if (TREE_SIDE_EFFECTS (captures[0]))
2086 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2087 5312 : if (TREE_SIDE_EFFECTS (captures[1]))
2088 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2089 5312 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 584, __FILE__, __LINE__, true);
2090 : return _r;
2091 : }
2092 0 : next_after_fail698:;
2093 : }
2094 : else
2095 : {
2096 0 : if (TREE_CODE (captures[1]) == INTEGER_CST && wi::neg_p (wi::to_wide (captures[1]))
2097 : )
2098 : {
2099 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail699;
2100 0 : {
2101 0 : tree _r;
2102 0 : _r = constant_boolean_node (cmp == LT_EXPR, type);
2103 0 : if (TREE_SIDE_EFFECTS (captures[0]))
2104 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2105 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2106 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2107 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 585, __FILE__, __LINE__, true);
2108 : return _r;
2109 : }
2110 0 : next_after_fail699:;
2111 : }
2112 : }
2113 : }
2114 : return NULL_TREE;
2115 : }
2116 :
2117 : tree
2118 9814 : generic_simplify_421 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2119 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2120 : const enum tree_code ARG_UNUSED (cmp))
2121 : {
2122 9814 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2123 9814 : if (single_use (captures[0])
2124 9814 : && ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2125 9798 : && TYPE_UNSIGNED (TREE_TYPE (captures[1]))
2126 : )
2127 : {
2128 7408 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail746;
2129 7408 : {
2130 7408 : tree res_op0;
2131 7408 : res_op0 = captures[2];
2132 7408 : tree res_op1;
2133 7408 : res_op1 = captures[1];
2134 7408 : tree _r;
2135 7408 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2136 7408 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 615, __FILE__, __LINE__, true);
2137 : return _r;
2138 : }
2139 0 : next_after_fail746:;
2140 : }
2141 : return NULL_TREE;
2142 : }
2143 :
2144 : tree
2145 1131 : generic_simplify_425 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2146 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2147 : const enum tree_code ARG_UNUSED (cmp),
2148 : const enum tree_code ARG_UNUSED (out))
2149 : {
2150 1131 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2151 1131 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2])) && !VECTOR_TYPE_P (TREE_TYPE (captures[2]))
2152 : )
2153 : {
2154 1113 : {
2155 1113 : tree t = TREE_TYPE (captures[2]), cpx = build_complex_type (t);
2156 1113 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail750;
2157 1101 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail750;
2158 1101 : {
2159 1101 : tree res_op0;
2160 1101 : {
2161 1101 : tree _o1[1], _r1;
2162 1101 : {
2163 1101 : tree _o2[2], _r2;
2164 1101 : _o2[0] = captures[2];
2165 1101 : _o2[1] = captures[1];
2166 1101 : _r2 = maybe_build_call_expr_loc (loc, CFN_MUL_OVERFLOW, cpx, 2, _o2[0], _o2[1]);
2167 1101 : if (!_r2)
2168 0 : goto next_after_fail750;
2169 1101 : _o1[0] = _r2;
2170 : }
2171 1101 : _r1 = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
2172 1101 : res_op0 = _r1;
2173 : }
2174 1101 : tree res_op1;
2175 1101 : res_op1 = build_zero_cst (t);
2176 1101 : tree _r;
2177 1101 : _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
2178 1101 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 619, __FILE__, __LINE__, true);
2179 : return _r;
2180 : }
2181 1131 : next_after_fail750:;
2182 : }
2183 : }
2184 : return NULL_TREE;
2185 : }
2186 :
2187 : tree
2188 20713716 : generic_simplify_432 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2189 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2190 : const enum tree_code ARG_UNUSED (cmp),
2191 : const enum tree_code ARG_UNUSED (acmp))
2192 : {
2193 20713716 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2194 20713716 : {
2195 20713716 : tree cst = uniform_integer_cst_p (captures[1]);
2196 20713716 : if (tree_int_cst_sgn (cst) == -1
2197 : )
2198 : {
2199 180435 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail764;
2200 180435 : {
2201 180435 : tree res_op0;
2202 180435 : res_op0 = captures[0];
2203 180435 : tree res_op1;
2204 180435 : res_op1 = build_uniform_cst (TREE_TYPE (captures[1]),
2205 180435 : wide_int_to_tree (TREE_TYPE (cst),
2206 180435 : wi::to_wide (cst)
2207 360870 : + 1));
2208 180435 : tree _r;
2209 180435 : _r = fold_build2_loc (loc, acmp, type, res_op0, res_op1);
2210 180435 : if (TREE_SIDE_EFFECTS (captures[1]))
2211 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2212 180435 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 633, __FILE__, __LINE__, true);
2213 : return _r;
2214 : }
2215 0 : next_after_fail764:;
2216 : }
2217 : }
2218 : return NULL_TREE;
2219 : }
2220 :
2221 : tree
2222 0 : generic_simplify_437 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2223 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2224 : const enum tree_code ARG_UNUSED (cmp),
2225 : const enum tree_code ARG_UNUSED (out))
2226 : {
2227 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2228 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2])) && !VECTOR_TYPE_P (TREE_TYPE (captures[2]))
2229 : )
2230 : {
2231 0 : {
2232 0 : tree t = TREE_TYPE (captures[2]), cpx = build_complex_type (t);
2233 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail769;
2234 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail769;
2235 0 : {
2236 0 : tree res_op0;
2237 0 : {
2238 0 : tree _o1[1], _r1;
2239 0 : {
2240 0 : tree _o2[2], _r2;
2241 0 : _o2[0] = captures[2];
2242 0 : _o2[1] = captures[1];
2243 0 : _r2 = maybe_build_call_expr_loc (loc, CFN_MUL_OVERFLOW, cpx, 2, _o2[0], _o2[1]);
2244 0 : if (!_r2)
2245 0 : goto next_after_fail769;
2246 0 : _o1[0] = _r2;
2247 : }
2248 0 : _r1 = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
2249 0 : res_op0 = _r1;
2250 : }
2251 0 : tree res_op1;
2252 0 : res_op1 = build_zero_cst (t);
2253 0 : tree _r;
2254 0 : _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
2255 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 619, __FILE__, __LINE__, true);
2256 : return _r;
2257 : }
2258 0 : next_after_fail769:;
2259 : }
2260 : }
2261 : return NULL_TREE;
2262 : }
2263 :
2264 : tree
2265 11 : generic_simplify_445 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2266 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2267 : {
2268 11 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2269 11 : if (wi::ltu_p (wi::to_wide (captures[1]), element_precision (type))
2270 : )
2271 : {
2272 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail781;
2273 11 : {
2274 11 : tree res_op0;
2275 11 : {
2276 11 : tree _o1[1], _r1;
2277 11 : _o1[0] = captures[0];
2278 11 : if (TREE_TYPE (_o1[0]) != type)
2279 : {
2280 8 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
2281 : }
2282 : else
2283 : _r1 = _o1[0];
2284 11 : res_op0 = _r1;
2285 : }
2286 11 : tree res_op1;
2287 11 : {
2288 11 : tree _o1[2], _r1;
2289 11 : _o1[0] = build_minus_one_cst (type);
2290 11 : _o1[1] = captures[1];
2291 11 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2292 11 : res_op1 = _r1;
2293 : }
2294 11 : tree _r;
2295 11 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2296 11 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 646, __FILE__, __LINE__, true);
2297 : return _r;
2298 : }
2299 0 : next_after_fail781:;
2300 : }
2301 : return NULL_TREE;
2302 : }
2303 :
2304 : tree
2305 28047 : generic_simplify_452 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2306 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2307 : const enum tree_code ARG_UNUSED (bit_op),
2308 : const enum tree_code ARG_UNUSED (shift))
2309 : {
2310 28047 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2311 28047 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[2]))
2312 : )
2313 : {
2314 28047 : {
2315 28047 : tree mask = int_const_binop (shift, fold_convert (type, captures[3]), captures[4]);
2316 28047 : if (mask
2317 : )
2318 : {
2319 28040 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail791;
2320 28040 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail791;
2321 28040 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail791;
2322 28040 : {
2323 28040 : tree res_op0;
2324 28040 : {
2325 28040 : tree _o1[2], _r1;
2326 28040 : {
2327 28040 : tree _o2[1], _r2;
2328 28040 : _o2[0] = captures[2];
2329 28040 : if (TREE_TYPE (_o2[0]) != type)
2330 : {
2331 70 : _r2 = fold_build1_loc (loc, NOP_EXPR, type, _o2[0]);
2332 : }
2333 : else
2334 : _r2 = _o2[0];
2335 28040 : _o1[0] = _r2;
2336 : }
2337 28040 : _o1[1] = captures[4];
2338 28040 : _r1 = fold_build2_loc (loc, shift, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2339 28040 : res_op0 = _r1;
2340 : }
2341 28040 : tree res_op1;
2342 28040 : res_op1 = mask;
2343 28040 : tree _r;
2344 28040 : _r = fold_build2_loc (loc, bit_op, type, res_op0, res_op1);
2345 28040 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 654, __FILE__, __LINE__, true);
2346 : return _r;
2347 : }
2348 28047 : next_after_fail791:;
2349 : }
2350 : }
2351 : }
2352 : return NULL_TREE;
2353 : }
2354 :
2355 : tree
2356 2396 : generic_simplify_459 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2357 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2358 : const enum tree_code ARG_UNUSED (eqne))
2359 : {
2360 2396 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2361 2396 : if ((integer_zerop (captures[1]) || integer_onep (captures[1]))
2362 : )
2363 : {
2364 2394 : if ((eqne == EQ_EXPR) ^ integer_zerop (captures[1])
2365 : )
2366 : {
2367 1571 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail804;
2368 1571 : {
2369 1571 : tree res_op0;
2370 1571 : res_op0 = captures[0];
2371 1571 : tree _r;
2372 1571 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2373 1571 : if (TREE_SIDE_EFFECTS (captures[1]))
2374 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2375 1571 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 667, __FILE__, __LINE__, true);
2376 : return _r;
2377 : }
2378 0 : next_after_fail804:;
2379 : }
2380 : else
2381 : {
2382 823 : if (types_match (type, TREE_TYPE (captures[0]))
2383 : )
2384 : {
2385 41 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail805;
2386 41 : {
2387 41 : tree res_op0;
2388 41 : res_op0 = captures[0];
2389 41 : tree res_op1;
2390 41 : res_op1 = build_one_cst (type);
2391 41 : tree _r;
2392 41 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
2393 41 : if (TREE_SIDE_EFFECTS (captures[1]))
2394 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2395 41 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 668, __FILE__, __LINE__, true);
2396 : return _r;
2397 : }
2398 0 : next_after_fail805:;
2399 : }
2400 : }
2401 : }
2402 : return NULL_TREE;
2403 : }
2404 :
2405 : tree
2406 22333222 : generic_simplify_464 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2407 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2408 : const enum tree_code ARG_UNUSED (op))
2409 : {
2410 22333222 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2411 22333222 : if (INTEGRAL_TYPE_P (type)
2412 20778909 : && op != MULT_EXPR
2413 20778909 : && op != RDIV_EXPR
2414 11495451 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2415 11495451 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2416 11495451 : && type_has_mode_precision_p (TREE_TYPE (captures[2]))
2417 11494143 : && type_has_mode_precision_p (TREE_TYPE (captures[4]))
2418 11494143 : && type_has_mode_precision_p (type)
2419 11458534 : && TYPE_PRECISION (TREE_TYPE (captures[1])) > TYPE_PRECISION (TREE_TYPE (captures[2]))
2420 0 : && types_match (captures[2], type)
2421 22333222 : && (types_match (captures[2], captures[4])
2422 0 : || poly_int_tree_p (captures[3]))
2423 : )
2424 : {
2425 0 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))
2426 : )
2427 : {
2428 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail819;
2429 0 : {
2430 0 : tree res_op0;
2431 0 : res_op0 = captures[2];
2432 0 : tree res_op1;
2433 0 : {
2434 0 : tree _o1[1], _r1;
2435 0 : _o1[0] = captures[4];
2436 0 : if (TREE_TYPE (_o1[0]) != type)
2437 : {
2438 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2439 : }
2440 : else
2441 : _r1 = _o1[0];
2442 0 : res_op1 = _r1;
2443 : }
2444 0 : tree _r;
2445 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2446 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 670, __FILE__, __LINE__, true);
2447 : return _r;
2448 : }
2449 0 : next_after_fail819:;
2450 : }
2451 : else
2452 : {
2453 0 : {
2454 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
2455 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail820;
2456 0 : {
2457 0 : tree res_op0;
2458 0 : {
2459 0 : tree _o1[2], _r1;
2460 0 : {
2461 0 : tree _o2[1], _r2;
2462 0 : _o2[0] = captures[2];
2463 0 : if (TREE_TYPE (_o2[0]) != utype)
2464 : {
2465 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2466 : }
2467 : else
2468 : _r2 = _o2[0];
2469 0 : _o1[0] = _r2;
2470 : }
2471 0 : {
2472 0 : tree _o2[1], _r2;
2473 0 : _o2[0] = captures[4];
2474 0 : if (TREE_TYPE (_o2[0]) != utype)
2475 : {
2476 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2477 : }
2478 : else
2479 : _r2 = _o2[0];
2480 0 : _o1[1] = _r2;
2481 : }
2482 0 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2483 0 : res_op0 = _r1;
2484 : }
2485 0 : tree _r;
2486 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2487 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 671, __FILE__, __LINE__, true);
2488 : return _r;
2489 : }
2490 0 : next_after_fail820:;
2491 : }
2492 : }
2493 : }
2494 : else
2495 : {
2496 22281227 : if (FLOAT_TYPE_P (type)
2497 22385217 : && DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
2498 51995 : == DECIMAL_FLOAT_TYPE_P (type)
2499 : )
2500 : {
2501 51955 : {
2502 51955 : tree arg0 = strip_float_extensions (captures[2]);
2503 51955 : tree arg1 = strip_float_extensions (captures[4]);
2504 51955 : tree itype = TREE_TYPE (captures[0]);
2505 51955 : tree ty1 = TREE_TYPE (arg0);
2506 51955 : tree ty2 = TREE_TYPE (arg1);
2507 51955 : enum tree_code code = TREE_CODE (itype);
2508 0 : if (FLOAT_TYPE_P (ty1)
2509 51955 : && FLOAT_TYPE_P (ty2)
2510 : )
2511 : {
2512 51955 : {
2513 51955 : tree newtype = type;
2514 51955 : if (TYPE_MODE (ty1) == SDmode
2515 51687 : || TYPE_MODE (ty2) == SDmode
2516 103642 : || TYPE_MODE (type) == SDmode)
2517 283 : newtype = dfloat32_type_node;
2518 51955 : if (TYPE_MODE (ty1) == DDmode
2519 51809 : || TYPE_MODE (ty2) == DDmode
2520 103637 : || TYPE_MODE (type) == DDmode)
2521 275 : newtype = dfloat64_type_node;
2522 51955 : if (TYPE_MODE (ty1) == TDmode
2523 51954 : || TYPE_MODE (ty2) == TDmode
2524 103657 : || TYPE_MODE (type) == TDmode)
2525 268 : newtype = dfloat128_type_node;
2526 51955 : if ((newtype == dfloat32_type_node
2527 51951 : || newtype == dfloat64_type_node
2528 51808 : || newtype == dfloat128_type_node)
2529 415 : && newtype == type
2530 51966 : && types_match (newtype, type)
2531 : )
2532 : {
2533 11 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail821;
2534 5 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail821;
2535 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail821;
2536 5 : {
2537 5 : tree res_op0;
2538 5 : {
2539 5 : tree _o1[1], _r1;
2540 5 : _o1[0] = captures[2];
2541 5 : if (TREE_TYPE (_o1[0]) != newtype)
2542 : {
2543 5 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
2544 : }
2545 : else
2546 : _r1 = _o1[0];
2547 5 : res_op0 = _r1;
2548 : }
2549 5 : tree res_op1;
2550 5 : {
2551 5 : tree _o1[1], _r1;
2552 5 : _o1[0] = captures[4];
2553 5 : if (TREE_TYPE (_o1[0]) != newtype)
2554 : {
2555 5 : _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
2556 : }
2557 : else
2558 : _r1 = _o1[0];
2559 5 : res_op1 = _r1;
2560 : }
2561 5 : tree _r;
2562 5 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2563 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 672, __FILE__, __LINE__, true);
2564 : return _r;
2565 : }
2566 22333222 : next_after_fail821:;
2567 : }
2568 : else
2569 : {
2570 51944 : {
2571 51944 : if (element_precision (ty1) > element_precision (newtype))
2572 11855 : newtype = ty1;
2573 51944 : if (element_precision (ty2) > element_precision (newtype))
2574 4895 : newtype = ty2;
2575 51944 : if (element_precision (newtype) < element_precision (itype)
2576 14633 : && (!VECTOR_MODE_P (TYPE_MODE (newtype))
2577 0 : || target_supports_op_p (newtype, op, optab_default))
2578 14633 : && (flag_unsafe_math_optimizations
2579 14625 : || (element_precision (newtype) == element_precision (type)
2580 14596 : && real_can_shorten_arithmetic (element_mode (itype),
2581 : element_mode (type))
2582 4623 : && !excess_precision_type (newtype)))
2583 52099 : && !types_match (itype, newtype)
2584 : )
2585 : {
2586 155 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail822;
2587 154 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail822;
2588 136 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail822;
2589 136 : {
2590 136 : tree res_op0;
2591 136 : {
2592 136 : tree _o1[2], _r1;
2593 136 : {
2594 136 : tree _o2[1], _r2;
2595 136 : _o2[0] = captures[2];
2596 136 : if (TREE_TYPE (_o2[0]) != newtype)
2597 : {
2598 136 : _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
2599 : }
2600 : else
2601 : _r2 = _o2[0];
2602 136 : _o1[0] = _r2;
2603 : }
2604 136 : {
2605 136 : tree _o2[1], _r2;
2606 136 : _o2[0] = captures[4];
2607 136 : if (TREE_TYPE (_o2[0]) != newtype)
2608 : {
2609 136 : _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
2610 : }
2611 : else
2612 : _r2 = _o2[0];
2613 136 : _o1[1] = _r2;
2614 : }
2615 136 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2616 136 : res_op0 = _r1;
2617 : }
2618 136 : tree _r;
2619 136 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2620 136 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 673, __FILE__, __LINE__, true);
2621 : return _r;
2622 : }
2623 22333222 : next_after_fail822:;
2624 : }
2625 : }
2626 : }
2627 : }
2628 : }
2629 : }
2630 : }
2631 : }
2632 : return NULL_TREE;
2633 : }
2634 :
2635 : tree
2636 0 : generic_simplify_496 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2637 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2638 : const enum tree_code ARG_UNUSED (cmp))
2639 : {
2640 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2641 0 : if (fold_before_rtl_expansion_p ()
2642 : )
2643 : {
2644 0 : if (INTEGRAL_TYPE_P (type)
2645 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2646 : )
2647 : {
2648 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail854;
2649 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail854;
2650 0 : {
2651 0 : tree res_op0;
2652 0 : res_op0 = captures[0];
2653 0 : tree res_op1;
2654 0 : res_op1 = captures[3];
2655 0 : tree res_op2;
2656 0 : res_op2 = build_zero_cst (type);
2657 0 : tree _r;
2658 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
2659 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 704, __FILE__, __LINE__, true);
2660 : return _r;
2661 : }
2662 0 : next_after_fail854:;
2663 : }
2664 : }
2665 : return NULL_TREE;
2666 : }
2667 :
2668 : tree
2669 0 : generic_simplify_506 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2670 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2671 : const enum tree_code ARG_UNUSED (eqne))
2672 : {
2673 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2674 0 : if (eqne == EQ_EXPR
2675 : )
2676 : {
2677 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail885;
2678 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail885;
2679 0 : {
2680 0 : tree _r;
2681 0 : _r = constant_boolean_node (false, type);
2682 0 : if (TREE_SIDE_EFFECTS (captures[2]))
2683 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2684 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 708, __FILE__, __LINE__, true);
2685 : return _r;
2686 : }
2687 0 : next_after_fail885:;
2688 : }
2689 : else
2690 : {
2691 0 : if (eqne == NE_EXPR
2692 : )
2693 : {
2694 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail886;
2695 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail886;
2696 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail886;
2697 0 : {
2698 0 : tree _r;
2699 0 : _r = captures[0];
2700 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 709, __FILE__, __LINE__, true);
2701 : return _r;
2702 : }
2703 0 : next_after_fail886:;
2704 : }
2705 : }
2706 : return NULL_TREE;
2707 : }
2708 :
2709 : tree
2710 4 : generic_simplify_514 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2711 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2712 : {
2713 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2714 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail906;
2715 4 : {
2716 4 : tree res_op0;
2717 4 : res_op0 = captures[1];
2718 4 : tree res_op1;
2719 4 : {
2720 4 : tree _o1[2], _r1;
2721 4 : _o1[0] = captures[2];
2722 4 : _o1[1] = captures[3];
2723 4 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2724 4 : if (EXPR_P (_r1))
2725 2 : goto next_after_fail906;
2726 2 : res_op1 = _r1;
2727 : }
2728 2 : tree _r;
2729 2 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
2730 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 727, __FILE__, __LINE__, true);
2731 : return _r;
2732 : }
2733 4 : next_after_fail906:;
2734 : return NULL_TREE;
2735 : }
2736 :
2737 : tree
2738 234 : generic_simplify_519 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2739 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2740 : const combined_fn ARG_UNUSED (bswap))
2741 : {
2742 234 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2743 234 : if (BITS_PER_UNIT == 8
2744 234 : && tree_fits_uhwi_p (captures[3])
2745 234 : && tree_fits_uhwi_p (captures[4])
2746 : )
2747 : {
2748 234 : {
2749 234 : unsigned HOST_WIDE_INT prec = TYPE_PRECISION (TREE_TYPE (captures[1]));
2750 234 : unsigned HOST_WIDE_INT bits = tree_to_uhwi (captures[3]);
2751 234 : unsigned HOST_WIDE_INT mask = tree_to_uhwi (captures[4]);
2752 234 : unsigned HOST_WIDE_INT lo = bits & 7;
2753 234 : unsigned HOST_WIDE_INT hi = bits - lo;
2754 234 : if (bits < prec
2755 234 : && mask < (256u>>lo)
2756 468 : && bits < TYPE_PRECISION (TREE_TYPE(captures[0]))
2757 : )
2758 : {
2759 234 : {
2760 234 : unsigned HOST_WIDE_INT ns = (prec - (hi + 8)) + lo;
2761 234 : if (ns == 0
2762 : )
2763 : {
2764 1 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail919;
2765 1 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail919;
2766 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail919;
2767 1 : {
2768 1 : tree res_op0;
2769 1 : {
2770 1 : tree _o1[1], _r1;
2771 1 : _o1[0] = captures[2];
2772 1 : if (TREE_TYPE (_o1[0]) != type)
2773 : {
2774 1 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2775 : }
2776 : else
2777 : _r1 = _o1[0];
2778 1 : res_op0 = _r1;
2779 : }
2780 1 : tree res_op1;
2781 1 : res_op1 = captures[4];
2782 1 : tree _r;
2783 1 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2784 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 731, __FILE__, __LINE__, true);
2785 234 : return _r;
2786 : }
2787 234 : next_after_fail919:;
2788 : }
2789 : else
2790 : {
2791 233 : {
2792 233 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
2793 233 : tree nst = build_int_cst (integer_type_node, ns);
2794 233 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail920;
2795 233 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail920;
2796 233 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail920;
2797 233 : {
2798 233 : tree res_op0;
2799 233 : {
2800 233 : tree _o1[1], _r1;
2801 233 : {
2802 233 : tree _o2[2], _r2;
2803 233 : {
2804 233 : tree _o3[1], _r3;
2805 233 : _o3[0] = captures[2];
2806 233 : if (TREE_TYPE (_o3[0]) != utype)
2807 : {
2808 0 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
2809 : }
2810 : else
2811 : _r3 = _o3[0];
2812 233 : _o2[0] = _r3;
2813 : }
2814 233 : _o2[1] = nst;
2815 233 : _r2 = fold_build2_loc (loc, RSHIFT_EXPR, utype, _o2[0], _o2[1]);
2816 233 : _o1[0] = _r2;
2817 : }
2818 233 : if (TREE_TYPE (_o1[0]) != type)
2819 : {
2820 101 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2821 : }
2822 : else
2823 : _r1 = _o1[0];
2824 233 : res_op0 = _r1;
2825 : }
2826 233 : tree res_op1;
2827 233 : res_op1 = captures[4];
2828 233 : tree _r;
2829 233 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2830 233 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 732, __FILE__, __LINE__, true);
2831 : return _r;
2832 : }
2833 234 : next_after_fail920:;
2834 : }
2835 : }
2836 : }
2837 : }
2838 : }
2839 : }
2840 : return NULL_TREE;
2841 : }
2842 :
2843 : tree
2844 0 : generic_simplify_521 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2845 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2846 : {
2847 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2848 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail922;
2849 0 : {
2850 0 : tree res_op0;
2851 0 : res_op0 = captures[0];
2852 0 : tree res_op1;
2853 0 : res_op1 = captures[1];
2854 0 : tree _r;
2855 0 : _r = fold_build2_loc (loc, LTGT_EXPR, type, res_op0, res_op1);
2856 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 734, __FILE__, __LINE__, true);
2857 : return _r;
2858 : }
2859 0 : next_after_fail922:;
2860 0 : return NULL_TREE;
2861 : }
2862 :
2863 : tree
2864 446280 : generic_simplify_522 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2865 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2866 : const enum tree_code ARG_UNUSED (op))
2867 : {
2868 446280 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2869 892560 : if (INTEGRAL_TYPE_P (type)
2870 446280 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2871 68045 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2872 68045 : && type_has_mode_precision_p (TREE_TYPE (captures[2]))
2873 68045 : && type_has_mode_precision_p (TREE_TYPE (captures[4]))
2874 68045 : && type_has_mode_precision_p (type)
2875 68045 : && TYPE_PRECISION (TREE_TYPE (captures[1])) > TYPE_PRECISION (TREE_TYPE (captures[2]))
2876 33 : && types_match (captures[2], captures[4])
2877 33 : && (tree_int_cst_min_precision (captures[5], TYPE_SIGN (TREE_TYPE (captures[2])))
2878 33 : <= TYPE_PRECISION (TREE_TYPE (captures[2])))
2879 446307 : && (wi::to_wide (captures[5])
2880 446334 : & wi::mask (TYPE_PRECISION (TREE_TYPE (captures[2])),
2881 446334 : true, TYPE_PRECISION (type))) == 0
2882 : )
2883 : {
2884 25 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))
2885 : )
2886 : {
2887 12 : {
2888 12 : tree ntype = TREE_TYPE (captures[2]);
2889 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail923;
2890 12 : {
2891 12 : tree res_op0;
2892 12 : {
2893 12 : tree _o1[2], _r1;
2894 12 : {
2895 12 : tree _o2[2], _r2;
2896 12 : _o2[0] = captures[2];
2897 12 : _o2[1] = captures[4];
2898 12 : _r2 = fold_build2_loc (loc, op, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
2899 12 : _o1[0] = _r2;
2900 : }
2901 12 : {
2902 12 : tree _o2[1], _r2;
2903 12 : _o2[0] = captures[5];
2904 12 : if (TREE_TYPE (_o2[0]) != ntype)
2905 : {
2906 12 : _r2 = fold_build1_loc (loc, NOP_EXPR, ntype, _o2[0]);
2907 : }
2908 : else
2909 : _r2 = _o2[0];
2910 12 : _o1[1] = _r2;
2911 : }
2912 12 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2913 12 : res_op0 = _r1;
2914 : }
2915 12 : tree _r;
2916 12 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2917 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 735, __FILE__, __LINE__, true);
2918 : return _r;
2919 : }
2920 0 : next_after_fail923:;
2921 : }
2922 : }
2923 : else
2924 : {
2925 13 : {
2926 13 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
2927 13 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail924;
2928 13 : {
2929 13 : tree res_op0;
2930 13 : {
2931 13 : tree _o1[2], _r1;
2932 13 : {
2933 13 : tree _o2[2], _r2;
2934 13 : {
2935 13 : tree _o3[1], _r3;
2936 13 : _o3[0] = captures[2];
2937 13 : if (TREE_TYPE (_o3[0]) != utype)
2938 : {
2939 13 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
2940 : }
2941 : else
2942 : _r3 = _o3[0];
2943 13 : _o2[0] = _r3;
2944 : }
2945 13 : {
2946 13 : tree _o3[1], _r3;
2947 13 : _o3[0] = captures[4];
2948 13 : if (TREE_TYPE (_o3[0]) != utype)
2949 : {
2950 13 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
2951 : }
2952 : else
2953 : _r3 = _o3[0];
2954 13 : _o2[1] = _r3;
2955 : }
2956 13 : _r2 = fold_build2_loc (loc, op, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
2957 13 : _o1[0] = _r2;
2958 : }
2959 13 : {
2960 13 : tree _o2[1], _r2;
2961 13 : _o2[0] = captures[5];
2962 13 : if (TREE_TYPE (_o2[0]) != utype)
2963 : {
2964 13 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2965 : }
2966 : else
2967 : _r2 = _o2[0];
2968 13 : _o1[1] = _r2;
2969 : }
2970 13 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2971 13 : res_op0 = _r1;
2972 : }
2973 13 : tree _r;
2974 13 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2975 13 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 736, __FILE__, __LINE__, true);
2976 : return _r;
2977 : }
2978 0 : next_after_fail924:;
2979 : }
2980 : }
2981 : }
2982 : return NULL_TREE;
2983 : }
2984 :
2985 : tree
2986 0 : generic_simplify_547 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2987 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2988 : const enum tree_code ARG_UNUSED (minmax),
2989 : const enum tree_code ARG_UNUSED (maxmin))
2990 : {
2991 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2992 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail951;
2993 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail951;
2994 0 : {
2995 0 : tree _r;
2996 0 : _r = captures[0];
2997 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 761, __FILE__, __LINE__, true);
2998 : return _r;
2999 : }
3000 0 : next_after_fail951:;
3001 : return NULL_TREE;
3002 : }
3003 :
3004 : tree
3005 0 : generic_simplify_554 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3006 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
3007 : const enum tree_code ARG_UNUSED (outer),
3008 : const enum tree_code ARG_UNUSED (inner))
3009 : {
3010 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3011 0 : if (TYPE_OVERFLOW_UNDEFINED (type)
3012 0 : && !TYPE_OVERFLOW_SANITIZED (type)
3013 0 : && ((outer == MIN_EXPR && tree_int_cst_sgn (captures[2]) > 0)
3014 0 : || (outer == MAX_EXPR && tree_int_cst_sgn (captures[2]) < 0))
3015 : )
3016 : {
3017 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail958;
3018 0 : {
3019 0 : tree _r;
3020 0 : _r = captures[1];
3021 0 : if (TREE_SIDE_EFFECTS (captures[0]))
3022 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3023 0 : if (TREE_SIDE_EFFECTS (captures[2]))
3024 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
3025 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 767, __FILE__, __LINE__, true);
3026 : return _r;
3027 : }
3028 0 : next_after_fail958:;
3029 : }
3030 : return NULL_TREE;
3031 : }
3032 :
3033 : tree
3034 2 : generic_simplify_563 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3035 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
3036 : const combined_fn ARG_UNUSED (func))
3037 : {
3038 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3039 2 : if (types_match (captures[1], captures[3])
3040 2 : && (!sanitize_flags_p (SANITIZE_BUILTIN)
3041 0 : || (cfun && (cfun->curr_properties & PROP_ssa) != 0))
3042 : )
3043 : {
3044 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail981;
3045 2 : {
3046 2 : tree res_op0;
3047 2 : {
3048 2 : tree _o1[2], _r1;
3049 2 : _o1[0] = captures[1];
3050 2 : _o1[1] = captures[3];
3051 2 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3052 2 : res_op0 = _r1;
3053 : }
3054 2 : tree _r;
3055 2 : _r = maybe_build_call_expr_loc (loc, func, type, 1, res_op0);
3056 2 : if (!_r)
3057 0 : goto next_after_fail981;
3058 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 778, __FILE__, __LINE__, true);
3059 : return _r;
3060 : }
3061 2 : next_after_fail981:;
3062 : }
3063 : return NULL_TREE;
3064 : }
3065 :
3066 : tree
3067 12 : generic_simplify_570 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3068 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
3069 : const enum tree_code ARG_UNUSED (op))
3070 : {
3071 12 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3072 12 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail988;
3073 12 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail988;
3074 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail988;
3075 12 : {
3076 12 : tree _r;
3077 12 : _r = captures[2];
3078 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 561, __FILE__, __LINE__, true);
3079 : return _r;
3080 : }
3081 12 : next_after_fail988:;
3082 : return NULL_TREE;
3083 : }
3084 :
3085 : tree
3086 0 : generic_simplify_578 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3087 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
3088 : const combined_fn ARG_UNUSED (cond_len_op))
3089 : {
3090 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3091 0 : {
3092 0 : tree op_type = TREE_TYPE (captures[3]);
3093 0 : if (element_precision (type) == element_precision (op_type)
3094 : )
3095 : {
3096 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail996;
3097 0 : {
3098 0 : tree res_op0;
3099 0 : {
3100 0 : tree _o1[6], _r1;
3101 0 : _o1[0] = captures[0];
3102 0 : _o1[1] = captures[1];
3103 0 : _o1[2] = captures[2];
3104 0 : {
3105 0 : tree _o2[1], _r2;
3106 0 : _o2[0] = captures[6];
3107 0 : if (TREE_TYPE (_o2[0]) != op_type)
3108 : {
3109 0 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
3110 : }
3111 : else
3112 : _r2 = _o2[0];
3113 0 : _o1[3] = _r2;
3114 : }
3115 0 : _o1[4] = captures[4];
3116 0 : _o1[5] = captures[5];
3117 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]);
3118 0 : if (!_r1)
3119 0 : goto next_after_fail996;
3120 0 : res_op0 = _r1;
3121 : }
3122 0 : tree _r;
3123 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3124 0 : if (TREE_SIDE_EFFECTS (captures[3]))
3125 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
3126 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 789, __FILE__, __LINE__, true);
3127 : return _r;
3128 : }
3129 0 : next_after_fail996:;
3130 : }
3131 : }
3132 : return NULL_TREE;
3133 : }
3134 :
3135 : tree
3136 0 : generic_simplify_589 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3137 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3138 : const combined_fn ARG_UNUSED (bswap))
3139 : {
3140 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3141 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1010;
3142 0 : {
3143 0 : tree res_op0;
3144 0 : res_op0 = captures[0];
3145 0 : tree _r;
3146 0 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
3147 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 803, __FILE__, __LINE__, true);
3148 : return _r;
3149 : }
3150 0 : next_after_fail1010:;
3151 0 : return NULL_TREE;
3152 : }
3153 :
3154 : tree
3155 0 : generic_simplify_596 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3156 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3157 : const combined_fn ARG_UNUSED (logs))
3158 : {
3159 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3160 0 : if (flag_unsafe_math_optimizations
3161 : )
3162 : {
3163 0 : if (! HONOR_SIGN_DEPENDENT_ROUNDING (type)
3164 0 : && ! HONOR_NANS (type) && ! HONOR_INFINITIES (type)
3165 0 : && ! flag_trapping_math
3166 0 : && ! flag_errno_math
3167 : )
3168 : {
3169 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1017;
3170 0 : {
3171 0 : tree res_op0;
3172 0 : {
3173 0 : tree _o1[1], _r1;
3174 0 : _o1[0] = captures[2];
3175 0 : _r1 = maybe_build_call_expr_loc (loc, logs, TREE_TYPE (_o1[0]), 1, _o1[0]);
3176 0 : if (!_r1)
3177 0 : goto next_after_fail1017;
3178 0 : res_op0 = _r1;
3179 : }
3180 0 : tree _r;
3181 0 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
3182 0 : if (TREE_SIDE_EFFECTS (captures[1]))
3183 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3184 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 810, __FILE__, __LINE__, true);
3185 : return _r;
3186 : }
3187 0 : next_after_fail1017:;
3188 : }
3189 : }
3190 : return NULL_TREE;
3191 : }
3192 :
3193 : tree
3194 0 : generic_simplify_605 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3195 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3196 : const combined_fn ARG_UNUSED (froms),
3197 : const combined_fn ARG_UNUSED (tos))
3198 : {
3199 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3200 0 : if (optimize && canonicalize_math_p ()
3201 : )
3202 : {
3203 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1026;
3204 0 : {
3205 0 : tree res_op0;
3206 0 : {
3207 0 : tree _o1[1], _r1;
3208 0 : _o1[0] = captures[0];
3209 0 : _r1 = maybe_build_call_expr_loc (loc, tos, TREE_TYPE (_o1[0]), 1, _o1[0]);
3210 0 : if (!_r1)
3211 0 : goto next_after_fail1026;
3212 0 : res_op0 = _r1;
3213 : }
3214 0 : tree _r;
3215 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3216 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 819, __FILE__, __LINE__, true);
3217 : return _r;
3218 : }
3219 0 : next_after_fail1026:;
3220 : }
3221 : return NULL_TREE;
3222 : }
3223 :
3224 : tree
3225 0 : generic_simplify_614 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3226 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3227 : const combined_fn ARG_UNUSED (ifn),
3228 : const combined_fn ARG_UNUSED (lfn),
3229 : const combined_fn ARG_UNUSED (llfn))
3230 : {
3231 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3232 0 : if (canonicalize_math_p ()
3233 : )
3234 : {
3235 0 : if (TYPE_PRECISION (long_long_integer_type_node)
3236 0 : == TYPE_PRECISION (long_integer_type_node)
3237 : )
3238 : {
3239 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1035;
3240 0 : {
3241 0 : tree res_op0;
3242 0 : res_op0 = captures[0];
3243 0 : tree _r;
3244 0 : _r = maybe_build_call_expr_loc (loc, lfn, type, 1, res_op0);
3245 0 : if (!_r)
3246 0 : goto next_after_fail1035;
3247 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 828, __FILE__, __LINE__, true);
3248 : return _r;
3249 : }
3250 0 : next_after_fail1035:;
3251 : }
3252 : }
3253 : return NULL_TREE;
3254 : }
3255 :
3256 : tree
3257 0 : generic_simplify_625 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3258 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures))
3259 : {
3260 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3261 0 : if (canonicalize_math_after_vectorization_p ()
3262 : )
3263 : {
3264 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1046;
3265 : {
3266 : tree res_op0;
3267 : res_op0 = captures[0];
3268 : tree res_op1;
3269 : res_op1 = captures[1];
3270 : tree res_op2;
3271 : res_op2 = captures[2];
3272 : tree _r;
3273 : _r = maybe_build_call_expr_loc (loc, CFN_FMS, type, 3, res_op0, res_op1, res_op2);
3274 : if (!_r)
3275 : goto next_after_fail1046;
3276 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 839, __FILE__, __LINE__, true);
3277 : return _r;
3278 : }
3279 0 : next_after_fail1046:;
3280 : }
3281 0 : return NULL_TREE;
3282 : }
3283 :
3284 : tree
3285 0 : generic_simplify_634 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3286 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree ARG_UNUSED (_p3), tree ARG_UNUSED (_p4), tree *ARG_UNUSED (captures))
3287 : {
3288 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3289 0 : if (canonicalize_math_after_vectorization_p ()
3290 : )
3291 : {
3292 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1055;
3293 : {
3294 : tree res_op0;
3295 : res_op0 = captures[0];
3296 : tree res_op1;
3297 : res_op1 = captures[1];
3298 : tree res_op2;
3299 : res_op2 = captures[2];
3300 : tree res_op3;
3301 : res_op3 = captures[3];
3302 : tree res_op4;
3303 : res_op4 = captures[4];
3304 : tree _r;
3305 : _r = maybe_build_call_expr_loc (loc, CFN_COND_FMS, type, 5, res_op0, res_op1, res_op2, res_op3, res_op4);
3306 : if (!_r)
3307 : goto next_after_fail1055;
3308 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 848, __FILE__, __LINE__, true);
3309 : return _r;
3310 : }
3311 0 : next_after_fail1055:;
3312 : }
3313 0 : return NULL_TREE;
3314 : }
3315 :
3316 : tree
3317 0 : generic_simplify_644 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3318 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3319 : const enum tree_code ARG_UNUSED (rot),
3320 : const combined_fn ARG_UNUSED (popcount))
3321 : {
3322 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3323 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3324 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
3325 0 : && (
3326 :
3327 0 : || !TREE_SIDE_EFFECTS (captures[3]))
3328 : )
3329 : {
3330 0 : {
3331 0 : tree type0 = TREE_TYPE (captures[0]);
3332 0 : tree type1 = TREE_TYPE (captures[1]);
3333 0 : unsigned int prec0 = TYPE_PRECISION (type0);
3334 0 : unsigned int prec1 = TYPE_PRECISION (type1);
3335 0 : if (prec0 == prec1 || (prec0 > prec1 && TYPE_UNSIGNED (type1))
3336 : )
3337 : {
3338 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1065;
3339 0 : {
3340 0 : tree res_op0;
3341 0 : {
3342 0 : tree _o1[1], _r1;
3343 0 : _o1[0] = captures[2];
3344 0 : if (TREE_TYPE (_o1[0]) != type0)
3345 : {
3346 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type0, _o1[0]);
3347 : }
3348 : else
3349 : _r1 = _o1[0];
3350 0 : res_op0 = _r1;
3351 : }
3352 0 : tree _r;
3353 0 : _r = maybe_build_call_expr_loc (loc, popcount, type, 1, res_op0);
3354 0 : if (!_r)
3355 0 : goto next_after_fail1065;
3356 0 : if (TREE_SIDE_EFFECTS (captures[3]))
3357 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
3358 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 852, __FILE__, __LINE__, true);
3359 : return _r;
3360 : }
3361 0 : next_after_fail1065:;
3362 : }
3363 : }
3364 : }
3365 : return NULL_TREE;
3366 : }
3367 :
3368 : tree
3369 3462195 : generic_simplify_ABS_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0)
3370 : {
3371 3462195 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3372 3462195 : switch (TREE_CODE (_p0))
3373 : {
3374 215307 : CASE_CONVERT:
3375 215307 : {
3376 215307 : tree _q20 = TREE_OPERAND (_p0, 0);
3377 215307 : {
3378 215307 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3379 430612 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3380 913 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
3381 841 : && element_precision (type) > element_precision (TREE_TYPE (captures[0]))
3382 215533 : && (!VECTOR_TYPE_P (type)
3383 0 : || target_supports_op_p (TREE_TYPE (captures[0]), ABSU_EXPR, optab_vector))
3384 : )
3385 : {
3386 226 : {
3387 226 : tree utype = unsigned_type_for (TREE_TYPE (captures[0]));
3388 226 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1079;
3389 226 : {
3390 226 : tree res_op0;
3391 226 : {
3392 226 : tree _o1[1], _r1;
3393 226 : _o1[0] = captures[0];
3394 226 : _r1 = fold_build1_loc (loc, ABSU_EXPR, utype, _o1[0]);
3395 226 : res_op0 = _r1;
3396 : }
3397 226 : tree _r;
3398 226 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3399 226 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 865, __FILE__, __LINE__, true);
3400 3462195 : return _r;
3401 : }
3402 0 : next_after_fail1079:;
3403 : }
3404 : }
3405 : }
3406 : break;
3407 : }
3408 12 : case ABS_EXPR:
3409 12 : {
3410 12 : tree _q20 = TREE_OPERAND (_p0, 0);
3411 12 : {
3412 12 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3413 12 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1080;
3414 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1080;
3415 12 : {
3416 12 : tree _r;
3417 12 : _r = captures[0];
3418 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 866, __FILE__, __LINE__, true);
3419 : return _r;
3420 : }
3421 3461897 : next_after_fail1080:;
3422 : }
3423 : break;
3424 : }
3425 57 : case NEGATE_EXPR:
3426 57 : {
3427 57 : tree _q20 = TREE_OPERAND (_p0, 0);
3428 57 : {
3429 57 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3430 57 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1081;
3431 57 : {
3432 57 : tree res_op0;
3433 57 : res_op0 = captures[0];
3434 57 : tree _r;
3435 57 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
3436 57 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 867, __FILE__, __LINE__, true);
3437 3462195 : return _r;
3438 : }
3439 0 : next_after_fail1081:;
3440 : }
3441 0 : break;
3442 : }
3443 317 : case PLUS_EXPR:
3444 317 : {
3445 317 : tree _q20 = TREE_OPERAND (_p0, 0);
3446 317 : tree _q21 = TREE_OPERAND (_p0, 1);
3447 317 : if (real_zerop (_q21))
3448 : {
3449 3 : {
3450 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3451 3 : tree res = generic_simplify_1 (loc, type, _p0, captures, PLUS_EXPR);
3452 3 : if (res) return res;
3453 : }
3454 : }
3455 : break;
3456 : }
3457 7913 : case MINUS_EXPR:
3458 7913 : {
3459 7913 : tree _q20 = TREE_OPERAND (_p0, 0);
3460 7913 : tree _q21 = TREE_OPERAND (_p0, 1);
3461 7913 : if (real_zerop (_q21))
3462 : {
3463 0 : {
3464 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3465 0 : tree res = generic_simplify_1 (loc, type, _p0, captures, MINUS_EXPR);
3466 0 : if (res) return res;
3467 : }
3468 : }
3469 : break;
3470 : }
3471 0 : case VEC_COND_EXPR:
3472 0 : {
3473 0 : tree _q20 = TREE_OPERAND (_p0, 0);
3474 0 : tree _q21 = TREE_OPERAND (_p0, 1);
3475 0 : tree _q22 = TREE_OPERAND (_p0, 2);
3476 0 : {
3477 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
3478 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1082;
3479 0 : {
3480 0 : tree res_op0;
3481 0 : res_op0 = captures[1];
3482 0 : tree res_op1;
3483 0 : {
3484 0 : tree _o1[1], _r1;
3485 0 : _o1[0] = captures[2];
3486 0 : _r1 = fold_build1_loc (loc, ABS_EXPR, type, _o1[0]);
3487 0 : if (EXPR_P (_r1))
3488 0 : goto next_after_fail1082;
3489 0 : res_op1 = _r1;
3490 : }
3491 0 : tree res_op2;
3492 0 : {
3493 0 : tree _o1[1], _r1;
3494 0 : _o1[0] = captures[3];
3495 0 : _r1 = fold_build1_loc (loc, ABS_EXPR, type, _o1[0]);
3496 0 : if (EXPR_P (_r1))
3497 0 : goto next_after_fail1082;
3498 0 : res_op2 = _r1;
3499 : }
3500 0 : tree _r;
3501 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
3502 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 868, __FILE__, __LINE__, true);
3503 : return _r;
3504 : }
3505 3461897 : next_after_fail1082:;
3506 : }
3507 : break;
3508 : }
3509 716 : case CALL_EXPR:
3510 716 : switch (get_call_combined_fn (_p0))
3511 : {
3512 0 : case CFN_BUILT_IN_COPYSIGNF16:
3513 0 : if (call_expr_nargs (_p0) == 2)
3514 : {
3515 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3516 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3517 0 : {
3518 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3519 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF16);
3520 0 : if (res) return res;
3521 : }
3522 : }
3523 : break;
3524 0 : case CFN_BUILT_IN_COPYSIGNF32:
3525 0 : if (call_expr_nargs (_p0) == 2)
3526 : {
3527 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3528 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3529 0 : {
3530 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3531 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF32);
3532 0 : if (res) return res;
3533 : }
3534 : }
3535 : break;
3536 0 : case CFN_BUILT_IN_COPYSIGNF64:
3537 0 : if (call_expr_nargs (_p0) == 2)
3538 : {
3539 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3540 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3541 0 : {
3542 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3543 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF64);
3544 0 : if (res) return res;
3545 : }
3546 : }
3547 : break;
3548 0 : case CFN_BUILT_IN_COPYSIGNF128X:
3549 0 : if (call_expr_nargs (_p0) == 2)
3550 : {
3551 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3552 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3553 0 : {
3554 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3555 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF128X);
3556 0 : if (res) return res;
3557 : }
3558 : }
3559 : break;
3560 0 : case CFN_BUILT_IN_COPYSIGNF128:
3561 0 : if (call_expr_nargs (_p0) == 2)
3562 : {
3563 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3564 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3565 0 : {
3566 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3567 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF128);
3568 0 : if (res) return res;
3569 : }
3570 : }
3571 : break;
3572 0 : case CFN_BUILT_IN_COPYSIGNF32X:
3573 0 : if (call_expr_nargs (_p0) == 2)
3574 : {
3575 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3576 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3577 0 : {
3578 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3579 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF32X);
3580 0 : if (res) return res;
3581 : }
3582 : }
3583 : break;
3584 0 : case CFN_BUILT_IN_COPYSIGNF64X:
3585 0 : if (call_expr_nargs (_p0) == 2)
3586 : {
3587 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3588 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3589 0 : {
3590 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3591 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF64X);
3592 0 : if (res) return res;
3593 : }
3594 : }
3595 : break;
3596 0 : case CFN_BUILT_IN_COPYSIGN:
3597 0 : if (call_expr_nargs (_p0) == 2)
3598 : {
3599 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3600 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3601 0 : {
3602 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3603 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGN);
3604 0 : if (res) return res;
3605 : }
3606 : }
3607 : break;
3608 1 : case CFN_BUILT_IN_COPYSIGNF:
3609 1 : if (call_expr_nargs (_p0) == 2)
3610 : {
3611 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3612 1 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3613 1 : {
3614 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3615 1 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF);
3616 1 : if (res) return res;
3617 : }
3618 : }
3619 : break;
3620 0 : case CFN_BUILT_IN_COPYSIGNL:
3621 0 : if (call_expr_nargs (_p0) == 2)
3622 : {
3623 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3624 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3625 0 : {
3626 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3627 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNL);
3628 0 : if (res) return res;
3629 : }
3630 : }
3631 : break;
3632 0 : case CFN_COPYSIGN:
3633 0 : if (call_expr_nargs (_p0) == 2)
3634 : {
3635 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3636 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3637 0 : {
3638 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3639 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_COPYSIGN);
3640 0 : if (res) return res;
3641 : }
3642 : }
3643 : break;
3644 : default:;
3645 : }
3646 : break;
3647 3461897 : default:;
3648 : }
3649 3461897 : if (tree_expr_nonnegative_p (_p0))
3650 : {
3651 557 : {
3652 557 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3653 557 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1083;
3654 557 : {
3655 557 : tree _r;
3656 557 : _r = captures[0];
3657 557 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 869, __FILE__, __LINE__, true);
3658 3462195 : return _r;
3659 : }
3660 0 : next_after_fail1083:;
3661 : }
3662 : }
3663 : return NULL_TREE;
3664 : }
3665 :
3666 : tree
3667 1070064 : 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)
3668 : {
3669 1070064 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3670 1070064 : switch (TREE_CODE (_p0))
3671 : {
3672 103 : case MINUS_EXPR:
3673 103 : {
3674 103 : tree _q20 = TREE_OPERAND (_p0, 0);
3675 103 : tree _q21 = TREE_OPERAND (_p0, 1);
3676 103 : switch (TREE_CODE (_q21))
3677 : {
3678 22 : CASE_CONVERT:
3679 22 : {
3680 22 : tree _q40 = TREE_OPERAND (_q21, 0);
3681 22 : switch (TREE_CODE (_q40))
3682 : {
3683 0 : case LT_EXPR:
3684 0 : {
3685 0 : tree _q50 = TREE_OPERAND (_q40, 0);
3686 0 : tree _q51 = TREE_OPERAND (_q40, 1);
3687 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
3688 : {
3689 0 : if (integer_zerop (_q51))
3690 : {
3691 0 : switch (TREE_CODE (_p1))
3692 : {
3693 0 : case NEGATE_EXPR:
3694 0 : {
3695 0 : tree _q80 = TREE_OPERAND (_p1, 0);
3696 0 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
3697 : {
3698 0 : {
3699 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3700 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3701 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
3702 : )
3703 : {
3704 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1202;
3705 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1202;
3706 0 : {
3707 0 : tree res_op0;
3708 0 : res_op0 = captures[0];
3709 0 : tree _r;
3710 0 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
3711 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 926, __FILE__, __LINE__, true);
3712 : return _r;
3713 : }
3714 1070064 : next_after_fail1202:;
3715 : }
3716 : }
3717 : }
3718 : break;
3719 : }
3720 : default:;
3721 : }
3722 : }
3723 : }
3724 : break;
3725 : }
3726 : default:;
3727 : }
3728 : break;
3729 : }
3730 : default:;
3731 : }
3732 : break;
3733 : }
3734 152 : case NEGATE_EXPR:
3735 152 : {
3736 152 : tree _q20 = TREE_OPERAND (_p0, 0);
3737 152 : switch (TREE_CODE (_p1))
3738 : {
3739 0 : case MINUS_EXPR:
3740 0 : {
3741 0 : tree _q40 = TREE_OPERAND (_p1, 0);
3742 0 : tree _q41 = TREE_OPERAND (_p1, 1);
3743 0 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
3744 : {
3745 0 : switch (TREE_CODE (_q41))
3746 : {
3747 0 : CASE_CONVERT:
3748 0 : {
3749 0 : tree _q70 = TREE_OPERAND (_q41, 0);
3750 0 : switch (TREE_CODE (_q70))
3751 : {
3752 0 : case LT_EXPR:
3753 0 : {
3754 0 : tree _q80 = TREE_OPERAND (_q70, 0);
3755 0 : tree _q81 = TREE_OPERAND (_q70, 1);
3756 0 : if ((_q80 == _q40 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q40, 0) && types_match (_q80, _q40)))
3757 : {
3758 0 : if (integer_zerop (_q81))
3759 : {
3760 0 : {
3761 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
3762 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3763 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
3764 : )
3765 : {
3766 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1203;
3767 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1203;
3768 0 : {
3769 0 : tree res_op0;
3770 0 : res_op0 = captures[0];
3771 0 : tree _r;
3772 0 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
3773 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 926, __FILE__, __LINE__, true);
3774 : return _r;
3775 : }
3776 1070064 : next_after_fail1203:;
3777 : }
3778 : }
3779 : }
3780 : }
3781 : break;
3782 : }
3783 : default:;
3784 : }
3785 : break;
3786 : }
3787 : default:;
3788 : }
3789 : }
3790 : break;
3791 : }
3792 : default:;
3793 : }
3794 : break;
3795 : }
3796 1070064 : default:;
3797 : }
3798 1070064 : if (integer_zerop (_p1))
3799 : {
3800 474 : {
3801 474 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3802 474 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1204;
3803 474 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1204;
3804 474 : {
3805 474 : tree res_op0;
3806 474 : res_op0 = captures[0];
3807 474 : tree _r;
3808 474 : _r = non_lvalue_loc (loc, res_op0);
3809 474 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
3810 1070064 : return _r;
3811 : }
3812 1069590 : next_after_fail1204:;
3813 : }
3814 : }
3815 1069590 : switch (TREE_CODE (_p0))
3816 : {
3817 3014 : case LSHIFT_EXPR:
3818 3014 : {
3819 3014 : tree _q20 = TREE_OPERAND (_p0, 0);
3820 3014 : tree _q21 = TREE_OPERAND (_p0, 1);
3821 3014 : switch (TREE_CODE (_p1))
3822 : {
3823 10 : case LSHIFT_EXPR:
3824 10 : {
3825 10 : tree _q50 = TREE_OPERAND (_p1, 0);
3826 10 : tree _q51 = TREE_OPERAND (_p1, 1);
3827 10 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
3828 : {
3829 1 : {
3830 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
3831 1 : tree res = generic_simplify_3 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LSHIFT_EXPR);
3832 1 : if (res) return res;
3833 : }
3834 : }
3835 : break;
3836 : }
3837 : default:;
3838 : }
3839 : break;
3840 : }
3841 23108 : case RSHIFT_EXPR:
3842 23108 : {
3843 23108 : tree _q20 = TREE_OPERAND (_p0, 0);
3844 23108 : tree _q21 = TREE_OPERAND (_p0, 1);
3845 23108 : switch (TREE_CODE (_p1))
3846 : {
3847 20 : case RSHIFT_EXPR:
3848 20 : {
3849 20 : tree _q50 = TREE_OPERAND (_p1, 0);
3850 20 : tree _q51 = TREE_OPERAND (_p1, 1);
3851 20 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
3852 : {
3853 10 : {
3854 10 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
3855 10 : tree res = generic_simplify_3 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, RSHIFT_EXPR);
3856 10 : if (res) return res;
3857 : }
3858 : }
3859 : break;
3860 : }
3861 : default:;
3862 : }
3863 : break;
3864 : }
3865 123 : case EQ_EXPR:
3866 123 : {
3867 123 : tree _q20 = TREE_OPERAND (_p0, 0);
3868 123 : tree _q21 = TREE_OPERAND (_p0, 1);
3869 123 : switch (TREE_CODE (_q20))
3870 : {
3871 25 : case BIT_AND_EXPR:
3872 25 : {
3873 25 : tree _q30 = TREE_OPERAND (_q20, 0);
3874 25 : tree _q31 = TREE_OPERAND (_q20, 1);
3875 25 : if (integer_pow2p (_q31))
3876 : {
3877 0 : if (integer_zerop (_q21))
3878 : {
3879 0 : switch (TREE_CODE (_p1))
3880 : {
3881 0 : case EQ_EXPR:
3882 0 : {
3883 0 : tree _q70 = TREE_OPERAND (_p1, 0);
3884 0 : tree _q71 = TREE_OPERAND (_p1, 1);
3885 0 : switch (TREE_CODE (_q70))
3886 : {
3887 0 : case BIT_AND_EXPR:
3888 0 : {
3889 0 : tree _q80 = TREE_OPERAND (_q70, 0);
3890 0 : tree _q81 = TREE_OPERAND (_q70, 1);
3891 0 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
3892 : {
3893 0 : if ((_q71 == _q21 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q21, 0) && types_match (_q71, _q21)))
3894 : {
3895 0 : {
3896 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70, _q80 };
3897 0 : const enum tree_code icmp0 = EQ_EXPR;
3898 0 : const enum tree_code icmp1 = EQ_EXPR;
3899 0 : if (types_match (captures[2], captures[7])
3900 : )
3901 : {
3902 0 : {
3903 0 : bool innersame = icmp0 == icmp1;
3904 0 : if (innersame == (BIT_XOR_EXPR == EQ_EXPR)
3905 : )
3906 : {
3907 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1205;
3908 : {
3909 : tree res_op0;
3910 : {
3911 : tree _o1[2], _r1;
3912 : {
3913 : tree _o2[2], _r2;
3914 : _o2[0] = captures[2];
3915 : _o2[1] = captures[7];
3916 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
3917 : _o1[0] = _r2;
3918 : }
3919 : _o1[1] = captures[3];
3920 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3921 : res_op0 = _r1;
3922 : }
3923 : tree res_op1;
3924 : res_op1 = captures[4];
3925 : tree _r;
3926 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
3927 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 928, __FILE__, __LINE__, true);
3928 : return _r;
3929 : }
3930 : next_after_fail1205:;
3931 : }
3932 : else
3933 : {
3934 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1206;
3935 0 : {
3936 0 : tree res_op0;
3937 0 : {
3938 0 : tree _o1[2], _r1;
3939 0 : {
3940 0 : tree _o2[2], _r2;
3941 0 : _o2[0] = captures[2];
3942 0 : _o2[1] = captures[7];
3943 0 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
3944 0 : _o1[0] = _r2;
3945 : }
3946 0 : _o1[1] = captures[3];
3947 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3948 0 : res_op0 = _r1;
3949 : }
3950 0 : tree res_op1;
3951 0 : res_op1 = captures[4];
3952 0 : tree _r;
3953 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
3954 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 929, __FILE__, __LINE__, true);
3955 : return _r;
3956 : }
3957 0 : next_after_fail1206:;
3958 : }
3959 : }
3960 : }
3961 : }
3962 : }
3963 : }
3964 : break;
3965 : }
3966 : default:;
3967 : }
3968 : break;
3969 : }
3970 0 : case NE_EXPR:
3971 0 : {
3972 0 : tree _q70 = TREE_OPERAND (_p1, 0);
3973 0 : tree _q71 = TREE_OPERAND (_p1, 1);
3974 0 : switch (TREE_CODE (_q70))
3975 : {
3976 0 : case BIT_AND_EXPR:
3977 0 : {
3978 0 : tree _q80 = TREE_OPERAND (_q70, 0);
3979 0 : tree _q81 = TREE_OPERAND (_q70, 1);
3980 0 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
3981 : {
3982 0 : if ((_q71 == _q21 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q21, 0) && types_match (_q71, _q21)))
3983 : {
3984 0 : {
3985 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70, _q80 };
3986 0 : const enum tree_code icmp0 = EQ_EXPR;
3987 0 : const enum tree_code icmp1 = NE_EXPR;
3988 0 : if (types_match (captures[2], captures[7])
3989 : )
3990 : {
3991 0 : {
3992 0 : bool innersame = icmp0 == icmp1;
3993 0 : if (innersame == (BIT_XOR_EXPR == EQ_EXPR)
3994 : )
3995 : {
3996 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1207;
3997 0 : {
3998 0 : tree res_op0;
3999 0 : {
4000 0 : tree _o1[2], _r1;
4001 0 : {
4002 0 : tree _o2[2], _r2;
4003 0 : _o2[0] = captures[2];
4004 0 : _o2[1] = captures[7];
4005 0 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
4006 0 : _o1[0] = _r2;
4007 : }
4008 0 : _o1[1] = captures[3];
4009 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4010 0 : res_op0 = _r1;
4011 : }
4012 0 : tree res_op1;
4013 0 : res_op1 = captures[4];
4014 0 : tree _r;
4015 0 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
4016 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 928, __FILE__, __LINE__, true);
4017 : return _r;
4018 : }
4019 0 : next_after_fail1207:;
4020 : }
4021 : else
4022 : {
4023 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1208;
4024 : {
4025 : tree res_op0;
4026 : {
4027 : tree _o1[2], _r1;
4028 : {
4029 : tree _o2[2], _r2;
4030 : _o2[0] = captures[2];
4031 : _o2[1] = captures[7];
4032 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
4033 : _o1[0] = _r2;
4034 : }
4035 : _o1[1] = captures[3];
4036 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4037 : res_op0 = _r1;
4038 : }
4039 : tree res_op1;
4040 : res_op1 = captures[4];
4041 : tree _r;
4042 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
4043 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 929, __FILE__, __LINE__, true);
4044 : return _r;
4045 : }
4046 : next_after_fail1208:;
4047 : }
4048 : }
4049 : }
4050 : }
4051 : }
4052 : }
4053 : break;
4054 : }
4055 : default:;
4056 : }
4057 : break;
4058 : }
4059 : default:;
4060 : }
4061 : }
4062 : }
4063 : break;
4064 : }
4065 : default:;
4066 : }
4067 : break;
4068 : }
4069 125 : case NE_EXPR:
4070 125 : {
4071 125 : tree _q20 = TREE_OPERAND (_p0, 0);
4072 125 : tree _q21 = TREE_OPERAND (_p0, 1);
4073 125 : switch (TREE_CODE (_q20))
4074 : {
4075 0 : case BIT_AND_EXPR:
4076 0 : {
4077 0 : tree _q30 = TREE_OPERAND (_q20, 0);
4078 0 : tree _q31 = TREE_OPERAND (_q20, 1);
4079 0 : if (integer_pow2p (_q31))
4080 : {
4081 0 : if (integer_zerop (_q21))
4082 : {
4083 0 : switch (TREE_CODE (_p1))
4084 : {
4085 0 : case EQ_EXPR:
4086 0 : {
4087 0 : tree _q70 = TREE_OPERAND (_p1, 0);
4088 0 : tree _q71 = TREE_OPERAND (_p1, 1);
4089 0 : switch (TREE_CODE (_q70))
4090 : {
4091 0 : case BIT_AND_EXPR:
4092 0 : {
4093 0 : tree _q80 = TREE_OPERAND (_q70, 0);
4094 0 : tree _q81 = TREE_OPERAND (_q70, 1);
4095 0 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
4096 : {
4097 0 : if ((_q71 == _q21 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q21, 0) && types_match (_q71, _q21)))
4098 : {
4099 0 : {
4100 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70, _q80 };
4101 0 : const enum tree_code icmp0 = NE_EXPR;
4102 0 : const enum tree_code icmp1 = EQ_EXPR;
4103 0 : if (types_match (captures[2], captures[7])
4104 : )
4105 : {
4106 0 : {
4107 0 : bool innersame = icmp0 == icmp1;
4108 0 : if (innersame == (BIT_XOR_EXPR == EQ_EXPR)
4109 : )
4110 : {
4111 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1209;
4112 0 : {
4113 0 : tree res_op0;
4114 0 : {
4115 0 : tree _o1[2], _r1;
4116 0 : {
4117 0 : tree _o2[2], _r2;
4118 0 : _o2[0] = captures[2];
4119 0 : _o2[1] = captures[7];
4120 0 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
4121 0 : _o1[0] = _r2;
4122 : }
4123 0 : _o1[1] = captures[3];
4124 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4125 0 : res_op0 = _r1;
4126 : }
4127 0 : tree res_op1;
4128 0 : res_op1 = captures[4];
4129 0 : tree _r;
4130 0 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
4131 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 928, __FILE__, __LINE__, true);
4132 : return _r;
4133 : }
4134 0 : next_after_fail1209:;
4135 : }
4136 : else
4137 : {
4138 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1210;
4139 : {
4140 : tree res_op0;
4141 : {
4142 : tree _o1[2], _r1;
4143 : {
4144 : tree _o2[2], _r2;
4145 : _o2[0] = captures[2];
4146 : _o2[1] = captures[7];
4147 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
4148 : _o1[0] = _r2;
4149 : }
4150 : _o1[1] = captures[3];
4151 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4152 : res_op0 = _r1;
4153 : }
4154 : tree res_op1;
4155 : res_op1 = captures[4];
4156 : tree _r;
4157 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
4158 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 929, __FILE__, __LINE__, true);
4159 : return _r;
4160 : }
4161 : next_after_fail1210:;
4162 : }
4163 : }
4164 : }
4165 : }
4166 : }
4167 : }
4168 : break;
4169 : }
4170 : default:;
4171 : }
4172 : break;
4173 : }
4174 0 : case NE_EXPR:
4175 0 : {
4176 0 : tree _q70 = TREE_OPERAND (_p1, 0);
4177 0 : tree _q71 = TREE_OPERAND (_p1, 1);
4178 0 : switch (TREE_CODE (_q70))
4179 : {
4180 0 : case BIT_AND_EXPR:
4181 0 : {
4182 0 : tree _q80 = TREE_OPERAND (_q70, 0);
4183 0 : tree _q81 = TREE_OPERAND (_q70, 1);
4184 0 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
4185 : {
4186 0 : if ((_q71 == _q21 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q21, 0) && types_match (_q71, _q21)))
4187 : {
4188 0 : {
4189 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70, _q80 };
4190 0 : const enum tree_code icmp0 = NE_EXPR;
4191 0 : const enum tree_code icmp1 = NE_EXPR;
4192 0 : if (types_match (captures[2], captures[7])
4193 : )
4194 : {
4195 0 : {
4196 0 : bool innersame = icmp0 == icmp1;
4197 0 : if (innersame == (BIT_XOR_EXPR == EQ_EXPR)
4198 : )
4199 : {
4200 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1211;
4201 : {
4202 : tree res_op0;
4203 : {
4204 : tree _o1[2], _r1;
4205 : {
4206 : tree _o2[2], _r2;
4207 : _o2[0] = captures[2];
4208 : _o2[1] = captures[7];
4209 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
4210 : _o1[0] = _r2;
4211 : }
4212 : _o1[1] = captures[3];
4213 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4214 : res_op0 = _r1;
4215 : }
4216 : tree res_op1;
4217 : res_op1 = captures[4];
4218 : tree _r;
4219 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
4220 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 928, __FILE__, __LINE__, true);
4221 : return _r;
4222 : }
4223 : next_after_fail1211:;
4224 : }
4225 : else
4226 : {
4227 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1212;
4228 0 : {
4229 0 : tree res_op0;
4230 0 : {
4231 0 : tree _o1[2], _r1;
4232 0 : {
4233 0 : tree _o2[2], _r2;
4234 0 : _o2[0] = captures[2];
4235 0 : _o2[1] = captures[7];
4236 0 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
4237 0 : _o1[0] = _r2;
4238 : }
4239 0 : _o1[1] = captures[3];
4240 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4241 0 : res_op0 = _r1;
4242 : }
4243 0 : tree res_op1;
4244 0 : res_op1 = captures[4];
4245 0 : tree _r;
4246 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
4247 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 929, __FILE__, __LINE__, true);
4248 : return _r;
4249 : }
4250 0 : next_after_fail1212:;
4251 : }
4252 : }
4253 : }
4254 : }
4255 : }
4256 : }
4257 : break;
4258 : }
4259 : default:;
4260 : }
4261 : break;
4262 : }
4263 : default:;
4264 : }
4265 : }
4266 : }
4267 : break;
4268 : }
4269 : default:;
4270 : }
4271 : break;
4272 : }
4273 4164 : case BIT_AND_EXPR:
4274 4164 : {
4275 4164 : tree _q20 = TREE_OPERAND (_p0, 0);
4276 4164 : tree _q21 = TREE_OPERAND (_p0, 1);
4277 4164 : switch (TREE_CODE (_p1))
4278 : {
4279 354 : case BIT_AND_EXPR:
4280 354 : {
4281 354 : tree _q50 = TREE_OPERAND (_p1, 0);
4282 354 : tree _q51 = TREE_OPERAND (_p1, 1);
4283 354 : {
4284 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51 };
4285 354 : tree res = generic_simplify_4 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4286 354 : if (res) return res;
4287 : }
4288 354 : {
4289 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q51, _q50 };
4290 354 : tree res = generic_simplify_4 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4291 354 : if (res) return res;
4292 : }
4293 354 : {
4294 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q50, _q51 };
4295 354 : tree res = generic_simplify_4 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4296 354 : if (res) return res;
4297 : }
4298 354 : {
4299 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q51, _q50 };
4300 354 : tree res = generic_simplify_4 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4301 354 : if (res) return res;
4302 : }
4303 354 : break;
4304 : }
4305 4164 : default:;
4306 : }
4307 4164 : switch (TREE_CODE (_q21))
4308 : {
4309 41 : case BIT_NOT_EXPR:
4310 41 : {
4311 41 : tree _q40 = TREE_OPERAND (_q21, 0);
4312 41 : switch (TREE_CODE (_p1))
4313 : {
4314 0 : case BIT_NOT_EXPR:
4315 0 : {
4316 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4317 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4318 : {
4319 0 : {
4320 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
4321 0 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures);
4322 0 : if (res) return res;
4323 : }
4324 : }
4325 : break;
4326 : }
4327 : default:;
4328 : }
4329 : break;
4330 : }
4331 4164 : default:;
4332 : }
4333 4164 : switch (TREE_CODE (_q20))
4334 : {
4335 92 : case BIT_NOT_EXPR:
4336 92 : {
4337 92 : tree _q30 = TREE_OPERAND (_q20, 0);
4338 92 : switch (TREE_CODE (_p1))
4339 : {
4340 0 : case BIT_NOT_EXPR:
4341 0 : {
4342 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4343 0 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
4344 : {
4345 0 : {
4346 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q30 };
4347 0 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures);
4348 0 : if (res) return res;
4349 : }
4350 : }
4351 : break;
4352 : }
4353 92 : default:;
4354 : }
4355 92 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
4356 : {
4357 0 : {
4358 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q21 };
4359 0 : tree res = generic_simplify_6 (loc, type, _p0, _p1, captures);
4360 0 : if (res) return res;
4361 : }
4362 : }
4363 : break;
4364 : }
4365 4164 : default:;
4366 : }
4367 4164 : switch (TREE_CODE (_q21))
4368 : {
4369 41 : case BIT_NOT_EXPR:
4370 41 : {
4371 41 : tree _q40 = TREE_OPERAND (_q21, 0);
4372 41 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
4373 : {
4374 0 : {
4375 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q20 };
4376 0 : tree res = generic_simplify_6 (loc, type, _p0, _p1, captures);
4377 0 : if (res) return res;
4378 : }
4379 : }
4380 : break;
4381 : }
4382 : default:;
4383 : }
4384 : break;
4385 : }
4386 505 : case BIT_NOT_EXPR:
4387 505 : {
4388 505 : tree _q20 = TREE_OPERAND (_p0, 0);
4389 505 : switch (TREE_CODE (_p1))
4390 : {
4391 51 : case BIT_AND_EXPR:
4392 51 : {
4393 51 : tree _q40 = TREE_OPERAND (_p1, 0);
4394 51 : tree _q41 = TREE_OPERAND (_p1, 1);
4395 51 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
4396 : {
4397 0 : switch (TREE_CODE (_q41))
4398 : {
4399 0 : case BIT_NOT_EXPR:
4400 0 : {
4401 0 : tree _q60 = TREE_OPERAND (_q41, 0);
4402 0 : {
4403 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q20, _q60 };
4404 0 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures);
4405 0 : if (res) return res;
4406 : }
4407 0 : break;
4408 : }
4409 : default:;
4410 : }
4411 : }
4412 51 : switch (TREE_CODE (_q40))
4413 : {
4414 7 : case BIT_NOT_EXPR:
4415 7 : {
4416 7 : tree _q50 = TREE_OPERAND (_q40, 0);
4417 7 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
4418 : {
4419 0 : {
4420 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q20, _q50 };
4421 0 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures);
4422 0 : if (res) return res;
4423 : }
4424 : }
4425 : break;
4426 : }
4427 : default:;
4428 : }
4429 : break;
4430 : }
4431 : default:;
4432 : }
4433 : break;
4434 : }
4435 1069579 : default:;
4436 : }
4437 1069579 : switch (TREE_CODE (_p1))
4438 : {
4439 885 : case BIT_AND_EXPR:
4440 885 : {
4441 885 : tree _q30 = TREE_OPERAND (_p1, 0);
4442 885 : tree _q31 = TREE_OPERAND (_p1, 1);
4443 885 : switch (TREE_CODE (_q30))
4444 : {
4445 57 : case BIT_NOT_EXPR:
4446 57 : {
4447 57 : tree _q40 = TREE_OPERAND (_q30, 0);
4448 57 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
4449 : {
4450 0 : {
4451 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q31 };
4452 0 : tree res = generic_simplify_6 (loc, type, _p0, _p1, captures);
4453 0 : if (res) return res;
4454 : }
4455 : }
4456 : break;
4457 : }
4458 885 : default:;
4459 : }
4460 885 : switch (TREE_CODE (_q31))
4461 : {
4462 8 : case BIT_NOT_EXPR:
4463 8 : {
4464 8 : tree _q50 = TREE_OPERAND (_q31, 0);
4465 8 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
4466 : {
4467 0 : {
4468 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q30 };
4469 0 : tree res = generic_simplify_6 (loc, type, _p0, _p1, captures);
4470 0 : if (res) return res;
4471 : }
4472 : }
4473 : break;
4474 : }
4475 : default:;
4476 : }
4477 : break;
4478 : }
4479 1069579 : default:;
4480 : }
4481 1069579 : switch (TREE_CODE (_p0))
4482 : {
4483 21665 : case PLUS_EXPR:
4484 21665 : {
4485 21665 : tree _q20 = TREE_OPERAND (_p0, 0);
4486 21665 : tree _q21 = TREE_OPERAND (_p0, 1);
4487 21665 : if (integer_minus_onep (_q21))
4488 : {
4489 10486 : switch (TREE_CODE (_p1))
4490 : {
4491 11 : case NEGATE_EXPR:
4492 11 : {
4493 11 : tree _q50 = TREE_OPERAND (_p1, 0);
4494 11 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4495 : {
4496 11 : {
4497 11 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4498 11 : tree res = generic_simplify_7 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4499 11 : if (res) return res;
4500 : }
4501 : }
4502 : break;
4503 : }
4504 : default:;
4505 : }
4506 : }
4507 : break;
4508 : }
4509 152 : case NEGATE_EXPR:
4510 152 : {
4511 152 : tree _q20 = TREE_OPERAND (_p0, 0);
4512 152 : switch (TREE_CODE (_p1))
4513 : {
4514 0 : case PLUS_EXPR:
4515 0 : {
4516 0 : tree _q40 = TREE_OPERAND (_p1, 0);
4517 0 : tree _q41 = TREE_OPERAND (_p1, 1);
4518 0 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
4519 : {
4520 0 : if (integer_minus_onep (_q41))
4521 : {
4522 0 : {
4523 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q41 };
4524 0 : tree res = generic_simplify_7 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4525 0 : if (res) return res;
4526 : }
4527 : }
4528 : }
4529 : break;
4530 : }
4531 0 : case MINUS_EXPR:
4532 0 : {
4533 0 : tree _q40 = TREE_OPERAND (_p1, 0);
4534 0 : tree _q41 = TREE_OPERAND (_p1, 1);
4535 0 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
4536 : {
4537 0 : if (integer_onep (_q41))
4538 : {
4539 0 : {
4540 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4541 0 : tree res = generic_simplify_8 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4542 0 : if (res) return res;
4543 : }
4544 : }
4545 : }
4546 : break;
4547 : }
4548 : default:;
4549 : }
4550 : break;
4551 : }
4552 103 : case MINUS_EXPR:
4553 103 : {
4554 103 : tree _q20 = TREE_OPERAND (_p0, 0);
4555 103 : tree _q21 = TREE_OPERAND (_p0, 1);
4556 103 : if (integer_onep (_q21))
4557 : {
4558 0 : switch (TREE_CODE (_p1))
4559 : {
4560 0 : case NEGATE_EXPR:
4561 0 : {
4562 0 : tree _q50 = TREE_OPERAND (_p1, 0);
4563 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4564 : {
4565 0 : {
4566 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4567 0 : tree res = generic_simplify_9 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4568 0 : if (res) return res;
4569 : }
4570 : }
4571 : break;
4572 : }
4573 : default:;
4574 : }
4575 : }
4576 : break;
4577 : }
4578 1310 : case BIT_IOR_EXPR:
4579 1310 : {
4580 1310 : tree _q20 = TREE_OPERAND (_p0, 0);
4581 1310 : tree _q21 = TREE_OPERAND (_p0, 1);
4582 1310 : switch (TREE_CODE (_p1))
4583 : {
4584 65 : case BIT_AND_EXPR:
4585 65 : {
4586 65 : tree _q50 = TREE_OPERAND (_p1, 0);
4587 65 : tree _q51 = TREE_OPERAND (_p1, 1);
4588 65 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4589 : {
4590 15 : {
4591 15 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4592 15 : tree res = generic_simplify_10 (loc, type, _p0, _p1, captures);
4593 15 : if (res) return res;
4594 : }
4595 : }
4596 65 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4597 : {
4598 12 : {
4599 12 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
4600 12 : tree res = generic_simplify_10 (loc, type, _p0, _p1, captures);
4601 12 : if (res) return res;
4602 : }
4603 : }
4604 65 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4605 : {
4606 3 : {
4607 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
4608 3 : tree res = generic_simplify_10 (loc, type, _p0, _p1, captures);
4609 3 : if (res) return res;
4610 : }
4611 : }
4612 65 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4613 : {
4614 6 : {
4615 6 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
4616 6 : tree res = generic_simplify_10 (loc, type, _p0, _p1, captures);
4617 6 : if (res) return res;
4618 : }
4619 : }
4620 : break;
4621 : }
4622 1310 : default:;
4623 : }
4624 1310 : switch (TREE_CODE (_q20))
4625 : {
4626 481 : case BIT_NOT_EXPR:
4627 481 : {
4628 481 : tree _q30 = TREE_OPERAND (_q20, 0);
4629 481 : {
4630 481 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _p1 };
4631 481 : tree res = generic_simplify_11 (loc, type, _p0, _p1, captures);
4632 481 : if (res) return res;
4633 : }
4634 480 : break;
4635 : }
4636 1309 : default:;
4637 : }
4638 1309 : switch (TREE_CODE (_q21))
4639 : {
4640 62 : case BIT_NOT_EXPR:
4641 62 : {
4642 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4643 62 : {
4644 62 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20, _p1 };
4645 62 : tree res = generic_simplify_11 (loc, type, _p0, _p1, captures);
4646 62 : if (res) return res;
4647 : }
4648 62 : break;
4649 : }
4650 : default:;
4651 : }
4652 : break;
4653 : }
4654 4164 : case BIT_AND_EXPR:
4655 4164 : {
4656 4164 : tree _q20 = TREE_OPERAND (_p0, 0);
4657 4164 : tree _q21 = TREE_OPERAND (_p0, 1);
4658 4164 : switch (TREE_CODE (_p1))
4659 : {
4660 74 : case BIT_IOR_EXPR:
4661 74 : {
4662 74 : tree _q50 = TREE_OPERAND (_p1, 0);
4663 74 : tree _q51 = TREE_OPERAND (_p1, 1);
4664 74 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4665 : {
4666 18 : {
4667 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q21, _q20 };
4668 18 : tree res = generic_simplify_10 (loc, type, _p0, _p1, captures);
4669 18 : if (res) return res;
4670 : }
4671 : }
4672 74 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4673 : {
4674 9 : {
4675 9 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q20, _q21 };
4676 9 : tree res = generic_simplify_10 (loc, type, _p0, _p1, captures);
4677 9 : if (res) return res;
4678 : }
4679 : }
4680 74 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4681 : {
4682 9 : {
4683 9 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q21, _q20 };
4684 9 : tree res = generic_simplify_10 (loc, type, _p0, _p1, captures);
4685 9 : if (res) return res;
4686 : }
4687 : }
4688 74 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4689 : {
4690 18 : {
4691 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q20, _q21 };
4692 18 : tree res = generic_simplify_10 (loc, type, _p0, _p1, captures);
4693 18 : if (res) return res;
4694 : }
4695 : }
4696 : break;
4697 : }
4698 : default:;
4699 : }
4700 : break;
4701 : }
4702 1069567 : default:;
4703 : }
4704 1069567 : switch (TREE_CODE (_p1))
4705 : {
4706 521 : case BIT_IOR_EXPR:
4707 521 : {
4708 521 : tree _q30 = TREE_OPERAND (_p1, 0);
4709 521 : tree _q31 = TREE_OPERAND (_p1, 1);
4710 521 : switch (TREE_CODE (_q30))
4711 : {
4712 21 : case BIT_NOT_EXPR:
4713 21 : {
4714 21 : tree _q40 = TREE_OPERAND (_q30, 0);
4715 21 : {
4716 21 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _q31, _p0 };
4717 21 : tree res = generic_simplify_11 (loc, type, _p0, _p1, captures);
4718 21 : if (res) return res;
4719 : }
4720 21 : break;
4721 : }
4722 521 : default:;
4723 : }
4724 521 : switch (TREE_CODE (_q31))
4725 : {
4726 25 : case BIT_NOT_EXPR:
4727 25 : {
4728 25 : tree _q50 = TREE_OPERAND (_q31, 0);
4729 25 : {
4730 25 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q31, _q50, _q30, _p0 };
4731 25 : tree res = generic_simplify_11 (loc, type, _p0, _p1, captures);
4732 25 : if (res) return res;
4733 : }
4734 25 : break;
4735 : }
4736 : default:;
4737 : }
4738 : break;
4739 : }
4740 1069567 : default:;
4741 : }
4742 1069567 : switch (TREE_CODE (_p0))
4743 : {
4744 4164 : case BIT_AND_EXPR:
4745 4164 : {
4746 4164 : tree _q20 = TREE_OPERAND (_p0, 0);
4747 4164 : tree _q21 = TREE_OPERAND (_p0, 1);
4748 4164 : switch (TREE_CODE (_q20))
4749 : {
4750 92 : case BIT_NOT_EXPR:
4751 92 : {
4752 92 : tree _q30 = TREE_OPERAND (_q20, 0);
4753 92 : {
4754 92 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _p1 };
4755 92 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4756 92 : if (res) return res;
4757 : }
4758 89 : break;
4759 : }
4760 4161 : default:;
4761 : }
4762 4161 : switch (TREE_CODE (_q21))
4763 : {
4764 41 : case BIT_NOT_EXPR:
4765 41 : {
4766 41 : tree _q40 = TREE_OPERAND (_q21, 0);
4767 41 : {
4768 41 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20, _p1 };
4769 41 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4770 41 : if (res) return res;
4771 : }
4772 41 : break;
4773 : }
4774 : default:;
4775 : }
4776 : break;
4777 : }
4778 1069564 : default:;
4779 : }
4780 1069564 : switch (TREE_CODE (_p1))
4781 : {
4782 885 : case BIT_AND_EXPR:
4783 885 : {
4784 885 : tree _q30 = TREE_OPERAND (_p1, 0);
4785 885 : tree _q31 = TREE_OPERAND (_p1, 1);
4786 885 : switch (TREE_CODE (_q30))
4787 : {
4788 57 : case BIT_NOT_EXPR:
4789 57 : {
4790 57 : tree _q40 = TREE_OPERAND (_q30, 0);
4791 57 : {
4792 57 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _q31, _p0 };
4793 57 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4794 57 : if (res) return res;
4795 : }
4796 57 : break;
4797 : }
4798 885 : default:;
4799 : }
4800 885 : switch (TREE_CODE (_q31))
4801 : {
4802 8 : case BIT_NOT_EXPR:
4803 8 : {
4804 8 : tree _q50 = TREE_OPERAND (_q31, 0);
4805 8 : {
4806 8 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q31, _q50, _q30, _p0 };
4807 8 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4808 8 : if (res) return res;
4809 : }
4810 8 : break;
4811 : }
4812 : default:;
4813 : }
4814 : break;
4815 : }
4816 1069564 : default:;
4817 : }
4818 1069564 : switch (TREE_CODE (_p0))
4819 : {
4820 689991 : CASE_CONVERT:
4821 689991 : {
4822 689991 : tree _q20 = TREE_OPERAND (_p0, 0);
4823 689991 : switch (TREE_CODE (_p1))
4824 : {
4825 685599 : CASE_CONVERT:
4826 685599 : {
4827 685599 : tree _q40 = TREE_OPERAND (_p1, 0);
4828 685599 : {
4829 685599 : tree _q40_pops[1];
4830 685599 : if (tree_maybe_bit_not (_q40, _q40_pops))
4831 : {
4832 0 : tree _q50 = _q40_pops[0];
4833 0 : {
4834 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
4835 0 : tree res = generic_simplify_13 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4836 0 : if (res) return res;
4837 : }
4838 : }
4839 : }
4840 685599 : break;
4841 : }
4842 689991 : default:;
4843 : }
4844 689991 : {
4845 689991 : tree _q20_pops[1];
4846 689991 : if (tree_maybe_bit_not (_q20, _q20_pops))
4847 : {
4848 65035 : tree _q30 = _q20_pops[0];
4849 65035 : switch (TREE_CODE (_p1))
4850 : {
4851 64985 : CASE_CONVERT:
4852 64985 : {
4853 64985 : tree _q50 = TREE_OPERAND (_p1, 0);
4854 64985 : {
4855 64985 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
4856 64985 : tree res = generic_simplify_13 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4857 64985 : if (res) return res;
4858 : }
4859 64985 : break;
4860 : }
4861 : default:;
4862 : }
4863 : }
4864 : }
4865 689991 : break;
4866 : }
4867 1069564 : default:;
4868 : }
4869 1069564 : {
4870 1069564 : tree _p1_pops[1];
4871 1069564 : if (tree_maybe_bit_not (_p1, _p1_pops))
4872 : {
4873 10296 : tree _q30 = _p1_pops[0];
4874 10296 : {
4875 10296 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
4876 10296 : tree res = generic_simplify_13 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4877 10296 : if (res) return res;
4878 : }
4879 : }
4880 : }
4881 1069564 : {
4882 1069564 : tree _p0_pops[1];
4883 1069564 : if (tree_maybe_bit_not (_p0, _p0_pops))
4884 : {
4885 1061 : tree _q20 = _p0_pops[0];
4886 1061 : {
4887 1061 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _q20 };
4888 1061 : tree res = generic_simplify_13 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4889 1061 : if (res) return res;
4890 : }
4891 : }
4892 : }
4893 1069543 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
4894 : {
4895 149 : {
4896 149 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4897 149 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1213;
4898 149 : {
4899 149 : tree _r;
4900 149 : _r = build_zero_cst (type);
4901 149 : if (TREE_SIDE_EFFECTS (captures[0]))
4902 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4903 149 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 930, __FILE__, __LINE__, true);
4904 1070064 : return _r;
4905 : }
4906 0 : next_after_fail1213:;
4907 : }
4908 : }
4909 1069394 : if (integer_all_onesp (_p1))
4910 : {
4911 1102 : {
4912 1102 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4913 1102 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1214;
4914 1102 : {
4915 1102 : tree res_op0;
4916 1102 : res_op0 = captures[0];
4917 1102 : tree _r;
4918 1102 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
4919 1102 : if (TREE_SIDE_EFFECTS (captures[1]))
4920 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4921 1102 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 931, __FILE__, __LINE__, true);
4922 : return _r;
4923 : }
4924 0 : next_after_fail1214:;
4925 : }
4926 : }
4927 1068292 : switch (TREE_CODE (_p0))
4928 : {
4929 1302 : case BIT_IOR_EXPR:
4930 1302 : {
4931 1302 : tree _q20 = TREE_OPERAND (_p0, 0);
4932 1302 : tree _q21 = TREE_OPERAND (_p0, 1);
4933 1302 : switch (TREE_CODE (_p1))
4934 : {
4935 179 : case BIT_IOR_EXPR:
4936 179 : {
4937 179 : tree _q50 = TREE_OPERAND (_p1, 0);
4938 179 : tree _q51 = TREE_OPERAND (_p1, 1);
4939 179 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4940 : {
4941 0 : switch (TREE_CODE (_q51))
4942 : {
4943 0 : case BIT_NOT_EXPR:
4944 0 : {
4945 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4946 0 : if ((_q70 == _q21 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q21, 0) && types_match (_q70, _q21)))
4947 : {
4948 0 : {
4949 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4950 0 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures);
4951 0 : if (res) return res;
4952 : }
4953 : }
4954 : break;
4955 : }
4956 : default:;
4957 : }
4958 : }
4959 179 : switch (TREE_CODE (_q50))
4960 : {
4961 20 : case BIT_NOT_EXPR:
4962 20 : {
4963 20 : tree _q60 = TREE_OPERAND (_q50, 0);
4964 20 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
4965 : {
4966 2 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4967 : {
4968 1 : {
4969 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4970 1 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures);
4971 1 : if (res) return res;
4972 : }
4973 : }
4974 : }
4975 19 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4976 : {
4977 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4978 : {
4979 0 : {
4980 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
4981 0 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures);
4982 0 : if (res) return res;
4983 : }
4984 : }
4985 : }
4986 : break;
4987 : }
4988 178 : default:;
4989 : }
4990 178 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4991 : {
4992 0 : switch (TREE_CODE (_q51))
4993 : {
4994 0 : case BIT_NOT_EXPR:
4995 0 : {
4996 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4997 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4998 : {
4999 0 : {
5000 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
5001 0 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures);
5002 0 : if (res) return res;
5003 : }
5004 : }
5005 : break;
5006 : }
5007 : default:;
5008 : }
5009 : }
5010 : break;
5011 : }
5012 1301 : default:;
5013 : }
5014 1301 : switch (TREE_CODE (_q21))
5015 : {
5016 62 : case BIT_NOT_EXPR:
5017 62 : {
5018 62 : tree _q40 = TREE_OPERAND (_q21, 0);
5019 62 : switch (TREE_CODE (_p1))
5020 : {
5021 9 : case BIT_IOR_EXPR:
5022 9 : {
5023 9 : tree _q60 = TREE_OPERAND (_p1, 0);
5024 9 : tree _q61 = TREE_OPERAND (_p1, 1);
5025 9 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
5026 : {
5027 0 : if ((_q61 == _q40 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q40, 0) && types_match (_q61, _q40)))
5028 : {
5029 0 : {
5030 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
5031 0 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures);
5032 0 : if (res) return res;
5033 : }
5034 : }
5035 : }
5036 : break;
5037 : }
5038 : default:;
5039 : }
5040 : break;
5041 : }
5042 1301 : default:;
5043 : }
5044 1301 : switch (TREE_CODE (_q20))
5045 : {
5046 480 : case BIT_NOT_EXPR:
5047 480 : {
5048 480 : tree _q30 = TREE_OPERAND (_q20, 0);
5049 480 : switch (TREE_CODE (_p1))
5050 : {
5051 28 : case BIT_IOR_EXPR:
5052 28 : {
5053 28 : tree _q60 = TREE_OPERAND (_p1, 0);
5054 28 : tree _q61 = TREE_OPERAND (_p1, 1);
5055 28 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
5056 : {
5057 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
5058 : {
5059 0 : {
5060 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q30 };
5061 0 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures);
5062 0 : if (res) return res;
5063 : }
5064 : }
5065 : }
5066 28 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
5067 : {
5068 9 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
5069 : {
5070 0 : {
5071 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q30 };
5072 0 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures);
5073 0 : if (res) return res;
5074 : }
5075 : }
5076 9 : switch (TREE_CODE (_q61))
5077 : {
5078 0 : case BIT_NOT_EXPR:
5079 0 : {
5080 0 : tree _q80 = TREE_OPERAND (_q61, 0);
5081 0 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
5082 : {
5083 0 : {
5084 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q21 };
5085 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures);
5086 0 : if (res) return res;
5087 : }
5088 : }
5089 : break;
5090 : }
5091 : default:;
5092 : }
5093 : }
5094 28 : switch (TREE_CODE (_q60))
5095 : {
5096 1 : case BIT_NOT_EXPR:
5097 1 : {
5098 1 : tree _q70 = TREE_OPERAND (_q60, 0);
5099 1 : if ((_q70 == _q21 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q21, 0) && types_match (_q70, _q21)))
5100 : {
5101 1 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
5102 : {
5103 1 : {
5104 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q21 };
5105 1 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures);
5106 1 : if (res) return res;
5107 : }
5108 : }
5109 : }
5110 : break;
5111 : }
5112 : default:;
5113 : }
5114 : break;
5115 : }
5116 9 : case BIT_XOR_EXPR:
5117 9 : {
5118 9 : tree _q60 = TREE_OPERAND (_p1, 0);
5119 9 : tree _q61 = TREE_OPERAND (_p1, 1);
5120 9 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
5121 : {
5122 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
5123 : {
5124 0 : {
5125 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q21, _p1 };
5126 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
5127 0 : if (res) return res;
5128 : }
5129 : }
5130 : }
5131 : break;
5132 : }
5133 479 : default:;
5134 : }
5135 479 : {
5136 479 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q21, _p1 };
5137 479 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
5138 479 : if (res) return res;
5139 : }
5140 431 : break;
5141 : }
5142 1252 : default:;
5143 : }
5144 1252 : switch (TREE_CODE (_q21))
5145 : {
5146 62 : case BIT_NOT_EXPR:
5147 62 : {
5148 62 : tree _q40 = TREE_OPERAND (_q21, 0);
5149 62 : switch (TREE_CODE (_p1))
5150 : {
5151 9 : case BIT_IOR_EXPR:
5152 9 : {
5153 9 : tree _q60 = TREE_OPERAND (_p1, 0);
5154 9 : tree _q61 = TREE_OPERAND (_p1, 1);
5155 9 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
5156 : {
5157 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
5158 : {
5159 0 : {
5160 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
5161 0 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures);
5162 0 : if (res) return res;
5163 : }
5164 : }
5165 : }
5166 : break;
5167 : }
5168 : default:;
5169 : }
5170 : break;
5171 : }
5172 1252 : default:;
5173 : }
5174 1252 : switch (TREE_CODE (_p1))
5175 : {
5176 65 : case BIT_AND_EXPR:
5177 65 : {
5178 65 : tree _q50 = TREE_OPERAND (_p1, 0);
5179 65 : tree _q51 = TREE_OPERAND (_p1, 1);
5180 65 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5181 : {
5182 6 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5183 : {
5184 0 : {
5185 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5186 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_XOR_EXPR);
5187 0 : if (res) return res;
5188 : }
5189 : }
5190 : }
5191 : break;
5192 : }
5193 36 : case BIT_XOR_EXPR:
5194 36 : {
5195 36 : tree _q50 = TREE_OPERAND (_p1, 0);
5196 36 : tree _q51 = TREE_OPERAND (_p1, 1);
5197 36 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5198 : {
5199 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5200 : {
5201 0 : {
5202 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5203 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5204 0 : if (res) return res;
5205 : }
5206 : }
5207 : }
5208 : break;
5209 : }
5210 1252 : default:;
5211 : }
5212 1252 : switch (TREE_CODE (_q21))
5213 : {
5214 62 : case BIT_NOT_EXPR:
5215 62 : {
5216 62 : tree _q40 = TREE_OPERAND (_q21, 0);
5217 62 : switch (TREE_CODE (_p1))
5218 : {
5219 9 : case BIT_XOR_EXPR:
5220 9 : {
5221 9 : tree _q60 = TREE_OPERAND (_p1, 0);
5222 9 : tree _q61 = TREE_OPERAND (_p1, 1);
5223 9 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
5224 : {
5225 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
5226 : {
5227 0 : {
5228 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q40, _q20, _p1 };
5229 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
5230 0 : if (res) return res;
5231 : }
5232 : }
5233 : }
5234 : break;
5235 : }
5236 9 : case BIT_IOR_EXPR:
5237 9 : {
5238 9 : tree _q60 = TREE_OPERAND (_p1, 0);
5239 9 : tree _q61 = TREE_OPERAND (_p1, 1);
5240 9 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
5241 : {
5242 0 : switch (TREE_CODE (_q61))
5243 : {
5244 0 : case BIT_NOT_EXPR:
5245 0 : {
5246 0 : tree _q80 = TREE_OPERAND (_q61, 0);
5247 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
5248 : {
5249 0 : {
5250 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
5251 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures);
5252 0 : if (res) return res;
5253 : }
5254 : }
5255 : break;
5256 : }
5257 : default:;
5258 : }
5259 : }
5260 9 : switch (TREE_CODE (_q60))
5261 : {
5262 0 : case BIT_NOT_EXPR:
5263 0 : {
5264 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5265 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
5266 : {
5267 0 : if ((_q61 == _q40 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q40, 0) && types_match (_q61, _q40)))
5268 : {
5269 0 : {
5270 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
5271 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures);
5272 0 : if (res) return res;
5273 : }
5274 : }
5275 : }
5276 : break;
5277 : }
5278 : default:;
5279 : }
5280 : break;
5281 : }
5282 : default:;
5283 : }
5284 : break;
5285 : }
5286 1252 : default:;
5287 : }
5288 1252 : switch (TREE_CODE (_p1))
5289 : {
5290 24 : CASE_CONVERT:
5291 24 : {
5292 24 : tree _q50 = TREE_OPERAND (_p1, 0);
5293 24 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
5294 : {
5295 0 : {
5296 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q20 };
5297 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5298 0 : if (res) return res;
5299 : }
5300 : }
5301 24 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q21, 0))
5302 : {
5303 0 : {
5304 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q21 };
5305 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5306 0 : if (res) return res;
5307 : }
5308 : }
5309 : break;
5310 : }
5311 1252 : default:;
5312 : }
5313 1252 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q20, 0))
5314 : {
5315 3 : {
5316 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q20 };
5317 3 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5318 3 : if (res) return res;
5319 : }
5320 : }
5321 1249 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q21, 0))
5322 : {
5323 3 : {
5324 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q21 };
5325 3 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5326 3 : if (res) return res;
5327 : }
5328 : }
5329 1246 : {
5330 1246 : tree _q20_pops[1];
5331 1246 : if (tree_nop_convert (_q20, _q20_pops))
5332 : {
5333 8 : tree _q30 = _q20_pops[0];
5334 8 : switch (TREE_CODE (_q30))
5335 : {
5336 8 : case BIT_NOT_EXPR:
5337 8 : {
5338 8 : tree _q40 = TREE_OPERAND (_q30, 0);
5339 8 : {
5340 8 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q21, _p1 };
5341 8 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
5342 8 : if (res) return res;
5343 : }
5344 0 : break;
5345 : }
5346 : default:;
5347 : }
5348 : }
5349 : }
5350 1238 : switch (TREE_CODE (_q21))
5351 : {
5352 62 : case BIT_NOT_EXPR:
5353 62 : {
5354 62 : tree _q40 = TREE_OPERAND (_q21, 0);
5355 62 : {
5356 62 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q20, _p1 };
5357 62 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
5358 62 : if (res) return res;
5359 : }
5360 54 : break;
5361 : }
5362 1230 : default:;
5363 : }
5364 1230 : {
5365 1230 : tree _q21_pops[1];
5366 1230 : if (tree_nop_convert (_q21, _q21_pops))
5367 : {
5368 0 : tree _q40 = _q21_pops[0];
5369 0 : switch (TREE_CODE (_q40))
5370 : {
5371 0 : case BIT_NOT_EXPR:
5372 0 : {
5373 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5374 0 : {
5375 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q20, _p1 };
5376 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
5377 0 : if (res) return res;
5378 : }
5379 0 : break;
5380 : }
5381 : default:;
5382 : }
5383 : }
5384 : }
5385 1230 : break;
5386 : }
5387 4161 : case BIT_AND_EXPR:
5388 4161 : {
5389 4161 : tree _q20 = TREE_OPERAND (_p0, 0);
5390 4161 : tree _q21 = TREE_OPERAND (_p0, 1);
5391 4161 : switch (TREE_CODE (_p1))
5392 : {
5393 74 : case BIT_IOR_EXPR:
5394 74 : {
5395 74 : tree _q50 = TREE_OPERAND (_p1, 0);
5396 74 : tree _q51 = TREE_OPERAND (_p1, 1);
5397 74 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5398 : {
5399 18 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5400 : {
5401 0 : {
5402 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5403 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_XOR_EXPR);
5404 0 : if (res) return res;
5405 : }
5406 : }
5407 : }
5408 : break;
5409 : }
5410 30 : case BIT_XOR_EXPR:
5411 30 : {
5412 30 : tree _q50 = TREE_OPERAND (_p1, 0);
5413 30 : tree _q51 = TREE_OPERAND (_p1, 1);
5414 30 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5415 : {
5416 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5417 : {
5418 0 : {
5419 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5420 0 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5421 0 : if (res) return res;
5422 : }
5423 : }
5424 : }
5425 : break;
5426 : }
5427 4161 : default:;
5428 : }
5429 4161 : switch (TREE_CODE (_q21))
5430 : {
5431 2328 : case INTEGER_CST:
5432 2328 : {
5433 2328 : switch (TREE_CODE (_p1))
5434 : {
5435 15 : CASE_CONVERT:
5436 15 : {
5437 15 : tree _q50 = TREE_OPERAND (_p1, 0);
5438 15 : switch (TREE_CODE (_q50))
5439 : {
5440 0 : case BIT_AND_EXPR:
5441 0 : {
5442 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5443 0 : tree _q61 = TREE_OPERAND (_q50, 1);
5444 0 : switch (TREE_CODE (_q61))
5445 : {
5446 0 : case INTEGER_CST:
5447 0 : {
5448 0 : {
5449 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50, _q60, _q61 };
5450 0 : tree res = generic_simplify_21 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5451 0 : if (res) return res;
5452 : }
5453 0 : break;
5454 : }
5455 : default:;
5456 : }
5457 : break;
5458 : }
5459 : default:;
5460 : }
5461 : break;
5462 : }
5463 210 : case BIT_AND_EXPR:
5464 210 : {
5465 210 : tree _q50 = TREE_OPERAND (_p1, 0);
5466 210 : tree _q51 = TREE_OPERAND (_p1, 1);
5467 210 : switch (TREE_CODE (_q51))
5468 : {
5469 210 : case INTEGER_CST:
5470 210 : {
5471 210 : {
5472 210 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50, _q51 };
5473 210 : tree res = generic_simplify_21 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5474 210 : if (res) return res;
5475 : }
5476 209 : break;
5477 : }
5478 : default:;
5479 : }
5480 : break;
5481 : }
5482 : default:;
5483 : }
5484 : break;
5485 : }
5486 : default:;
5487 : }
5488 : break;
5489 : }
5490 4061 : case BIT_XOR_EXPR:
5491 4061 : {
5492 4061 : tree _q20 = TREE_OPERAND (_p0, 0);
5493 4061 : tree _q21 = TREE_OPERAND (_p0, 1);
5494 4061 : switch (TREE_CODE (_p1))
5495 : {
5496 203 : case BIT_IOR_EXPR:
5497 203 : {
5498 203 : tree _q50 = TREE_OPERAND (_p1, 0);
5499 203 : tree _q51 = TREE_OPERAND (_p1, 1);
5500 203 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5501 : {
5502 1 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5503 : {
5504 0 : {
5505 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5506 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5507 0 : if (res) return res;
5508 : }
5509 : }
5510 : }
5511 203 : switch (TREE_CODE (_q50))
5512 : {
5513 1 : case BIT_NOT_EXPR:
5514 1 : {
5515 1 : tree _q60 = TREE_OPERAND (_q50, 0);
5516 1 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
5517 : {
5518 1 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5519 : {
5520 1 : {
5521 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q20, _q21, _p0 };
5522 1 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
5523 1 : if (res) return res;
5524 : }
5525 : }
5526 : }
5527 : break;
5528 : }
5529 202 : default:;
5530 : }
5531 202 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5532 : {
5533 0 : switch (TREE_CODE (_q51))
5534 : {
5535 0 : case BIT_NOT_EXPR:
5536 0 : {
5537 0 : tree _q70 = TREE_OPERAND (_q51, 0);
5538 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
5539 : {
5540 0 : {
5541 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q20, _q21, _p0 };
5542 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
5543 0 : if (res) return res;
5544 : }
5545 : }
5546 : break;
5547 : }
5548 : default:;
5549 : }
5550 : }
5551 : break;
5552 : }
5553 41 : case BIT_AND_EXPR:
5554 41 : {
5555 41 : tree _q50 = TREE_OPERAND (_p1, 0);
5556 41 : tree _q51 = TREE_OPERAND (_p1, 1);
5557 41 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5558 : {
5559 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5560 : {
5561 0 : {
5562 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5563 0 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5564 0 : if (res) return res;
5565 : }
5566 : }
5567 : }
5568 : break;
5569 : }
5570 202 : CASE_CONVERT:
5571 202 : {
5572 202 : tree _q50 = TREE_OPERAND (_p1, 0);
5573 202 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q21, 0))
5574 : {
5575 0 : {
5576 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q21 };
5577 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5578 0 : if (res) return res;
5579 : }
5580 : }
5581 202 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
5582 : {
5583 0 : {
5584 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q20 };
5585 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5586 0 : if (res) return res;
5587 : }
5588 : }
5589 : break;
5590 : }
5591 4060 : default:;
5592 : }
5593 4060 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q21, 0))
5594 : {
5595 0 : {
5596 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q21 };
5597 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5598 0 : if (res) return res;
5599 : }
5600 : }
5601 4060 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q20, 0))
5602 : {
5603 11 : {
5604 11 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q20 };
5605 11 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5606 11 : if (res) return res;
5607 : }
5608 : }
5609 : break;
5610 : }
5611 689834 : CASE_CONVERT:
5612 689834 : {
5613 689834 : tree _q20 = TREE_OPERAND (_p0, 0);
5614 689834 : switch (TREE_CODE (_q20))
5615 : {
5616 80 : case BIT_AND_EXPR:
5617 80 : {
5618 80 : tree _q30 = TREE_OPERAND (_q20, 0);
5619 80 : tree _q31 = TREE_OPERAND (_q20, 1);
5620 80 : switch (TREE_CODE (_q31))
5621 : {
5622 0 : case INTEGER_CST:
5623 0 : {
5624 0 : switch (TREE_CODE (_p1))
5625 : {
5626 0 : CASE_CONVERT:
5627 0 : {
5628 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5629 0 : switch (TREE_CODE (_q60))
5630 : {
5631 0 : case BIT_AND_EXPR:
5632 0 : {
5633 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5634 0 : tree _q71 = TREE_OPERAND (_q60, 1);
5635 0 : switch (TREE_CODE (_q71))
5636 : {
5637 0 : case INTEGER_CST:
5638 0 : {
5639 0 : {
5640 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q60, _q70, _q71 };
5641 0 : tree res = generic_simplify_21 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5642 0 : if (res) return res;
5643 : }
5644 0 : break;
5645 : }
5646 : default:;
5647 : }
5648 : break;
5649 : }
5650 : default:;
5651 : }
5652 : break;
5653 : }
5654 0 : case BIT_AND_EXPR:
5655 0 : {
5656 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5657 0 : tree _q61 = TREE_OPERAND (_p1, 1);
5658 0 : switch (TREE_CODE (_q61))
5659 : {
5660 0 : case INTEGER_CST:
5661 0 : {
5662 0 : {
5663 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _p1, _q60, _q61 };
5664 0 : tree res = generic_simplify_21 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5665 0 : if (res) return res;
5666 : }
5667 0 : break;
5668 : }
5669 : default:;
5670 : }
5671 : break;
5672 : }
5673 : default:;
5674 : }
5675 : break;
5676 : }
5677 : default:;
5678 : }
5679 : break;
5680 : }
5681 24 : case BIT_IOR_EXPR:
5682 24 : {
5683 24 : tree _q30 = TREE_OPERAND (_q20, 0);
5684 24 : tree _q31 = TREE_OPERAND (_q20, 1);
5685 24 : switch (TREE_CODE (_p1))
5686 : {
5687 16 : CASE_CONVERT:
5688 16 : {
5689 16 : tree _q60 = TREE_OPERAND (_p1, 0);
5690 16 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q30, 0))
5691 : {
5692 0 : {
5693 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q30 };
5694 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5695 0 : if (res) return res;
5696 : }
5697 : }
5698 16 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q31, 0))
5699 : {
5700 0 : {
5701 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q31 };
5702 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5703 0 : if (res) return res;
5704 : }
5705 : }
5706 : break;
5707 : }
5708 24 : default:;
5709 : }
5710 24 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q30, 0))
5711 : {
5712 0 : {
5713 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q30 };
5714 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5715 0 : if (res) return res;
5716 : }
5717 : }
5718 24 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q31, 0))
5719 : {
5720 0 : {
5721 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q31 };
5722 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5723 0 : if (res) return res;
5724 : }
5725 : }
5726 : break;
5727 : }
5728 689834 : default:;
5729 : }
5730 689834 : switch (TREE_CODE (_p1))
5731 : {
5732 685592 : CASE_CONVERT:
5733 685592 : {
5734 685592 : tree _q40 = TREE_OPERAND (_p1, 0);
5735 685592 : switch (TREE_CODE (_q40))
5736 : {
5737 0 : case BIT_IOR_EXPR:
5738 0 : {
5739 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5740 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5741 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
5742 : {
5743 0 : {
5744 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
5745 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5746 0 : if (res) return res;
5747 : }
5748 : }
5749 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
5750 : {
5751 0 : {
5752 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q50, _q20 };
5753 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5754 0 : if (res) return res;
5755 : }
5756 : }
5757 : break;
5758 : }
5759 : default:;
5760 : }
5761 : break;
5762 : }
5763 26 : case BIT_IOR_EXPR:
5764 26 : {
5765 26 : tree _q40 = TREE_OPERAND (_p1, 0);
5766 26 : tree _q41 = TREE_OPERAND (_p1, 1);
5767 26 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _q20, 0))
5768 : {
5769 0 : {
5770 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q20 };
5771 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5772 0 : if (res) return res;
5773 : }
5774 : }
5775 26 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _q20, 0))
5776 : {
5777 0 : {
5778 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q20 };
5779 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5780 0 : if (res) return res;
5781 : }
5782 : }
5783 : break;
5784 : }
5785 : default:;
5786 : }
5787 : break;
5788 : }
5789 1068207 : default:;
5790 : }
5791 1068207 : switch (TREE_CODE (_p1))
5792 : {
5793 823119 : CASE_CONVERT:
5794 823119 : {
5795 823119 : tree _q30 = TREE_OPERAND (_p1, 0);
5796 823119 : switch (TREE_CODE (_q30))
5797 : {
5798 6 : case BIT_IOR_EXPR:
5799 6 : {
5800 6 : tree _q40 = TREE_OPERAND (_q30, 0);
5801 6 : tree _q41 = TREE_OPERAND (_q30, 1);
5802 6 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _p0, 0))
5803 : {
5804 0 : {
5805 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _p0 };
5806 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5807 0 : if (res) return res;
5808 : }
5809 : }
5810 6 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _p0, 0))
5811 : {
5812 0 : {
5813 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _p0 };
5814 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5815 0 : if (res) return res;
5816 : }
5817 : }
5818 : break;
5819 : }
5820 : default:;
5821 : }
5822 : break;
5823 : }
5824 518 : case BIT_IOR_EXPR:
5825 518 : {
5826 518 : tree _q30 = TREE_OPERAND (_p1, 0);
5827 518 : tree _q31 = TREE_OPERAND (_p1, 1);
5828 518 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || operand_equal_p (_q30, _p0, 0))
5829 : {
5830 1 : {
5831 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
5832 1 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5833 1 : if (res) return res;
5834 : }
5835 : }
5836 517 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || operand_equal_p (_q31, _p0, 0))
5837 : {
5838 1 : {
5839 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _p0 };
5840 1 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5841 1 : if (res) return res;
5842 : }
5843 : }
5844 : break;
5845 : }
5846 1068205 : default:;
5847 : }
5848 1068205 : {
5849 1068205 : tree _p0_pops[1];
5850 1068205 : if (tree_nop_convert (_p0, _p0_pops))
5851 : {
5852 551262 : tree _q20 = _p0_pops[0];
5853 551262 : switch (TREE_CODE (_q20))
5854 : {
5855 16 : case BIT_IOR_EXPR:
5856 16 : {
5857 16 : tree _q30 = TREE_OPERAND (_q20, 0);
5858 16 : tree _q31 = TREE_OPERAND (_q20, 1);
5859 16 : {
5860 16 : tree _q30_pops[1];
5861 16 : if (tree_nop_convert (_q30, _q30_pops))
5862 : {
5863 0 : tree _q40 = _q30_pops[0];
5864 0 : switch (TREE_CODE (_q40))
5865 : {
5866 0 : case BIT_NOT_EXPR:
5867 0 : {
5868 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5869 0 : {
5870 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q31, _p1 };
5871 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
5872 0 : if (res) return res;
5873 : }
5874 0 : break;
5875 : }
5876 : default:;
5877 : }
5878 : }
5879 : }
5880 16 : {
5881 16 : tree _q31_pops[1];
5882 16 : if (tree_nop_convert (_q31, _q31_pops))
5883 : {
5884 0 : tree _q50 = _q31_pops[0];
5885 0 : switch (TREE_CODE (_q50))
5886 : {
5887 0 : case BIT_NOT_EXPR:
5888 0 : {
5889 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5890 0 : {
5891 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q30, _p1 };
5892 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
5893 0 : if (res) return res;
5894 : }
5895 0 : break;
5896 : }
5897 : default:;
5898 : }
5899 : }
5900 : }
5901 16 : switch (TREE_CODE (_q30))
5902 : {
5903 16 : case BIT_NOT_EXPR:
5904 16 : {
5905 16 : tree _q40 = TREE_OPERAND (_q30, 0);
5906 16 : {
5907 16 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q31, _p1 };
5908 16 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
5909 16 : if (res) return res;
5910 : }
5911 0 : break;
5912 : }
5913 0 : default:;
5914 : }
5915 0 : switch (TREE_CODE (_q31))
5916 : {
5917 0 : case BIT_NOT_EXPR:
5918 0 : {
5919 0 : tree _q50 = TREE_OPERAND (_q31, 0);
5920 0 : {
5921 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q30, _p1 };
5922 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
5923 0 : if (res) return res;
5924 : }
5925 0 : break;
5926 : }
5927 : default:;
5928 : }
5929 : break;
5930 : }
5931 : default:;
5932 : }
5933 : }
5934 : }
5935 1068189 : switch (TREE_CODE (_p1))
5936 : {
5937 516 : case BIT_IOR_EXPR:
5938 516 : {
5939 516 : tree _q30 = TREE_OPERAND (_p1, 0);
5940 516 : tree _q31 = TREE_OPERAND (_p1, 1);
5941 516 : {
5942 516 : tree _q30_pops[1];
5943 516 : if (tree_nop_convert (_q30, _q30_pops))
5944 : {
5945 2 : tree _q40 = _q30_pops[0];
5946 2 : switch (TREE_CODE (_q40))
5947 : {
5948 0 : case BIT_NOT_EXPR:
5949 0 : {
5950 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5951 0 : {
5952 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q31, _p0 };
5953 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
5954 0 : if (res) return res;
5955 : }
5956 0 : break;
5957 : }
5958 : default:;
5959 : }
5960 : }
5961 : }
5962 516 : {
5963 516 : tree _q31_pops[1];
5964 516 : if (tree_nop_convert (_q31, _q31_pops))
5965 : {
5966 2 : tree _q50 = _q31_pops[0];
5967 2 : switch (TREE_CODE (_q50))
5968 : {
5969 0 : case BIT_NOT_EXPR:
5970 0 : {
5971 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5972 0 : {
5973 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q30, _p0 };
5974 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
5975 0 : if (res) return res;
5976 : }
5977 0 : break;
5978 : }
5979 : default:;
5980 : }
5981 : }
5982 : }
5983 516 : switch (TREE_CODE (_q30))
5984 : {
5985 18 : case BIT_NOT_EXPR:
5986 18 : {
5987 18 : tree _q40 = TREE_OPERAND (_q30, 0);
5988 18 : {
5989 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q31, _p0 };
5990 18 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
5991 18 : if (res) return res;
5992 : }
5993 18 : break;
5994 : }
5995 516 : default:;
5996 : }
5997 516 : switch (TREE_CODE (_q31))
5998 : {
5999 25 : case BIT_NOT_EXPR:
6000 25 : {
6001 25 : tree _q50 = TREE_OPERAND (_q31, 0);
6002 25 : {
6003 25 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q30, _p0 };
6004 25 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
6005 25 : if (res) return res;
6006 : }
6007 17 : break;
6008 : }
6009 : default:;
6010 : }
6011 : break;
6012 : }
6013 1068181 : default:;
6014 : }
6015 1068181 : {
6016 1068181 : tree _p1_pops[1];
6017 1068181 : if (tree_nop_convert (_p1, _p1_pops))
6018 : {
6019 687279 : tree _q30 = _p1_pops[0];
6020 687279 : switch (TREE_CODE (_q30))
6021 : {
6022 0 : case BIT_IOR_EXPR:
6023 0 : {
6024 0 : tree _q40 = TREE_OPERAND (_q30, 0);
6025 0 : tree _q41 = TREE_OPERAND (_q30, 1);
6026 0 : {
6027 0 : tree _q40_pops[1];
6028 0 : if (tree_nop_convert (_q40, _q40_pops))
6029 : {
6030 0 : tree _q50 = _q40_pops[0];
6031 0 : switch (TREE_CODE (_q50))
6032 : {
6033 0 : case BIT_NOT_EXPR:
6034 0 : {
6035 0 : tree _q60 = TREE_OPERAND (_q50, 0);
6036 0 : {
6037 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q41, _p0 };
6038 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
6039 0 : if (res) return res;
6040 : }
6041 0 : break;
6042 : }
6043 : default:;
6044 : }
6045 : }
6046 : }
6047 0 : {
6048 0 : tree _q41_pops[1];
6049 0 : if (tree_nop_convert (_q41, _q41_pops))
6050 : {
6051 0 : tree _q60 = _q41_pops[0];
6052 0 : switch (TREE_CODE (_q60))
6053 : {
6054 0 : case BIT_NOT_EXPR:
6055 0 : {
6056 0 : tree _q70 = TREE_OPERAND (_q60, 0);
6057 0 : {
6058 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q70, _q40, _p0 };
6059 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
6060 0 : if (res) return res;
6061 : }
6062 0 : break;
6063 : }
6064 : default:;
6065 : }
6066 : }
6067 : }
6068 0 : switch (TREE_CODE (_q40))
6069 : {
6070 0 : case BIT_NOT_EXPR:
6071 0 : {
6072 0 : tree _q50 = TREE_OPERAND (_q40, 0);
6073 0 : {
6074 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q41, _p0 };
6075 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
6076 0 : if (res) return res;
6077 : }
6078 0 : break;
6079 : }
6080 0 : default:;
6081 : }
6082 0 : switch (TREE_CODE (_q41))
6083 : {
6084 0 : case BIT_NOT_EXPR:
6085 0 : {
6086 0 : tree _q60 = TREE_OPERAND (_q41, 0);
6087 0 : {
6088 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q40, _p0 };
6089 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
6090 0 : if (res) return res;
6091 : }
6092 0 : break;
6093 : }
6094 : default:;
6095 : }
6096 : break;
6097 : }
6098 : default:;
6099 : }
6100 : }
6101 : }
6102 1068181 : switch (TREE_CODE (_p0))
6103 : {
6104 689810 : CASE_CONVERT:
6105 689810 : {
6106 689810 : tree _q20 = TREE_OPERAND (_p0, 0);
6107 689810 : switch (TREE_CODE (_q20))
6108 : {
6109 50 : case BIT_NOT_EXPR:
6110 50 : {
6111 50 : tree _q30 = TREE_OPERAND (_q20, 0);
6112 50 : switch (TREE_CODE (_p1))
6113 : {
6114 0 : CASE_CONVERT:
6115 0 : {
6116 0 : tree _q50 = TREE_OPERAND (_p1, 0);
6117 0 : switch (TREE_CODE (_q50))
6118 : {
6119 0 : case BIT_NOT_EXPR:
6120 0 : {
6121 0 : tree _q60 = TREE_OPERAND (_q50, 0);
6122 0 : {
6123 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q60 };
6124 0 : tree res = generic_simplify_23 (loc, type, _p0, _p1, captures);
6125 0 : if (res) return res;
6126 : }
6127 0 : break;
6128 : }
6129 : default:;
6130 : }
6131 : break;
6132 : }
6133 0 : case BIT_NOT_EXPR:
6134 0 : {
6135 0 : tree _q50 = TREE_OPERAND (_p1, 0);
6136 0 : {
6137 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q50 };
6138 0 : tree res = generic_simplify_23 (loc, type, _p0, _p1, captures);
6139 0 : if (res) return res;
6140 : }
6141 0 : break;
6142 : }
6143 26 : case INTEGER_CST:
6144 26 : {
6145 26 : {
6146 26 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p1 };
6147 26 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
6148 26 : if (res) return res;
6149 : }
6150 24 : break;
6151 : }
6152 : default:;
6153 : }
6154 : break;
6155 : }
6156 : default:;
6157 : }
6158 : break;
6159 : }
6160 484 : case BIT_NOT_EXPR:
6161 484 : {
6162 484 : tree _q20 = TREE_OPERAND (_p0, 0);
6163 484 : switch (TREE_CODE (_p1))
6164 : {
6165 18 : CASE_CONVERT:
6166 18 : {
6167 18 : tree _q40 = TREE_OPERAND (_p1, 0);
6168 18 : switch (TREE_CODE (_q40))
6169 : {
6170 0 : case BIT_NOT_EXPR:
6171 0 : {
6172 0 : tree _q50 = TREE_OPERAND (_q40, 0);
6173 0 : {
6174 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
6175 0 : tree res = generic_simplify_23 (loc, type, _p0, _p1, captures);
6176 0 : if (res) return res;
6177 : }
6178 0 : break;
6179 : }
6180 : default:;
6181 : }
6182 : break;
6183 : }
6184 10 : case BIT_NOT_EXPR:
6185 10 : {
6186 10 : tree _q40 = TREE_OPERAND (_p1, 0);
6187 10 : {
6188 10 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6189 10 : tree res = generic_simplify_23 (loc, type, _p0, _p1, captures);
6190 10 : if (res) return res;
6191 : }
6192 0 : break;
6193 : }
6194 31 : case INTEGER_CST:
6195 31 : {
6196 31 : {
6197 31 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
6198 31 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
6199 31 : if (res) return res;
6200 : }
6201 0 : break;
6202 : }
6203 443 : default:;
6204 : }
6205 443 : {
6206 443 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _p1 };
6207 443 : tree res = generic_simplify_25 (loc, type, _p0, _p1, captures);
6208 443 : if (res) return res;
6209 : }
6210 0 : break;
6211 : }
6212 4158 : case BIT_AND_EXPR:
6213 4158 : {
6214 4158 : tree _q20 = TREE_OPERAND (_p0, 0);
6215 4158 : tree _q21 = TREE_OPERAND (_p0, 1);
6216 4158 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
6217 : {
6218 113 : {
6219 113 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
6220 113 : tree res = generic_simplify_26 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
6221 113 : if (res) return res;
6222 : }
6223 : }
6224 4045 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
6225 : {
6226 3 : {
6227 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
6228 3 : tree res = generic_simplify_26 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
6229 3 : if (res) return res;
6230 : }
6231 : }
6232 4042 : switch (TREE_CODE (_p1))
6233 : {
6234 353 : case BIT_AND_EXPR:
6235 353 : {
6236 353 : tree _q50 = TREE_OPERAND (_p1, 0);
6237 353 : tree _q51 = TREE_OPERAND (_p1, 1);
6238 353 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
6239 : {
6240 21 : {
6241 21 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q51, _q20 };
6242 21 : tree res = generic_simplify_27 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
6243 21 : if (res) return res;
6244 : }
6245 : }
6246 332 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
6247 : {
6248 0 : {
6249 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q20 };
6250 0 : tree res = generic_simplify_27 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
6251 0 : if (res) return res;
6252 : }
6253 : }
6254 332 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q21, 0))
6255 : {
6256 0 : {
6257 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q51, _q21 };
6258 0 : tree res = generic_simplify_27 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
6259 0 : if (res) return res;
6260 : }
6261 : }
6262 332 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q21, 0))
6263 : {
6264 201 : {
6265 201 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q50, _q21 };
6266 201 : tree res = generic_simplify_27 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
6267 201 : if (res) return res;
6268 : }
6269 : }
6270 : break;
6271 : }
6272 : default:;
6273 : }
6274 : break;
6275 : }
6276 1067357 : default:;
6277 : }
6278 1067357 : switch (TREE_CODE (_p1))
6279 : {
6280 609 : case BIT_AND_EXPR:
6281 609 : {
6282 609 : tree _q30 = TREE_OPERAND (_p1, 0);
6283 609 : tree _q31 = TREE_OPERAND (_p1, 1);
6284 609 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6285 : {
6286 0 : {
6287 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
6288 0 : tree res = generic_simplify_26 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
6289 0 : if (res) return res;
6290 : }
6291 : }
6292 609 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
6293 : {
6294 1 : {
6295 1 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q31, _p0 };
6296 1 : tree res = generic_simplify_26 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
6297 1 : if (res) return res;
6298 : }
6299 : }
6300 : break;
6301 : }
6302 1067356 : default:;
6303 : }
6304 1067356 : switch (TREE_CODE (_p0))
6305 : {
6306 689807 : CASE_CONVERT:
6307 689807 : {
6308 689807 : tree _q20 = TREE_OPERAND (_p0, 0);
6309 689807 : switch (TREE_CODE (_q20))
6310 : {
6311 80 : case BIT_AND_EXPR:
6312 80 : {
6313 80 : tree _q30 = TREE_OPERAND (_q20, 0);
6314 80 : tree _q31 = TREE_OPERAND (_q20, 1);
6315 80 : switch (TREE_CODE (_p1))
6316 : {
6317 8 : CASE_CONVERT:
6318 8 : {
6319 8 : tree _q60 = TREE_OPERAND (_p1, 0);
6320 8 : switch (TREE_CODE (_q60))
6321 : {
6322 0 : case BIT_AND_EXPR:
6323 0 : {
6324 0 : tree _q70 = TREE_OPERAND (_q60, 0);
6325 0 : tree _q71 = TREE_OPERAND (_q60, 1);
6326 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || operand_equal_p (_q70, _q30, 0))
6327 : {
6328 0 : {
6329 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q71, _q30 };
6330 0 : tree res = generic_simplify_27 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
6331 0 : if (res) return res;
6332 : }
6333 : }
6334 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || operand_equal_p (_q71, _q30, 0))
6335 : {
6336 0 : {
6337 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q70, _q30 };
6338 0 : tree res = generic_simplify_27 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
6339 0 : if (res) return res;
6340 : }
6341 : }
6342 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || operand_equal_p (_q70, _q31, 0))
6343 : {
6344 0 : {
6345 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q31, _q30, _q71, _q31 };
6346 0 : tree res = generic_simplify_27 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
6347 0 : if (res) return res;
6348 : }
6349 : }
6350 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || operand_equal_p (_q71, _q31, 0))
6351 : {
6352 0 : {
6353 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q31, _q30, _q70, _q31 };
6354 0 : tree res = generic_simplify_27 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
6355 0 : if (res) return res;
6356 : }
6357 : }
6358 : break;
6359 : }
6360 : default:;
6361 : }
6362 : break;
6363 : }
6364 : default:;
6365 : }
6366 : break;
6367 : }
6368 65109 : case BIT_XOR_EXPR:
6369 65109 : {
6370 65109 : tree _q30 = TREE_OPERAND (_q20, 0);
6371 65109 : tree _q31 = TREE_OPERAND (_q20, 1);
6372 65109 : switch (TREE_CODE (_p1))
6373 : {
6374 65037 : CASE_CONVERT:
6375 65037 : {
6376 65037 : tree _q60 = TREE_OPERAND (_p1, 0);
6377 65037 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q31, 0))
6378 : {
6379 0 : {
6380 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q31 };
6381 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
6382 0 : if (res) return res;
6383 : }
6384 : }
6385 65037 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q30, 0))
6386 : {
6387 0 : {
6388 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q30 };
6389 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
6390 0 : if (res) return res;
6391 : }
6392 : }
6393 : break;
6394 : }
6395 65109 : default:;
6396 : }
6397 65109 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q31, 0))
6398 : {
6399 0 : {
6400 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q31 };
6401 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
6402 0 : if (res) return res;
6403 : }
6404 : }
6405 65109 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q30, 0))
6406 : {
6407 0 : {
6408 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q30 };
6409 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
6410 0 : if (res) return res;
6411 : }
6412 : }
6413 : break;
6414 : }
6415 689807 : default:;
6416 : }
6417 689807 : switch (TREE_CODE (_p1))
6418 : {
6419 685576 : CASE_CONVERT:
6420 685576 : {
6421 685576 : tree _q40 = TREE_OPERAND (_p1, 0);
6422 685576 : switch (TREE_CODE (_q40))
6423 : {
6424 0 : case BIT_XOR_EXPR:
6425 0 : {
6426 0 : tree _q50 = TREE_OPERAND (_q40, 0);
6427 0 : tree _q51 = TREE_OPERAND (_q40, 1);
6428 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
6429 : {
6430 0 : {
6431 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
6432 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
6433 0 : if (res) return res;
6434 : }
6435 : }
6436 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
6437 : {
6438 0 : {
6439 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q50, _q20 };
6440 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
6441 0 : if (res) return res;
6442 : }
6443 : }
6444 : break;
6445 : }
6446 : default:;
6447 : }
6448 : break;
6449 : }
6450 2 : case BIT_XOR_EXPR:
6451 2 : {
6452 2 : tree _q40 = TREE_OPERAND (_p1, 0);
6453 2 : tree _q41 = TREE_OPERAND (_p1, 1);
6454 2 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _q20, 0))
6455 : {
6456 0 : {
6457 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q20 };
6458 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
6459 0 : if (res) return res;
6460 : }
6461 : }
6462 2 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _q20, 0))
6463 : {
6464 0 : {
6465 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q20 };
6466 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
6467 0 : if (res) return res;
6468 : }
6469 : }
6470 : break;
6471 : }
6472 : default:;
6473 : }
6474 : break;
6475 : }
6476 1067356 : default:;
6477 : }
6478 1067356 : switch (TREE_CODE (_p1))
6479 : {
6480 823085 : CASE_CONVERT:
6481 823085 : {
6482 823085 : tree _q30 = TREE_OPERAND (_p1, 0);
6483 823085 : switch (TREE_CODE (_q30))
6484 : {
6485 8 : case BIT_XOR_EXPR:
6486 8 : {
6487 8 : tree _q40 = TREE_OPERAND (_q30, 0);
6488 8 : tree _q41 = TREE_OPERAND (_q30, 1);
6489 8 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _p0, 0))
6490 : {
6491 0 : {
6492 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _p0 };
6493 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
6494 0 : if (res) return res;
6495 : }
6496 : }
6497 8 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _p0, 0))
6498 : {
6499 0 : {
6500 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _p0 };
6501 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
6502 0 : if (res) return res;
6503 : }
6504 : }
6505 : break;
6506 : }
6507 : default:;
6508 : }
6509 : break;
6510 : }
6511 86 : case BIT_XOR_EXPR:
6512 86 : {
6513 86 : tree _q30 = TREE_OPERAND (_p1, 0);
6514 86 : tree _q31 = TREE_OPERAND (_p1, 1);
6515 86 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || operand_equal_p (_q31, _p0, 0))
6516 : {
6517 0 : {
6518 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
6519 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
6520 0 : if (res) return res;
6521 : }
6522 : }
6523 86 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || operand_equal_p (_q30, _p0, 0))
6524 : {
6525 0 : {
6526 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _p0 };
6527 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
6528 0 : if (res) return res;
6529 : }
6530 : }
6531 : break;
6532 : }
6533 1067356 : default:;
6534 : }
6535 1067356 : switch (TREE_CODE (_p0))
6536 : {
6537 689807 : CASE_CONVERT:
6538 689807 : {
6539 689807 : tree _q20 = TREE_OPERAND (_p0, 0);
6540 689807 : switch (TREE_CODE (_q20))
6541 : {
6542 65109 : case BIT_XOR_EXPR:
6543 65109 : {
6544 65109 : tree _q30 = TREE_OPERAND (_q20, 0);
6545 65109 : tree _q31 = TREE_OPERAND (_q20, 1);
6546 65109 : switch (TREE_CODE (_p1))
6547 : {
6548 65037 : CASE_CONVERT:
6549 65037 : {
6550 65037 : tree _q60 = TREE_OPERAND (_p1, 0);
6551 65037 : switch (TREE_CODE (_q60))
6552 : {
6553 0 : case BIT_XOR_EXPR:
6554 0 : {
6555 0 : tree _q70 = TREE_OPERAND (_q60, 0);
6556 0 : tree _q71 = TREE_OPERAND (_q60, 1);
6557 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
6558 : {
6559 0 : {
6560 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q71 };
6561 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
6562 0 : if (res) return res;
6563 : }
6564 : }
6565 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
6566 : {
6567 0 : {
6568 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q70 };
6569 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
6570 0 : if (res) return res;
6571 : }
6572 : }
6573 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
6574 : {
6575 0 : {
6576 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q71 };
6577 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
6578 0 : if (res) return res;
6579 : }
6580 : }
6581 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
6582 : {
6583 0 : {
6584 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q70 };
6585 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
6586 0 : if (res) return res;
6587 : }
6588 : }
6589 : break;
6590 : }
6591 : default:;
6592 : }
6593 : break;
6594 : }
6595 0 : case BIT_XOR_EXPR:
6596 0 : {
6597 0 : tree _q60 = TREE_OPERAND (_p1, 0);
6598 0 : tree _q61 = TREE_OPERAND (_p1, 1);
6599 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
6600 : {
6601 0 : {
6602 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q61 };
6603 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
6604 0 : if (res) return res;
6605 : }
6606 : }
6607 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
6608 : {
6609 0 : {
6610 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q60 };
6611 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
6612 0 : if (res) return res;
6613 : }
6614 : }
6615 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
6616 : {
6617 0 : {
6618 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q61 };
6619 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
6620 0 : if (res) return res;
6621 : }
6622 : }
6623 0 : if ((_q61 == _q31 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q31, 0) && types_match (_q61, _q31)))
6624 : {
6625 0 : {
6626 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q60 };
6627 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
6628 0 : if (res) return res;
6629 : }
6630 : }
6631 : break;
6632 : }
6633 : default:;
6634 : }
6635 : break;
6636 : }
6637 689807 : default:;
6638 : }
6639 689807 : switch (TREE_CODE (_p1))
6640 : {
6641 685576 : CASE_CONVERT:
6642 685576 : {
6643 685576 : tree _q40 = TREE_OPERAND (_p1, 0);
6644 685576 : {
6645 685576 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
6646 685576 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
6647 685576 : if (res) return res;
6648 : }
6649 591614 : break;
6650 : }
6651 595845 : default:;
6652 : }
6653 595845 : {
6654 595845 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
6655 595845 : tree res = generic_simplify_30 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
6656 595845 : if (res) return res;
6657 : }
6658 595737 : break;
6659 : }
6660 4049 : case BIT_XOR_EXPR:
6661 4049 : {
6662 4049 : tree _q20 = TREE_OPERAND (_p0, 0);
6663 4049 : tree _q21 = TREE_OPERAND (_p0, 1);
6664 4049 : switch (TREE_CODE (_p1))
6665 : {
6666 202 : CASE_CONVERT:
6667 202 : {
6668 202 : tree _q50 = TREE_OPERAND (_p1, 0);
6669 202 : switch (TREE_CODE (_q50))
6670 : {
6671 0 : case BIT_XOR_EXPR:
6672 0 : {
6673 0 : tree _q60 = TREE_OPERAND (_q50, 0);
6674 0 : tree _q61 = TREE_OPERAND (_q50, 1);
6675 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6676 : {
6677 0 : {
6678 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q61 };
6679 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
6680 0 : if (res) return res;
6681 : }
6682 : }
6683 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
6684 : {
6685 0 : {
6686 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q60 };
6687 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
6688 0 : if (res) return res;
6689 : }
6690 : }
6691 0 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
6692 : {
6693 0 : {
6694 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q61 };
6695 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
6696 0 : if (res) return res;
6697 : }
6698 : }
6699 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
6700 : {
6701 0 : {
6702 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q60 };
6703 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
6704 0 : if (res) return res;
6705 : }
6706 : }
6707 : break;
6708 : }
6709 : default:;
6710 : }
6711 : break;
6712 : }
6713 18 : case BIT_XOR_EXPR:
6714 18 : {
6715 18 : tree _q50 = TREE_OPERAND (_p1, 0);
6716 18 : tree _q51 = TREE_OPERAND (_p1, 1);
6717 18 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6718 : {
6719 0 : {
6720 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
6721 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
6722 0 : if (res) return res;
6723 : }
6724 : }
6725 18 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6726 : {
6727 0 : {
6728 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
6729 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
6730 0 : if (res) return res;
6731 : }
6732 : }
6733 18 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6734 : {
6735 0 : {
6736 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
6737 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
6738 0 : if (res) return res;
6739 : }
6740 : }
6741 18 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6742 : {
6743 0 : {
6744 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
6745 0 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
6746 0 : if (res) return res;
6747 : }
6748 : }
6749 : break;
6750 : }
6751 : default:;
6752 : }
6753 : break;
6754 : }
6755 3820 : case BIT_AND_EXPR:
6756 3820 : {
6757 3820 : tree _q20 = TREE_OPERAND (_p0, 0);
6758 3820 : tree _q21 = TREE_OPERAND (_p0, 1);
6759 3820 : {
6760 3820 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6761 3820 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR, BIT_IOR_EXPR);
6762 3820 : if (res) return res;
6763 : }
6764 3820 : {
6765 3820 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _p1 };
6766 3820 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR, BIT_IOR_EXPR);
6767 3820 : if (res) return res;
6768 : }
6769 3820 : if (tree_truth_valued_p (_q20))
6770 : {
6771 0 : if (tree_truth_valued_p (_q21))
6772 : {
6773 0 : switch (TREE_CODE (_p1))
6774 : {
6775 0 : case EQ_EXPR:
6776 0 : {
6777 0 : tree _q50 = TREE_OPERAND (_p1, 0);
6778 0 : tree _q51 = TREE_OPERAND (_p1, 1);
6779 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6780 : {
6781 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6782 : {
6783 0 : {
6784 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6785 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6786 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
6787 : )
6788 : {
6789 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1215;
6790 0 : {
6791 0 : tree res_op0;
6792 0 : {
6793 0 : tree _o1[1], _r1;
6794 0 : {
6795 0 : tree _o2[2], _r2;
6796 0 : _o2[0] = captures[0];
6797 0 : _o2[1] = captures[1];
6798 0 : _r2 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
6799 0 : _o1[0] = _r2;
6800 : }
6801 0 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
6802 0 : res_op0 = _r1;
6803 : }
6804 0 : tree _r;
6805 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
6806 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 932, __FILE__, __LINE__, true);
6807 : return _r;
6808 : }
6809 0 : next_after_fail1215:;
6810 : }
6811 : else
6812 : {
6813 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1216;
6814 0 : {
6815 0 : tree res_op0;
6816 0 : {
6817 0 : tree _o1[2], _r1;
6818 0 : {
6819 0 : tree _o2[2], _r2;
6820 0 : _o2[0] = captures[0];
6821 0 : _o2[1] = captures[1];
6822 0 : _r2 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
6823 0 : _o1[0] = _r2;
6824 : }
6825 0 : _o1[1] = build_one_cst (TREE_TYPE (captures[0]));
6826 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
6827 0 : res_op0 = _r1;
6828 : }
6829 0 : tree _r;
6830 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
6831 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 933, __FILE__, __LINE__, true);
6832 : return _r;
6833 : }
6834 0 : next_after_fail1216:;
6835 : }
6836 : }
6837 : }
6838 : }
6839 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6840 : {
6841 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6842 : {
6843 0 : {
6844 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6845 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6846 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
6847 : )
6848 : {
6849 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1217;
6850 0 : {
6851 0 : tree res_op0;
6852 0 : {
6853 0 : tree _o1[1], _r1;
6854 0 : {
6855 0 : tree _o2[2], _r2;
6856 0 : _o2[0] = captures[0];
6857 0 : _o2[1] = captures[1];
6858 0 : _r2 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
6859 0 : _o1[0] = _r2;
6860 : }
6861 0 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
6862 0 : res_op0 = _r1;
6863 : }
6864 0 : tree _r;
6865 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
6866 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 932, __FILE__, __LINE__, true);
6867 : return _r;
6868 : }
6869 0 : next_after_fail1217:;
6870 : }
6871 : else
6872 : {
6873 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1218;
6874 0 : {
6875 0 : tree res_op0;
6876 0 : {
6877 0 : tree _o1[2], _r1;
6878 0 : {
6879 0 : tree _o2[2], _r2;
6880 0 : _o2[0] = captures[0];
6881 0 : _o2[1] = captures[1];
6882 0 : _r2 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
6883 0 : _o1[0] = _r2;
6884 : }
6885 0 : _o1[1] = build_one_cst (TREE_TYPE (captures[0]));
6886 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
6887 0 : res_op0 = _r1;
6888 : }
6889 0 : tree _r;
6890 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
6891 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 933, __FILE__, __LINE__, true);
6892 : return _r;
6893 : }
6894 0 : next_after_fail1218:;
6895 : }
6896 : }
6897 : }
6898 : }
6899 : break;
6900 : }
6901 : default:;
6902 : }
6903 : }
6904 : }
6905 : break;
6906 : }
6907 973286 : default:;
6908 : }
6909 973286 : switch (TREE_CODE (_p1))
6910 : {
6911 608 : case BIT_AND_EXPR:
6912 608 : {
6913 608 : tree _q30 = TREE_OPERAND (_p1, 0);
6914 608 : tree _q31 = TREE_OPERAND (_p1, 1);
6915 608 : {
6916 608 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
6917 608 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR, BIT_IOR_EXPR);
6918 608 : if (res) return res;
6919 : }
6920 608 : {
6921 608 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _p0 };
6922 608 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR, BIT_IOR_EXPR);
6923 608 : if (res) return res;
6924 : }
6925 608 : break;
6926 : }
6927 973286 : default:;
6928 : }
6929 973286 : switch (TREE_CODE (_p0))
6930 : {
6931 4049 : case BIT_XOR_EXPR:
6932 4049 : {
6933 4049 : tree _q20 = TREE_OPERAND (_p0, 0);
6934 4049 : tree _q21 = TREE_OPERAND (_p0, 1);
6935 4049 : if (CONSTANT_CLASS_P (_q21))
6936 : {
6937 49 : if (CONSTANT_CLASS_P (_p1))
6938 : {
6939 30 : {
6940 30 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6941 30 : tree res = generic_simplify_32 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
6942 30 : if (res) return res;
6943 : }
6944 : }
6945 : }
6946 : break;
6947 : }
6948 70 : case COND_EXPR:
6949 70 : {
6950 70 : tree _q20 = TREE_OPERAND (_p0, 0);
6951 70 : tree _q21 = TREE_OPERAND (_p0, 1);
6952 70 : tree _q22 = TREE_OPERAND (_p0, 2);
6953 70 : if (integer_zerop (_q22))
6954 : {
6955 70 : switch (TREE_CODE (_p1))
6956 : {
6957 4 : case COND_EXPR:
6958 4 : {
6959 4 : tree _q60 = TREE_OPERAND (_p1, 0);
6960 4 : tree _q61 = TREE_OPERAND (_p1, 1);
6961 4 : tree _q62 = TREE_OPERAND (_p1, 2);
6962 4 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6963 : {
6964 0 : if (integer_zerop (_q61))
6965 : {
6966 0 : {
6967 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q62 };
6968 0 : const enum tree_code op = BIT_XOR_EXPR;
6969 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1219;
6970 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1219;
6971 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1219;
6972 0 : {
6973 0 : tree res_op0;
6974 0 : res_op0 = captures[1];
6975 0 : tree res_op1;
6976 0 : res_op1 = captures[2];
6977 0 : tree res_op2;
6978 0 : res_op2 = captures[4];
6979 0 : tree _r;
6980 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
6981 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 934, __FILE__, __LINE__, true);
6982 : return _r;
6983 : }
6984 70 : next_after_fail1219:;
6985 : }
6986 : }
6987 : }
6988 : break;
6989 : }
6990 : default:;
6991 : }
6992 : }
6993 70 : if (integer_zerop (_q21))
6994 : {
6995 0 : switch (TREE_CODE (_p1))
6996 : {
6997 0 : case COND_EXPR:
6998 0 : {
6999 0 : tree _q60 = TREE_OPERAND (_p1, 0);
7000 0 : tree _q61 = TREE_OPERAND (_p1, 1);
7001 0 : tree _q62 = TREE_OPERAND (_p1, 2);
7002 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7003 : {
7004 0 : if (integer_zerop (_q62))
7005 : {
7006 0 : {
7007 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q20, _q61, _p0, _q22 };
7008 0 : const enum tree_code op = BIT_XOR_EXPR;
7009 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1220;
7010 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1220;
7011 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1220;
7012 0 : {
7013 0 : tree res_op0;
7014 0 : res_op0 = captures[1];
7015 0 : tree res_op1;
7016 0 : res_op1 = captures[2];
7017 0 : tree res_op2;
7018 0 : res_op2 = captures[4];
7019 0 : tree _r;
7020 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
7021 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 934, __FILE__, __LINE__, true);
7022 : return _r;
7023 : }
7024 70 : next_after_fail1220:;
7025 : }
7026 : }
7027 : }
7028 : break;
7029 : }
7030 : default:;
7031 : }
7032 : }
7033 70 : switch (TREE_CODE (_q20))
7034 : {
7035 0 : case LT_EXPR:
7036 0 : {
7037 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7038 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7039 0 : if (zerop (_q22))
7040 : {
7041 0 : switch (TREE_CODE (_p1))
7042 : {
7043 0 : case COND_EXPR:
7044 0 : {
7045 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7046 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7047 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7048 0 : switch (TREE_CODE (_q80))
7049 : {
7050 0 : case GE_EXPR:
7051 0 : {
7052 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7053 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7054 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7055 : {
7056 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7057 : {
7058 0 : if (zerop (_q82))
7059 : {
7060 0 : {
7061 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7062 0 : tree res = generic_simplify_33 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LT_EXPR, GE_EXPR);
7063 0 : if (res) return res;
7064 : }
7065 : }
7066 : }
7067 : }
7068 : break;
7069 : }
7070 : default:;
7071 : }
7072 : break;
7073 : }
7074 : default:;
7075 : }
7076 : }
7077 : break;
7078 : }
7079 38 : case LE_EXPR:
7080 38 : {
7081 38 : tree _q30 = TREE_OPERAND (_q20, 0);
7082 38 : tree _q31 = TREE_OPERAND (_q20, 1);
7083 38 : if (zerop (_q22))
7084 : {
7085 38 : switch (TREE_CODE (_p1))
7086 : {
7087 0 : case COND_EXPR:
7088 0 : {
7089 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7090 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7091 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7092 0 : switch (TREE_CODE (_q80))
7093 : {
7094 0 : case GT_EXPR:
7095 0 : {
7096 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7097 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7098 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7099 : {
7100 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7101 : {
7102 0 : if (zerop (_q82))
7103 : {
7104 0 : {
7105 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7106 0 : tree res = generic_simplify_33 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LE_EXPR, GT_EXPR);
7107 0 : if (res) return res;
7108 : }
7109 : }
7110 : }
7111 : }
7112 : break;
7113 : }
7114 : default:;
7115 : }
7116 : break;
7117 : }
7118 : default:;
7119 : }
7120 : }
7121 : break;
7122 : }
7123 0 : case EQ_EXPR:
7124 0 : {
7125 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7126 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7127 0 : if (zerop (_q22))
7128 : {
7129 0 : switch (TREE_CODE (_p1))
7130 : {
7131 0 : case COND_EXPR:
7132 0 : {
7133 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7134 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7135 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7136 0 : switch (TREE_CODE (_q80))
7137 : {
7138 0 : case NE_EXPR:
7139 0 : {
7140 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7141 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7142 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7143 : {
7144 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7145 : {
7146 0 : if (zerop (_q82))
7147 : {
7148 0 : {
7149 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7150 0 : tree res = generic_simplify_33 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, EQ_EXPR, NE_EXPR);
7151 0 : if (res) return res;
7152 : }
7153 : }
7154 : }
7155 : }
7156 : break;
7157 : }
7158 : default:;
7159 : }
7160 : break;
7161 : }
7162 : default:;
7163 : }
7164 : }
7165 : break;
7166 : }
7167 32 : case NE_EXPR:
7168 32 : {
7169 32 : tree _q30 = TREE_OPERAND (_q20, 0);
7170 32 : tree _q31 = TREE_OPERAND (_q20, 1);
7171 32 : if (zerop (_q22))
7172 : {
7173 32 : switch (TREE_CODE (_p1))
7174 : {
7175 4 : case COND_EXPR:
7176 4 : {
7177 4 : tree _q80 = TREE_OPERAND (_p1, 0);
7178 4 : tree _q81 = TREE_OPERAND (_p1, 1);
7179 4 : tree _q82 = TREE_OPERAND (_p1, 2);
7180 4 : switch (TREE_CODE (_q80))
7181 : {
7182 0 : case EQ_EXPR:
7183 0 : {
7184 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7185 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7186 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7187 : {
7188 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7189 : {
7190 0 : if (zerop (_q82))
7191 : {
7192 0 : {
7193 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7194 0 : tree res = generic_simplify_33 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, NE_EXPR, EQ_EXPR);
7195 0 : if (res) return res;
7196 : }
7197 : }
7198 : }
7199 : }
7200 : break;
7201 : }
7202 : default:;
7203 : }
7204 : break;
7205 : }
7206 : default:;
7207 : }
7208 : }
7209 : break;
7210 : }
7211 0 : case GE_EXPR:
7212 0 : {
7213 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7214 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7215 0 : if (zerop (_q22))
7216 : {
7217 0 : switch (TREE_CODE (_p1))
7218 : {
7219 0 : case COND_EXPR:
7220 0 : {
7221 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7222 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7223 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7224 0 : switch (TREE_CODE (_q80))
7225 : {
7226 0 : case LT_EXPR:
7227 0 : {
7228 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7229 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7230 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7231 : {
7232 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7233 : {
7234 0 : if (zerop (_q82))
7235 : {
7236 0 : {
7237 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7238 0 : tree res = generic_simplify_33 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GE_EXPR, LT_EXPR);
7239 0 : if (res) return res;
7240 : }
7241 : }
7242 : }
7243 : }
7244 : break;
7245 : }
7246 : default:;
7247 : }
7248 : break;
7249 : }
7250 : default:;
7251 : }
7252 : }
7253 : break;
7254 : }
7255 0 : case GT_EXPR:
7256 0 : {
7257 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7258 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7259 0 : if (zerop (_q22))
7260 : {
7261 0 : switch (TREE_CODE (_p1))
7262 : {
7263 0 : case COND_EXPR:
7264 0 : {
7265 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7266 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7267 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7268 0 : switch (TREE_CODE (_q80))
7269 : {
7270 0 : case LE_EXPR:
7271 0 : {
7272 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7273 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7274 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7275 : {
7276 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7277 : {
7278 0 : if (zerop (_q82))
7279 : {
7280 0 : {
7281 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7282 0 : tree res = generic_simplify_33 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GT_EXPR, LE_EXPR);
7283 0 : if (res) return res;
7284 : }
7285 : }
7286 : }
7287 : }
7288 : break;
7289 : }
7290 : default:;
7291 : }
7292 : break;
7293 : }
7294 : default:;
7295 : }
7296 : }
7297 : break;
7298 : }
7299 0 : case UNORDERED_EXPR:
7300 0 : {
7301 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7302 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7303 0 : if (zerop (_q22))
7304 : {
7305 0 : switch (TREE_CODE (_p1))
7306 : {
7307 0 : case COND_EXPR:
7308 0 : {
7309 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7310 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7311 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7312 0 : switch (TREE_CODE (_q80))
7313 : {
7314 0 : case ORDERED_EXPR:
7315 0 : {
7316 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7317 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7318 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7319 : {
7320 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7321 : {
7322 0 : if (zerop (_q82))
7323 : {
7324 0 : {
7325 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7326 0 : tree res = generic_simplify_33 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNORDERED_EXPR, ORDERED_EXPR);
7327 0 : if (res) return res;
7328 : }
7329 : }
7330 : }
7331 : }
7332 : break;
7333 : }
7334 : default:;
7335 : }
7336 : break;
7337 : }
7338 : default:;
7339 : }
7340 : }
7341 : break;
7342 : }
7343 0 : case ORDERED_EXPR:
7344 0 : {
7345 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7346 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7347 0 : if (zerop (_q22))
7348 : {
7349 0 : switch (TREE_CODE (_p1))
7350 : {
7351 0 : case COND_EXPR:
7352 0 : {
7353 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7354 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7355 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7356 0 : switch (TREE_CODE (_q80))
7357 : {
7358 0 : case UNORDERED_EXPR:
7359 0 : {
7360 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7361 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7362 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7363 : {
7364 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7365 : {
7366 0 : if (zerop (_q82))
7367 : {
7368 0 : {
7369 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7370 0 : tree res = generic_simplify_33 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, ORDERED_EXPR, UNORDERED_EXPR);
7371 0 : if (res) return res;
7372 : }
7373 : }
7374 : }
7375 : }
7376 : break;
7377 : }
7378 : default:;
7379 : }
7380 : break;
7381 : }
7382 : default:;
7383 : }
7384 : }
7385 : break;
7386 : }
7387 0 : case UNLT_EXPR:
7388 0 : {
7389 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7390 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7391 0 : if (zerop (_q22))
7392 : {
7393 0 : switch (TREE_CODE (_p1))
7394 : {
7395 0 : case COND_EXPR:
7396 0 : {
7397 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7398 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7399 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7400 0 : switch (TREE_CODE (_q80))
7401 : {
7402 0 : case GE_EXPR:
7403 0 : {
7404 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7405 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7406 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7407 : {
7408 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7409 : {
7410 0 : if (zerop (_q82))
7411 : {
7412 0 : {
7413 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7414 0 : tree res = generic_simplify_33 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLT_EXPR, GE_EXPR);
7415 0 : if (res) return res;
7416 : }
7417 : }
7418 : }
7419 : }
7420 : break;
7421 : }
7422 : default:;
7423 : }
7424 : break;
7425 : }
7426 : default:;
7427 : }
7428 : }
7429 : break;
7430 : }
7431 0 : case UNLE_EXPR:
7432 0 : {
7433 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7434 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7435 0 : if (zerop (_q22))
7436 : {
7437 0 : switch (TREE_CODE (_p1))
7438 : {
7439 0 : case COND_EXPR:
7440 0 : {
7441 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7442 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7443 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7444 0 : switch (TREE_CODE (_q80))
7445 : {
7446 0 : case GT_EXPR:
7447 0 : {
7448 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7449 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7450 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7451 : {
7452 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7453 : {
7454 0 : if (zerop (_q82))
7455 : {
7456 0 : {
7457 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7458 0 : tree res = generic_simplify_33 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLE_EXPR, GT_EXPR);
7459 0 : if (res) return res;
7460 : }
7461 : }
7462 : }
7463 : }
7464 : break;
7465 : }
7466 : default:;
7467 : }
7468 : break;
7469 : }
7470 : default:;
7471 : }
7472 : }
7473 : break;
7474 : }
7475 0 : case UNGT_EXPR:
7476 0 : {
7477 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7478 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7479 0 : if (zerop (_q22))
7480 : {
7481 0 : switch (TREE_CODE (_p1))
7482 : {
7483 0 : case COND_EXPR:
7484 0 : {
7485 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7486 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7487 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7488 0 : switch (TREE_CODE (_q80))
7489 : {
7490 0 : case LE_EXPR:
7491 0 : {
7492 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7493 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7494 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7495 : {
7496 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7497 : {
7498 0 : if (zerop (_q82))
7499 : {
7500 0 : {
7501 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7502 0 : tree res = generic_simplify_33 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGT_EXPR, LE_EXPR);
7503 0 : if (res) return res;
7504 : }
7505 : }
7506 : }
7507 : }
7508 : break;
7509 : }
7510 : default:;
7511 : }
7512 : break;
7513 : }
7514 : default:;
7515 : }
7516 : }
7517 : break;
7518 : }
7519 0 : case UNGE_EXPR:
7520 0 : {
7521 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7522 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7523 0 : if (zerop (_q22))
7524 : {
7525 0 : switch (TREE_CODE (_p1))
7526 : {
7527 0 : case COND_EXPR:
7528 0 : {
7529 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7530 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7531 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7532 0 : switch (TREE_CODE (_q80))
7533 : {
7534 0 : case LT_EXPR:
7535 0 : {
7536 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7537 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7538 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7539 : {
7540 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7541 : {
7542 0 : if (zerop (_q82))
7543 : {
7544 0 : {
7545 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7546 0 : tree res = generic_simplify_33 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGE_EXPR, LT_EXPR);
7547 0 : if (res) return res;
7548 : }
7549 : }
7550 : }
7551 : }
7552 : break;
7553 : }
7554 : default:;
7555 : }
7556 : break;
7557 : }
7558 : default:;
7559 : }
7560 : }
7561 : break;
7562 : }
7563 0 : case UNEQ_EXPR:
7564 0 : {
7565 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7566 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7567 0 : if (zerop (_q22))
7568 : {
7569 0 : switch (TREE_CODE (_p1))
7570 : {
7571 0 : case COND_EXPR:
7572 0 : {
7573 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7574 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7575 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7576 0 : switch (TREE_CODE (_q80))
7577 : {
7578 0 : case LTGT_EXPR:
7579 0 : {
7580 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7581 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7582 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7583 : {
7584 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7585 : {
7586 0 : if (zerop (_q82))
7587 : {
7588 0 : {
7589 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7590 0 : tree res = generic_simplify_33 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNEQ_EXPR, LTGT_EXPR);
7591 0 : if (res) return res;
7592 : }
7593 : }
7594 : }
7595 : }
7596 : break;
7597 : }
7598 : default:;
7599 : }
7600 : break;
7601 : }
7602 : default:;
7603 : }
7604 : }
7605 : break;
7606 : }
7607 0 : case LTGT_EXPR:
7608 0 : {
7609 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7610 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7611 0 : if (zerop (_q22))
7612 : {
7613 0 : switch (TREE_CODE (_p1))
7614 : {
7615 0 : case COND_EXPR:
7616 0 : {
7617 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7618 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7619 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7620 0 : switch (TREE_CODE (_q80))
7621 : {
7622 0 : case UNEQ_EXPR:
7623 0 : {
7624 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7625 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7626 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7627 : {
7628 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7629 : {
7630 0 : if (zerop (_q82))
7631 : {
7632 0 : {
7633 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7634 0 : tree res = generic_simplify_33 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LTGT_EXPR, UNEQ_EXPR);
7635 0 : if (res) return res;
7636 : }
7637 : }
7638 : }
7639 : }
7640 : break;
7641 : }
7642 : default:;
7643 : }
7644 : break;
7645 : }
7646 : default:;
7647 : }
7648 : }
7649 : break;
7650 : }
7651 : default:;
7652 : }
7653 : break;
7654 : }
7655 1 : case VEC_COND_EXPR:
7656 1 : {
7657 1 : tree _q20 = TREE_OPERAND (_p0, 0);
7658 1 : tree _q21 = TREE_OPERAND (_p0, 1);
7659 1 : tree _q22 = TREE_OPERAND (_p0, 2);
7660 1 : if (integer_zerop (_q22))
7661 : {
7662 1 : switch (TREE_CODE (_p1))
7663 : {
7664 0 : case VEC_COND_EXPR:
7665 0 : {
7666 0 : tree _q60 = TREE_OPERAND (_p1, 0);
7667 0 : tree _q61 = TREE_OPERAND (_p1, 1);
7668 0 : tree _q62 = TREE_OPERAND (_p1, 2);
7669 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7670 : {
7671 0 : if (integer_zerop (_q61))
7672 : {
7673 0 : {
7674 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q62 };
7675 0 : const enum tree_code op = BIT_XOR_EXPR;
7676 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1221;
7677 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1221;
7678 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1221;
7679 0 : {
7680 0 : tree res_op0;
7681 0 : res_op0 = captures[1];
7682 0 : tree res_op1;
7683 0 : res_op1 = captures[2];
7684 0 : tree res_op2;
7685 0 : res_op2 = captures[4];
7686 0 : tree _r;
7687 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7688 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 934, __FILE__, __LINE__, true);
7689 : return _r;
7690 : }
7691 1 : next_after_fail1221:;
7692 : }
7693 : }
7694 : }
7695 : break;
7696 : }
7697 : default:;
7698 : }
7699 : }
7700 1 : if (integer_zerop (_q21))
7701 : {
7702 0 : switch (TREE_CODE (_p1))
7703 : {
7704 0 : case VEC_COND_EXPR:
7705 0 : {
7706 0 : tree _q60 = TREE_OPERAND (_p1, 0);
7707 0 : tree _q61 = TREE_OPERAND (_p1, 1);
7708 0 : tree _q62 = TREE_OPERAND (_p1, 2);
7709 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7710 : {
7711 0 : if (integer_zerop (_q62))
7712 : {
7713 0 : {
7714 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q20, _q61, _p0, _q22 };
7715 0 : const enum tree_code op = BIT_XOR_EXPR;
7716 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1222;
7717 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1222;
7718 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1222;
7719 0 : {
7720 0 : tree res_op0;
7721 0 : res_op0 = captures[1];
7722 0 : tree res_op1;
7723 0 : res_op1 = captures[2];
7724 0 : tree res_op2;
7725 0 : res_op2 = captures[4];
7726 0 : tree _r;
7727 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7728 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 934, __FILE__, __LINE__, true);
7729 : return _r;
7730 : }
7731 1 : next_after_fail1222:;
7732 : }
7733 : }
7734 : }
7735 : break;
7736 : }
7737 : default:;
7738 : }
7739 : }
7740 1 : switch (TREE_CODE (_q20))
7741 : {
7742 0 : case LT_EXPR:
7743 0 : {
7744 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7745 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7746 0 : if (integer_zerop (_q22))
7747 : {
7748 0 : switch (TREE_CODE (_p1))
7749 : {
7750 0 : case VEC_COND_EXPR:
7751 0 : {
7752 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7753 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7754 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7755 0 : switch (TREE_CODE (_q80))
7756 : {
7757 0 : case GE_EXPR:
7758 0 : {
7759 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7760 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7761 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7762 : {
7763 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7764 : {
7765 0 : if (integer_zerop (_q82))
7766 : {
7767 0 : {
7768 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7769 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LT_EXPR, GE_EXPR);
7770 0 : if (res) return res;
7771 : }
7772 : }
7773 : }
7774 : }
7775 : break;
7776 : }
7777 : default:;
7778 : }
7779 : break;
7780 : }
7781 : default:;
7782 : }
7783 : }
7784 : break;
7785 : }
7786 0 : case LE_EXPR:
7787 0 : {
7788 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7789 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7790 0 : if (integer_zerop (_q22))
7791 : {
7792 0 : switch (TREE_CODE (_p1))
7793 : {
7794 0 : case VEC_COND_EXPR:
7795 0 : {
7796 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7797 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7798 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7799 0 : switch (TREE_CODE (_q80))
7800 : {
7801 0 : case GT_EXPR:
7802 0 : {
7803 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7804 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7805 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7806 : {
7807 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7808 : {
7809 0 : if (integer_zerop (_q82))
7810 : {
7811 0 : {
7812 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7813 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LE_EXPR, GT_EXPR);
7814 0 : if (res) return res;
7815 : }
7816 : }
7817 : }
7818 : }
7819 : break;
7820 : }
7821 : default:;
7822 : }
7823 : break;
7824 : }
7825 : default:;
7826 : }
7827 : }
7828 : break;
7829 : }
7830 0 : case EQ_EXPR:
7831 0 : {
7832 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7833 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7834 0 : if (integer_zerop (_q22))
7835 : {
7836 0 : switch (TREE_CODE (_p1))
7837 : {
7838 0 : case VEC_COND_EXPR:
7839 0 : {
7840 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7841 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7842 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7843 0 : switch (TREE_CODE (_q80))
7844 : {
7845 0 : case NE_EXPR:
7846 0 : {
7847 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7848 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7849 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7850 : {
7851 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7852 : {
7853 0 : if (integer_zerop (_q82))
7854 : {
7855 0 : {
7856 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7857 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, EQ_EXPR, NE_EXPR);
7858 0 : if (res) return res;
7859 : }
7860 : }
7861 : }
7862 : }
7863 : break;
7864 : }
7865 : default:;
7866 : }
7867 : break;
7868 : }
7869 : default:;
7870 : }
7871 : }
7872 : break;
7873 : }
7874 1 : case NE_EXPR:
7875 1 : {
7876 1 : tree _q30 = TREE_OPERAND (_q20, 0);
7877 1 : tree _q31 = TREE_OPERAND (_q20, 1);
7878 1 : if (integer_zerop (_q22))
7879 : {
7880 1 : switch (TREE_CODE (_p1))
7881 : {
7882 0 : case VEC_COND_EXPR:
7883 0 : {
7884 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7885 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7886 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7887 0 : switch (TREE_CODE (_q80))
7888 : {
7889 0 : case EQ_EXPR:
7890 0 : {
7891 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7892 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7893 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7894 : {
7895 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7896 : {
7897 0 : if (integer_zerop (_q82))
7898 : {
7899 0 : {
7900 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7901 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, NE_EXPR, EQ_EXPR);
7902 0 : if (res) return res;
7903 : }
7904 : }
7905 : }
7906 : }
7907 : break;
7908 : }
7909 : default:;
7910 : }
7911 : break;
7912 : }
7913 : default:;
7914 : }
7915 : }
7916 : break;
7917 : }
7918 0 : case GE_EXPR:
7919 0 : {
7920 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7921 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7922 0 : if (integer_zerop (_q22))
7923 : {
7924 0 : switch (TREE_CODE (_p1))
7925 : {
7926 0 : case VEC_COND_EXPR:
7927 0 : {
7928 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7929 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7930 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7931 0 : switch (TREE_CODE (_q80))
7932 : {
7933 0 : case LT_EXPR:
7934 0 : {
7935 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7936 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7937 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7938 : {
7939 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7940 : {
7941 0 : if (integer_zerop (_q82))
7942 : {
7943 0 : {
7944 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7945 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GE_EXPR, LT_EXPR);
7946 0 : if (res) return res;
7947 : }
7948 : }
7949 : }
7950 : }
7951 : break;
7952 : }
7953 : default:;
7954 : }
7955 : break;
7956 : }
7957 : default:;
7958 : }
7959 : }
7960 : break;
7961 : }
7962 0 : case GT_EXPR:
7963 0 : {
7964 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7965 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7966 0 : if (integer_zerop (_q22))
7967 : {
7968 0 : switch (TREE_CODE (_p1))
7969 : {
7970 0 : case VEC_COND_EXPR:
7971 0 : {
7972 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7973 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7974 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7975 0 : switch (TREE_CODE (_q80))
7976 : {
7977 0 : case LE_EXPR:
7978 0 : {
7979 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7980 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7981 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7982 : {
7983 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7984 : {
7985 0 : if (integer_zerop (_q82))
7986 : {
7987 0 : {
7988 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7989 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GT_EXPR, LE_EXPR);
7990 0 : if (res) return res;
7991 : }
7992 : }
7993 : }
7994 : }
7995 : break;
7996 : }
7997 : default:;
7998 : }
7999 : break;
8000 : }
8001 : default:;
8002 : }
8003 : }
8004 : break;
8005 : }
8006 0 : case UNORDERED_EXPR:
8007 0 : {
8008 0 : tree _q30 = TREE_OPERAND (_q20, 0);
8009 0 : tree _q31 = TREE_OPERAND (_q20, 1);
8010 0 : if (integer_zerop (_q22))
8011 : {
8012 0 : switch (TREE_CODE (_p1))
8013 : {
8014 0 : case VEC_COND_EXPR:
8015 0 : {
8016 0 : tree _q80 = TREE_OPERAND (_p1, 0);
8017 0 : tree _q81 = TREE_OPERAND (_p1, 1);
8018 0 : tree _q82 = TREE_OPERAND (_p1, 2);
8019 0 : switch (TREE_CODE (_q80))
8020 : {
8021 0 : case ORDERED_EXPR:
8022 0 : {
8023 0 : tree _q90 = TREE_OPERAND (_q80, 0);
8024 0 : tree _q91 = TREE_OPERAND (_q80, 1);
8025 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
8026 : {
8027 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
8028 : {
8029 0 : if (integer_zerop (_q82))
8030 : {
8031 0 : {
8032 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
8033 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNORDERED_EXPR, ORDERED_EXPR);
8034 0 : if (res) return res;
8035 : }
8036 : }
8037 : }
8038 : }
8039 : break;
8040 : }
8041 : default:;
8042 : }
8043 : break;
8044 : }
8045 : default:;
8046 : }
8047 : }
8048 : break;
8049 : }
8050 0 : case ORDERED_EXPR:
8051 0 : {
8052 0 : tree _q30 = TREE_OPERAND (_q20, 0);
8053 0 : tree _q31 = TREE_OPERAND (_q20, 1);
8054 0 : if (integer_zerop (_q22))
8055 : {
8056 0 : switch (TREE_CODE (_p1))
8057 : {
8058 0 : case VEC_COND_EXPR:
8059 0 : {
8060 0 : tree _q80 = TREE_OPERAND (_p1, 0);
8061 0 : tree _q81 = TREE_OPERAND (_p1, 1);
8062 0 : tree _q82 = TREE_OPERAND (_p1, 2);
8063 0 : switch (TREE_CODE (_q80))
8064 : {
8065 0 : case UNORDERED_EXPR:
8066 0 : {
8067 0 : tree _q90 = TREE_OPERAND (_q80, 0);
8068 0 : tree _q91 = TREE_OPERAND (_q80, 1);
8069 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
8070 : {
8071 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
8072 : {
8073 0 : if (integer_zerop (_q82))
8074 : {
8075 0 : {
8076 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
8077 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, ORDERED_EXPR, UNORDERED_EXPR);
8078 0 : if (res) return res;
8079 : }
8080 : }
8081 : }
8082 : }
8083 : break;
8084 : }
8085 : default:;
8086 : }
8087 : break;
8088 : }
8089 : default:;
8090 : }
8091 : }
8092 : break;
8093 : }
8094 0 : case UNLT_EXPR:
8095 0 : {
8096 0 : tree _q30 = TREE_OPERAND (_q20, 0);
8097 0 : tree _q31 = TREE_OPERAND (_q20, 1);
8098 0 : if (integer_zerop (_q22))
8099 : {
8100 0 : switch (TREE_CODE (_p1))
8101 : {
8102 0 : case VEC_COND_EXPR:
8103 0 : {
8104 0 : tree _q80 = TREE_OPERAND (_p1, 0);
8105 0 : tree _q81 = TREE_OPERAND (_p1, 1);
8106 0 : tree _q82 = TREE_OPERAND (_p1, 2);
8107 0 : switch (TREE_CODE (_q80))
8108 : {
8109 0 : case GE_EXPR:
8110 0 : {
8111 0 : tree _q90 = TREE_OPERAND (_q80, 0);
8112 0 : tree _q91 = TREE_OPERAND (_q80, 1);
8113 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
8114 : {
8115 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
8116 : {
8117 0 : if (integer_zerop (_q82))
8118 : {
8119 0 : {
8120 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
8121 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLT_EXPR, GE_EXPR);
8122 0 : if (res) return res;
8123 : }
8124 : }
8125 : }
8126 : }
8127 : break;
8128 : }
8129 : default:;
8130 : }
8131 : break;
8132 : }
8133 : default:;
8134 : }
8135 : }
8136 : break;
8137 : }
8138 0 : case UNLE_EXPR:
8139 0 : {
8140 0 : tree _q30 = TREE_OPERAND (_q20, 0);
8141 0 : tree _q31 = TREE_OPERAND (_q20, 1);
8142 0 : if (integer_zerop (_q22))
8143 : {
8144 0 : switch (TREE_CODE (_p1))
8145 : {
8146 0 : case VEC_COND_EXPR:
8147 0 : {
8148 0 : tree _q80 = TREE_OPERAND (_p1, 0);
8149 0 : tree _q81 = TREE_OPERAND (_p1, 1);
8150 0 : tree _q82 = TREE_OPERAND (_p1, 2);
8151 0 : switch (TREE_CODE (_q80))
8152 : {
8153 0 : case GT_EXPR:
8154 0 : {
8155 0 : tree _q90 = TREE_OPERAND (_q80, 0);
8156 0 : tree _q91 = TREE_OPERAND (_q80, 1);
8157 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
8158 : {
8159 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
8160 : {
8161 0 : if (integer_zerop (_q82))
8162 : {
8163 0 : {
8164 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
8165 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLE_EXPR, GT_EXPR);
8166 0 : if (res) return res;
8167 : }
8168 : }
8169 : }
8170 : }
8171 : break;
8172 : }
8173 : default:;
8174 : }
8175 : break;
8176 : }
8177 : default:;
8178 : }
8179 : }
8180 : break;
8181 : }
8182 0 : case UNGT_EXPR:
8183 0 : {
8184 0 : tree _q30 = TREE_OPERAND (_q20, 0);
8185 0 : tree _q31 = TREE_OPERAND (_q20, 1);
8186 0 : if (integer_zerop (_q22))
8187 : {
8188 0 : switch (TREE_CODE (_p1))
8189 : {
8190 0 : case VEC_COND_EXPR:
8191 0 : {
8192 0 : tree _q80 = TREE_OPERAND (_p1, 0);
8193 0 : tree _q81 = TREE_OPERAND (_p1, 1);
8194 0 : tree _q82 = TREE_OPERAND (_p1, 2);
8195 0 : switch (TREE_CODE (_q80))
8196 : {
8197 0 : case LE_EXPR:
8198 0 : {
8199 0 : tree _q90 = TREE_OPERAND (_q80, 0);
8200 0 : tree _q91 = TREE_OPERAND (_q80, 1);
8201 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
8202 : {
8203 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
8204 : {
8205 0 : if (integer_zerop (_q82))
8206 : {
8207 0 : {
8208 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
8209 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGT_EXPR, LE_EXPR);
8210 0 : if (res) return res;
8211 : }
8212 : }
8213 : }
8214 : }
8215 : break;
8216 : }
8217 : default:;
8218 : }
8219 : break;
8220 : }
8221 : default:;
8222 : }
8223 : }
8224 : break;
8225 : }
8226 0 : case UNGE_EXPR:
8227 0 : {
8228 0 : tree _q30 = TREE_OPERAND (_q20, 0);
8229 0 : tree _q31 = TREE_OPERAND (_q20, 1);
8230 0 : if (integer_zerop (_q22))
8231 : {
8232 0 : switch (TREE_CODE (_p1))
8233 : {
8234 0 : case VEC_COND_EXPR:
8235 0 : {
8236 0 : tree _q80 = TREE_OPERAND (_p1, 0);
8237 0 : tree _q81 = TREE_OPERAND (_p1, 1);
8238 0 : tree _q82 = TREE_OPERAND (_p1, 2);
8239 0 : switch (TREE_CODE (_q80))
8240 : {
8241 0 : case LT_EXPR:
8242 0 : {
8243 0 : tree _q90 = TREE_OPERAND (_q80, 0);
8244 0 : tree _q91 = TREE_OPERAND (_q80, 1);
8245 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
8246 : {
8247 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
8248 : {
8249 0 : if (integer_zerop (_q82))
8250 : {
8251 0 : {
8252 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
8253 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGE_EXPR, LT_EXPR);
8254 0 : if (res) return res;
8255 : }
8256 : }
8257 : }
8258 : }
8259 : break;
8260 : }
8261 : default:;
8262 : }
8263 : break;
8264 : }
8265 : default:;
8266 : }
8267 : }
8268 : break;
8269 : }
8270 0 : case UNEQ_EXPR:
8271 0 : {
8272 0 : tree _q30 = TREE_OPERAND (_q20, 0);
8273 0 : tree _q31 = TREE_OPERAND (_q20, 1);
8274 0 : if (integer_zerop (_q22))
8275 : {
8276 0 : switch (TREE_CODE (_p1))
8277 : {
8278 0 : case VEC_COND_EXPR:
8279 0 : {
8280 0 : tree _q80 = TREE_OPERAND (_p1, 0);
8281 0 : tree _q81 = TREE_OPERAND (_p1, 1);
8282 0 : tree _q82 = TREE_OPERAND (_p1, 2);
8283 0 : switch (TREE_CODE (_q80))
8284 : {
8285 0 : case LTGT_EXPR:
8286 0 : {
8287 0 : tree _q90 = TREE_OPERAND (_q80, 0);
8288 0 : tree _q91 = TREE_OPERAND (_q80, 1);
8289 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
8290 : {
8291 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
8292 : {
8293 0 : if (integer_zerop (_q82))
8294 : {
8295 0 : {
8296 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
8297 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNEQ_EXPR, LTGT_EXPR);
8298 0 : if (res) return res;
8299 : }
8300 : }
8301 : }
8302 : }
8303 : break;
8304 : }
8305 : default:;
8306 : }
8307 : break;
8308 : }
8309 : default:;
8310 : }
8311 : }
8312 : break;
8313 : }
8314 0 : case LTGT_EXPR:
8315 0 : {
8316 0 : tree _q30 = TREE_OPERAND (_q20, 0);
8317 0 : tree _q31 = TREE_OPERAND (_q20, 1);
8318 0 : if (integer_zerop (_q22))
8319 : {
8320 0 : switch (TREE_CODE (_p1))
8321 : {
8322 0 : case VEC_COND_EXPR:
8323 0 : {
8324 0 : tree _q80 = TREE_OPERAND (_p1, 0);
8325 0 : tree _q81 = TREE_OPERAND (_p1, 1);
8326 0 : tree _q82 = TREE_OPERAND (_p1, 2);
8327 0 : switch (TREE_CODE (_q80))
8328 : {
8329 0 : case UNEQ_EXPR:
8330 0 : {
8331 0 : tree _q90 = TREE_OPERAND (_q80, 0);
8332 0 : tree _q91 = TREE_OPERAND (_q80, 1);
8333 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
8334 : {
8335 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
8336 : {
8337 0 : if (integer_zerop (_q82))
8338 : {
8339 0 : {
8340 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
8341 0 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LTGT_EXPR, UNEQ_EXPR);
8342 0 : if (res) return res;
8343 : }
8344 : }
8345 : }
8346 : }
8347 : break;
8348 : }
8349 : default:;
8350 : }
8351 : break;
8352 : }
8353 : default:;
8354 : }
8355 : }
8356 : break;
8357 : }
8358 : default:;
8359 : }
8360 : break;
8361 : }
8362 123 : case EQ_EXPR:
8363 123 : {
8364 123 : tree _q20 = TREE_OPERAND (_p0, 0);
8365 123 : tree _q21 = TREE_OPERAND (_p0, 1);
8366 123 : switch (TREE_CODE (_p1))
8367 : {
8368 0 : case BIT_AND_EXPR:
8369 0 : {
8370 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8371 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8372 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8373 : {
8374 0 : if (tree_truth_valued_p (_q50))
8375 : {
8376 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8377 : {
8378 0 : if (tree_truth_valued_p (_q51))
8379 : {
8380 0 : {
8381 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8382 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8383 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
8384 : )
8385 : {
8386 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1223;
8387 0 : {
8388 0 : tree res_op0;
8389 0 : {
8390 0 : tree _o1[1], _r1;
8391 0 : {
8392 0 : tree _o2[2], _r2;
8393 0 : _o2[0] = captures[0];
8394 0 : _o2[1] = captures[1];
8395 0 : _r2 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8396 0 : _o1[0] = _r2;
8397 : }
8398 0 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
8399 0 : res_op0 = _r1;
8400 : }
8401 0 : tree _r;
8402 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
8403 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 932, __FILE__, __LINE__, true);
8404 : return _r;
8405 : }
8406 0 : next_after_fail1223:;
8407 : }
8408 : else
8409 : {
8410 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1224;
8411 0 : {
8412 0 : tree res_op0;
8413 0 : {
8414 0 : tree _o1[2], _r1;
8415 0 : {
8416 0 : tree _o2[2], _r2;
8417 0 : _o2[0] = captures[0];
8418 0 : _o2[1] = captures[1];
8419 0 : _r2 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8420 0 : _o1[0] = _r2;
8421 : }
8422 0 : _o1[1] = build_one_cst (TREE_TYPE (captures[0]));
8423 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8424 0 : res_op0 = _r1;
8425 : }
8426 0 : tree _r;
8427 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
8428 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 933, __FILE__, __LINE__, true);
8429 : return _r;
8430 : }
8431 0 : next_after_fail1224:;
8432 : }
8433 : }
8434 : }
8435 : }
8436 : }
8437 : }
8438 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8439 : {
8440 0 : if (tree_truth_valued_p (_q50))
8441 : {
8442 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8443 : {
8444 0 : if (tree_truth_valued_p (_q51))
8445 : {
8446 0 : {
8447 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8448 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8449 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
8450 : )
8451 : {
8452 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1225;
8453 0 : {
8454 0 : tree res_op0;
8455 0 : {
8456 0 : tree _o1[1], _r1;
8457 0 : {
8458 0 : tree _o2[2], _r2;
8459 0 : _o2[0] = captures[0];
8460 0 : _o2[1] = captures[1];
8461 0 : _r2 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8462 0 : _o1[0] = _r2;
8463 : }
8464 0 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
8465 0 : res_op0 = _r1;
8466 : }
8467 0 : tree _r;
8468 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
8469 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 932, __FILE__, __LINE__, true);
8470 : return _r;
8471 : }
8472 0 : next_after_fail1225:;
8473 : }
8474 : else
8475 : {
8476 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1226;
8477 0 : {
8478 0 : tree res_op0;
8479 0 : {
8480 0 : tree _o1[2], _r1;
8481 0 : {
8482 0 : tree _o2[2], _r2;
8483 0 : _o2[0] = captures[0];
8484 0 : _o2[1] = captures[1];
8485 0 : _r2 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8486 0 : _o1[0] = _r2;
8487 : }
8488 0 : _o1[1] = build_one_cst (TREE_TYPE (captures[0]));
8489 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8490 0 : res_op0 = _r1;
8491 : }
8492 0 : tree _r;
8493 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
8494 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 933, __FILE__, __LINE__, true);
8495 : return _r;
8496 : }
8497 0 : next_after_fail1226:;
8498 : }
8499 : }
8500 : }
8501 : }
8502 : }
8503 : }
8504 : break;
8505 : }
8506 : default:;
8507 : }
8508 : break;
8509 : }
8510 973256 : default:;
8511 : }
8512 973256 : {
8513 973256 : tree _p0_pops[1];
8514 973256 : if (tree_logical_inverted_value (_p0, _p0_pops))
8515 : {
8516 56 : tree _q20 = _p0_pops[0];
8517 56 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
8518 : {
8519 4 : if (tree_truth_valued_p (_p1))
8520 : {
8521 4 : {
8522 4 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8523 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1227;
8524 4 : {
8525 4 : tree _r;
8526 4 : _r = constant_boolean_node (BIT_XOR_EXPR != EQ_EXPR, type);
8527 4 : if (TREE_SIDE_EFFECTS (captures[0]))
8528 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
8529 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 935, __FILE__, __LINE__, true);
8530 4 : return _r;
8531 : }
8532 0 : next_after_fail1227:;
8533 : }
8534 : }
8535 : }
8536 : }
8537 : }
8538 973252 : {
8539 973252 : tree _p0_pops[1];
8540 973252 : if (tree_nop_convert (_p0, _p0_pops))
8541 : {
8542 551244 : tree _q20 = _p0_pops[0];
8543 551244 : switch (TREE_CODE (_q20))
8544 : {
8545 24 : case BIT_NOT_EXPR:
8546 24 : {
8547 24 : tree _q30 = TREE_OPERAND (_q20, 0);
8548 24 : {
8549 24 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _p1 };
8550 24 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures);
8551 24 : if (res) return res;
8552 : }
8553 0 : break;
8554 : }
8555 20 : case MULT_EXPR:
8556 20 : {
8557 20 : tree _q30 = TREE_OPERAND (_q20, 0);
8558 20 : tree _q31 = TREE_OPERAND (_q20, 1);
8559 20 : {
8560 20 : tree _q30_pops[1];
8561 20 : if (tree_nop_convert (_q30, _q30_pops))
8562 : {
8563 0 : tree _q40 = _q30_pops[0];
8564 0 : switch (TREE_CODE (_q31))
8565 : {
8566 0 : case INTEGER_CST:
8567 0 : {
8568 0 : switch (TREE_CODE (_p1))
8569 : {
8570 0 : case LSHIFT_EXPR:
8571 0 : {
8572 0 : tree _q70 = TREE_OPERAND (_p1, 0);
8573 0 : tree _q71 = TREE_OPERAND (_p1, 1);
8574 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
8575 : {
8576 0 : switch (TREE_CODE (_q71))
8577 : {
8578 0 : case INTEGER_CST:
8579 0 : {
8580 0 : {
8581 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31, _p1, _q71 };
8582 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
8583 0 : if (res) return res;
8584 : }
8585 0 : break;
8586 : }
8587 : default:;
8588 : }
8589 : }
8590 : break;
8591 : }
8592 0 : default:;
8593 : }
8594 0 : {
8595 0 : tree _p1_pops[1];
8596 0 : if (tree_nop_convert (_p1, _p1_pops))
8597 : {
8598 0 : tree _q70 = _p1_pops[0];
8599 0 : switch (TREE_CODE (_q70))
8600 : {
8601 0 : case MULT_EXPR:
8602 0 : {
8603 0 : tree _q80 = TREE_OPERAND (_q70, 0);
8604 0 : tree _q81 = TREE_OPERAND (_q70, 1);
8605 0 : {
8606 0 : tree _q80_pops[1];
8607 0 : if (tree_nop_convert (_q80, _q80_pops))
8608 : {
8609 0 : tree _q90 = _q80_pops[0];
8610 0 : switch (TREE_CODE (_q81))
8611 : {
8612 0 : case INTEGER_CST:
8613 0 : {
8614 0 : {
8615 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31, _p1, _q70, _q90, _q81 };
8616 0 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
8617 0 : if (res) return res;
8618 : }
8619 0 : break;
8620 : }
8621 : default:;
8622 : }
8623 : }
8624 : }
8625 0 : break;
8626 : }
8627 : default:;
8628 : }
8629 : }
8630 : }
8631 0 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
8632 : {
8633 0 : {
8634 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31 };
8635 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
8636 0 : if (res) return res;
8637 : }
8638 : }
8639 : break;
8640 : }
8641 : default:;
8642 : }
8643 : }
8644 : }
8645 20 : break;
8646 : }
8647 : default:;
8648 : }
8649 : }
8650 : }
8651 973228 : if (tree_truth_valued_p (_p0))
8652 : {
8653 145729 : {
8654 145729 : tree _p1_pops[1];
8655 145729 : if (tree_logical_inverted_value (_p1, _p1_pops))
8656 : {
8657 17 : tree _q30 = _p1_pops[0];
8658 17 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
8659 : {
8660 0 : {
8661 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8662 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1228;
8663 0 : {
8664 0 : tree _r;
8665 0 : _r = constant_boolean_node (BIT_XOR_EXPR != EQ_EXPR, type);
8666 0 : if (TREE_SIDE_EFFECTS (captures[0]))
8667 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
8668 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 935, __FILE__, __LINE__, true);
8669 0 : return _r;
8670 : }
8671 0 : next_after_fail1228:;
8672 : }
8673 : }
8674 : }
8675 : }
8676 : }
8677 973228 : switch (TREE_CODE (_p1))
8678 : {
8679 288 : case BIT_NOT_EXPR:
8680 288 : {
8681 288 : tree _q30 = TREE_OPERAND (_p1, 0);
8682 288 : {
8683 288 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0 };
8684 288 : tree res = generic_simplify_25 (loc, type, _p0, _p1, captures);
8685 288 : if (res) return res;
8686 : }
8687 0 : break;
8688 : }
8689 972940 : default:;
8690 : }
8691 972940 : {
8692 972940 : tree _p1_pops[1];
8693 972940 : if (tree_nop_convert (_p1, _p1_pops))
8694 : {
8695 687270 : tree _q30 = _p1_pops[0];
8696 687270 : switch (TREE_CODE (_q30))
8697 : {
8698 0 : case BIT_NOT_EXPR:
8699 0 : {
8700 0 : tree _q40 = TREE_OPERAND (_q30, 0);
8701 0 : {
8702 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0 };
8703 0 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures);
8704 0 : if (res) return res;
8705 : }
8706 0 : break;
8707 : }
8708 : default:;
8709 : }
8710 : }
8711 : }
8712 972940 : switch (TREE_CODE (_p0))
8713 : {
8714 1131 : case BIT_IOR_EXPR:
8715 1131 : {
8716 1131 : tree _q20 = TREE_OPERAND (_p0, 0);
8717 1131 : tree _q21 = TREE_OPERAND (_p0, 1);
8718 1131 : switch (TREE_CODE (_q21))
8719 : {
8720 23 : case INTEGER_CST:
8721 23 : {
8722 23 : switch (TREE_CODE (_p1))
8723 : {
8724 23 : case INTEGER_CST:
8725 23 : {
8726 23 : {
8727 23 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
8728 23 : tree res = generic_simplify_39 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_XOR_EXPR);
8729 23 : if (res) return res;
8730 : }
8731 23 : break;
8732 : }
8733 : default:;
8734 : }
8735 : break;
8736 : }
8737 : default:;
8738 : }
8739 : break;
8740 : }
8741 90 : case LT_EXPR:
8742 90 : {
8743 90 : tree _q20 = TREE_OPERAND (_p0, 0);
8744 90 : tree _q21 = TREE_OPERAND (_p0, 1);
8745 90 : switch (TREE_CODE (_p1))
8746 : {
8747 0 : case GT_EXPR:
8748 0 : {
8749 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8750 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8751 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8752 : {
8753 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8754 : {
8755 0 : {
8756 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8757 0 : const enum tree_code cmp1 = LT_EXPR;
8758 0 : const enum tree_code cmp2 = GT_EXPR;
8759 0 : const enum tree_code rcmp = NE_EXPR;
8760 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8761 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8762 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8763 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8764 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8765 : )
8766 : {
8767 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1229;
8768 0 : {
8769 0 : tree res_op0;
8770 0 : res_op0 = captures[0];
8771 0 : tree res_op1;
8772 0 : res_op1 = captures[1];
8773 0 : tree _r;
8774 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8775 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
8776 : return _r;
8777 : }
8778 0 : next_after_fail1229:;
8779 : }
8780 : }
8781 : }
8782 : }
8783 : break;
8784 : }
8785 0 : case EQ_EXPR:
8786 0 : {
8787 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8788 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8789 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8790 : {
8791 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8792 : {
8793 0 : {
8794 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8795 0 : const enum tree_code cmp1 = LT_EXPR;
8796 0 : const enum tree_code cmp2 = EQ_EXPR;
8797 0 : const enum tree_code rcmp = LE_EXPR;
8798 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8799 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8800 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8801 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8802 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8803 : )
8804 : {
8805 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1230;
8806 0 : {
8807 0 : tree res_op0;
8808 0 : res_op0 = captures[0];
8809 0 : tree res_op1;
8810 0 : res_op1 = captures[1];
8811 0 : tree _r;
8812 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8813 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
8814 : return _r;
8815 : }
8816 0 : next_after_fail1230:;
8817 : }
8818 : }
8819 : }
8820 : }
8821 : break;
8822 : }
8823 0 : case NE_EXPR:
8824 0 : {
8825 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8826 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8827 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8828 : {
8829 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8830 : {
8831 0 : {
8832 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8833 0 : const enum tree_code cmp1 = LT_EXPR;
8834 0 : const enum tree_code cmp2 = NE_EXPR;
8835 0 : const enum tree_code rcmp = GT_EXPR;
8836 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8837 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8838 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8839 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8840 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8841 : )
8842 : {
8843 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1231;
8844 0 : {
8845 0 : tree res_op0;
8846 0 : res_op0 = captures[0];
8847 0 : tree res_op1;
8848 0 : res_op1 = captures[1];
8849 0 : tree _r;
8850 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8851 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
8852 : return _r;
8853 : }
8854 0 : next_after_fail1231:;
8855 : }
8856 : }
8857 : }
8858 : }
8859 : break;
8860 : }
8861 : default:;
8862 : }
8863 : break;
8864 : }
8865 85 : case LE_EXPR:
8866 85 : {
8867 85 : tree _q20 = TREE_OPERAND (_p0, 0);
8868 85 : tree _q21 = TREE_OPERAND (_p0, 1);
8869 85 : switch (TREE_CODE (_p1))
8870 : {
8871 0 : case GE_EXPR:
8872 0 : {
8873 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8874 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8875 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8876 : {
8877 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8878 : {
8879 0 : {
8880 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8881 0 : const enum tree_code cmp1 = LE_EXPR;
8882 0 : const enum tree_code cmp2 = GE_EXPR;
8883 0 : const enum tree_code rcmp = NE_EXPR;
8884 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8885 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8886 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8887 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8888 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8889 : )
8890 : {
8891 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1232;
8892 0 : {
8893 0 : tree res_op0;
8894 0 : res_op0 = captures[0];
8895 0 : tree res_op1;
8896 0 : res_op1 = captures[1];
8897 0 : tree _r;
8898 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8899 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
8900 : return _r;
8901 : }
8902 0 : next_after_fail1232:;
8903 : }
8904 : }
8905 : }
8906 : }
8907 : break;
8908 : }
8909 0 : case EQ_EXPR:
8910 0 : {
8911 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8912 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8913 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8914 : {
8915 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8916 : {
8917 0 : {
8918 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8919 0 : const enum tree_code cmp1 = LE_EXPR;
8920 0 : const enum tree_code cmp2 = EQ_EXPR;
8921 0 : const enum tree_code rcmp = LT_EXPR;
8922 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8923 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8924 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8925 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8926 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8927 : )
8928 : {
8929 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1233;
8930 0 : {
8931 0 : tree res_op0;
8932 0 : res_op0 = captures[0];
8933 0 : tree res_op1;
8934 0 : res_op1 = captures[1];
8935 0 : tree _r;
8936 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8937 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
8938 : return _r;
8939 : }
8940 0 : next_after_fail1233:;
8941 : }
8942 : }
8943 : }
8944 : }
8945 : break;
8946 : }
8947 0 : case NE_EXPR:
8948 0 : {
8949 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8950 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8951 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8952 : {
8953 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8954 : {
8955 0 : {
8956 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8957 0 : const enum tree_code cmp1 = LE_EXPR;
8958 0 : const enum tree_code cmp2 = NE_EXPR;
8959 0 : const enum tree_code rcmp = GE_EXPR;
8960 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8961 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8962 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
8963 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
8964 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8965 : )
8966 : {
8967 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1234;
8968 0 : {
8969 0 : tree res_op0;
8970 0 : res_op0 = captures[0];
8971 0 : tree res_op1;
8972 0 : res_op1 = captures[1];
8973 0 : tree _r;
8974 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8975 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
8976 : return _r;
8977 : }
8978 0 : next_after_fail1234:;
8979 : }
8980 : }
8981 : }
8982 : }
8983 : break;
8984 : }
8985 : default:;
8986 : }
8987 : break;
8988 : }
8989 100 : case GT_EXPR:
8990 100 : {
8991 100 : tree _q20 = TREE_OPERAND (_p0, 0);
8992 100 : tree _q21 = TREE_OPERAND (_p0, 1);
8993 100 : switch (TREE_CODE (_p1))
8994 : {
8995 0 : case GT_EXPR:
8996 0 : {
8997 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8998 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8999 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9000 : {
9001 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9002 : {
9003 0 : {
9004 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9005 0 : const enum tree_code cmp1 = LT_EXPR;
9006 0 : const enum tree_code cmp2 = GT_EXPR;
9007 0 : const enum tree_code rcmp = NE_EXPR;
9008 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9009 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9010 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9011 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9012 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9013 : )
9014 : {
9015 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1235;
9016 0 : {
9017 0 : tree res_op0;
9018 0 : res_op0 = captures[0];
9019 0 : tree res_op1;
9020 0 : res_op1 = captures[1];
9021 0 : tree _r;
9022 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9023 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
9024 : return _r;
9025 : }
9026 0 : next_after_fail1235:;
9027 : }
9028 : }
9029 0 : {
9030 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9031 0 : const enum tree_code cmp1 = LT_EXPR;
9032 0 : const enum tree_code cmp2 = GT_EXPR;
9033 0 : const enum tree_code rcmp = NE_EXPR;
9034 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9035 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9036 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9037 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9038 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9039 : )
9040 : {
9041 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1236;
9042 0 : {
9043 0 : tree res_op0;
9044 0 : res_op0 = captures[0];
9045 0 : tree res_op1;
9046 0 : res_op1 = captures[1];
9047 0 : tree _r;
9048 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9049 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
9050 : return _r;
9051 : }
9052 0 : next_after_fail1236:;
9053 : }
9054 : }
9055 : }
9056 : }
9057 : break;
9058 : }
9059 0 : case EQ_EXPR:
9060 0 : {
9061 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9062 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9063 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9064 : {
9065 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9066 : {
9067 0 : {
9068 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9069 0 : const enum tree_code cmp1 = LT_EXPR;
9070 0 : const enum tree_code cmp2 = EQ_EXPR;
9071 0 : const enum tree_code rcmp = LE_EXPR;
9072 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9073 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9074 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9075 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9076 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9077 : )
9078 : {
9079 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1237;
9080 0 : {
9081 0 : tree res_op0;
9082 0 : res_op0 = captures[0];
9083 0 : tree res_op1;
9084 0 : res_op1 = captures[1];
9085 0 : tree _r;
9086 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9087 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
9088 : return _r;
9089 : }
9090 0 : next_after_fail1237:;
9091 : }
9092 : }
9093 : }
9094 : }
9095 : break;
9096 : }
9097 12 : case NE_EXPR:
9098 12 : {
9099 12 : tree _q50 = TREE_OPERAND (_p1, 0);
9100 12 : tree _q51 = TREE_OPERAND (_p1, 1);
9101 12 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9102 : {
9103 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9104 : {
9105 0 : {
9106 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9107 0 : const enum tree_code cmp1 = LT_EXPR;
9108 0 : const enum tree_code cmp2 = NE_EXPR;
9109 0 : const enum tree_code rcmp = GT_EXPR;
9110 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9111 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9112 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9113 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9114 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9115 : )
9116 : {
9117 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1238;
9118 0 : {
9119 0 : tree res_op0;
9120 0 : res_op0 = captures[0];
9121 0 : tree res_op1;
9122 0 : res_op1 = captures[1];
9123 0 : tree _r;
9124 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9125 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
9126 : return _r;
9127 : }
9128 0 : next_after_fail1238:;
9129 : }
9130 : }
9131 : }
9132 : }
9133 : break;
9134 : }
9135 0 : case LT_EXPR:
9136 0 : {
9137 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9138 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9139 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9140 : {
9141 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9142 : {
9143 0 : {
9144 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9145 0 : const enum tree_code cmp1 = LT_EXPR;
9146 0 : const enum tree_code cmp2 = GT_EXPR;
9147 0 : const enum tree_code rcmp = NE_EXPR;
9148 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9149 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9150 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9151 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9152 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9153 : )
9154 : {
9155 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1239;
9156 0 : {
9157 0 : tree res_op0;
9158 0 : res_op0 = captures[0];
9159 0 : tree res_op1;
9160 0 : res_op1 = captures[1];
9161 0 : tree _r;
9162 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9163 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
9164 : return _r;
9165 : }
9166 0 : next_after_fail1239:;
9167 : }
9168 : }
9169 : }
9170 : }
9171 : break;
9172 : }
9173 : default:;
9174 : }
9175 : break;
9176 : }
9177 62 : case GE_EXPR:
9178 62 : {
9179 62 : tree _q20 = TREE_OPERAND (_p0, 0);
9180 62 : tree _q21 = TREE_OPERAND (_p0, 1);
9181 62 : switch (TREE_CODE (_p1))
9182 : {
9183 1 : case GE_EXPR:
9184 1 : {
9185 1 : tree _q50 = TREE_OPERAND (_p1, 0);
9186 1 : tree _q51 = TREE_OPERAND (_p1, 1);
9187 1 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9188 : {
9189 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9190 : {
9191 0 : {
9192 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9193 0 : const enum tree_code cmp1 = LE_EXPR;
9194 0 : const enum tree_code cmp2 = GE_EXPR;
9195 0 : const enum tree_code rcmp = NE_EXPR;
9196 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9197 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9198 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9199 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9200 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9201 : )
9202 : {
9203 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1240;
9204 0 : {
9205 0 : tree res_op0;
9206 0 : res_op0 = captures[0];
9207 0 : tree res_op1;
9208 0 : res_op1 = captures[1];
9209 0 : tree _r;
9210 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9211 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
9212 : return _r;
9213 : }
9214 0 : next_after_fail1240:;
9215 : }
9216 : }
9217 0 : {
9218 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9219 0 : const enum tree_code cmp1 = LE_EXPR;
9220 0 : const enum tree_code cmp2 = GE_EXPR;
9221 0 : const enum tree_code rcmp = NE_EXPR;
9222 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9223 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9224 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9225 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9226 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9227 : )
9228 : {
9229 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1241;
9230 0 : {
9231 0 : tree res_op0;
9232 0 : res_op0 = captures[0];
9233 0 : tree res_op1;
9234 0 : res_op1 = captures[1];
9235 0 : tree _r;
9236 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9237 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
9238 : return _r;
9239 : }
9240 0 : next_after_fail1241:;
9241 : }
9242 : }
9243 : }
9244 : }
9245 : break;
9246 : }
9247 0 : case EQ_EXPR:
9248 0 : {
9249 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9250 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9251 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9252 : {
9253 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9254 : {
9255 0 : {
9256 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9257 0 : const enum tree_code cmp1 = LE_EXPR;
9258 0 : const enum tree_code cmp2 = EQ_EXPR;
9259 0 : const enum tree_code rcmp = LT_EXPR;
9260 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9261 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9262 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9263 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9264 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9265 : )
9266 : {
9267 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1242;
9268 0 : {
9269 0 : tree res_op0;
9270 0 : res_op0 = captures[0];
9271 0 : tree res_op1;
9272 0 : res_op1 = captures[1];
9273 0 : tree _r;
9274 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9275 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
9276 : return _r;
9277 : }
9278 0 : next_after_fail1242:;
9279 : }
9280 : }
9281 : }
9282 : }
9283 : break;
9284 : }
9285 8 : case NE_EXPR:
9286 8 : {
9287 8 : tree _q50 = TREE_OPERAND (_p1, 0);
9288 8 : tree _q51 = TREE_OPERAND (_p1, 1);
9289 8 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9290 : {
9291 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9292 : {
9293 0 : {
9294 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9295 0 : const enum tree_code cmp1 = LE_EXPR;
9296 0 : const enum tree_code cmp2 = NE_EXPR;
9297 0 : const enum tree_code rcmp = GE_EXPR;
9298 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9299 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9300 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9301 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9302 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9303 : )
9304 : {
9305 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1243;
9306 0 : {
9307 0 : tree res_op0;
9308 0 : res_op0 = captures[0];
9309 0 : tree res_op1;
9310 0 : res_op1 = captures[1];
9311 0 : tree _r;
9312 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9313 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
9314 : return _r;
9315 : }
9316 0 : next_after_fail1243:;
9317 : }
9318 : }
9319 : }
9320 : }
9321 : break;
9322 : }
9323 0 : case LE_EXPR:
9324 0 : {
9325 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9326 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9327 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9328 : {
9329 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9330 : {
9331 0 : {
9332 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9333 0 : const enum tree_code cmp1 = LE_EXPR;
9334 0 : const enum tree_code cmp2 = GE_EXPR;
9335 0 : const enum tree_code rcmp = NE_EXPR;
9336 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9337 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9338 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9339 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9340 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9341 : )
9342 : {
9343 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1244;
9344 0 : {
9345 0 : tree res_op0;
9346 0 : res_op0 = captures[0];
9347 0 : tree res_op1;
9348 0 : res_op1 = captures[1];
9349 0 : tree _r;
9350 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9351 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
9352 : return _r;
9353 : }
9354 0 : next_after_fail1244:;
9355 : }
9356 : }
9357 : }
9358 : }
9359 : break;
9360 : }
9361 : default:;
9362 : }
9363 : break;
9364 : }
9365 123 : case EQ_EXPR:
9366 123 : {
9367 123 : tree _q20 = TREE_OPERAND (_p0, 0);
9368 123 : tree _q21 = TREE_OPERAND (_p0, 1);
9369 123 : switch (TREE_CODE (_p1))
9370 : {
9371 0 : case LT_EXPR:
9372 0 : {
9373 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9374 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9375 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9376 : {
9377 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9378 : {
9379 0 : {
9380 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9381 0 : const enum tree_code cmp1 = LT_EXPR;
9382 0 : const enum tree_code cmp2 = EQ_EXPR;
9383 0 : const enum tree_code rcmp = LE_EXPR;
9384 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9385 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9386 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9387 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9388 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9389 : )
9390 : {
9391 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1245;
9392 0 : {
9393 0 : tree res_op0;
9394 0 : res_op0 = captures[0];
9395 0 : tree res_op1;
9396 0 : res_op1 = captures[1];
9397 0 : tree _r;
9398 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9399 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
9400 : return _r;
9401 : }
9402 0 : next_after_fail1245:;
9403 : }
9404 : }
9405 : }
9406 : }
9407 : break;
9408 : }
9409 0 : case LE_EXPR:
9410 0 : {
9411 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9412 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9413 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9414 : {
9415 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9416 : {
9417 0 : {
9418 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9419 0 : const enum tree_code cmp1 = LE_EXPR;
9420 0 : const enum tree_code cmp2 = EQ_EXPR;
9421 0 : const enum tree_code rcmp = LT_EXPR;
9422 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9423 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9424 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9425 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9426 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9427 : )
9428 : {
9429 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1246;
9430 0 : {
9431 0 : tree res_op0;
9432 0 : res_op0 = captures[0];
9433 0 : tree res_op1;
9434 0 : res_op1 = captures[1];
9435 0 : tree _r;
9436 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9437 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
9438 : return _r;
9439 : }
9440 0 : next_after_fail1246:;
9441 : }
9442 : }
9443 : }
9444 : }
9445 : break;
9446 : }
9447 0 : case GT_EXPR:
9448 0 : {
9449 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9450 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9451 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9452 : {
9453 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9454 : {
9455 0 : {
9456 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9457 0 : const enum tree_code cmp1 = LT_EXPR;
9458 0 : const enum tree_code cmp2 = EQ_EXPR;
9459 0 : const enum tree_code rcmp = LE_EXPR;
9460 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9461 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9462 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9463 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9464 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9465 : )
9466 : {
9467 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1247;
9468 0 : {
9469 0 : tree res_op0;
9470 0 : res_op0 = captures[0];
9471 0 : tree res_op1;
9472 0 : res_op1 = captures[1];
9473 0 : tree _r;
9474 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9475 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
9476 : return _r;
9477 : }
9478 0 : next_after_fail1247:;
9479 : }
9480 : }
9481 : }
9482 : }
9483 : break;
9484 : }
9485 8 : case GE_EXPR:
9486 8 : {
9487 8 : tree _q50 = TREE_OPERAND (_p1, 0);
9488 8 : tree _q51 = TREE_OPERAND (_p1, 1);
9489 8 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9490 : {
9491 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9492 : {
9493 0 : {
9494 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9495 0 : const enum tree_code cmp1 = LE_EXPR;
9496 0 : const enum tree_code cmp2 = EQ_EXPR;
9497 0 : const enum tree_code rcmp = LT_EXPR;
9498 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9499 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9500 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9501 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9502 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9503 : )
9504 : {
9505 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1248;
9506 0 : {
9507 0 : tree res_op0;
9508 0 : res_op0 = captures[0];
9509 0 : tree res_op1;
9510 0 : res_op1 = captures[1];
9511 0 : tree _r;
9512 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9513 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
9514 : return _r;
9515 : }
9516 0 : next_after_fail1248:;
9517 : }
9518 : }
9519 : }
9520 : }
9521 : break;
9522 : }
9523 : default:;
9524 : }
9525 : break;
9526 : }
9527 118 : case NE_EXPR:
9528 118 : {
9529 118 : tree _q20 = TREE_OPERAND (_p0, 0);
9530 118 : tree _q21 = TREE_OPERAND (_p0, 1);
9531 118 : switch (TREE_CODE (_p1))
9532 : {
9533 0 : case LT_EXPR:
9534 0 : {
9535 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9536 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9537 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9538 : {
9539 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9540 : {
9541 0 : {
9542 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9543 0 : const enum tree_code cmp1 = LT_EXPR;
9544 0 : const enum tree_code cmp2 = NE_EXPR;
9545 0 : const enum tree_code rcmp = GT_EXPR;
9546 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9547 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9548 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9549 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9550 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9551 : )
9552 : {
9553 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1249;
9554 0 : {
9555 0 : tree res_op0;
9556 0 : res_op0 = captures[0];
9557 0 : tree res_op1;
9558 0 : res_op1 = captures[1];
9559 0 : tree _r;
9560 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9561 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
9562 : return _r;
9563 : }
9564 0 : next_after_fail1249:;
9565 : }
9566 : }
9567 : }
9568 : }
9569 : break;
9570 : }
9571 0 : case LE_EXPR:
9572 0 : {
9573 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9574 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9575 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9576 : {
9577 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9578 : {
9579 0 : {
9580 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9581 0 : const enum tree_code cmp1 = LE_EXPR;
9582 0 : const enum tree_code cmp2 = NE_EXPR;
9583 0 : const enum tree_code rcmp = GE_EXPR;
9584 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9585 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9586 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9587 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9588 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9589 : )
9590 : {
9591 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1250;
9592 0 : {
9593 0 : tree res_op0;
9594 0 : res_op0 = captures[0];
9595 0 : tree res_op1;
9596 0 : res_op1 = captures[1];
9597 0 : tree _r;
9598 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9599 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
9600 : return _r;
9601 : }
9602 0 : next_after_fail1250:;
9603 : }
9604 : }
9605 : }
9606 : }
9607 : break;
9608 : }
9609 0 : case GT_EXPR:
9610 0 : {
9611 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9612 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9613 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9614 : {
9615 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9616 : {
9617 0 : {
9618 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9619 0 : const enum tree_code cmp1 = LT_EXPR;
9620 0 : const enum tree_code cmp2 = NE_EXPR;
9621 0 : const enum tree_code rcmp = GT_EXPR;
9622 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9623 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9624 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9625 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9626 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9627 : )
9628 : {
9629 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1251;
9630 0 : {
9631 0 : tree res_op0;
9632 0 : res_op0 = captures[0];
9633 0 : tree res_op1;
9634 0 : res_op1 = captures[1];
9635 0 : tree _r;
9636 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9637 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
9638 : return _r;
9639 : }
9640 0 : next_after_fail1251:;
9641 : }
9642 : }
9643 : }
9644 : }
9645 : break;
9646 : }
9647 6 : case GE_EXPR:
9648 6 : {
9649 6 : tree _q50 = TREE_OPERAND (_p1, 0);
9650 6 : tree _q51 = TREE_OPERAND (_p1, 1);
9651 6 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9652 : {
9653 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9654 : {
9655 0 : {
9656 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9657 0 : const enum tree_code cmp1 = LE_EXPR;
9658 0 : const enum tree_code cmp2 = NE_EXPR;
9659 0 : const enum tree_code rcmp = GE_EXPR;
9660 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
9661 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
9662 0 : || ((VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[1]))
9663 0 : || VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (captures[1])))
9664 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
9665 : )
9666 : {
9667 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1252;
9668 0 : {
9669 0 : tree res_op0;
9670 0 : res_op0 = captures[0];
9671 0 : tree res_op1;
9672 0 : res_op1 = captures[1];
9673 0 : tree _r;
9674 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
9675 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
9676 : return _r;
9677 : }
9678 0 : next_after_fail1252:;
9679 : }
9680 : }
9681 : }
9682 : }
9683 : break;
9684 : }
9685 : default:;
9686 : }
9687 : break;
9688 : }
9689 556 : case MULT_EXPR:
9690 556 : {
9691 556 : tree _q20 = TREE_OPERAND (_p0, 0);
9692 556 : tree _q21 = TREE_OPERAND (_p0, 1);
9693 556 : switch (TREE_CODE (_q21))
9694 : {
9695 505 : case INTEGER_CST:
9696 505 : {
9697 505 : switch (TREE_CODE (_p1))
9698 : {
9699 12 : case MULT_EXPR:
9700 12 : {
9701 12 : tree _q50 = TREE_OPERAND (_p1, 0);
9702 12 : tree _q51 = TREE_OPERAND (_p1, 1);
9703 12 : switch (TREE_CODE (_q51))
9704 : {
9705 12 : case INTEGER_CST:
9706 12 : {
9707 12 : {
9708 12 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1, _p1, _q50, _q51 };
9709 12 : tree res = generic_simplify_40 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9710 12 : if (res) return res;
9711 : }
9712 12 : break;
9713 : }
9714 : default:;
9715 : }
9716 : break;
9717 : }
9718 0 : case LSHIFT_EXPR:
9719 0 : {
9720 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9721 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9722 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9723 : {
9724 0 : switch (TREE_CODE (_q51))
9725 : {
9726 0 : case INTEGER_CST:
9727 0 : {
9728 0 : {
9729 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1, _q51 };
9730 0 : tree res = generic_simplify_41 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9731 0 : if (res) return res;
9732 : }
9733 0 : break;
9734 : }
9735 : default:;
9736 : }
9737 : }
9738 : break;
9739 : }
9740 505 : default:;
9741 : }
9742 505 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9743 : {
9744 18 : {
9745 18 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
9746 18 : tree res = generic_simplify_42 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9747 18 : if (res) return res;
9748 : }
9749 : }
9750 : break;
9751 : }
9752 556 : default:;
9753 : }
9754 556 : switch (TREE_CODE (_q20))
9755 : {
9756 0 : case BIT_XOR_EXPR:
9757 0 : {
9758 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9759 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9760 0 : if (tree_zero_one_valued_p (_q21))
9761 : {
9762 0 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
9763 : {
9764 0 : {
9765 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q21 };
9766 0 : tree res = generic_simplify_43 (loc, type, _p0, _p1, captures);
9767 0 : if (res) return res;
9768 : }
9769 : }
9770 0 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
9771 : {
9772 0 : {
9773 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q21 };
9774 0 : tree res = generic_simplify_43 (loc, type, _p0, _p1, captures);
9775 0 : if (res) return res;
9776 : }
9777 : }
9778 : }
9779 : break;
9780 : }
9781 556 : default:;
9782 : }
9783 556 : if (tree_zero_one_valued_p (_q20))
9784 : {
9785 38 : switch (TREE_CODE (_q21))
9786 : {
9787 2 : case BIT_XOR_EXPR:
9788 2 : {
9789 2 : tree _q40 = TREE_OPERAND (_q21, 0);
9790 2 : tree _q41 = TREE_OPERAND (_q21, 1);
9791 2 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
9792 : {
9793 2 : {
9794 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q20 };
9795 2 : tree res = generic_simplify_43 (loc, type, _p0, _p1, captures);
9796 2 : if (res) return res;
9797 : }
9798 : }
9799 0 : if ((_p1 == _q41 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q41, 0) && types_match (_p1, _q41)))
9800 : {
9801 0 : {
9802 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q20 };
9803 0 : tree res = generic_simplify_43 (loc, type, _p0, _p1, captures);
9804 0 : if (res) return res;
9805 : }
9806 : }
9807 : break;
9808 : }
9809 : default:;
9810 : }
9811 : }
9812 : break;
9813 : }
9814 2535 : case LSHIFT_EXPR:
9815 2535 : {
9816 2535 : tree _q20 = TREE_OPERAND (_p0, 0);
9817 2535 : tree _q21 = TREE_OPERAND (_p0, 1);
9818 2535 : switch (TREE_CODE (_q21))
9819 : {
9820 1154 : case INTEGER_CST:
9821 1154 : {
9822 1154 : switch (TREE_CODE (_p1))
9823 : {
9824 0 : case MULT_EXPR:
9825 0 : {
9826 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9827 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9828 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9829 : {
9830 0 : switch (TREE_CODE (_q51))
9831 : {
9832 0 : case INTEGER_CST:
9833 0 : {
9834 0 : {
9835 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _p1, _q20, _q51, _p0, _q21 };
9836 0 : tree res = generic_simplify_41 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9837 0 : if (res) return res;
9838 : }
9839 0 : break;
9840 : }
9841 : default:;
9842 : }
9843 : }
9844 : break;
9845 : }
9846 1154 : default:;
9847 : }
9848 1154 : {
9849 1154 : tree _p1_pops[1];
9850 1154 : if (tree_nop_convert (_p1, _p1_pops))
9851 : {
9852 23 : tree _q50 = _p1_pops[0];
9853 23 : switch (TREE_CODE (_q50))
9854 : {
9855 0 : case MULT_EXPR:
9856 0 : {
9857 0 : tree _q60 = TREE_OPERAND (_q50, 0);
9858 0 : tree _q61 = TREE_OPERAND (_q50, 1);
9859 0 : {
9860 0 : tree _q60_pops[1];
9861 0 : if (tree_nop_convert (_q60, _q60_pops))
9862 : {
9863 0 : tree _q70 = _q60_pops[0];
9864 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
9865 : {
9866 0 : switch (TREE_CODE (_q61))
9867 : {
9868 0 : case INTEGER_CST:
9869 0 : {
9870 0 : {
9871 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _q50, _q20, _q61, _p0, _q21 };
9872 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9873 0 : if (res) return res;
9874 : }
9875 0 : break;
9876 : }
9877 : default:;
9878 : }
9879 : }
9880 : }
9881 : }
9882 0 : break;
9883 : }
9884 : default:;
9885 : }
9886 : }
9887 : }
9888 1154 : break;
9889 : }
9890 : default:;
9891 : }
9892 : break;
9893 : }
9894 972938 : default:;
9895 : }
9896 972938 : switch (TREE_CODE (_p1))
9897 : {
9898 244 : case MULT_EXPR:
9899 244 : {
9900 244 : tree _q30 = TREE_OPERAND (_p1, 0);
9901 244 : tree _q31 = TREE_OPERAND (_p1, 1);
9902 244 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9903 : {
9904 0 : switch (TREE_CODE (_q31))
9905 : {
9906 0 : case INTEGER_CST:
9907 0 : {
9908 0 : {
9909 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _p0, _q31 };
9910 0 : tree res = generic_simplify_42 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9911 0 : if (res) return res;
9912 : }
9913 0 : break;
9914 : }
9915 : default:;
9916 : }
9917 : }
9918 : break;
9919 : }
9920 972938 : default:;
9921 : }
9922 972938 : {
9923 972938 : tree _p1_pops[1];
9924 972938 : if (tree_nop_convert (_p1, _p1_pops))
9925 : {
9926 687270 : tree _q30 = _p1_pops[0];
9927 687270 : switch (TREE_CODE (_q30))
9928 : {
9929 17 : case MULT_EXPR:
9930 17 : {
9931 17 : tree _q40 = TREE_OPERAND (_q30, 0);
9932 17 : tree _q41 = TREE_OPERAND (_q30, 1);
9933 17 : {
9934 17 : tree _q40_pops[1];
9935 17 : if (tree_nop_convert (_q40, _q40_pops))
9936 : {
9937 0 : tree _q50 = _q40_pops[0];
9938 0 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
9939 : {
9940 0 : switch (TREE_CODE (_q41))
9941 : {
9942 0 : case INTEGER_CST:
9943 0 : {
9944 0 : {
9945 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _p0, _q41 };
9946 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9947 0 : if (res) return res;
9948 : }
9949 0 : break;
9950 : }
9951 : default:;
9952 : }
9953 : }
9954 : }
9955 : }
9956 17 : break;
9957 : }
9958 : default:;
9959 : }
9960 : }
9961 : }
9962 972938 : switch (TREE_CODE (_p0))
9963 : {
9964 2535 : case LSHIFT_EXPR:
9965 2535 : {
9966 2535 : tree _q20 = TREE_OPERAND (_p0, 0);
9967 2535 : tree _q21 = TREE_OPERAND (_p0, 1);
9968 2535 : switch (TREE_CODE (_q21))
9969 : {
9970 1154 : case INTEGER_CST:
9971 1154 : {
9972 1154 : switch (TREE_CODE (_p1))
9973 : {
9974 9 : case LSHIFT_EXPR:
9975 9 : {
9976 9 : tree _q50 = TREE_OPERAND (_p1, 0);
9977 9 : tree _q51 = TREE_OPERAND (_p1, 1);
9978 9 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9979 : {
9980 3 : switch (TREE_CODE (_q51))
9981 : {
9982 3 : case INTEGER_CST:
9983 3 : {
9984 3 : {
9985 3 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
9986 3 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9987 3 : if (res) return res;
9988 : }
9989 1 : break;
9990 : }
9991 : default:;
9992 : }
9993 : }
9994 : break;
9995 : }
9996 1152 : default:;
9997 : }
9998 1152 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9999 : {
10000 89 : {
10001 89 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
10002 89 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
10003 89 : if (res) return res;
10004 : }
10005 : }
10006 : break;
10007 : }
10008 : default:;
10009 : }
10010 : break;
10011 : }
10012 972936 : default:;
10013 : }
10014 972936 : switch (TREE_CODE (_p1))
10015 : {
10016 2000 : case LSHIFT_EXPR:
10017 2000 : {
10018 2000 : tree _q30 = TREE_OPERAND (_p1, 0);
10019 2000 : tree _q31 = TREE_OPERAND (_p1, 1);
10020 2000 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
10021 : {
10022 3 : switch (TREE_CODE (_q31))
10023 : {
10024 3 : case INTEGER_CST:
10025 3 : {
10026 3 : {
10027 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q31 };
10028 3 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
10029 3 : if (res) return res;
10030 : }
10031 0 : break;
10032 : }
10033 : default:;
10034 : }
10035 : }
10036 : break;
10037 : }
10038 972933 : default:;
10039 : }
10040 972933 : switch (TREE_CODE (_p0))
10041 : {
10042 0 : case MIN_EXPR:
10043 0 : {
10044 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10045 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10046 0 : switch (TREE_CODE (_p1))
10047 : {
10048 0 : case MAX_EXPR:
10049 0 : {
10050 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10051 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10052 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10053 : {
10054 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10055 : {
10056 0 : {
10057 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10058 0 : if (!HONOR_NANS (captures[0])
10059 : )
10060 : {
10061 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1253;
10062 0 : {
10063 0 : tree res_op0;
10064 0 : res_op0 = captures[0];
10065 0 : tree res_op1;
10066 0 : res_op1 = captures[1];
10067 0 : tree _r;
10068 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
10069 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 937, __FILE__, __LINE__, true);
10070 : return _r;
10071 : }
10072 0 : next_after_fail1253:;
10073 : }
10074 : }
10075 : }
10076 : }
10077 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10078 : {
10079 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10080 : {
10081 0 : {
10082 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10083 0 : if (!HONOR_NANS (captures[0])
10084 : )
10085 : {
10086 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1254;
10087 0 : {
10088 0 : tree res_op0;
10089 0 : res_op0 = captures[0];
10090 0 : tree res_op1;
10091 0 : res_op1 = captures[1];
10092 0 : tree _r;
10093 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
10094 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 937, __FILE__, __LINE__, true);
10095 : return _r;
10096 : }
10097 0 : next_after_fail1254:;
10098 : }
10099 : }
10100 : }
10101 : }
10102 : break;
10103 : }
10104 : default:;
10105 : }
10106 : break;
10107 : }
10108 144 : case MAX_EXPR:
10109 144 : {
10110 144 : tree _q20 = TREE_OPERAND (_p0, 0);
10111 144 : tree _q21 = TREE_OPERAND (_p0, 1);
10112 144 : switch (TREE_CODE (_p1))
10113 : {
10114 0 : case MIN_EXPR:
10115 0 : {
10116 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10117 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10118 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10119 : {
10120 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10121 : {
10122 0 : {
10123 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10124 0 : if (!HONOR_NANS (captures[0])
10125 : )
10126 : {
10127 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1255;
10128 0 : {
10129 0 : tree res_op0;
10130 0 : res_op0 = captures[0];
10131 0 : tree res_op1;
10132 0 : res_op1 = captures[1];
10133 0 : tree _r;
10134 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
10135 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 937, __FILE__, __LINE__, true);
10136 : return _r;
10137 : }
10138 0 : next_after_fail1255:;
10139 : }
10140 : }
10141 : }
10142 : }
10143 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10144 : {
10145 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10146 : {
10147 0 : {
10148 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10149 0 : if (!HONOR_NANS (captures[0])
10150 : )
10151 : {
10152 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1256;
10153 0 : {
10154 0 : tree res_op0;
10155 0 : res_op0 = captures[0];
10156 0 : tree res_op1;
10157 0 : res_op1 = captures[1];
10158 0 : tree _r;
10159 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
10160 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 937, __FILE__, __LINE__, true);
10161 : return _r;
10162 : }
10163 0 : next_after_fail1256:;
10164 : }
10165 : }
10166 : }
10167 : }
10168 : break;
10169 : }
10170 : default:;
10171 : }
10172 : break;
10173 : }
10174 972933 : default:;
10175 : }
10176 972933 : switch (TREE_CODE (_p1))
10177 : {
10178 244 : case MULT_EXPR:
10179 244 : {
10180 244 : tree _q30 = TREE_OPERAND (_p1, 0);
10181 244 : tree _q31 = TREE_OPERAND (_p1, 1);
10182 244 : switch (TREE_CODE (_q30))
10183 : {
10184 0 : case BIT_XOR_EXPR:
10185 0 : {
10186 0 : tree _q40 = TREE_OPERAND (_q30, 0);
10187 0 : tree _q41 = TREE_OPERAND (_q30, 1);
10188 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
10189 : {
10190 0 : if (tree_zero_one_valued_p (_q31))
10191 : {
10192 0 : {
10193 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q31 };
10194 0 : tree res = generic_simplify_43 (loc, type, _p0, _p1, captures);
10195 0 : if (res) return res;
10196 : }
10197 : }
10198 : }
10199 0 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
10200 : {
10201 0 : if (tree_zero_one_valued_p (_q31))
10202 : {
10203 0 : {
10204 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q31 };
10205 0 : tree res = generic_simplify_43 (loc, type, _p0, _p1, captures);
10206 0 : if (res) return res;
10207 : }
10208 : }
10209 : }
10210 : break;
10211 : }
10212 244 : default:;
10213 : }
10214 244 : if (tree_zero_one_valued_p (_q30))
10215 : {
10216 17 : switch (TREE_CODE (_q31))
10217 : {
10218 0 : case BIT_XOR_EXPR:
10219 0 : {
10220 0 : tree _q50 = TREE_OPERAND (_q31, 0);
10221 0 : tree _q51 = TREE_OPERAND (_q31, 1);
10222 0 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
10223 : {
10224 0 : {
10225 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q51, _q30 };
10226 0 : tree res = generic_simplify_43 (loc, type, _p0, _p1, captures);
10227 0 : if (res) return res;
10228 : }
10229 : }
10230 0 : if ((_q51 == _p0 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _p0, 0) && types_match (_q51, _p0)))
10231 : {
10232 0 : {
10233 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q50, _q30 };
10234 0 : tree res = generic_simplify_43 (loc, type, _p0, _p1, captures);
10235 0 : if (res) return res;
10236 : }
10237 : }
10238 : break;
10239 : }
10240 : default:;
10241 : }
10242 : }
10243 : break;
10244 : }
10245 972933 : default:;
10246 : }
10247 972933 : switch (TREE_CODE (_p0))
10248 : {
10249 1 : case VEC_COND_EXPR:
10250 1 : {
10251 1 : tree _q20 = TREE_OPERAND (_p0, 0);
10252 1 : tree _q21 = TREE_OPERAND (_p0, 1);
10253 1 : tree _q22 = TREE_OPERAND (_p0, 2);
10254 1 : switch (TREE_CODE (_p1))
10255 : {
10256 0 : case VEC_COND_EXPR:
10257 0 : {
10258 0 : tree _q60 = TREE_OPERAND (_p1, 0);
10259 0 : tree _q61 = TREE_OPERAND (_p1, 1);
10260 0 : tree _q62 = TREE_OPERAND (_p1, 2);
10261 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
10262 : {
10263 0 : {
10264 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
10265 0 : if (VECTOR_TYPE_P (type)
10266 : && (TREE_CODE_CLASS (BIT_XOR_EXPR) != tcc_comparison
10267 : || types_match (type, TREE_TYPE (captures[2]))
10268 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10269 : || (optimize_vectors_before_lowering_p ()
10270 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10271 : )
10272 : {
10273 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1257;
10274 0 : {
10275 0 : tree res_op0;
10276 0 : res_op0 = captures[1];
10277 0 : tree res_op1;
10278 0 : {
10279 0 : tree _o1[2], _r1;
10280 0 : _o1[0] = captures[2];
10281 0 : _o1[1] = captures[5];
10282 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
10283 0 : if (EXPR_P (_r1))
10284 0 : goto next_after_fail1257;
10285 0 : res_op1 = _r1;
10286 : }
10287 0 : tree res_op2;
10288 0 : {
10289 0 : tree _o1[2], _r1;
10290 0 : _o1[0] = captures[3];
10291 0 : _o1[1] = captures[6];
10292 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
10293 0 : if (EXPR_P (_r1))
10294 0 : goto next_after_fail1257;
10295 0 : res_op2 = _r1;
10296 : }
10297 0 : tree _r;
10298 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10299 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 938, __FILE__, __LINE__, true);
10300 : return _r;
10301 : }
10302 1 : next_after_fail1257:;
10303 : }
10304 : }
10305 : }
10306 : break;
10307 : }
10308 1 : default:;
10309 : }
10310 1 : if (integer_minus_onep (_q21))
10311 : {
10312 1 : if (integer_zerop (_q22))
10313 : {
10314 1 : switch (TREE_CODE (_p1))
10315 : {
10316 0 : case VEC_COND_EXPR:
10317 0 : {
10318 0 : tree _q60 = TREE_OPERAND (_p1, 0);
10319 0 : tree _q61 = TREE_OPERAND (_p1, 1);
10320 0 : tree _q62 = TREE_OPERAND (_p1, 2);
10321 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
10322 : {
10323 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
10324 : {
10325 0 : {
10326 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10327 0 : const enum tree_code lop = BIT_XOR_EXPR;
10328 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10329 : )
10330 : {
10331 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1258;
10332 0 : {
10333 0 : tree res_op0;
10334 0 : {
10335 0 : tree _o1[2], _r1;
10336 0 : _o1[0] = captures[0];
10337 0 : _o1[1] = captures[3];
10338 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10339 0 : res_op0 = _r1;
10340 : }
10341 0 : tree res_op1;
10342 0 : res_op1 = captures[1];
10343 0 : tree res_op2;
10344 0 : res_op2 = captures[2];
10345 0 : tree _r;
10346 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10347 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10348 : return _r;
10349 : }
10350 0 : next_after_fail1258:;
10351 : }
10352 : }
10353 0 : {
10354 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10355 0 : const enum tree_code lop = BIT_XOR_EXPR;
10356 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10357 : )
10358 : {
10359 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1259;
10360 0 : {
10361 0 : tree res_op0;
10362 0 : {
10363 0 : tree _o1[2], _r1;
10364 0 : _o1[0] = captures[0];
10365 0 : _o1[1] = captures[3];
10366 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10367 0 : res_op0 = _r1;
10368 : }
10369 0 : tree res_op1;
10370 0 : res_op1 = captures[1];
10371 0 : tree res_op2;
10372 0 : res_op2 = captures[2];
10373 0 : tree _r;
10374 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10375 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10376 : return _r;
10377 : }
10378 0 : next_after_fail1259:;
10379 : }
10380 : }
10381 0 : {
10382 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10383 0 : const enum tree_code lop = BIT_XOR_EXPR;
10384 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10385 : )
10386 : {
10387 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1260;
10388 0 : {
10389 0 : tree res_op0;
10390 0 : {
10391 0 : tree _o1[2], _r1;
10392 0 : _o1[0] = captures[0];
10393 0 : _o1[1] = captures[3];
10394 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10395 0 : res_op0 = _r1;
10396 : }
10397 0 : tree res_op1;
10398 0 : res_op1 = captures[1];
10399 0 : tree res_op2;
10400 0 : res_op2 = captures[2];
10401 0 : tree _r;
10402 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10403 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10404 : return _r;
10405 : }
10406 0 : next_after_fail1260:;
10407 : }
10408 : }
10409 0 : {
10410 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10411 0 : const enum tree_code lop = BIT_XOR_EXPR;
10412 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10413 : )
10414 : {
10415 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1261;
10416 0 : {
10417 0 : tree res_op0;
10418 0 : {
10419 0 : tree _o1[2], _r1;
10420 0 : _o1[0] = captures[0];
10421 0 : _o1[1] = captures[3];
10422 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10423 0 : res_op0 = _r1;
10424 : }
10425 0 : tree res_op1;
10426 0 : res_op1 = captures[1];
10427 0 : tree res_op2;
10428 0 : res_op2 = captures[2];
10429 0 : tree _r;
10430 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10431 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10432 : return _r;
10433 : }
10434 0 : next_after_fail1261:;
10435 : }
10436 : }
10437 0 : {
10438 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10439 0 : const enum tree_code lop = BIT_XOR_EXPR;
10440 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10441 : )
10442 : {
10443 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1262;
10444 0 : {
10445 0 : tree res_op0;
10446 0 : {
10447 0 : tree _o1[2], _r1;
10448 0 : _o1[0] = captures[0];
10449 0 : _o1[1] = captures[3];
10450 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10451 0 : res_op0 = _r1;
10452 : }
10453 0 : tree res_op1;
10454 0 : res_op1 = captures[1];
10455 0 : tree res_op2;
10456 0 : res_op2 = captures[2];
10457 0 : tree _r;
10458 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10459 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10460 : return _r;
10461 : }
10462 0 : next_after_fail1262:;
10463 : }
10464 : }
10465 0 : {
10466 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10467 0 : const enum tree_code lop = BIT_XOR_EXPR;
10468 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10469 : )
10470 : {
10471 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1263;
10472 0 : {
10473 0 : tree res_op0;
10474 0 : {
10475 0 : tree _o1[2], _r1;
10476 0 : _o1[0] = captures[0];
10477 0 : _o1[1] = captures[3];
10478 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10479 0 : res_op0 = _r1;
10480 : }
10481 0 : tree res_op1;
10482 0 : res_op1 = captures[1];
10483 0 : tree res_op2;
10484 0 : res_op2 = captures[2];
10485 0 : tree _r;
10486 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10487 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10488 : return _r;
10489 : }
10490 0 : next_after_fail1263:;
10491 : }
10492 : }
10493 0 : {
10494 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10495 0 : const enum tree_code lop = BIT_XOR_EXPR;
10496 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10497 : )
10498 : {
10499 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1264;
10500 0 : {
10501 0 : tree res_op0;
10502 0 : {
10503 0 : tree _o1[2], _r1;
10504 0 : _o1[0] = captures[0];
10505 0 : _o1[1] = captures[3];
10506 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10507 0 : res_op0 = _r1;
10508 : }
10509 0 : tree res_op1;
10510 0 : res_op1 = captures[1];
10511 0 : tree res_op2;
10512 0 : res_op2 = captures[2];
10513 0 : tree _r;
10514 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10515 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10516 : return _r;
10517 : }
10518 0 : next_after_fail1264:;
10519 : }
10520 : }
10521 0 : {
10522 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10523 0 : const enum tree_code lop = BIT_XOR_EXPR;
10524 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10525 : )
10526 : {
10527 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1265;
10528 0 : {
10529 0 : tree res_op0;
10530 0 : {
10531 0 : tree _o1[2], _r1;
10532 0 : _o1[0] = captures[0];
10533 0 : _o1[1] = captures[3];
10534 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10535 0 : res_op0 = _r1;
10536 : }
10537 0 : tree res_op1;
10538 0 : res_op1 = captures[1];
10539 0 : tree res_op2;
10540 0 : res_op2 = captures[2];
10541 0 : tree _r;
10542 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10543 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10544 : return _r;
10545 : }
10546 0 : next_after_fail1265:;
10547 : }
10548 : }
10549 0 : {
10550 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10551 0 : const enum tree_code lop = BIT_XOR_EXPR;
10552 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10553 : )
10554 : {
10555 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1266;
10556 0 : {
10557 0 : tree res_op0;
10558 0 : {
10559 0 : tree _o1[2], _r1;
10560 0 : _o1[0] = captures[0];
10561 0 : _o1[1] = captures[3];
10562 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10563 0 : res_op0 = _r1;
10564 : }
10565 0 : tree res_op1;
10566 0 : res_op1 = captures[1];
10567 0 : tree res_op2;
10568 0 : res_op2 = captures[2];
10569 0 : tree _r;
10570 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10571 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10572 : return _r;
10573 : }
10574 0 : next_after_fail1266:;
10575 : }
10576 : }
10577 0 : {
10578 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10579 0 : const enum tree_code lop = BIT_XOR_EXPR;
10580 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10581 : )
10582 : {
10583 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1267;
10584 0 : {
10585 0 : tree res_op0;
10586 0 : {
10587 0 : tree _o1[2], _r1;
10588 0 : _o1[0] = captures[0];
10589 0 : _o1[1] = captures[3];
10590 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10591 0 : res_op0 = _r1;
10592 : }
10593 0 : tree res_op1;
10594 0 : res_op1 = captures[1];
10595 0 : tree res_op2;
10596 0 : res_op2 = captures[2];
10597 0 : tree _r;
10598 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10599 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10600 : return _r;
10601 : }
10602 0 : next_after_fail1267:;
10603 : }
10604 : }
10605 0 : {
10606 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10607 0 : const enum tree_code lop = BIT_XOR_EXPR;
10608 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10609 : )
10610 : {
10611 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1268;
10612 0 : {
10613 0 : tree res_op0;
10614 0 : {
10615 0 : tree _o1[2], _r1;
10616 0 : _o1[0] = captures[0];
10617 0 : _o1[1] = captures[3];
10618 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10619 0 : res_op0 = _r1;
10620 : }
10621 0 : tree res_op1;
10622 0 : res_op1 = captures[1];
10623 0 : tree res_op2;
10624 0 : res_op2 = captures[2];
10625 0 : tree _r;
10626 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10627 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10628 : return _r;
10629 : }
10630 0 : next_after_fail1268:;
10631 : }
10632 : }
10633 0 : {
10634 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10635 0 : const enum tree_code lop = BIT_XOR_EXPR;
10636 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10637 : )
10638 : {
10639 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1269;
10640 0 : {
10641 0 : tree res_op0;
10642 0 : {
10643 0 : tree _o1[2], _r1;
10644 0 : _o1[0] = captures[0];
10645 0 : _o1[1] = captures[3];
10646 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10647 0 : res_op0 = _r1;
10648 : }
10649 0 : tree res_op1;
10650 0 : res_op1 = captures[1];
10651 0 : tree res_op2;
10652 0 : res_op2 = captures[2];
10653 0 : tree _r;
10654 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10655 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10656 : return _r;
10657 : }
10658 0 : next_after_fail1269:;
10659 : }
10660 : }
10661 0 : {
10662 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10663 0 : const enum tree_code lop = BIT_XOR_EXPR;
10664 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10665 : )
10666 : {
10667 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1270;
10668 0 : {
10669 0 : tree res_op0;
10670 0 : {
10671 0 : tree _o1[2], _r1;
10672 0 : _o1[0] = captures[0];
10673 0 : _o1[1] = captures[3];
10674 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10675 0 : res_op0 = _r1;
10676 : }
10677 0 : tree res_op1;
10678 0 : res_op1 = captures[1];
10679 0 : tree res_op2;
10680 0 : res_op2 = captures[2];
10681 0 : tree _r;
10682 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10683 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10684 : return _r;
10685 : }
10686 0 : next_after_fail1270:;
10687 : }
10688 : }
10689 0 : {
10690 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10691 0 : const enum tree_code lop = BIT_XOR_EXPR;
10692 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10693 : )
10694 : {
10695 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1271;
10696 0 : {
10697 0 : tree res_op0;
10698 0 : {
10699 0 : tree _o1[2], _r1;
10700 0 : _o1[0] = captures[0];
10701 0 : _o1[1] = captures[3];
10702 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10703 0 : res_op0 = _r1;
10704 : }
10705 0 : tree res_op1;
10706 0 : res_op1 = captures[1];
10707 0 : tree res_op2;
10708 0 : res_op2 = captures[2];
10709 0 : tree _r;
10710 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10711 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10712 : return _r;
10713 : }
10714 0 : next_after_fail1271:;
10715 : }
10716 : }
10717 0 : {
10718 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10719 0 : const enum tree_code lop = BIT_XOR_EXPR;
10720 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10721 : )
10722 : {
10723 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1272;
10724 0 : {
10725 0 : tree res_op0;
10726 0 : {
10727 0 : tree _o1[2], _r1;
10728 0 : _o1[0] = captures[0];
10729 0 : _o1[1] = captures[3];
10730 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10731 0 : res_op0 = _r1;
10732 : }
10733 0 : tree res_op1;
10734 0 : res_op1 = captures[1];
10735 0 : tree res_op2;
10736 0 : res_op2 = captures[2];
10737 0 : tree _r;
10738 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10739 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10740 : return _r;
10741 : }
10742 0 : next_after_fail1272:;
10743 : }
10744 : }
10745 0 : {
10746 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10747 0 : const enum tree_code lop = BIT_XOR_EXPR;
10748 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10749 : )
10750 : {
10751 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1273;
10752 0 : {
10753 0 : tree res_op0;
10754 0 : {
10755 0 : tree _o1[2], _r1;
10756 0 : _o1[0] = captures[0];
10757 0 : _o1[1] = captures[3];
10758 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10759 0 : res_op0 = _r1;
10760 : }
10761 0 : tree res_op1;
10762 0 : res_op1 = captures[1];
10763 0 : tree res_op2;
10764 0 : res_op2 = captures[2];
10765 0 : tree _r;
10766 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10767 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10768 : return _r;
10769 : }
10770 0 : next_after_fail1273:;
10771 : }
10772 : }
10773 0 : {
10774 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10775 0 : const enum tree_code lop = BIT_XOR_EXPR;
10776 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10777 : )
10778 : {
10779 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1274;
10780 0 : {
10781 0 : tree res_op0;
10782 0 : {
10783 0 : tree _o1[2], _r1;
10784 0 : _o1[0] = captures[0];
10785 0 : _o1[1] = captures[3];
10786 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10787 0 : res_op0 = _r1;
10788 : }
10789 0 : tree res_op1;
10790 0 : res_op1 = captures[1];
10791 0 : tree res_op2;
10792 0 : res_op2 = captures[2];
10793 0 : tree _r;
10794 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10795 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10796 : return _r;
10797 : }
10798 0 : next_after_fail1274:;
10799 : }
10800 : }
10801 0 : {
10802 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10803 0 : const enum tree_code lop = BIT_XOR_EXPR;
10804 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10805 : )
10806 : {
10807 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1275;
10808 0 : {
10809 0 : tree res_op0;
10810 0 : {
10811 0 : tree _o1[2], _r1;
10812 0 : _o1[0] = captures[0];
10813 0 : _o1[1] = captures[3];
10814 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10815 0 : res_op0 = _r1;
10816 : }
10817 0 : tree res_op1;
10818 0 : res_op1 = captures[1];
10819 0 : tree res_op2;
10820 0 : res_op2 = captures[2];
10821 0 : tree _r;
10822 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10823 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10824 : return _r;
10825 : }
10826 0 : next_after_fail1275:;
10827 : }
10828 : }
10829 0 : {
10830 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10831 0 : const enum tree_code lop = BIT_XOR_EXPR;
10832 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10833 : )
10834 : {
10835 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1276;
10836 0 : {
10837 0 : tree res_op0;
10838 0 : {
10839 0 : tree _o1[2], _r1;
10840 0 : _o1[0] = captures[0];
10841 0 : _o1[1] = captures[3];
10842 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10843 0 : res_op0 = _r1;
10844 : }
10845 0 : tree res_op1;
10846 0 : res_op1 = captures[1];
10847 0 : tree res_op2;
10848 0 : res_op2 = captures[2];
10849 0 : tree _r;
10850 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10851 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10852 : return _r;
10853 : }
10854 0 : next_after_fail1276:;
10855 : }
10856 : }
10857 0 : {
10858 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10859 0 : const enum tree_code lop = BIT_XOR_EXPR;
10860 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10861 : )
10862 : {
10863 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1277;
10864 0 : {
10865 0 : tree res_op0;
10866 0 : {
10867 0 : tree _o1[2], _r1;
10868 0 : _o1[0] = captures[0];
10869 0 : _o1[1] = captures[3];
10870 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10871 0 : res_op0 = _r1;
10872 : }
10873 0 : tree res_op1;
10874 0 : res_op1 = captures[1];
10875 0 : tree res_op2;
10876 0 : res_op2 = captures[2];
10877 0 : tree _r;
10878 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10879 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10880 : return _r;
10881 : }
10882 0 : next_after_fail1277:;
10883 : }
10884 : }
10885 0 : {
10886 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10887 0 : const enum tree_code lop = BIT_XOR_EXPR;
10888 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10889 : )
10890 : {
10891 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1278;
10892 0 : {
10893 0 : tree res_op0;
10894 0 : {
10895 0 : tree _o1[2], _r1;
10896 0 : _o1[0] = captures[0];
10897 0 : _o1[1] = captures[3];
10898 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10899 0 : res_op0 = _r1;
10900 : }
10901 0 : tree res_op1;
10902 0 : res_op1 = captures[1];
10903 0 : tree res_op2;
10904 0 : res_op2 = captures[2];
10905 0 : tree _r;
10906 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10907 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10908 : return _r;
10909 : }
10910 0 : next_after_fail1278:;
10911 : }
10912 : }
10913 0 : {
10914 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10915 0 : const enum tree_code lop = BIT_XOR_EXPR;
10916 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10917 : )
10918 : {
10919 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1279;
10920 0 : {
10921 0 : tree res_op0;
10922 0 : {
10923 0 : tree _o1[2], _r1;
10924 0 : _o1[0] = captures[0];
10925 0 : _o1[1] = captures[3];
10926 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10927 0 : res_op0 = _r1;
10928 : }
10929 0 : tree res_op1;
10930 0 : res_op1 = captures[1];
10931 0 : tree res_op2;
10932 0 : res_op2 = captures[2];
10933 0 : tree _r;
10934 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10935 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10936 : return _r;
10937 : }
10938 0 : next_after_fail1279:;
10939 : }
10940 : }
10941 0 : {
10942 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10943 0 : const enum tree_code lop = BIT_XOR_EXPR;
10944 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10945 : )
10946 : {
10947 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1280;
10948 0 : {
10949 0 : tree res_op0;
10950 0 : {
10951 0 : tree _o1[2], _r1;
10952 0 : _o1[0] = captures[0];
10953 0 : _o1[1] = captures[3];
10954 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10955 0 : res_op0 = _r1;
10956 : }
10957 0 : tree res_op1;
10958 0 : res_op1 = captures[1];
10959 0 : tree res_op2;
10960 0 : res_op2 = captures[2];
10961 0 : tree _r;
10962 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10963 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10964 : return _r;
10965 : }
10966 0 : next_after_fail1280:;
10967 : }
10968 : }
10969 0 : {
10970 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10971 0 : const enum tree_code lop = BIT_XOR_EXPR;
10972 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10973 : )
10974 : {
10975 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1281;
10976 0 : {
10977 0 : tree res_op0;
10978 0 : {
10979 0 : tree _o1[2], _r1;
10980 0 : _o1[0] = captures[0];
10981 0 : _o1[1] = captures[3];
10982 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10983 0 : res_op0 = _r1;
10984 : }
10985 0 : tree res_op1;
10986 0 : res_op1 = captures[1];
10987 0 : tree res_op2;
10988 0 : res_op2 = captures[2];
10989 0 : tree _r;
10990 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10991 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
10992 : return _r;
10993 : }
10994 0 : next_after_fail1281:;
10995 : }
10996 : }
10997 0 : {
10998 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10999 0 : const enum tree_code lop = BIT_XOR_EXPR;
11000 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
11001 : )
11002 : {
11003 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1282;
11004 0 : {
11005 0 : tree res_op0;
11006 0 : {
11007 0 : tree _o1[2], _r1;
11008 0 : _o1[0] = captures[0];
11009 0 : _o1[1] = captures[3];
11010 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
11011 0 : res_op0 = _r1;
11012 : }
11013 0 : tree res_op1;
11014 0 : res_op1 = captures[1];
11015 0 : tree res_op2;
11016 0 : res_op2 = captures[2];
11017 0 : tree _r;
11018 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11019 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
11020 : return _r;
11021 : }
11022 0 : next_after_fail1282:;
11023 : }
11024 : }
11025 0 : {
11026 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
11027 0 : const enum tree_code lop = BIT_XOR_EXPR;
11028 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
11029 : )
11030 : {
11031 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1283;
11032 0 : {
11033 0 : tree res_op0;
11034 0 : {
11035 0 : tree _o1[2], _r1;
11036 0 : _o1[0] = captures[0];
11037 0 : _o1[1] = captures[3];
11038 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
11039 0 : res_op0 = _r1;
11040 : }
11041 0 : tree res_op1;
11042 0 : res_op1 = captures[1];
11043 0 : tree res_op2;
11044 0 : res_op2 = captures[2];
11045 0 : tree _r;
11046 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11047 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
11048 : return _r;
11049 : }
11050 0 : next_after_fail1283:;
11051 : }
11052 : }
11053 0 : {
11054 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
11055 0 : const enum tree_code lop = BIT_XOR_EXPR;
11056 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
11057 : )
11058 : {
11059 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1284;
11060 0 : {
11061 0 : tree res_op0;
11062 0 : {
11063 0 : tree _o1[2], _r1;
11064 0 : _o1[0] = captures[0];
11065 0 : _o1[1] = captures[3];
11066 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
11067 0 : res_op0 = _r1;
11068 : }
11069 0 : tree res_op1;
11070 0 : res_op1 = captures[1];
11071 0 : tree res_op2;
11072 0 : res_op2 = captures[2];
11073 0 : tree _r;
11074 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11075 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
11076 : return _r;
11077 : }
11078 0 : next_after_fail1284:;
11079 : }
11080 : }
11081 0 : {
11082 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
11083 0 : const enum tree_code lop = BIT_XOR_EXPR;
11084 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
11085 : )
11086 : {
11087 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1285;
11088 0 : {
11089 0 : tree res_op0;
11090 0 : {
11091 0 : tree _o1[2], _r1;
11092 0 : _o1[0] = captures[0];
11093 0 : _o1[1] = captures[3];
11094 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
11095 0 : res_op0 = _r1;
11096 : }
11097 0 : tree res_op1;
11098 0 : res_op1 = captures[1];
11099 0 : tree res_op2;
11100 0 : res_op2 = captures[2];
11101 0 : tree _r;
11102 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11103 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
11104 : return _r;
11105 : }
11106 0 : next_after_fail1285:;
11107 : }
11108 : }
11109 0 : {
11110 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
11111 0 : const enum tree_code lop = BIT_XOR_EXPR;
11112 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
11113 : )
11114 : {
11115 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1286;
11116 0 : {
11117 0 : tree res_op0;
11118 0 : {
11119 0 : tree _o1[2], _r1;
11120 0 : _o1[0] = captures[0];
11121 0 : _o1[1] = captures[3];
11122 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
11123 0 : res_op0 = _r1;
11124 : }
11125 0 : tree res_op1;
11126 0 : res_op1 = captures[1];
11127 0 : tree res_op2;
11128 0 : res_op2 = captures[2];
11129 0 : tree _r;
11130 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11131 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
11132 : return _r;
11133 : }
11134 0 : next_after_fail1286:;
11135 : }
11136 : }
11137 0 : {
11138 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
11139 0 : const enum tree_code lop = BIT_XOR_EXPR;
11140 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
11141 : )
11142 : {
11143 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1287;
11144 0 : {
11145 0 : tree res_op0;
11146 0 : {
11147 0 : tree _o1[2], _r1;
11148 0 : _o1[0] = captures[0];
11149 0 : _o1[1] = captures[3];
11150 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
11151 0 : res_op0 = _r1;
11152 : }
11153 0 : tree res_op1;
11154 0 : res_op1 = captures[1];
11155 0 : tree res_op2;
11156 0 : res_op2 = captures[2];
11157 0 : tree _r;
11158 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11159 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
11160 : return _r;
11161 : }
11162 0 : next_after_fail1287:;
11163 : }
11164 : }
11165 0 : {
11166 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
11167 0 : const enum tree_code lop = BIT_XOR_EXPR;
11168 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
11169 : )
11170 : {
11171 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1288;
11172 0 : {
11173 0 : tree res_op0;
11174 0 : {
11175 0 : tree _o1[2], _r1;
11176 0 : _o1[0] = captures[0];
11177 0 : _o1[1] = captures[3];
11178 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
11179 0 : res_op0 = _r1;
11180 : }
11181 0 : tree res_op1;
11182 0 : res_op1 = captures[1];
11183 0 : tree res_op2;
11184 0 : res_op2 = captures[2];
11185 0 : tree _r;
11186 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11187 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
11188 : return _r;
11189 : }
11190 0 : next_after_fail1288:;
11191 : }
11192 : }
11193 0 : {
11194 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
11195 0 : const enum tree_code lop = BIT_XOR_EXPR;
11196 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
11197 : )
11198 : {
11199 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1289;
11200 0 : {
11201 0 : tree res_op0;
11202 0 : {
11203 0 : tree _o1[2], _r1;
11204 0 : _o1[0] = captures[0];
11205 0 : _o1[1] = captures[3];
11206 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
11207 0 : res_op0 = _r1;
11208 : }
11209 0 : tree res_op1;
11210 0 : res_op1 = captures[1];
11211 0 : tree res_op2;
11212 0 : res_op2 = captures[2];
11213 0 : tree _r;
11214 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11215 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
11216 : return _r;
11217 : }
11218 0 : next_after_fail1289:;
11219 : }
11220 : }
11221 0 : {
11222 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
11223 0 : const enum tree_code lop = BIT_XOR_EXPR;
11224 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
11225 : )
11226 : {
11227 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1290;
11228 0 : {
11229 0 : tree res_op0;
11230 0 : {
11231 0 : tree _o1[2], _r1;
11232 0 : _o1[0] = captures[0];
11233 0 : _o1[1] = captures[3];
11234 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
11235 0 : res_op0 = _r1;
11236 : }
11237 0 : tree res_op1;
11238 0 : res_op1 = captures[1];
11239 0 : tree res_op2;
11240 0 : res_op2 = captures[2];
11241 0 : tree _r;
11242 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11243 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
11244 : return _r;
11245 : }
11246 0 : next_after_fail1290:;
11247 : }
11248 : }
11249 0 : {
11250 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
11251 0 : const enum tree_code lop = BIT_XOR_EXPR;
11252 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
11253 : )
11254 : {
11255 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1291;
11256 0 : {
11257 0 : tree res_op0;
11258 0 : {
11259 0 : tree _o1[2], _r1;
11260 0 : _o1[0] = captures[0];
11261 0 : _o1[1] = captures[3];
11262 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
11263 0 : res_op0 = _r1;
11264 : }
11265 0 : tree res_op1;
11266 0 : res_op1 = captures[1];
11267 0 : tree res_op2;
11268 0 : res_op2 = captures[2];
11269 0 : tree _r;
11270 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11271 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
11272 : return _r;
11273 : }
11274 0 : next_after_fail1291:;
11275 : }
11276 : }
11277 : }
11278 : }
11279 : break;
11280 : }
11281 : default:;
11282 : }
11283 : }
11284 : }
11285 1 : {
11286 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
11287 1 : if (VECTOR_TYPE_P (type)
11288 : && (TREE_CODE_CLASS (BIT_XOR_EXPR) != tcc_comparison
11289 : || types_match (type, TREE_TYPE (captures[2]))
11290 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
11291 : || (optimize_vectors_before_lowering_p ()
11292 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
11293 : )
11294 : {
11295 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1292;
11296 1 : {
11297 1 : if (! tree_invariant_p (captures[4])) goto next_after_fail1292;
11298 0 : tree res_op0;
11299 0 : res_op0 = captures[1];
11300 0 : tree res_op1;
11301 0 : {
11302 0 : tree _o1[2], _r1;
11303 0 : _o1[0] = captures[2];
11304 0 : _o1[1] = unshare_expr (captures[4]);
11305 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
11306 0 : if (EXPR_P (_r1))
11307 0 : goto next_after_fail1292;
11308 0 : res_op1 = _r1;
11309 : }
11310 0 : tree res_op2;
11311 0 : {
11312 0 : tree _o1[2], _r1;
11313 0 : _o1[0] = captures[3];
11314 0 : _o1[1] = captures[4];
11315 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
11316 0 : if (EXPR_P (_r1))
11317 0 : goto next_after_fail1292;
11318 0 : res_op2 = _r1;
11319 : }
11320 0 : tree _r;
11321 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11322 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 940, __FILE__, __LINE__, true);
11323 : return _r;
11324 : }
11325 972933 : next_after_fail1292:;
11326 : }
11327 : }
11328 : break;
11329 : }
11330 972933 : default:;
11331 : }
11332 972933 : switch (TREE_CODE (_p1))
11333 : {
11334 0 : case VEC_COND_EXPR:
11335 0 : {
11336 0 : tree _q30 = TREE_OPERAND (_p1, 0);
11337 0 : tree _q31 = TREE_OPERAND (_p1, 1);
11338 0 : tree _q32 = TREE_OPERAND (_p1, 2);
11339 0 : {
11340 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
11341 0 : if (VECTOR_TYPE_P (type)
11342 : && (TREE_CODE_CLASS (BIT_XOR_EXPR) != tcc_comparison
11343 : || types_match (type, TREE_TYPE (captures[3]))
11344 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
11345 : || (optimize_vectors_before_lowering_p ()
11346 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
11347 : )
11348 : {
11349 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1293;
11350 0 : {
11351 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1293;
11352 0 : tree res_op0;
11353 0 : res_op0 = captures[2];
11354 0 : tree res_op1;
11355 0 : {
11356 0 : tree _o1[2], _r1;
11357 0 : _o1[0] = unshare_expr (captures[0]);
11358 0 : _o1[1] = captures[3];
11359 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
11360 0 : if (EXPR_P (_r1))
11361 0 : goto next_after_fail1293;
11362 0 : res_op1 = _r1;
11363 : }
11364 0 : tree res_op2;
11365 0 : {
11366 0 : tree _o1[2], _r1;
11367 0 : _o1[0] = captures[0];
11368 0 : _o1[1] = captures[4];
11369 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
11370 0 : if (EXPR_P (_r1))
11371 0 : goto next_after_fail1293;
11372 0 : res_op2 = _r1;
11373 : }
11374 0 : tree _r;
11375 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
11376 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 941, __FILE__, __LINE__, true);
11377 : return _r;
11378 : }
11379 972933 : next_after_fail1293:;
11380 : }
11381 : }
11382 : break;
11383 : }
11384 972933 : default:;
11385 : }
11386 972933 : switch (TREE_CODE (_p0))
11387 : {
11388 90 : case LT_EXPR:
11389 90 : {
11390 90 : tree _q20 = TREE_OPERAND (_p0, 0);
11391 90 : tree _q21 = TREE_OPERAND (_p0, 1);
11392 90 : if (integer_truep (_p1))
11393 : {
11394 14 : {
11395 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11396 14 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, LT_EXPR, GE_EXPR, UNGE_EXPR);
11397 14 : if (res) return res;
11398 : }
11399 : }
11400 76 : if (integer_zerop (_q21))
11401 : {
11402 24 : switch (TREE_CODE (_p1))
11403 : {
11404 17 : case LT_EXPR:
11405 17 : {
11406 17 : tree _q50 = TREE_OPERAND (_p1, 0);
11407 17 : tree _q51 = TREE_OPERAND (_p1, 1);
11408 17 : if (integer_zerop (_q51))
11409 : {
11410 17 : {
11411 17 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q50 };
11412 17 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures, LT_EXPR);
11413 17 : if (res) return res;
11414 : }
11415 : }
11416 : break;
11417 : }
11418 0 : case GE_EXPR:
11419 0 : {
11420 0 : tree _q50 = TREE_OPERAND (_p1, 0);
11421 0 : tree _q51 = TREE_OPERAND (_p1, 1);
11422 0 : if (integer_zerop (_q51))
11423 : {
11424 0 : {
11425 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q50 };
11426 0 : tree res = generic_simplify_48 (loc, type, _p0, _p1, captures);
11427 0 : if (res) return res;
11428 : }
11429 : }
11430 : break;
11431 : }
11432 : default:;
11433 : }
11434 : }
11435 : break;
11436 : }
11437 85 : case LE_EXPR:
11438 85 : {
11439 85 : tree _q20 = TREE_OPERAND (_p0, 0);
11440 85 : tree _q21 = TREE_OPERAND (_p0, 1);
11441 85 : if (integer_truep (_p1))
11442 : {
11443 15 : {
11444 15 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11445 15 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR, UNGT_EXPR);
11446 15 : if (res) return res;
11447 : }
11448 : }
11449 : break;
11450 : }
11451 123 : case EQ_EXPR:
11452 123 : {
11453 123 : tree _q20 = TREE_OPERAND (_p0, 0);
11454 123 : tree _q21 = TREE_OPERAND (_p0, 1);
11455 123 : if (integer_truep (_p1))
11456 : {
11457 14 : {
11458 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11459 14 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR, NE_EXPR);
11460 14 : if (res) return res;
11461 : }
11462 : }
11463 : break;
11464 : }
11465 118 : case NE_EXPR:
11466 118 : {
11467 118 : tree _q20 = TREE_OPERAND (_p0, 0);
11468 118 : tree _q21 = TREE_OPERAND (_p0, 1);
11469 118 : if (integer_truep (_p1))
11470 : {
11471 7 : {
11472 7 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11473 7 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR, EQ_EXPR);
11474 7 : if (res) return res;
11475 : }
11476 : }
11477 : break;
11478 : }
11479 62 : case GE_EXPR:
11480 62 : {
11481 62 : tree _q20 = TREE_OPERAND (_p0, 0);
11482 62 : tree _q21 = TREE_OPERAND (_p0, 1);
11483 62 : if (integer_truep (_p1))
11484 : {
11485 0 : {
11486 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11487 0 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, GE_EXPR, LT_EXPR, UNLT_EXPR);
11488 0 : if (res) return res;
11489 : }
11490 : }
11491 62 : if (integer_zerop (_q21))
11492 : {
11493 26 : switch (TREE_CODE (_p1))
11494 : {
11495 1 : case GE_EXPR:
11496 1 : {
11497 1 : tree _q50 = TREE_OPERAND (_p1, 0);
11498 1 : tree _q51 = TREE_OPERAND (_p1, 1);
11499 1 : if (integer_zerop (_q51))
11500 : {
11501 1 : {
11502 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q50 };
11503 1 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures, GE_EXPR);
11504 1 : if (res) return res;
11505 : }
11506 : }
11507 : break;
11508 : }
11509 5 : case LT_EXPR:
11510 5 : {
11511 5 : tree _q50 = TREE_OPERAND (_p1, 0);
11512 5 : tree _q51 = TREE_OPERAND (_p1, 1);
11513 5 : if (integer_zerop (_q51))
11514 : {
11515 5 : {
11516 5 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q50, _p0, _q20 };
11517 5 : tree res = generic_simplify_48 (loc, type, _p0, _p1, captures);
11518 5 : if (res) return res;
11519 : }
11520 : }
11521 : break;
11522 : }
11523 : default:;
11524 : }
11525 : }
11526 : break;
11527 : }
11528 100 : case GT_EXPR:
11529 100 : {
11530 100 : tree _q20 = TREE_OPERAND (_p0, 0);
11531 100 : tree _q21 = TREE_OPERAND (_p0, 1);
11532 100 : if (integer_truep (_p1))
11533 : {
11534 14 : {
11535 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11536 14 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, GT_EXPR, LE_EXPR, UNLE_EXPR);
11537 14 : if (res) return res;
11538 : }
11539 : }
11540 : break;
11541 : }
11542 0 : case UNORDERED_EXPR:
11543 0 : {
11544 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11545 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11546 0 : if (integer_truep (_p1))
11547 : {
11548 0 : {
11549 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11550 0 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR);
11551 0 : if (res) return res;
11552 : }
11553 : }
11554 : break;
11555 : }
11556 0 : case ORDERED_EXPR:
11557 0 : {
11558 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11559 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11560 0 : if (integer_truep (_p1))
11561 : {
11562 0 : {
11563 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11564 0 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR);
11565 0 : if (res) return res;
11566 : }
11567 : }
11568 : break;
11569 : }
11570 0 : case UNLT_EXPR:
11571 0 : {
11572 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11573 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11574 0 : if (integer_truep (_p1))
11575 : {
11576 0 : {
11577 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11578 0 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, UNLT_EXPR, GE_EXPR, GE_EXPR);
11579 0 : if (res) return res;
11580 : }
11581 : }
11582 : break;
11583 : }
11584 0 : case UNLE_EXPR:
11585 0 : {
11586 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11587 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11588 0 : if (integer_truep (_p1))
11589 : {
11590 0 : {
11591 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11592 0 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, UNLE_EXPR, GT_EXPR, GT_EXPR);
11593 0 : if (res) return res;
11594 : }
11595 : }
11596 : break;
11597 : }
11598 0 : case UNGT_EXPR:
11599 0 : {
11600 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11601 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11602 0 : if (integer_truep (_p1))
11603 : {
11604 0 : {
11605 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11606 0 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, UNGT_EXPR, LE_EXPR, LE_EXPR);
11607 0 : if (res) return res;
11608 : }
11609 : }
11610 : break;
11611 : }
11612 0 : case UNGE_EXPR:
11613 0 : {
11614 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11615 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11616 0 : if (integer_truep (_p1))
11617 : {
11618 0 : {
11619 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11620 0 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, UNGE_EXPR, LT_EXPR, LT_EXPR);
11621 0 : if (res) return res;
11622 : }
11623 : }
11624 : break;
11625 : }
11626 0 : case UNEQ_EXPR:
11627 0 : {
11628 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11629 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11630 0 : if (integer_truep (_p1))
11631 : {
11632 0 : {
11633 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11634 0 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR);
11635 0 : if (res) return res;
11636 : }
11637 : }
11638 : break;
11639 : }
11640 0 : case LTGT_EXPR:
11641 0 : {
11642 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11643 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11644 0 : if (integer_truep (_p1))
11645 : {
11646 0 : {
11647 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11648 0 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR);
11649 0 : if (res) return res;
11650 : }
11651 : }
11652 : break;
11653 : }
11654 7 : case VEC_PERM_EXPR:
11655 7 : {
11656 7 : tree _q20 = TREE_OPERAND (_p0, 0);
11657 7 : tree _q21 = TREE_OPERAND (_p0, 1);
11658 7 : tree _q22 = TREE_OPERAND (_p0, 2);
11659 7 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
11660 : {
11661 0 : switch (TREE_CODE (_p1))
11662 : {
11663 0 : case VEC_PERM_EXPR:
11664 0 : {
11665 0 : tree _q60 = TREE_OPERAND (_p1, 0);
11666 0 : tree _q61 = TREE_OPERAND (_p1, 1);
11667 0 : tree _q62 = TREE_OPERAND (_p1, 2);
11668 0 : if ((_q61 == _q60 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q60, 0) && types_match (_q61, _q60)))
11669 : {
11670 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
11671 : {
11672 0 : {
11673 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q22, _q60 };
11674 0 : if (VECTOR_INTEGER_TYPE_P (type)
11675 : )
11676 : {
11677 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1294;
11678 0 : {
11679 0 : tree res_op0;
11680 0 : {
11681 0 : tree _o1[2], _r1;
11682 0 : _o1[0] = captures[0];
11683 0 : _o1[1] = captures[2];
11684 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
11685 0 : captures[3] = _r1;
11686 : }
11687 0 : res_op0 = unshare_expr (captures[3]);
11688 0 : tree res_op1;
11689 0 : res_op1 = captures[3];
11690 0 : tree res_op2;
11691 0 : res_op2 = captures[1];
11692 0 : tree _r;
11693 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
11694 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 942, __FILE__, __LINE__, true);
11695 1070064 : return _r;
11696 : }
11697 0 : next_after_fail1294:;
11698 : }
11699 : }
11700 : }
11701 : }
11702 : break;
11703 : }
11704 : default:;
11705 : }
11706 : }
11707 : break;
11708 : }
11709 3305 : case CALL_EXPR:
11710 3305 : switch (get_call_combined_fn (_p0))
11711 : {
11712 1 : case CFN_PARITY:
11713 1 : if (call_expr_nargs (_p0) == 1)
11714 : {
11715 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11716 1 : switch (TREE_CODE (_p1))
11717 : {
11718 1 : case CALL_EXPR:
11719 1 : switch (get_call_combined_fn (_p1))
11720 : {
11721 1 : case CFN_PARITY:
11722 1 : if (call_expr_nargs (_p1) == 1)
11723 : {
11724 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11725 1 : {
11726 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11727 1 : tree res = generic_simplify_49 (loc, type, _p0, _p1, captures, CFN_PARITY);
11728 1 : if (res) return res;
11729 : }
11730 : }
11731 : break;
11732 : default:;
11733 : }
11734 : break;
11735 : default:;
11736 : }
11737 : }
11738 : break;
11739 0 : case CFN_REDUC_XOR:
11740 0 : if (call_expr_nargs (_p0) == 1)
11741 : {
11742 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11743 0 : switch (TREE_CODE (_p1))
11744 : {
11745 0 : case CALL_EXPR:
11746 0 : switch (get_call_combined_fn (_p1))
11747 : {
11748 0 : case CFN_REDUC_XOR:
11749 0 : if (call_expr_nargs (_p1) == 1)
11750 : {
11751 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11752 0 : {
11753 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11754 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, CFN_REDUC_XOR, BIT_XOR_EXPR);
11755 0 : if (res) return res;
11756 : }
11757 : }
11758 : break;
11759 : default:;
11760 : }
11761 : break;
11762 : default:;
11763 : }
11764 : }
11765 : break;
11766 1 : case CFN_BUILT_IN_PARITYL:
11767 1 : if (call_expr_nargs (_p0) == 1)
11768 : {
11769 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11770 1 : switch (TREE_CODE (_p1))
11771 : {
11772 1 : case CALL_EXPR:
11773 1 : switch (get_call_combined_fn (_p1))
11774 : {
11775 1 : case CFN_BUILT_IN_PARITYL:
11776 1 : if (call_expr_nargs (_p1) == 1)
11777 : {
11778 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11779 1 : {
11780 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11781 1 : tree res = generic_simplify_49 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITYL);
11782 1 : if (res) return res;
11783 : }
11784 : }
11785 : break;
11786 : default:;
11787 : }
11788 : break;
11789 : default:;
11790 : }
11791 : }
11792 : break;
11793 0 : case CFN_BUILT_IN_PARITYIMAX:
11794 0 : if (call_expr_nargs (_p0) == 1)
11795 : {
11796 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11797 0 : switch (TREE_CODE (_p1))
11798 : {
11799 0 : case CALL_EXPR:
11800 0 : switch (get_call_combined_fn (_p1))
11801 : {
11802 0 : case CFN_BUILT_IN_PARITYIMAX:
11803 0 : if (call_expr_nargs (_p1) == 1)
11804 : {
11805 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11806 0 : {
11807 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11808 0 : tree res = generic_simplify_49 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITYIMAX);
11809 0 : if (res) return res;
11810 : }
11811 : }
11812 : break;
11813 : default:;
11814 : }
11815 : break;
11816 : default:;
11817 : }
11818 : }
11819 : break;
11820 1 : case CFN_BUILT_IN_PARITY:
11821 1 : if (call_expr_nargs (_p0) == 1)
11822 : {
11823 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11824 1 : switch (TREE_CODE (_p1))
11825 : {
11826 1 : case CALL_EXPR:
11827 1 : switch (get_call_combined_fn (_p1))
11828 : {
11829 1 : case CFN_BUILT_IN_PARITY:
11830 1 : if (call_expr_nargs (_p1) == 1)
11831 : {
11832 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11833 1 : {
11834 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11835 1 : tree res = generic_simplify_49 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITY);
11836 1 : if (res) return res;
11837 : }
11838 : }
11839 : break;
11840 : default:;
11841 : }
11842 : break;
11843 : default:;
11844 : }
11845 : }
11846 : break;
11847 8 : case CFN_BUILT_IN_PARITYLL:
11848 8 : if (call_expr_nargs (_p0) == 1)
11849 : {
11850 8 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11851 8 : switch (TREE_CODE (_p1))
11852 : {
11853 8 : case CALL_EXPR:
11854 8 : switch (get_call_combined_fn (_p1))
11855 : {
11856 8 : case CFN_BUILT_IN_PARITYLL:
11857 8 : if (call_expr_nargs (_p1) == 1)
11858 : {
11859 8 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11860 8 : {
11861 8 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11862 8 : tree res = generic_simplify_49 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITYLL);
11863 8 : if (res) return res;
11864 : }
11865 : }
11866 : break;
11867 : default:;
11868 : }
11869 : break;
11870 : default:;
11871 : }
11872 : }
11873 : break;
11874 : default:;
11875 : }
11876 : break;
11877 : default:;
11878 : }
11879 : return NULL_TREE;
11880 : }
11881 :
11882 : tree
11883 660186638 : generic_simplify (location_t loc, enum tree_code code, const tree type ATTRIBUTE_UNUSED, tree _p0, tree _p1)
11884 : {
11885 660186638 : switch (code)
11886 : {
11887 1070064 : case BIT_XOR_EXPR:
11888 1070064 : return generic_simplify_BIT_XOR_EXPR (loc, code, type, _p0, _p1);
11889 99376822 : case PLUS_EXPR:
11890 99376822 : return generic_simplify_PLUS_EXPR (loc, code, type, _p0, _p1);
11891 82268105 : case POINTER_PLUS_EXPR:
11892 82268105 : return generic_simplify_POINTER_PLUS_EXPR (loc, code, type, _p0, _p1);
11893 33788763 : case MINUS_EXPR:
11894 33788763 : return generic_simplify_MINUS_EXPR (loc, code, type, _p0, _p1);
11895 1941034 : case BIT_IOR_EXPR:
11896 1941034 : return generic_simplify_BIT_IOR_EXPR (loc, code, type, _p0, _p1);
11897 3314044 : case POINTER_DIFF_EXPR:
11898 3314044 : return generic_simplify_POINTER_DIFF_EXPR (loc, code, type, _p0, _p1);
11899 72733665 : case MULT_EXPR:
11900 72733665 : return generic_simplify_MULT_EXPR (loc, code, type, _p0, _p1);
11901 28253050 : case EQ_EXPR:
11902 28253050 : return generic_simplify_EQ_EXPR (loc, code, type, _p0, _p1);
11903 39445458 : case NE_EXPR:
11904 39445458 : return generic_simplify_NE_EXPR (loc, code, type, _p0, _p1);
11905 2200761 : case TRUNC_DIV_EXPR:
11906 2200761 : return generic_simplify_TRUNC_DIV_EXPR (loc, code, type, _p0, _p1);
11907 7190 : case CEIL_DIV_EXPR:
11908 7190 : return generic_simplify_CEIL_DIV_EXPR (loc, code, type, _p0, _p1);
11909 2138147 : case FLOOR_DIV_EXPR:
11910 2138147 : return generic_simplify_FLOOR_DIV_EXPR (loc, code, type, _p0, _p1);
11911 0 : case ROUND_DIV_EXPR:
11912 0 : return generic_simplify_ROUND_DIV_EXPR (loc, code, type, _p0, _p1);
11913 3635046 : case EXACT_DIV_EXPR:
11914 3635046 : return generic_simplify_EXACT_DIV_EXPR (loc, code, type, _p0, _p1);
11915 889686 : case FLOOR_MOD_EXPR:
11916 889686 : return generic_simplify_FLOOR_MOD_EXPR (loc, code, type, _p0, _p1);
11917 6463967 : case RDIV_EXPR:
11918 6463967 : return generic_simplify_RDIV_EXPR (loc, code, type, _p0, _p1);
11919 17939535 : case LT_EXPR:
11920 17939535 : return generic_simplify_LT_EXPR (loc, code, type, _p0, _p1);
11921 9483964 : case LE_EXPR:
11922 9483964 : return generic_simplify_LE_EXPR (loc, code, type, _p0, _p1);
11923 21259761 : case GT_EXPR:
11924 21259761 : return generic_simplify_GT_EXPR (loc, code, type, _p0, _p1);
11925 6882650 : case GE_EXPR:
11926 6882650 : return generic_simplify_GE_EXPR (loc, code, type, _p0, _p1);
11927 4284 : case CEIL_MOD_EXPR:
11928 4284 : return generic_simplify_CEIL_MOD_EXPR (loc, code, type, _p0, _p1);
11929 0 : case ROUND_MOD_EXPR:
11930 0 : return generic_simplify_ROUND_MOD_EXPR (loc, code, type, _p0, _p1);
11931 2102160 : case TRUNC_MOD_EXPR:
11932 2102160 : return generic_simplify_TRUNC_MOD_EXPR (loc, code, type, _p0, _p1);
11933 1291666 : case LSHIFT_EXPR:
11934 1291666 : return generic_simplify_LSHIFT_EXPR (loc, code, type, _p0, _p1);
11935 1022974 : case RSHIFT_EXPR:
11936 1022974 : return generic_simplify_RSHIFT_EXPR (loc, code, type, _p0, _p1);
11937 7293807 : case BIT_AND_EXPR:
11938 7293807 : return generic_simplify_BIT_AND_EXPR (loc, code, type, _p0, _p1);
11939 10876544 : case TRUTH_AND_EXPR:
11940 10876544 : return generic_simplify_TRUTH_AND_EXPR (loc, code, type, _p0, _p1);
11941 9534528 : case TRUTH_OR_EXPR:
11942 9534528 : return generic_simplify_TRUTH_OR_EXPR (loc, code, type, _p0, _p1);
11943 82667 : case MIN_EXPR:
11944 82667 : return generic_simplify_MIN_EXPR (loc, code, type, _p0, _p1);
11945 393609 : case MAX_EXPR:
11946 393609 : return generic_simplify_MAX_EXPR (loc, code, type, _p0, _p1);
11947 1940 : case LROTATE_EXPR:
11948 1940 : return generic_simplify_LROTATE_EXPR (loc, code, type, _p0, _p1);
11949 2791 : case RROTATE_EXPR:
11950 2791 : return generic_simplify_RROTATE_EXPR (loc, code, type, _p0, _p1);
11951 670047 : case COMPLEX_EXPR:
11952 670047 : return generic_simplify_COMPLEX_EXPR (loc, code, type, _p0, _p1);
11953 793770 : case UNORDERED_EXPR:
11954 793770 : return generic_simplify_UNORDERED_EXPR (loc, code, type, _p0, _p1);
11955 204905 : case ORDERED_EXPR:
11956 204905 : return generic_simplify_ORDERED_EXPR (loc, code, type, _p0, _p1);
11957 758052 : case UNLT_EXPR:
11958 758052 : return generic_simplify_UNLT_EXPR (loc, code, type, _p0, _p1);
11959 1650331 : case UNLE_EXPR:
11960 1650331 : return generic_simplify_UNLE_EXPR (loc, code, type, _p0, _p1);
11961 1774730 : case UNGT_EXPR:
11962 1774730 : return generic_simplify_UNGT_EXPR (loc, code, type, _p0, _p1);
11963 434634 : case UNGE_EXPR:
11964 434634 : return generic_simplify_UNGE_EXPR (loc, code, type, _p0, _p1);
11965 377270 : case UNEQ_EXPR:
11966 377270 : return generic_simplify_UNEQ_EXPR (loc, code, type, _p0, _p1);
11967 79 : case LTGT_EXPR:
11968 79 : return generic_simplify_LTGT_EXPR (loc, code, type, _p0, _p1);
11969 3531561 : case TRUTH_ORIF_EXPR:
11970 3531561 : return generic_simplify_TRUTH_ORIF_EXPR (loc, code, type, _p0, _p1);
11971 : default:;
11972 : }
11973 : return NULL_TREE;
11974 : }
11975 :
11976 : tree
11977 836984 : generic_simplify_VEC_PERM_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1, tree _p2)
11978 : {
11979 836984 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
11980 836984 : switch (TREE_CODE (_p0))
11981 : {
11982 0 : case PLUS_EXPR:
11983 0 : {
11984 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11985 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11986 0 : switch (TREE_CODE (_p1))
11987 : {
11988 0 : case MINUS_EXPR:
11989 0 : {
11990 0 : tree _q50 = TREE_OPERAND (_p1, 0);
11991 0 : tree _q51 = TREE_OPERAND (_p1, 1);
11992 0 : switch (TREE_CODE (_p2))
11993 : {
11994 0 : case VECTOR_CST:
11995 0 : {
11996 0 : {
11997 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51, _p2 };
11998 0 : tree res = generic_simplify_653 (loc, type, _p0, _p1, _p2, captures, PLUS_EXPR, MINUS_EXPR);
11999 0 : if (res) return res;
12000 : }
12001 0 : break;
12002 : }
12003 : default:;
12004 : }
12005 : break;
12006 : }
12007 : default:;
12008 : }
12009 : break;
12010 : }
12011 0 : case MINUS_EXPR:
12012 0 : {
12013 0 : tree _q20 = TREE_OPERAND (_p0, 0);
12014 0 : tree _q21 = TREE_OPERAND (_p0, 1);
12015 0 : switch (TREE_CODE (_p1))
12016 : {
12017 0 : case PLUS_EXPR:
12018 0 : {
12019 0 : tree _q50 = TREE_OPERAND (_p1, 0);
12020 0 : tree _q51 = TREE_OPERAND (_p1, 1);
12021 0 : switch (TREE_CODE (_p2))
12022 : {
12023 0 : case VECTOR_CST:
12024 0 : {
12025 0 : {
12026 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51, _p2 };
12027 0 : tree res = generic_simplify_653 (loc, type, _p0, _p1, _p2, captures, MINUS_EXPR, PLUS_EXPR);
12028 0 : if (res) return res;
12029 : }
12030 0 : break;
12031 : }
12032 : default:;
12033 : }
12034 : break;
12035 : }
12036 : default:;
12037 : }
12038 : break;
12039 : }
12040 836984 : default:;
12041 : }
12042 836984 : switch (TREE_CODE (_p2))
12043 : {
12044 825510 : case VECTOR_CST:
12045 825510 : {
12046 825510 : {
12047 825510 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _p2 };
12048 825510 : {
12049 825510 : tree op0 = captures[0], op1 = captures[1], op2 = captures[2];
12050 825510 : machine_mode result_mode = TYPE_MODE (type);
12051 825510 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (op0));
12052 825510 : vec_perm_builder builder;
12053 825510 : if (tree_to_vec_perm_builder (&builder, op2)
12054 : )
12055 : {
12056 825498 : {
12057 825498 : poly_uint64 nelts = TYPE_VECTOR_SUBPARTS (type);
12058 825498 : poly_uint64 nelts_in = TYPE_VECTOR_SUBPARTS (TREE_TYPE (op0));
12059 825498 : bool single_arg = (op0 == op1);
12060 1441658 : vec_perm_indices sel (builder, single_arg ? 1 : 2, nelts_in);
12061 825498 : if (known_eq (nelts, nelts_in) && sel.series_p (0, 1, 0, 1)
12062 : )
12063 : {
12064 21770 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail2074;
12065 21770 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail2074;
12066 21770 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail2074;
12067 21770 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2074;
12068 21770 : {
12069 21770 : tree res_op0;
12070 21770 : res_op0 = captures[0];
12071 21770 : tree _r;
12072 21770 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
12073 21770 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1147, __FILE__, __LINE__, true);
12074 : return _r;
12075 : }
12076 772084 : next_after_fail2074:;
12077 : }
12078 : else
12079 : {
12080 803728 : if (known_eq (nelts, nelts_in) && sel.series_p (0, 1, nelts_in, 1)
12081 : )
12082 : {
12083 13 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail2075;
12084 13 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail2075;
12085 13 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail2075;
12086 13 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2075;
12087 13 : {
12088 13 : tree res_op0;
12089 13 : res_op0 = captures[1];
12090 13 : tree _r;
12091 13 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
12092 13 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1148, __FILE__, __LINE__, true);
12093 : return _r;
12094 : }
12095 772084 : next_after_fail2075:;
12096 : }
12097 : else
12098 : {
12099 803715 : {
12100 803715 : if (!single_arg)
12101 : {
12102 595053 : if (sel.all_from_input_p (0))
12103 : op1 = op0;
12104 574841 : else if (sel.all_from_input_p (1))
12105 : {
12106 33 : op0 = op1;
12107 33 : sel.rotate_inputs (1);
12108 : }
12109 574808 : else if (known_ge (poly_uint64 (sel[0]), nelts_in))
12110 : {
12111 169 : std::swap (op0, op1);
12112 169 : sel.rotate_inputs (1);
12113 : }
12114 : }
12115 803715 : gassign *def;
12116 803715 : tree cop0 = op0, cop1 = op1;
12117 803715 : if (TREE_CODE (op0) == SSA_NAME
12118 755519 : && (def = dyn_cast <gassign *> (SSA_NAME_DEF_STMT (op0)))
12119 1523264 : && gimple_assign_rhs_code (def) == CONSTRUCTOR)
12120 14246 : cop0 = gimple_assign_rhs1 (def);
12121 803715 : if (TREE_CODE (op1) == SSA_NAME
12122 733551 : && (def = dyn_cast <gassign *> (SSA_NAME_DEF_STMT (op1)))
12123 1503219 : && gimple_assign_rhs_code (def) == CONSTRUCTOR)
12124 21172 : cop1 = gimple_assign_rhs1 (def);
12125 803715 : tree t;
12126 803715 : if ((TREE_CODE (cop0) == VECTOR_CST
12127 760063 : || TREE_CODE (cop0) == CONSTRUCTOR)
12128 59730 : && (TREE_CODE (cop1) == VECTOR_CST
12129 25893 : || TREE_CODE (cop1) == CONSTRUCTOR)
12130 850636 : && (t = fold_vec_perm (type, cop0, cop1, sel))
12131 : )
12132 : {
12133 29153 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail2076;
12134 29153 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail2076;
12135 29153 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail2076;
12136 29153 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2076;
12137 29153 : {
12138 29153 : tree _r;
12139 29153 : _r = t;
12140 29153 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1149, __FILE__, __LINE__, true);
12141 : return _r;
12142 : }
12143 772084 : next_after_fail2076:;
12144 : }
12145 : else
12146 : {
12147 774562 : {
12148 774562 : bool changed = (op0 == op1 && !single_arg);
12149 774562 : tree ins = NULL_TREE;
12150 774562 : unsigned at = 0;
12151 774562 : if (op_mode != BLKmode
12152 762303 : && known_eq (nelts, nelts_in)
12153 1536712 : && (TREE_CODE (cop0) == VECTOR_CST
12154 746671 : || TREE_CODE (cop0) == CONSTRUCTOR
12155 736985 : || TREE_CODE (cop1) == VECTOR_CST
12156 704992 : || TREE_CODE (cop1) == CONSTRUCTOR))
12157 : {
12158 66276 : bool insert_first_p = sel.series_p (1, 1, nelts + 1, 1);
12159 66276 : if (insert_first_p)
12160 : {
12161 779 : at = 0;
12162 779 : if ((ins = fold_read_from_vector (cop0, sel[0])))
12163 115 : op0 = op1;
12164 : }
12165 779 : if (!insert_first_p || (!ins && maybe_eq (nelts, 2u)))
12166 : {
12167 65961 : unsigned int encoded_nelts = sel.encoding ().encoded_nelts ();
12168 141766 : for (at = 0; at < encoded_nelts; ++at)
12169 141619 : if (maybe_ne (sel[at], at))
12170 : break;
12171 65961 : if (at < encoded_nelts
12172 65961 : && (known_eq (at + 1, nelts)
12173 65961 : || sel.series_p (at + 1, 1, at + 1, 1)))
12174 : {
12175 2102 : if (known_lt (poly_uint64 (sel[at]), nelts))
12176 0 : ins = fold_read_from_vector (cop0, sel[at]);
12177 : else
12178 2102 : ins = fold_read_from_vector (cop1, sel[at] - nelts);
12179 : }
12180 : }
12181 : }
12182 774562 : if (!ins && sel.encoding () != builder)
12183 : {
12184 1048 : tree oldop2 = op2;
12185 1048 : if (sel.ninputs () == 2
12186 1048 : || can_vec_perm_const_p (result_mode, op_mode, sel, false))
12187 713 : op2 = vec_perm_indices_to_tree (TREE_TYPE (op2), sel);
12188 : else
12189 : {
12190 335 : vec_perm_indices sel2 (builder, 2, nelts);
12191 335 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false))
12192 60 : op2 = vec_perm_indices_to_tree (TREE_TYPE (op2), sel2);
12193 : else
12194 275 : op2 = vec_perm_indices_to_tree (TREE_TYPE (op2), sel);
12195 335 : }
12196 1048 : if (!operand_equal_p (op2, oldop2, 0))
12197 988 : changed = true;
12198 : }
12199 774562 : if (ins
12200 : )
12201 : {
12202 1489 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail2077;
12203 1489 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail2077;
12204 1489 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail2077;
12205 1489 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2077;
12206 1489 : {
12207 1489 : tree res_op0;
12208 1489 : res_op0 = op0;
12209 1489 : tree res_op1;
12210 1489 : res_op1 = ins;
12211 1489 : tree res_op2;
12212 1489 : res_op2 = bitsize_int (at * vector_element_bits (type));
12213 1489 : tree _r;
12214 1489 : _r = fold_build3_loc (loc, BIT_INSERT_EXPR, type, res_op0, res_op1, res_op2);
12215 1489 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1150, __FILE__, __LINE__, true);
12216 53414 : return _r;
12217 : }
12218 772084 : next_after_fail2077:;
12219 : }
12220 : else
12221 : {
12222 773073 : if (changed
12223 : )
12224 : {
12225 989 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail2078;
12226 989 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail2078;
12227 989 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail2078;
12228 989 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2078;
12229 989 : {
12230 989 : tree res_op0;
12231 989 : res_op0 = op0;
12232 989 : tree res_op1;
12233 989 : res_op1 = op1;
12234 989 : tree res_op2;
12235 989 : res_op2 = op2;
12236 989 : tree _r;
12237 989 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
12238 989 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1151, __FILE__, __LINE__, true);
12239 : return _r;
12240 : }
12241 772084 : next_after_fail2078:;
12242 : }
12243 : }
12244 : }
12245 : }
12246 : }
12247 : }
12248 : }
12249 825498 : }
12250 : }
12251 53414 : }
12252 : }
12253 772096 : break;
12254 : }
12255 783570 : default:;
12256 : }
12257 783570 : switch (TREE_CODE (_p0))
12258 : {
12259 0 : case VIEW_CONVERT_EXPR:
12260 0 : {
12261 0 : tree _q20 = TREE_OPERAND (_p0, 0);
12262 0 : switch (TREE_CODE (_q20))
12263 : {
12264 0 : case VEC_PERM_EXPR:
12265 0 : {
12266 0 : tree _q30 = TREE_OPERAND (_q20, 0);
12267 0 : tree _q31 = TREE_OPERAND (_q20, 1);
12268 0 : tree _q32 = TREE_OPERAND (_q20, 2);
12269 0 : switch (TREE_CODE (_q32))
12270 : {
12271 0 : case VECTOR_CST:
12272 0 : {
12273 0 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
12274 : {
12275 0 : switch (TREE_CODE (_p2))
12276 : {
12277 0 : case VECTOR_CST:
12278 0 : {
12279 0 : {
12280 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q32, _p2 };
12281 0 : if (TYPE_VECTOR_SUBPARTS (type).is_constant ()
12282 : )
12283 : {
12284 0 : {
12285 0 : machine_mode result_mode = TYPE_MODE (type);
12286 0 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (captures[2]));
12287 0 : int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
12288 0 : vec_perm_indices sel0, sel1;
12289 0 : if (tree_to_vec_perm_indices (&sel0, captures[2], captures[3], captures[4])
12290 0 : && tree_to_vec_perm_indices (&sel1, captures[0], captures[0], captures[5])
12291 0 : && TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0])))
12292 0 : == TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[1])))
12293 : )
12294 : {
12295 0 : {
12296 0 : vec_perm_builder builder2 (nelts, nelts, 1);
12297 0 : for (int i = 0; i < nelts; i++)
12298 0 : builder2.quick_push (sel0[sel1[i].to_constant ()]);
12299 0 : vec_perm_indices sel2 (builder2, 2, nelts);
12300 0 : tree op0 = NULL_TREE;
12301 0 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false)
12302 0 : || (single_use (captures[0])
12303 0 : ? (!can_vec_perm_const_p (result_mode, op_mode, sel0, true)
12304 0 : || !can_vec_perm_const_p (result_mode, op_mode, sel1, true))
12305 : : !can_vec_perm_const_p (result_mode, op_mode, sel1, true)))
12306 0 : op0 = vec_perm_indices_to_tree (TREE_TYPE (captures[5]), sel2);
12307 0 : if (op0
12308 : )
12309 : {
12310 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail2079;
12311 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2079;
12312 0 : {
12313 0 : tree res_op0;
12314 0 : {
12315 0 : tree _o1[3], _r1;
12316 0 : _o1[0] = captures[2];
12317 0 : _o1[1] = captures[3];
12318 0 : _o1[2] = op0;
12319 0 : _r1 = fold_build3_loc (loc, VEC_PERM_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1], _o1[2]);
12320 0 : res_op0 = _r1;
12321 : }
12322 0 : tree _r;
12323 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
12324 0 : if (TREE_SIDE_EFFECTS (captures[4]))
12325 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
12326 0 : if (TREE_SIDE_EFFECTS (captures[5]))
12327 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
12328 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1152, __FILE__, __LINE__, true);
12329 0 : return _r;
12330 : }
12331 0 : next_after_fail2079:;
12332 : }
12333 0 : }
12334 : }
12335 0 : }
12336 : }
12337 : }
12338 0 : break;
12339 : }
12340 : default:;
12341 : }
12342 : }
12343 : break;
12344 : }
12345 : default:;
12346 : }
12347 : break;
12348 : }
12349 : default:;
12350 : }
12351 : break;
12352 : }
12353 0 : case VEC_PERM_EXPR:
12354 0 : {
12355 0 : tree _q20 = TREE_OPERAND (_p0, 0);
12356 0 : tree _q21 = TREE_OPERAND (_p0, 1);
12357 0 : tree _q22 = TREE_OPERAND (_p0, 2);
12358 0 : switch (TREE_CODE (_q22))
12359 : {
12360 0 : case VECTOR_CST:
12361 0 : {
12362 0 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
12363 : {
12364 0 : switch (TREE_CODE (_p2))
12365 : {
12366 0 : case VECTOR_CST:
12367 0 : {
12368 0 : {
12369 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _q22, _p2 };
12370 0 : if (TYPE_VECTOR_SUBPARTS (type).is_constant ()
12371 : )
12372 : {
12373 0 : {
12374 0 : machine_mode result_mode = TYPE_MODE (type);
12375 0 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (captures[2]));
12376 0 : int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
12377 0 : vec_perm_indices sel0, sel1;
12378 0 : if (tree_to_vec_perm_indices (&sel0, captures[2], captures[3], captures[4])
12379 0 : && tree_to_vec_perm_indices (&sel1, captures[0], captures[0], captures[5])
12380 0 : && TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0])))
12381 0 : == TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[1])))
12382 : )
12383 : {
12384 0 : {
12385 0 : vec_perm_builder builder2 (nelts, nelts, 1);
12386 0 : for (int i = 0; i < nelts; i++)
12387 0 : builder2.quick_push (sel0[sel1[i].to_constant ()]);
12388 0 : vec_perm_indices sel2 (builder2, 2, nelts);
12389 0 : tree op0 = NULL_TREE;
12390 0 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false)
12391 0 : || (single_use (captures[0])
12392 0 : ? (!can_vec_perm_const_p (result_mode, op_mode, sel0, true)
12393 0 : || !can_vec_perm_const_p (result_mode, op_mode, sel1, true))
12394 : : !can_vec_perm_const_p (result_mode, op_mode, sel1, true)))
12395 0 : op0 = vec_perm_indices_to_tree (TREE_TYPE (captures[5]), sel2);
12396 0 : if (op0
12397 : )
12398 : {
12399 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail2080;
12400 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2080;
12401 0 : {
12402 0 : tree res_op0;
12403 0 : {
12404 0 : tree _o1[3], _r1;
12405 0 : _o1[0] = captures[2];
12406 0 : _o1[1] = captures[3];
12407 0 : _o1[2] = op0;
12408 0 : _r1 = fold_build3_loc (loc, VEC_PERM_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1], _o1[2]);
12409 0 : res_op0 = _r1;
12410 : }
12411 0 : tree _r;
12412 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
12413 0 : if (TREE_SIDE_EFFECTS (captures[4]))
12414 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
12415 0 : if (TREE_SIDE_EFFECTS (captures[5]))
12416 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
12417 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1152, __FILE__, __LINE__, true);
12418 0 : return _r;
12419 : }
12420 0 : next_after_fail2080:;
12421 : }
12422 0 : }
12423 : }
12424 0 : }
12425 : }
12426 : }
12427 0 : break;
12428 : }
12429 : default:;
12430 : }
12431 : }
12432 : break;
12433 : }
12434 : default:;
12435 : }
12436 : break;
12437 : }
12438 783570 : default:;
12439 : }
12440 783570 : if (tree_vec_same_elem_p (_p0))
12441 : {
12442 13971 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
12443 : {
12444 0 : {
12445 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p2 };
12446 0 : if (types_match (type, TREE_TYPE (captures[0]))
12447 : )
12448 : {
12449 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2081;
12450 0 : {
12451 0 : tree _r;
12452 0 : _r = captures[0];
12453 0 : if (TREE_SIDE_EFFECTS (captures[1]))
12454 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
12455 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1153, __FILE__, __LINE__, true);
12456 : return _r;
12457 : }
12458 0 : next_after_fail2081:;
12459 : }
12460 : else
12461 : {
12462 0 : {
12463 0 : tree elem = uniform_vector_p (captures[0]);
12464 0 : if (elem
12465 : )
12466 : {
12467 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2082;
12468 0 : {
12469 0 : tree _r;
12470 0 : _r = build_vector_from_val (type, elem);
12471 0 : if (TREE_SIDE_EFFECTS (captures[0]))
12472 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
12473 0 : if (TREE_SIDE_EFFECTS (captures[1]))
12474 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
12475 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1154, __FILE__, __LINE__, true);
12476 : return _r;
12477 : }
12478 0 : next_after_fail2082:;
12479 : }
12480 : }
12481 : }
12482 : }
12483 : }
12484 : }
12485 783570 : switch (TREE_CODE (_p1))
12486 : {
12487 0 : case VEC_PERM_EXPR:
12488 0 : {
12489 0 : tree _q30 = TREE_OPERAND (_p1, 0);
12490 0 : tree _q31 = TREE_OPERAND (_p1, 1);
12491 0 : tree _q32 = TREE_OPERAND (_p1, 2);
12492 0 : switch (TREE_CODE (_q32))
12493 : {
12494 0 : case VECTOR_CST:
12495 0 : {
12496 0 : switch (TREE_CODE (_p2))
12497 : {
12498 0 : case VECTOR_CST:
12499 0 : {
12500 0 : {
12501 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32, _p2 };
12502 0 : if (TYPE_VECTOR_SUBPARTS (type).is_constant ()
12503 : )
12504 : {
12505 0 : {
12506 0 : machine_mode result_mode = TYPE_MODE (type);
12507 0 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (captures[2]));
12508 0 : int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
12509 0 : vec_perm_indices sel0, sel1;
12510 0 : if (tree_to_vec_perm_indices (&sel0, captures[2], captures[3], captures[4])
12511 0 : && tree_to_vec_perm_indices (&sel1, captures[0], captures[1], captures[5])
12512 : )
12513 : {
12514 0 : {
12515 0 : bool use_1 = false, use_2 = false;
12516 0 : vec_perm_builder builder2 (nelts, nelts, 2);
12517 0 : for (int i = 0; i < nelts; i++)
12518 : {
12519 0 : if (known_lt ((poly_uint64)sel1[i], sel1.nelts_per_input ()))
12520 0 : builder2.quick_push (sel1[i]);
12521 : else
12522 : {
12523 0 : poly_uint64 j = sel0[(sel1[i] - sel1.nelts_per_input ())
12524 0 : .to_constant ()];
12525 0 : if (known_lt (j, sel0.nelts_per_input ()))
12526 : use_1 = true;
12527 : else
12528 : {
12529 0 : use_2 = true;
12530 0 : j -= sel0.nelts_per_input ();
12531 : }
12532 0 : builder2.quick_push (j + sel1.nelts_per_input ());
12533 : }
12534 : }
12535 0 : if (use_1 ^ use_2
12536 : )
12537 : {
12538 0 : {
12539 0 : vec_perm_indices sel2 (builder2, 2, nelts);
12540 0 : tree op0 = NULL_TREE;
12541 0 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false)
12542 0 : || (single_use (captures[1])
12543 0 : ? (!can_vec_perm_const_p (result_mode, op_mode, sel0, true)
12544 0 : || !can_vec_perm_const_p (result_mode, op_mode, sel1, true))
12545 : : !can_vec_perm_const_p (result_mode, op_mode, sel1, true)))
12546 0 : op0 = vec_perm_indices_to_tree (TREE_TYPE (captures[5]), sel2);
12547 0 : if (op0
12548 : )
12549 : {
12550 0 : if (use_1
12551 : )
12552 : {
12553 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail2083;
12554 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2083;
12555 0 : {
12556 0 : tree res_op0;
12557 0 : res_op0 = captures[0];
12558 0 : tree res_op1;
12559 0 : res_op1 = captures[2];
12560 0 : tree res_op2;
12561 0 : res_op2 = op0;
12562 0 : tree _r;
12563 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
12564 0 : if (TREE_SIDE_EFFECTS (captures[3]))
12565 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
12566 0 : if (TREE_SIDE_EFFECTS (captures[4]))
12567 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
12568 0 : if (TREE_SIDE_EFFECTS (captures[5]))
12569 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
12570 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1155, __FILE__, __LINE__, true);
12571 : return _r;
12572 : }
12573 0 : next_after_fail2083:;
12574 : }
12575 : else
12576 : {
12577 0 : if (use_2
12578 : )
12579 : {
12580 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail2084;
12581 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2084;
12582 0 : {
12583 0 : tree res_op0;
12584 0 : res_op0 = captures[0];
12585 0 : tree res_op1;
12586 0 : res_op1 = captures[3];
12587 0 : tree res_op2;
12588 0 : res_op2 = op0;
12589 0 : tree _r;
12590 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
12591 0 : if (TREE_SIDE_EFFECTS (captures[2]))
12592 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
12593 0 : if (TREE_SIDE_EFFECTS (captures[4]))
12594 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
12595 0 : if (TREE_SIDE_EFFECTS (captures[5]))
12596 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
12597 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1156, __FILE__, __LINE__, true);
12598 : return _r;
12599 : }
12600 0 : next_after_fail2084:;
12601 : }
12602 : }
12603 : }
12604 0 : }
12605 : }
12606 0 : }
12607 : }
12608 0 : }
12609 : }
12610 : }
12611 0 : break;
12612 : }
12613 : default:;
12614 : }
12615 : break;
12616 : }
12617 : default:;
12618 : }
12619 : break;
12620 : }
12621 783570 : default:;
12622 : }
12623 783570 : switch (TREE_CODE (_p0))
12624 : {
12625 0 : case VEC_PERM_EXPR:
12626 0 : {
12627 0 : tree _q20 = TREE_OPERAND (_p0, 0);
12628 0 : tree _q21 = TREE_OPERAND (_p0, 1);
12629 0 : tree _q22 = TREE_OPERAND (_p0, 2);
12630 0 : switch (TREE_CODE (_q22))
12631 : {
12632 0 : case VECTOR_CST:
12633 0 : {
12634 0 : switch (TREE_CODE (_p2))
12635 : {
12636 0 : case VECTOR_CST:
12637 0 : {
12638 0 : {
12639 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _p2 };
12640 0 : if (TYPE_VECTOR_SUBPARTS (type).is_constant ()
12641 : )
12642 : {
12643 0 : {
12644 0 : machine_mode result_mode = TYPE_MODE (type);
12645 0 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (captures[1]));
12646 0 : int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
12647 0 : vec_perm_indices sel0, sel1;
12648 0 : if (tree_to_vec_perm_indices (&sel0, captures[1], captures[2], captures[3])
12649 0 : && tree_to_vec_perm_indices (&sel1, captures[0], captures[4], captures[5])
12650 : )
12651 : {
12652 0 : {
12653 0 : bool use_1 = false, use_2 = false;
12654 0 : vec_perm_builder builder2 (nelts, nelts, 2);
12655 0 : for (int i = 0; i < nelts; i++)
12656 : {
12657 0 : if (known_ge ((poly_uint64)sel1[i], sel1.nelts_per_input ()))
12658 0 : builder2.quick_push (sel1[i]);
12659 : else
12660 : {
12661 0 : poly_uint64 j = sel0[sel1[i].to_constant ()];
12662 0 : if (known_lt (j, sel0.nelts_per_input ()))
12663 : use_1 = true;
12664 : else
12665 : {
12666 0 : use_2 = true;
12667 0 : j -= sel0.nelts_per_input ();
12668 : }
12669 0 : builder2.quick_push (j);
12670 : }
12671 : }
12672 0 : if (use_1 ^ use_2
12673 : )
12674 : {
12675 0 : {
12676 0 : vec_perm_indices sel2 (builder2, 2, nelts);
12677 0 : tree op0 = NULL_TREE;
12678 0 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false)
12679 0 : || (single_use (captures[0])
12680 0 : ? (!can_vec_perm_const_p (result_mode, op_mode, sel0, true)
12681 0 : || !can_vec_perm_const_p (result_mode, op_mode, sel1, true))
12682 : : !can_vec_perm_const_p (result_mode, op_mode, sel1, true)))
12683 0 : op0 = vec_perm_indices_to_tree (TREE_TYPE (captures[5]), sel2);
12684 0 : if (op0
12685 : )
12686 : {
12687 0 : if (use_1
12688 : )
12689 : {
12690 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail2085;
12691 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2085;
12692 0 : {
12693 0 : tree res_op0;
12694 0 : res_op0 = captures[1];
12695 0 : tree res_op1;
12696 0 : res_op1 = captures[4];
12697 0 : tree res_op2;
12698 0 : res_op2 = op0;
12699 0 : tree _r;
12700 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
12701 0 : if (TREE_SIDE_EFFECTS (captures[2]))
12702 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
12703 0 : if (TREE_SIDE_EFFECTS (captures[3]))
12704 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
12705 0 : if (TREE_SIDE_EFFECTS (captures[5]))
12706 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
12707 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1157, __FILE__, __LINE__, true);
12708 : return _r;
12709 : }
12710 0 : next_after_fail2085:;
12711 : }
12712 : else
12713 : {
12714 0 : if (use_2
12715 : )
12716 : {
12717 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail2086;
12718 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2086;
12719 0 : {
12720 0 : tree res_op0;
12721 0 : res_op0 = captures[2];
12722 0 : tree res_op1;
12723 0 : res_op1 = captures[4];
12724 0 : tree res_op2;
12725 0 : res_op2 = op0;
12726 0 : tree _r;
12727 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
12728 0 : if (TREE_SIDE_EFFECTS (captures[1]))
12729 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
12730 0 : if (TREE_SIDE_EFFECTS (captures[3]))
12731 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
12732 0 : if (TREE_SIDE_EFFECTS (captures[5]))
12733 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
12734 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1158, __FILE__, __LINE__, true);
12735 : return _r;
12736 : }
12737 0 : next_after_fail2086:;
12738 : }
12739 : }
12740 : }
12741 0 : }
12742 : }
12743 0 : }
12744 : }
12745 0 : }
12746 : }
12747 : }
12748 0 : break;
12749 : }
12750 0 : default:;
12751 : }
12752 0 : switch (TREE_CODE (_p1))
12753 : {
12754 0 : case VEC_PERM_EXPR:
12755 0 : {
12756 0 : tree _q60 = TREE_OPERAND (_p1, 0);
12757 0 : tree _q61 = TREE_OPERAND (_p1, 1);
12758 0 : tree _q62 = TREE_OPERAND (_p1, 2);
12759 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
12760 : {
12761 0 : switch (TREE_CODE (_q62))
12762 : {
12763 0 : case VECTOR_CST:
12764 0 : {
12765 0 : switch (TREE_CODE (_p2))
12766 : {
12767 0 : case VECTOR_CST:
12768 0 : {
12769 0 : {
12770 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60, _q61, _p2 };
12771 0 : tree res = generic_simplify_654 (loc, type, _p0, _p1, _p2, captures);
12772 0 : if (res) return res;
12773 : }
12774 0 : break;
12775 : }
12776 : default:;
12777 : }
12778 : break;
12779 : }
12780 : default:;
12781 : }
12782 : }
12783 : break;
12784 : }
12785 : default:;
12786 : }
12787 : break;
12788 : }
12789 : default:;
12790 : }
12791 : break;
12792 : }
12793 0 : case VIEW_CONVERT_EXPR:
12794 0 : {
12795 0 : tree _q20 = TREE_OPERAND (_p0, 0);
12796 0 : switch (TREE_CODE (_q20))
12797 : {
12798 0 : case VEC_PERM_EXPR:
12799 0 : {
12800 0 : tree _q30 = TREE_OPERAND (_q20, 0);
12801 0 : tree _q31 = TREE_OPERAND (_q20, 1);
12802 0 : tree _q32 = TREE_OPERAND (_q20, 2);
12803 0 : switch (TREE_CODE (_q32))
12804 : {
12805 0 : case VECTOR_CST:
12806 0 : {
12807 0 : switch (TREE_CODE (_p1))
12808 : {
12809 0 : case VIEW_CONVERT_EXPR:
12810 0 : {
12811 0 : tree _q70 = TREE_OPERAND (_p1, 0);
12812 0 : switch (TREE_CODE (_q70))
12813 : {
12814 0 : case VEC_PERM_EXPR:
12815 0 : {
12816 0 : tree _q80 = TREE_OPERAND (_q70, 0);
12817 0 : tree _q81 = TREE_OPERAND (_q70, 1);
12818 0 : tree _q82 = TREE_OPERAND (_q70, 2);
12819 0 : if ((_q82 == _q32 && ! TREE_SIDE_EFFECTS (_q82)) || (operand_equal_p (_q82, _q32, 0) && types_match (_q82, _q32)))
12820 : {
12821 0 : switch (TREE_CODE (_q82))
12822 : {
12823 0 : case VECTOR_CST:
12824 0 : {
12825 0 : switch (TREE_CODE (_p2))
12826 : {
12827 0 : case VECTOR_CST:
12828 0 : {
12829 0 : {
12830 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q30, _q31, _q32, _q80, _q81, _p2 };
12831 0 : tree res = generic_simplify_654 (loc, type, _p0, _p1, _p2, captures);
12832 0 : if (res) return res;
12833 : }
12834 0 : break;
12835 : }
12836 : default:;
12837 : }
12838 : break;
12839 : }
12840 : default:;
12841 : }
12842 : }
12843 : break;
12844 : }
12845 : default:;
12846 : }
12847 : break;
12848 : }
12849 : default:;
12850 : }
12851 : break;
12852 : }
12853 : default:;
12854 : }
12855 : break;
12856 : }
12857 : default:;
12858 : }
12859 : break;
12860 : }
12861 : default:;
12862 : }
12863 : return NULL_TREE;
12864 : }
12865 : #pragma GCC diagnostic pop
|
