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 112464302 : tree_bit_xor_cst (tree t, tree *res_ops)
11 : {
12 112464302 : const tree type = TREE_TYPE (t);
13 112464302 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 112464302 : if (TREE_SIDE_EFFECTS (t)) return false;
15 112464302 : switch (TREE_CODE (t))
16 : {
17 93178 : case BIT_XOR_EXPR:
18 93178 : {
19 93178 : tree _p0 = TREE_OPERAND (t, 0);
20 93178 : tree _p1 = TREE_OPERAND (t, 1);
21 93178 : if (uniform_integer_cst_p (_p1))
22 : {
23 1601 : {
24 1601 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
25 1601 : {
26 1601 : res_ops[0] = captures[0];
27 1601 : res_ops[1] = captures[1];
28 1601 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 4, __FILE__, __LINE__, false);
29 1601 : return true;
30 : }
31 : }
32 : }
33 : break;
34 : }
35 : default:;
36 : }
37 : return false;
38 : }
39 :
40 : bool
41 77743013 : tree_with_possible_nonzero_bits_1 (tree t)
42 : {
43 77743013 : const tree type = TREE_TYPE (t);
44 77743013 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
45 77743013 : if (TREE_SIDE_EFFECTS (t)) return false;
46 77743013 : switch (TREE_CODE (t))
47 : {
48 16589038 : case INTEGER_CST:
49 16589038 : {
50 16589038 : {
51 16589038 : tree captures[1] ATTRIBUTE_UNUSED = { t };
52 16589038 : {
53 16589038 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 32, __FILE__, __LINE__, false);
54 16589038 : return true;
55 : }
56 : }
57 0 : break;
58 : }
59 0 : case POLY_INT_CST:
60 0 : {
61 0 : {
62 0 : tree captures[1] ATTRIBUTE_UNUSED = { t };
63 0 : {
64 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 33, __FILE__, __LINE__, false);
65 0 : return true;
66 : }
67 : }
68 26220177 : break;
69 : }
70 26220177 : case SSA_NAME:
71 26220177 : {
72 26220177 : {
73 26220177 : tree captures[1] ATTRIBUTE_UNUSED = { t };
74 26220177 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
75 : )
76 : {
77 25704447 : {
78 25704447 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 34, __FILE__, __LINE__, false);
79 25704447 : return true;
80 : }
81 : }
82 : }
83 : break;
84 : }
85 : default:;
86 : }
87 : return false;
88 : }
89 :
90 : bool
91 2335 : tree_max_value (tree t)
92 : {
93 2335 : const tree type = TREE_TYPE (t);
94 2335 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
95 2335 : if (TREE_SIDE_EFFECTS (t)) return false;
96 2327 : if (uniform_integer_cst_p (t))
97 : {
98 2062 : {
99 2062 : {
100 2062 : tree int_cst = uniform_integer_cst_p (t);
101 2062 : tree itype = TREE_TYPE (int_cst);
102 4124 : if ((INTEGRAL_TYPE_P (itype)
103 17 : || POINTER_TYPE_P (itype))
104 4141 : && wi::eq_p (wi::to_wide (int_cst), wi::max_value (itype))
105 : )
106 : {
107 24 : {
108 24 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 42, __FILE__, __LINE__, false);
109 24 : return true;
110 : }
111 : }
112 : }
113 : }
114 : }
115 : return false;
116 : }
117 :
118 : tree
119 72220 : generic_simplify_5 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
120 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
121 : const enum tree_code ARG_UNUSED (op))
122 : {
123 72220 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
124 72220 : {
125 72220 : bool wascmp0, wascmp1;
126 72220 : if (bitwise_inverted_equal_p (captures[1], captures[3], wascmp0)
127 1194 : && bitwise_inverted_equal_p (captures[0], captures[2], wascmp1)
128 72224 : && ((!wascmp0 && !wascmp1)
129 0 : || element_precision (type) == 1)
130 : )
131 : {
132 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail76;
133 4 : {
134 4 : tree res_op0;
135 4 : res_op0 = captures[0];
136 4 : tree res_op1;
137 4 : res_op1 = captures[3];
138 4 : tree _r;
139 4 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
140 4 : if (TREE_SIDE_EFFECTS (captures[1]))
141 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
142 4 : if (TREE_SIDE_EFFECTS (captures[2]))
143 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
144 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 53, __FILE__, __LINE__, true);
145 4 : return _r;
146 : }
147 0 : next_after_fail76:;
148 : }
149 : }
150 72216 : return NULL_TREE;
151 : }
152 :
153 : tree
154 1 : generic_simplify_16 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
155 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
156 : {
157 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
158 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail91;
159 1 : {
160 1 : tree res_op0;
161 1 : res_op0 = captures[0];
162 1 : tree _r;
163 1 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
164 1 : if (TREE_SIDE_EFFECTS (captures[1]))
165 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
166 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 64, __FILE__, __LINE__, true);
167 : return _r;
168 : }
169 0 : next_after_fail91:;
170 0 : return NULL_TREE;
171 : }
172 :
173 : tree
174 8 : generic_simplify_22 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
175 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
176 : {
177 8 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
178 8 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
179 : )
180 : {
181 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail97;
182 8 : {
183 8 : tree res_op0;
184 8 : {
185 8 : tree _o1[2], _r1;
186 8 : _o1[0] = captures[1];
187 8 : {
188 8 : tree _o2[1], _r2;
189 8 : _o2[0] = captures[0];
190 8 : _r2 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
191 8 : _o1[1] = _r2;
192 : }
193 8 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
194 8 : res_op0 = _r1;
195 : }
196 8 : tree _r;
197 8 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
198 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 70, __FILE__, __LINE__, true);
199 8 : return _r;
200 : }
201 0 : next_after_fail97:;
202 : }
203 : return NULL_TREE;
204 : }
205 :
206 : tree
207 1980612 : generic_simplify_32 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
208 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
209 : const enum tree_code ARG_UNUSED (bitop))
210 : {
211 1980612 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
212 1980612 : if (((TREE_CODE (captures[3]) == INTEGER_CST
213 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
214 0 : && (int_fits_type_p (captures[3], TREE_TYPE (captures[1]))
215 0 : || tree_nop_conversion_p (TREE_TYPE (captures[1]), type)))
216 1980612 : || types_match (captures[1], captures[3]))
217 1847083 : && !POINTER_TYPE_P (TREE_TYPE (captures[1]))
218 1846820 : && !VECTOR_TYPE_P (TREE_TYPE (captures[1]))
219 1846757 : && TREE_CODE (TREE_TYPE (captures[1])) != OFFSET_TYPE
220 1846757 : && (bitop != BIT_AND_EXPR ||
221 :
222 : )
223 1980612 : && (
224 1076467 : TYPE_PRECISION (TREE_TYPE (captures[1])) < TYPE_PRECISION (type)
225 : || (
226 :
227 : && TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (type))
228 987125 : || GET_MODE_CLASS (TYPE_MODE (type)) != MODE_INT
229 987125 : || !type_has_mode_precision_p (type)
230 987125 : || (
231 :
232 : && TREE_CODE (captures[3]) != INTEGER_CST
233 : && tree_nop_conversion_p (type, TREE_TYPE (captures[1]))
234 : && single_use (captures[0])
235 : && single_use (captures[2])))
236 : )
237 : {
238 89342 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail107;
239 89342 : {
240 89342 : tree res_op0;
241 89342 : {
242 89342 : tree _o1[2], _r1;
243 89342 : _o1[0] = captures[1];
244 89342 : {
245 89342 : tree _o2[1], _r2;
246 89342 : _o2[0] = captures[3];
247 89342 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
248 : {
249 51348 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
250 : }
251 : else
252 : _r2 = _o2[0];
253 89342 : _o1[1] = _r2;
254 : }
255 89342 : _r1 = fold_build2_loc (loc, bitop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
256 89342 : res_op0 = _r1;
257 : }
258 89342 : tree _r;
259 89342 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
260 89342 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 80, __FILE__, __LINE__, true);
261 89342 : return _r;
262 : }
263 0 : next_after_fail107:;
264 : }
265 : return NULL_TREE;
266 : }
267 :
268 : tree
269 18 : generic_simplify_46 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
270 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
271 : const enum tree_code ARG_UNUSED (op))
272 : {
273 18 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
274 36 : if (INTEGRAL_TYPE_P (type)
275 54 : && (tree_nonzero_bits (captures[0]) & tree_nonzero_bits (captures[2])) == 0
276 : )
277 : {
278 0 : {
279 0 : tree t = type;
280 0 : if (!TYPE_OVERFLOW_WRAPS (t))
281 0 : t = unsigned_type_for (t);
282 0 : wide_int c = wi::add (wi::to_wide (captures[3]), 1);
283 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail124;
284 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail124;
285 0 : {
286 0 : tree res_op0;
287 0 : {
288 0 : tree _o1[2], _r1;
289 0 : {
290 0 : tree _o2[1], _r2;
291 0 : _o2[0] = captures[2];
292 0 : if (TREE_TYPE (_o2[0]) != t)
293 : {
294 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, t, _o2[0]);
295 : }
296 : else
297 : _r2 = _o2[0];
298 0 : _o1[0] = _r2;
299 : }
300 0 : _o1[1] = wide_int_to_tree (t, c);
301 0 : _r1 = fold_build2_loc (loc, MULT_EXPR, t, _o1[0], _o1[1]);
302 0 : res_op0 = _r1;
303 : }
304 0 : tree _r;
305 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
306 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 90, __FILE__, __LINE__, true);
307 0 : return _r;
308 : }
309 0 : next_after_fail124:;
310 0 : }
311 : }
312 : return NULL_TREE;
313 : }
314 :
315 : tree
316 66 : generic_simplify_56 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
317 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
318 : {
319 66 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
320 66 : if (ANY_INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_UNDEFINED (type)
321 : )
322 : {
323 66 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail137;
324 66 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail137;
325 66 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail137;
326 66 : {
327 66 : tree res_op0;
328 66 : res_op0 = captures[0];
329 66 : tree _r;
330 66 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
331 66 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 105, __FILE__, __LINE__, true);
332 66 : return _r;
333 : }
334 : next_after_fail137:;
335 : }
336 : return NULL_TREE;
337 : }
338 :
339 : tree
340 2 : generic_simplify_60 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
341 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
342 : {
343 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
344 2 : if (!TYPE_OVERFLOW_SANITIZED (type) && !TYPE_OVERFLOW_TRAPS (type)
345 2 : && !TYPE_SATURATING (type) && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[0]))
346 2 : && !TYPE_OVERFLOW_TRAPS (TREE_TYPE (captures[0]))
347 4 : && !TYPE_SATURATING (TREE_TYPE (captures[0]))
348 : )
349 : {
350 2 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail141;
351 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail141;
352 2 : {
353 2 : tree res_op0;
354 2 : {
355 2 : tree _o1[1], _r1;
356 2 : {
357 2 : tree _o2[2], _r2;
358 2 : _o2[0] = captures[1];
359 2 : _o2[1] = captures[2];
360 2 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
361 2 : _o1[0] = _r2;
362 : }
363 2 : if (TREE_TYPE (_o1[0]) != type)
364 : {
365 1 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
366 : }
367 : else
368 : _r1 = _o1[0];
369 2 : res_op0 = _r1;
370 : }
371 2 : tree _r;
372 2 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
373 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 109, __FILE__, __LINE__, true);
374 2 : return _r;
375 : }
376 : next_after_fail141:;
377 : }
378 : return NULL_TREE;
379 : }
380 :
381 : tree
382 2235719 : generic_simplify_71 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
383 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
384 : const enum tree_code ARG_UNUSED (plusminus))
385 : {
386 2235719 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
387 2235719 : if (!TYPE_SATURATING (type)
388 2235719 : && (!FLOAT_TYPE_P (type) || flag_associative_math)
389 : )
390 : {
391 110 : if (!ANY_INTEGRAL_TYPE_P (type)
392 2235495 : || TYPE_OVERFLOW_WRAPS (type)
393 3938789 : || (INTEGRAL_TYPE_P (type)
394 1703184 : && tree_expr_nonzero_p (captures[1])
395 3144170 : && expr_not_equal_to (captures[1], wi::minus_one (TYPE_PRECISION (type)),
396 : gimple_match_ctx (captures[0])))
397 : )
398 : {
399 1440847 : if (single_use (captures[0]) || single_use (captures[3])
400 : )
401 : {
402 1440847 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail160;
403 1440847 : {
404 1440847 : tree res_op0;
405 1440847 : {
406 1440847 : tree _o1[2], _r1;
407 1440847 : _o1[0] = captures[2];
408 1440847 : _o1[1] = captures[4];
409 1440847 : _r1 = fold_build2_loc (loc, plusminus, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
410 1440847 : res_op0 = _r1;
411 : }
412 1440847 : tree res_op1;
413 1440847 : res_op1 = captures[1];
414 1440847 : tree _r;
415 1440847 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
416 1440847 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 128, __FILE__, __LINE__, true);
417 1440847 : return _r;
418 : }
419 0 : next_after_fail160:;
420 : }
421 : else
422 : {
423 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail161;
424 : {
425 : tree res_op0;
426 : {
427 : tree _o1[2], _r1;
428 : _o1[0] = captures[2];
429 : _o1[1] = captures[4];
430 : _r1 = fold_build2_loc (loc, plusminus, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
431 : res_op0 = _r1;
432 : }
433 : tree res_op1;
434 : res_op1 = captures[1];
435 : tree _r;
436 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
437 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 129, __FILE__, __LINE__, true);
438 : return _r;
439 : }
440 : next_after_fail161:;
441 : }
442 : }
443 : }
444 : return NULL_TREE;
445 : }
446 :
447 : tree
448 4 : generic_simplify_82 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
449 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
450 : const combined_fn ARG_UNUSED (POPCOUNT))
451 : {
452 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
453 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail173;
454 4 : {
455 4 : tree res_op0;
456 4 : {
457 4 : tree _o1[1], _r1;
458 4 : _o1[0] = captures[2];
459 4 : _r1 = maybe_build_call_expr_loc (loc, POPCOUNT, type, 1, _o1[0]);
460 4 : if (!_r1)
461 0 : goto next_after_fail173;
462 4 : res_op0 = _r1;
463 : }
464 4 : tree res_op1;
465 4 : {
466 4 : tree _o1[1], _r1;
467 4 : _o1[0] = captures[3];
468 4 : _r1 = maybe_build_call_expr_loc (loc, POPCOUNT, type, 1, _o1[0]);
469 4 : if (!_r1)
470 0 : goto next_after_fail173;
471 4 : res_op1 = _r1;
472 : }
473 4 : tree _r;
474 4 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
475 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 141, __FILE__, __LINE__, true);
476 : return _r;
477 : }
478 : next_after_fail173:;
479 : return NULL_TREE;
480 : }
481 :
482 : tree
483 2 : generic_simplify_90 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
484 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
485 : {
486 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
487 2 : if (!TYPE_OVERFLOW_SANITIZED (type) && !TYPE_OVERFLOW_TRAPS (type)
488 2 : && !TYPE_SATURATING (type) && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[2]))
489 2 : && !TYPE_OVERFLOW_TRAPS (TREE_TYPE (captures[2]))
490 4 : && !TYPE_SATURATING (TREE_TYPE (captures[2]))
491 : )
492 : {
493 2 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail181;
494 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail181;
495 2 : {
496 2 : tree res_op0;
497 2 : {
498 2 : tree _o1[1], _r1;
499 2 : {
500 2 : tree _o2[2], _r2;
501 2 : _o2[0] = captures[0];
502 2 : _o2[1] = captures[1];
503 2 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
504 2 : _o1[0] = _r2;
505 : }
506 2 : if (TREE_TYPE (_o1[0]) != type)
507 : {
508 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
509 : }
510 : else
511 : _r1 = _o1[0];
512 2 : res_op0 = _r1;
513 : }
514 2 : tree _r;
515 2 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
516 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 149, __FILE__, __LINE__, true);
517 2 : return _r;
518 : }
519 : next_after_fail181:;
520 : }
521 : return NULL_TREE;
522 : }
523 :
524 : tree
525 0 : generic_simplify_100 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
526 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
527 : {
528 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
529 0 : if (!TYPE_SATURATING (type)
530 : )
531 : {
532 0 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
533 0 : && !FIXED_POINT_TYPE_P (type)
534 : )
535 : {
536 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail193;
537 0 : {
538 0 : tree res_op0;
539 0 : res_op0 = captures[1];
540 0 : tree res_op1;
541 0 : res_op1 = captures[2];
542 0 : tree _r;
543 0 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
544 0 : if (TREE_SIDE_EFFECTS (captures[0]))
545 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
546 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 160, __FILE__, __LINE__, true);
547 0 : return _r;
548 : }
549 0 : next_after_fail193:;
550 : }
551 : }
552 : return NULL_TREE;
553 : }
554 :
555 : tree
556 0 : generic_simplify_107 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
557 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
558 : {
559 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
560 0 : if (VECTOR_TYPE_P (type)
561 0 : && known_eq (TYPE_VECTOR_SUBPARTS (type),
562 : TYPE_VECTOR_SUBPARTS (TREE_TYPE (captures[3])))
563 0 : && (TYPE_MODE (TREE_TYPE (type))
564 0 : == TYPE_MODE (TREE_TYPE (TREE_TYPE (captures[3]))))
565 : )
566 : {
567 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail204;
568 0 : {
569 0 : tree res_op0;
570 0 : res_op0 = captures[0];
571 0 : tree res_op1;
572 0 : {
573 0 : tree _o1[1], _r1;
574 0 : {
575 0 : tree _o2[3], _r2;
576 0 : _o2[0] = captures[2];
577 0 : {
578 0 : tree _o3[1], _r3;
579 0 : _o3[0] = captures[3];
580 0 : _r3 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o3[0]), _o3[0]);
581 0 : _o2[1] = _r3;
582 : }
583 0 : _o2[2] = captures[4];
584 0 : _r2 = fold_build3_loc (loc, VEC_COND_EXPR, TREE_TYPE (_o2[1]), _o2[0], _o2[1], _o2[2]);
585 0 : _o1[0] = _r2;
586 : }
587 0 : if (TREE_TYPE (_o1[0]) != type)
588 : {
589 0 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
590 : }
591 : else
592 : _r1 = _o1[0];
593 0 : res_op1 = _r1;
594 : }
595 0 : tree _r;
596 0 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
597 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 171, __FILE__, __LINE__, true);
598 0 : return _r;
599 : }
600 0 : next_after_fail204:;
601 : }
602 : return NULL_TREE;
603 : }
604 :
605 : tree
606 16 : generic_simplify_114 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
607 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
608 : {
609 16 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
610 16 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail211;
611 16 : {
612 16 : tree res_op0;
613 16 : res_op0 = captures[0];
614 16 : tree res_op1;
615 16 : res_op1 = captures[1];
616 16 : tree _r;
617 16 : _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
618 16 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 178, __FILE__, __LINE__, true);
619 : return _r;
620 : }
621 0 : next_after_fail211:;
622 0 : return NULL_TREE;
623 : }
624 :
625 : tree
626 0 : generic_simplify_121 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
627 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
628 : const enum tree_code ARG_UNUSED (op))
629 : {
630 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
631 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail218;
632 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail218;
633 0 : {
634 0 : tree _r;
635 0 : _r = captures[0];
636 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 184, __FILE__, __LINE__, true);
637 : return _r;
638 : }
639 : next_after_fail218:;
640 : return NULL_TREE;
641 : }
642 :
643 : tree
644 0 : generic_simplify_127 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
645 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
646 : {
647 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
648 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail224;
649 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail224;
650 0 : {
651 0 : tree _r;
652 0 : _r = captures[2];
653 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 185, __FILE__, __LINE__, true);
654 : return _r;
655 : }
656 : next_after_fail224:;
657 : return NULL_TREE;
658 : }
659 :
660 : tree
661 0 : generic_simplify_135 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
662 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
663 : {
664 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
665 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail232;
666 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail232;
667 0 : {
668 0 : tree _r;
669 0 : _r = captures[0];
670 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 190, __FILE__, __LINE__, true);
671 : return _r;
672 : }
673 : next_after_fail232:;
674 : return NULL_TREE;
675 : }
676 :
677 : tree
678 2 : generic_simplify_144 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
679 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
680 : const enum tree_code ARG_UNUSED (bitop),
681 : const enum tree_code ARG_UNUSED (rbitop))
682 : {
683 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
684 2 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail245;
685 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail245;
686 2 : {
687 2 : tree res_op0;
688 2 : res_op0 = captures[0];
689 2 : tree res_op1;
690 2 : res_op1 = captures[2];
691 2 : tree _r;
692 2 : _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
693 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 199, __FILE__, __LINE__, true);
694 : return _r;
695 : }
696 : next_after_fail245:;
697 : return NULL_TREE;
698 : }
699 :
700 : tree
701 700 : generic_simplify_149 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
702 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
703 : const enum tree_code ARG_UNUSED (op))
704 : {
705 700 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
706 700 : if (bitwise_equal_p (captures[4], captures[7])
707 : )
708 : {
709 40 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail251;
710 40 : {
711 40 : tree res_op0;
712 40 : {
713 40 : tree _o1[2], _r1;
714 40 : {
715 40 : tree _o2[2], _r2;
716 40 : _o2[0] = captures[5];
717 40 : {
718 40 : tree _o3[1], _r3;
719 40 : _o3[0] = captures[6];
720 40 : if (TREE_TYPE (_o3[0]) != TREE_TYPE (_o2[0]))
721 : {
722 0 : _r3 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o2[0]), _o3[0]);
723 : }
724 : else
725 : _r3 = _o3[0];
726 40 : _o2[1] = _r3;
727 : }
728 40 : _r2 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
729 40 : _o1[0] = _r2;
730 : }
731 40 : {
732 40 : tree _o2[1], _r2;
733 40 : _o2[0] = captures[4];
734 40 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
735 : {
736 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
737 : }
738 : else
739 : _r2 = _o2[0];
740 40 : _o1[1] = _r2;
741 : }
742 40 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
743 40 : res_op0 = _r1;
744 : }
745 40 : tree _r;
746 40 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
747 40 : if (TREE_SIDE_EFFECTS (captures[7]))
748 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[7]), _r);
749 40 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 202, __FILE__, __LINE__, true);
750 40 : return _r;
751 : }
752 0 : next_after_fail251:;
753 : }
754 : return NULL_TREE;
755 : }
756 :
757 : tree
758 31 : generic_simplify_160 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
759 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
760 : const enum tree_code ARG_UNUSED (code2),
761 : const enum tree_code ARG_UNUSED (code1))
762 : {
763 31 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
764 31 : if ((TREE_CODE (captures[2]) == INTEGER_CST
765 7 : && TREE_CODE (captures[4]) == INTEGER_CST)
766 31 : || ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
767 24 : || POINTER_TYPE_P (TREE_TYPE (captures[2])))
768 0 : && operand_equal_p (captures[2], captures[4]))
769 : )
770 : {
771 7 : {
772 7 : int cmp = 0;
773 7 : if (TREE_CODE (captures[2]) == INTEGER_CST
774 7 : && TREE_CODE (captures[4]) == INTEGER_CST)
775 7 : cmp = tree_int_cst_compare (captures[2], captures[4]);
776 7 : if ((code1 == LT_EXPR || code1 == LE_EXPR)
777 7 : && (code2 == LT_EXPR || code2 == LE_EXPR)
778 : )
779 : {
780 7 : if ((cmp < 0) || (cmp == 0 && code1 == LT_EXPR)
781 : )
782 : {
783 7 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail277;
784 7 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail277;
785 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail277;
786 7 : {
787 7 : tree _r;
788 7 : _r = captures[3];
789 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 219, __FILE__, __LINE__, true);
790 7 : return _r;
791 : }
792 : next_after_fail277:;
793 : }
794 : else
795 : {
796 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail278;
797 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail278;
798 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail278;
799 0 : {
800 0 : tree _r;
801 0 : _r = captures[0];
802 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 220, __FILE__, __LINE__, true);
803 0 : return _r;
804 : }
805 : next_after_fail278:;
806 : }
807 : }
808 : else
809 : {
810 0 : if ((code1 == GT_EXPR || code1 == GE_EXPR)
811 0 : && (code2 == GT_EXPR || code2 == GE_EXPR)
812 : )
813 : {
814 0 : if ((cmp > 0) || (cmp == 0 && code1 == GT_EXPR)
815 : )
816 : {
817 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail279;
818 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail279;
819 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail279;
820 0 : {
821 0 : tree _r;
822 0 : _r = captures[3];
823 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 221, __FILE__, __LINE__, true);
824 0 : return _r;
825 : }
826 : next_after_fail279:;
827 : }
828 : else
829 : {
830 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail280;
831 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail280;
832 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail280;
833 0 : {
834 0 : tree _r;
835 0 : _r = captures[0];
836 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 222, __FILE__, __LINE__, true);
837 0 : return _r;
838 : }
839 : next_after_fail280:;
840 : }
841 : }
842 : else
843 : {
844 0 : if (cmp == 0
845 0 : && ((code1 == LT_EXPR && code2 == GT_EXPR)
846 0 : || (code1 == GT_EXPR && code2 == LT_EXPR))
847 : )
848 : {
849 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail281;
850 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail281;
851 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail281;
852 0 : {
853 0 : tree res_op0;
854 0 : res_op0 = captures[1];
855 0 : tree res_op1;
856 0 : res_op1 = captures[4];
857 0 : tree _r;
858 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
859 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 223, __FILE__, __LINE__, true);
860 0 : return _r;
861 : }
862 : next_after_fail281:;
863 : }
864 : else
865 : {
866 0 : if (cmp >= 0
867 0 : && (code1 == LT_EXPR || code1 == LE_EXPR)
868 0 : && (code2 == GT_EXPR || code2 == GE_EXPR)
869 : )
870 : {
871 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail282;
872 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail282;
873 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail282;
874 0 : {
875 0 : tree _r;
876 0 : _r = constant_boolean_node (true, type);
877 0 : if (TREE_SIDE_EFFECTS (captures[1]))
878 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
879 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 224, __FILE__, __LINE__, true);
880 0 : return _r;
881 : }
882 : next_after_fail282:;
883 : }
884 : else
885 : {
886 0 : if (cmp <= 0
887 0 : && (code1 == GT_EXPR || code1 == GE_EXPR)
888 0 : && (code2 == LT_EXPR || code2 == LE_EXPR)
889 : )
890 : {
891 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail283;
892 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail283;
893 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail283;
894 0 : {
895 0 : tree _r;
896 0 : _r = constant_boolean_node (true, type);
897 0 : if (TREE_SIDE_EFFECTS (captures[1]))
898 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
899 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 225, __FILE__, __LINE__, true);
900 0 : return _r;
901 : }
902 : next_after_fail283:;
903 : }
904 : }
905 : }
906 : }
907 : }
908 : }
909 : }
910 : return NULL_TREE;
911 : }
912 :
913 : tree
914 1206 : generic_simplify_191 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
915 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
916 : const enum tree_code ARG_UNUSED (cmp))
917 : {
918 1206 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
919 1206 : if (fold_before_rtl_expansion_p ()
920 : )
921 : {
922 0 : if (INTEGRAL_TYPE_P (type)
923 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
924 : )
925 : {
926 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail330;
927 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail330;
928 0 : {
929 0 : tree res_op0;
930 0 : res_op0 = captures[0];
931 0 : tree res_op1;
932 0 : res_op1 = captures[3];
933 0 : tree res_op2;
934 0 : res_op2 = build_zero_cst (type);
935 0 : tree _r;
936 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
937 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 246, __FILE__, __LINE__, true);
938 0 : return _r;
939 : }
940 : next_after_fail330:;
941 : }
942 : }
943 : return NULL_TREE;
944 : }
945 :
946 : tree
947 168808 : generic_simplify_196 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
948 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
949 : {
950 168808 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
951 168808 : {
952 168808 : poly_widest_int factor;
953 168808 : if (multiple_p (wi::to_poly_widest (captures[2]), wi::to_widest (captures[1]), &factor)
954 : )
955 : {
956 53206 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail335;
957 53206 : {
958 53206 : tree res_op0;
959 53206 : {
960 53206 : tree _o1[1], _r1;
961 53206 : _o1[0] = captures[0];
962 53206 : if (TREE_TYPE (_o1[0]) != type)
963 : {
964 9793 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
965 : }
966 : else
967 : _r1 = _o1[0];
968 53206 : res_op0 = _r1;
969 : }
970 53206 : tree res_op1;
971 53206 : res_op1 = wide_int_to_tree (type, factor);
972 53206 : tree _r;
973 53206 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
974 53206 : if (TREE_SIDE_EFFECTS (captures[1]))
975 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
976 53206 : if (TREE_SIDE_EFFECTS (captures[2]))
977 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
978 53206 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 250, __FILE__, __LINE__, true);
979 53206 : return _r;
980 : }
981 0 : next_after_fail335:;
982 : }
983 168808 : }
984 115602 : return NULL_TREE;
985 : }
986 :
987 : tree
988 2 : generic_simplify_205 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
989 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
990 : const combined_fn ARG_UNUSED (POW))
991 : {
992 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
993 2 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
994 : )
995 : {
996 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail345;
997 2 : {
998 2 : tree res_op0;
999 2 : {
1000 2 : tree _o1[2], _r1;
1001 2 : _o1[0] = captures[1];
1002 2 : _o1[1] = captures[4];
1003 2 : _r1 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1004 2 : res_op0 = _r1;
1005 : }
1006 2 : tree res_op1;
1007 2 : res_op1 = captures[2];
1008 2 : tree _r;
1009 2 : _r = maybe_build_call_expr_loc (loc, POW, type, 2, res_op0, res_op1);
1010 2 : if (!_r)
1011 0 : goto next_after_fail345;
1012 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 260, __FILE__, __LINE__, true);
1013 2 : return _r;
1014 : }
1015 : next_after_fail345:;
1016 : }
1017 : return NULL_TREE;
1018 : }
1019 :
1020 : tree
1021 0 : generic_simplify_214 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1022 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1023 : const enum tree_code ARG_UNUSED (neeq))
1024 : {
1025 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1026 0 : if (TREE_CODE (TREE_TYPE (captures[0])) == BOOLEAN_TYPE
1027 0 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
1028 0 : && TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1029 : )
1030 : {
1031 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail357;
1032 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail357;
1033 0 : {
1034 0 : tree res_op0;
1035 0 : res_op0 = captures[1];
1036 0 : tree res_op1;
1037 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[1]));
1038 0 : tree _r;
1039 0 : _r = fold_build2_loc (loc, neeq, type, res_op0, res_op1);
1040 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 271, __FILE__, __LINE__, true);
1041 0 : return _r;
1042 : }
1043 : next_after_fail357:;
1044 : }
1045 : return NULL_TREE;
1046 : }
1047 :
1048 : tree
1049 1744558 : generic_simplify_219 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1050 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1051 : const enum tree_code ARG_UNUSED (cmp))
1052 : {
1053 1744558 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1054 3489116 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1055 1744558 : && integer_nonzerop (captures[2])
1056 1742769 : && !TREE_OVERFLOW (captures[2])
1057 3487327 : && !TREE_OVERFLOW (captures[3])
1058 : )
1059 : {
1060 1742769 : {
1061 1742769 : tree lo, hi; bool neg_overflow;
1062 1742769 : enum tree_code code = fold_div_compare (cmp, captures[2], captures[3], &lo, &hi,
1063 : &neg_overflow);
1064 1742769 : if (code == LT_EXPR || code == GE_EXPR
1065 : )
1066 : {
1067 40184 : if (TREE_OVERFLOW (lo)
1068 : )
1069 : {
1070 4830 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail362;
1071 4830 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail362;
1072 4830 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail362;
1073 4830 : {
1074 4830 : tree _r;
1075 4830 : _r = build_int_cst (type, (code == LT_EXPR) ^ neg_overflow);
1076 4830 : if (TREE_SIDE_EFFECTS (captures[1]))
1077 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1078 4830 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 276, __FILE__, __LINE__, true);
1079 1742766 : return _r;
1080 : }
1081 3 : next_after_fail362:;
1082 : }
1083 : else
1084 : {
1085 35354 : if (code == LT_EXPR
1086 : )
1087 : {
1088 722 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail363;
1089 722 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail363;
1090 722 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail363;
1091 722 : {
1092 722 : tree res_op0;
1093 722 : res_op0 = captures[1];
1094 722 : tree res_op1;
1095 722 : res_op1 = lo;
1096 722 : tree _r;
1097 722 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
1098 722 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 277, __FILE__, __LINE__, true);
1099 722 : return _r;
1100 : }
1101 3 : next_after_fail363:;
1102 : }
1103 : else
1104 : {
1105 34632 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail364;
1106 34632 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail364;
1107 34632 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail364;
1108 34632 : {
1109 34632 : tree res_op0;
1110 34632 : res_op0 = captures[1];
1111 34632 : tree res_op1;
1112 34632 : res_op1 = lo;
1113 34632 : tree _r;
1114 34632 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
1115 34632 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 278, __FILE__, __LINE__, true);
1116 34632 : return _r;
1117 : }
1118 3 : next_after_fail364:;
1119 : }
1120 : }
1121 : }
1122 : else
1123 : {
1124 1702585 : if (code == LE_EXPR || code == GT_EXPR
1125 : )
1126 : {
1127 1699502 : if (TREE_OVERFLOW (hi)
1128 : )
1129 : {
1130 534259 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail365;
1131 534259 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail365;
1132 534259 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail365;
1133 534259 : {
1134 534259 : tree _r;
1135 534259 : _r = build_int_cst (type, (code == LE_EXPR) ^ neg_overflow);
1136 534259 : if (TREE_SIDE_EFFECTS (captures[1]))
1137 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1138 534259 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 279, __FILE__, __LINE__, true);
1139 534259 : return _r;
1140 : }
1141 3 : next_after_fail365:;
1142 : }
1143 : else
1144 : {
1145 1165243 : if (code == LE_EXPR
1146 : )
1147 : {
1148 638 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail366;
1149 638 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail366;
1150 638 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail366;
1151 638 : {
1152 638 : tree res_op0;
1153 638 : res_op0 = captures[1];
1154 638 : tree res_op1;
1155 638 : res_op1 = hi;
1156 638 : tree _r;
1157 638 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1158 638 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 280, __FILE__, __LINE__, true);
1159 638 : return _r;
1160 : }
1161 3 : next_after_fail366:;
1162 : }
1163 : else
1164 : {
1165 1164605 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail367;
1166 1164605 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail367;
1167 1164605 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail367;
1168 1164605 : {
1169 1164605 : tree res_op0;
1170 1164605 : res_op0 = captures[1];
1171 1164605 : tree res_op1;
1172 1164605 : res_op1 = hi;
1173 1164605 : tree _r;
1174 1164605 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
1175 1164605 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 281, __FILE__, __LINE__, true);
1176 1164605 : return _r;
1177 : }
1178 3 : next_after_fail367:;
1179 : }
1180 : }
1181 : }
1182 : else
1183 : {
1184 3083 : if (!lo && !hi
1185 : )
1186 : {
1187 40 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail368;
1188 40 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail368;
1189 40 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail368;
1190 40 : {
1191 40 : tree _r;
1192 40 : _r = build_int_cst (type, code == NE_EXPR);
1193 40 : if (TREE_SIDE_EFFECTS (captures[1]))
1194 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1195 40 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 282, __FILE__, __LINE__, true);
1196 40 : return _r;
1197 : }
1198 3 : next_after_fail368:;
1199 : }
1200 : else
1201 : {
1202 3043 : if (code == EQ_EXPR && !hi
1203 : )
1204 : {
1205 15 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail369;
1206 15 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail369;
1207 15 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail369;
1208 15 : {
1209 15 : tree res_op0;
1210 15 : res_op0 = captures[1];
1211 15 : tree res_op1;
1212 15 : res_op1 = lo;
1213 15 : tree _r;
1214 15 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
1215 15 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 283, __FILE__, __LINE__, true);
1216 15 : return _r;
1217 : }
1218 3 : next_after_fail369:;
1219 : }
1220 : else
1221 : {
1222 930 : if (code == EQ_EXPR && !lo
1223 : )
1224 : {
1225 11 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail370;
1226 11 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail370;
1227 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail370;
1228 11 : {
1229 11 : tree res_op0;
1230 11 : res_op0 = captures[1];
1231 11 : tree res_op1;
1232 11 : res_op1 = hi;
1233 11 : tree _r;
1234 11 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1235 11 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 284, __FILE__, __LINE__, true);
1236 11 : return _r;
1237 : }
1238 3 : next_after_fail370:;
1239 : }
1240 : else
1241 : {
1242 3017 : if (code == NE_EXPR && !hi
1243 : )
1244 : {
1245 4 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail371;
1246 4 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail371;
1247 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail371;
1248 4 : {
1249 4 : tree res_op0;
1250 4 : res_op0 = captures[1];
1251 4 : tree res_op1;
1252 4 : res_op1 = lo;
1253 4 : tree _r;
1254 4 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
1255 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 285, __FILE__, __LINE__, true);
1256 4 : return _r;
1257 : }
1258 3 : next_after_fail371:;
1259 : }
1260 : else
1261 : {
1262 2094 : if (code == NE_EXPR && !lo
1263 : )
1264 : {
1265 18 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail372;
1266 18 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail372;
1267 18 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail372;
1268 18 : {
1269 18 : tree res_op0;
1270 18 : res_op0 = captures[1];
1271 18 : tree res_op1;
1272 18 : res_op1 = hi;
1273 18 : tree _r;
1274 18 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
1275 18 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 286, __FILE__, __LINE__, true);
1276 18 : return _r;
1277 : }
1278 3 : next_after_fail372:;
1279 : }
1280 : else
1281 : {
1282 2995 : if (1
1283 : )
1284 : {
1285 2995 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail373;
1286 2992 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail373;
1287 2992 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail373;
1288 2992 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail373;
1289 2992 : {
1290 2992 : tree _r;
1291 2992 : _r = build_range_check (UNKNOWN_LOCATION, type, captures[1], code == EQ_EXPR,
1292 : lo, hi);
1293 2992 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 287, __FILE__, __LINE__, true);
1294 2992 : return _r;
1295 : }
1296 3 : next_after_fail373:;
1297 : }
1298 : else
1299 : {
1300 : {
1301 : tree etype = range_check_type (TREE_TYPE (captures[1]));
1302 : if (etype)
1303 : {
1304 : hi = fold_convert (etype, hi);
1305 : lo = fold_convert (etype, lo);
1306 : hi = const_binop (MINUS_EXPR, etype, hi, lo);
1307 : }
1308 : if (etype && hi && !TREE_OVERFLOW (hi)
1309 : )
1310 : {
1311 : if (code == EQ_EXPR
1312 : )
1313 : {
1314 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail374;
1315 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail374;
1316 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail374;
1317 : {
1318 : tree res_op0;
1319 : {
1320 : tree _o1[2], _r1;
1321 : {
1322 : tree _o2[1], _r2;
1323 : _o2[0] = captures[1];
1324 : if (TREE_TYPE (_o2[0]) != etype)
1325 : {
1326 : _r2 = fold_build1_loc (loc, NOP_EXPR, etype, _o2[0]);
1327 : }
1328 : else
1329 : _r2 = _o2[0];
1330 : _o1[0] = _r2;
1331 : }
1332 : _o1[1] = lo;
1333 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1334 : res_op0 = _r1;
1335 : }
1336 : tree res_op1;
1337 : res_op1 = hi;
1338 : tree _r;
1339 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1340 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 288, __FILE__, __LINE__, true);
1341 : return _r;
1342 : }
1343 : next_after_fail374:;
1344 : }
1345 : else
1346 : {
1347 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail375;
1348 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail375;
1349 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail375;
1350 : {
1351 : tree res_op0;
1352 : {
1353 : tree _o1[2], _r1;
1354 : {
1355 : tree _o2[1], _r2;
1356 : _o2[0] = captures[1];
1357 : if (TREE_TYPE (_o2[0]) != etype)
1358 : {
1359 : _r2 = fold_build1_loc (loc, NOP_EXPR, etype, _o2[0]);
1360 : }
1361 : else
1362 : _r2 = _o2[0];
1363 : _o1[0] = _r2;
1364 : }
1365 : _o1[1] = lo;
1366 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1367 : res_op0 = _r1;
1368 : }
1369 : tree res_op1;
1370 : res_op1 = hi;
1371 : tree _r;
1372 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
1373 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 289, __FILE__, __LINE__, true);
1374 : return _r;
1375 : }
1376 : next_after_fail375:;
1377 : }
1378 : }
1379 : }
1380 : }
1381 : }
1382 : }
1383 : }
1384 : }
1385 : }
1386 : }
1387 : }
1388 : }
1389 : }
1390 : return NULL_TREE;
1391 : }
1392 :
1393 : tree
1394 451 : generic_simplify_277 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1395 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1396 : const enum tree_code ARG_UNUSED (cmp))
1397 : {
1398 451 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1399 451 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail509;
1400 451 : {
1401 451 : tree res_op0;
1402 451 : {
1403 451 : tree _o1[2], _r1;
1404 451 : _o1[0] = captures[0];
1405 451 : {
1406 451 : tree _o2[1], _r2;
1407 451 : _o2[0] = captures[1];
1408 451 : _r2 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
1409 451 : if (EXPR_P (_r2))
1410 443 : goto next_after_fail509;
1411 8 : _o1[1] = _r2;
1412 : }
1413 8 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1414 8 : res_op0 = _r1;
1415 : }
1416 8 : tree res_op1;
1417 8 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
1418 8 : tree _r;
1419 8 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1420 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 412, __FILE__, __LINE__, true);
1421 : return _r;
1422 : }
1423 : next_after_fail509:;
1424 : return NULL_TREE;
1425 : }
1426 :
1427 : tree
1428 108442 : generic_simplify_281 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1429 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1430 : const enum tree_code ARG_UNUSED (cmp),
1431 : const enum tree_code ARG_UNUSED (icmp))
1432 : {
1433 108442 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1434 108442 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail513;
1435 108418 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail513;
1436 108418 : {
1437 108418 : tree res_op0;
1438 108418 : res_op0 = captures[0];
1439 108418 : tree res_op1;
1440 108418 : res_op1 = build_zero_cst (TREE_TYPE (captures[1]));
1441 108418 : tree _r;
1442 108418 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
1443 108418 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 416, __FILE__, __LINE__, true);
1444 : return _r;
1445 : }
1446 : next_after_fail513:;
1447 : return NULL_TREE;
1448 : }
1449 :
1450 : tree
1451 18 : generic_simplify_286 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1452 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1453 : const enum tree_code ARG_UNUSED (cmp),
1454 : const enum tree_code ARG_UNUSED (ncmp))
1455 : {
1456 18 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1457 36 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1458 18 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1459 36 : && types_match (captures[0], captures[2])
1460 : )
1461 : {
1462 2 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail518;
1463 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail518;
1464 2 : {
1465 2 : tree res_op0;
1466 2 : {
1467 2 : tree _o1[2], _r1;
1468 2 : _o1[0] = captures[0];
1469 2 : _o1[1] = captures[2];
1470 2 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1471 2 : res_op0 = _r1;
1472 : }
1473 2 : tree res_op1;
1474 2 : res_op1 = captures[1];
1475 2 : tree _r;
1476 2 : _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
1477 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 419, __FILE__, __LINE__, true);
1478 2 : return _r;
1479 : }
1480 : next_after_fail518:;
1481 : }
1482 : return NULL_TREE;
1483 : }
1484 :
1485 : tree
1486 0 : generic_simplify_292 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1487 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1488 : const enum tree_code ARG_UNUSED (inner),
1489 : const enum tree_code ARG_UNUSED (outer))
1490 : {
1491 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1492 0 : {
1493 0 : bool cst1 = integer_onep (captures[1]);
1494 0 : bool cst0 = integer_zerop (captures[1]);
1495 0 : bool innereq = inner == EQ_EXPR;
1496 0 : bool outereq = outer == EQ_EXPR;
1497 0 : if (innereq ? cst0 : cst1
1498 : )
1499 : {
1500 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail538;
1501 0 : {
1502 0 : tree _r;
1503 0 : _r = constant_boolean_node (!outereq, type);
1504 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1505 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1506 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1507 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1508 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 431, __FILE__, __LINE__, true);
1509 0 : return _r;
1510 : }
1511 0 : next_after_fail538:;
1512 : }
1513 : else
1514 : {
1515 0 : if (innereq ? cst1 : cst0
1516 : )
1517 : {
1518 0 : {
1519 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[0]));
1520 0 : tree ucst1 = build_one_cst (utype);
1521 0 : if (!outereq
1522 : )
1523 : {
1524 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail539;
1525 0 : {
1526 0 : tree res_op0;
1527 0 : {
1528 0 : tree _o1[1], _r1;
1529 0 : _o1[0] = captures[0];
1530 0 : if (TREE_TYPE (_o1[0]) != utype)
1531 : {
1532 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, utype, _o1[0]);
1533 : }
1534 : else
1535 : _r1 = _o1[0];
1536 0 : res_op0 = _r1;
1537 : }
1538 0 : tree res_op1;
1539 0 : res_op1 = ucst1;
1540 0 : tree _r;
1541 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
1542 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1543 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1544 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 432, __FILE__, __LINE__, true);
1545 0 : return _r;
1546 : }
1547 0 : next_after_fail539:;
1548 : }
1549 : else
1550 : {
1551 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail540;
1552 0 : {
1553 0 : tree res_op0;
1554 0 : {
1555 0 : tree _o1[1], _r1;
1556 0 : _o1[0] = captures[0];
1557 0 : if (TREE_TYPE (_o1[0]) != utype)
1558 : {
1559 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, utype, _o1[0]);
1560 : }
1561 : else
1562 : _r1 = _o1[0];
1563 0 : res_op0 = _r1;
1564 : }
1565 0 : tree res_op1;
1566 0 : res_op1 = ucst1;
1567 0 : tree _r;
1568 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1569 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1570 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1571 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 433, __FILE__, __LINE__, true);
1572 0 : return _r;
1573 : }
1574 0 : next_after_fail540:;
1575 : }
1576 : }
1577 : }
1578 : else
1579 : {
1580 0 : {
1581 0 : tree value = build_int_cst (TREE_TYPE (captures[0]), !innereq);
1582 0 : if (outereq
1583 : )
1584 : {
1585 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail541;
1586 0 : {
1587 0 : tree res_op0;
1588 0 : res_op0 = captures[0];
1589 0 : tree res_op1;
1590 0 : res_op1 = value;
1591 0 : tree _r;
1592 0 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
1593 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1594 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1595 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 434, __FILE__, __LINE__, true);
1596 0 : return _r;
1597 : }
1598 0 : next_after_fail541:;
1599 : }
1600 : else
1601 : {
1602 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail542;
1603 0 : {
1604 0 : tree res_op0;
1605 0 : res_op0 = captures[0];
1606 0 : tree res_op1;
1607 0 : res_op1 = value;
1608 0 : tree _r;
1609 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
1610 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1611 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1612 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 435, __FILE__, __LINE__, true);
1613 0 : return _r;
1614 : }
1615 0 : next_after_fail542:;
1616 : }
1617 : }
1618 : }
1619 : }
1620 : }
1621 : return NULL_TREE;
1622 : }
1623 :
1624 : tree
1625 374 : generic_simplify_298 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1626 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1627 : const enum tree_code ARG_UNUSED (op),
1628 : const combined_fn ARG_UNUSED (ctz))
1629 : {
1630 374 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1631 374 : {
1632 374 : tree type0 = TREE_TYPE (captures[1]);
1633 374 : int prec = TYPE_PRECISION (type0);
1634 374 : bool ok = true;
1635 374 : if (sanitize_flags_p (SANITIZE_BUILTIN)
1636 374 : && (!cfun
1637 64 : || (cfun->curr_properties & PROP_ssa) == 0))
1638 : ok = false;
1639 620 : if (ok && prec <= MAX_FIXED_MODE_SIZE
1640 : )
1641 : {
1642 310 : if (tree_int_cst_sgn (captures[2]) < 0 || wi::to_widest (captures[2]) >= prec
1643 : )
1644 : {
1645 36 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail559;
1646 36 : {
1647 36 : tree _r;
1648 36 : _r = constant_boolean_node (op == EQ_EXPR ? false : true, type);
1649 36 : if (TREE_SIDE_EFFECTS (captures[1]))
1650 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1651 36 : if (TREE_SIDE_EFFECTS (captures[2]))
1652 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1653 36 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 452, __FILE__, __LINE__, true);
1654 310 : return _r;
1655 : }
1656 0 : next_after_fail559:;
1657 : }
1658 : else
1659 : {
1660 274 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail560;
1661 274 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail560;
1662 274 : {
1663 274 : tree res_op0;
1664 274 : {
1665 274 : tree _o1[2], _r1;
1666 274 : _o1[0] = captures[1];
1667 274 : _o1[1] = wide_int_to_tree (type0,
1668 274 : wi::mask (tree_to_uhwi (captures[2]) + 1,
1669 : false, prec));
1670 274 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1671 274 : res_op0 = _r1;
1672 : }
1673 274 : tree res_op1;
1674 274 : res_op1 = wide_int_to_tree (type0,
1675 274 : wi::shifted_mask (tree_to_uhwi (captures[2]), 1,
1676 : false, prec));
1677 274 : tree _r;
1678 274 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1679 274 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 453, __FILE__, __LINE__, true);
1680 274 : return _r;
1681 : }
1682 64 : next_after_fail560:;
1683 : }
1684 : }
1685 : }
1686 64 : return NULL_TREE;
1687 : }
1688 :
1689 : tree
1690 0 : generic_simplify_310 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1691 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1692 : const combined_fn ARG_UNUSED (COPYSIGN_ALL))
1693 : {
1694 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1695 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail576;
1696 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail576;
1697 0 : {
1698 0 : tree _r;
1699 0 : _r = captures[1];
1700 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 469, __FILE__, __LINE__, true);
1701 : return _r;
1702 : }
1703 : next_after_fail576:;
1704 : return NULL_TREE;
1705 : }
1706 :
1707 : tree
1708 893 : generic_simplify_317 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1709 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1710 : const enum tree_code ARG_UNUSED (div))
1711 : {
1712 893 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1713 1786 : if (!ALL_FRACT_MODE_P (TYPE_MODE (type))
1714 893 : && !integer_zerop (captures[0])
1715 1160 : && (!flag_non_call_exceptions || tree_expr_nonzero_p (captures[0]))
1716 : )
1717 : {
1718 111 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail585;
1719 111 : {
1720 111 : tree _r;
1721 111 : _r = build_one_cst (type);
1722 111 : if (TREE_SIDE_EFFECTS (captures[0]))
1723 2 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1724 111 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 476, __FILE__, __LINE__, true);
1725 111 : return _r;
1726 : }
1727 0 : next_after_fail585:;
1728 : }
1729 : return NULL_TREE;
1730 : }
1731 :
1732 : tree
1733 192 : generic_simplify_323 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1734 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1735 : const enum tree_code ARG_UNUSED (div))
1736 : {
1737 192 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1738 192 : if (ANY_INTEGRAL_TYPE_P (type)
1739 : )
1740 : {
1741 192 : if (TYPE_OVERFLOW_UNDEFINED (type) && !TYPE_OVERFLOW_SANITIZED (type)
1742 : )
1743 : {
1744 164 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail592;
1745 164 : {
1746 164 : tree _r;
1747 164 : _r = captures[1];
1748 164 : if (TREE_SIDE_EFFECTS (captures[2]))
1749 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1750 164 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 483, __FILE__, __LINE__, true);
1751 164 : return _r;
1752 : }
1753 0 : next_after_fail592:;
1754 : }
1755 : }
1756 : return NULL_TREE;
1757 : }
1758 :
1759 : tree
1760 212870 : generic_simplify_327 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1761 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1762 : const enum tree_code ARG_UNUSED (mod))
1763 : {
1764 212870 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1765 212870 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail596;
1766 212870 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail596;
1767 212870 : {
1768 212870 : tree _r;
1769 212870 : _r = build_zero_cst (type);
1770 212870 : if (TREE_SIDE_EFFECTS (captures[0]))
1771 47 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1772 212870 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 487, __FILE__, __LINE__, true);
1773 : return _r;
1774 : }
1775 : next_after_fail596:;
1776 : return NULL_TREE;
1777 : }
1778 :
1779 : tree
1780 6 : generic_simplify_337 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1781 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1782 : const combined_fn ARG_UNUSED (SIN),
1783 : const combined_fn ARG_UNUSED (TAN),
1784 : const combined_fn ARG_UNUSED (COS))
1785 : {
1786 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1787 6 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1788 : )
1789 : {
1790 6 : if (! HONOR_NANS (captures[1])
1791 6 : && ! HONOR_INFINITIES (captures[1])
1792 : )
1793 : {
1794 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail608;
1795 6 : {
1796 6 : tree res_op0;
1797 6 : res_op0 = captures[1];
1798 6 : tree _r;
1799 6 : _r = maybe_build_call_expr_loc (loc, COS, type, 1, res_op0);
1800 6 : if (!_r)
1801 0 : goto next_after_fail608;
1802 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 499, __FILE__, __LINE__, true);
1803 6 : return _r;
1804 : }
1805 : next_after_fail608:;
1806 : }
1807 : }
1808 : return NULL_TREE;
1809 : }
1810 :
1811 : tree
1812 161905 : generic_simplify_345 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1813 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1814 : const enum tree_code ARG_UNUSED (cmp))
1815 : {
1816 161905 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1817 161905 : {
1818 161905 : tree from_type = TREE_TYPE (captures[0]);
1819 161905 : tree c1_type = TREE_TYPE (captures[1]), c2_type = TREE_TYPE (captures[2]);
1820 161905 : enum tree_code code = ERROR_MARK;
1821 161905 : if (integer_zerop (captures[1])
1822 67417 : && INTEGRAL_TYPE_P (from_type)
1823 65106 : && (cmp == GE_EXPR || cmp == LT_EXPR)
1824 17333 : && TYPE_UNSIGNED (from_type)
1825 1764 : && !TYPE_UNSIGNED (c1_type)
1826 1764 : && TYPE_PRECISION (from_type) == TYPE_PRECISION (c1_type)
1827 587 : && int_fits_type_p (captures[2], from_type)
1828 162492 : && (types_match (c2_type, from_type)
1829 0 : || (TYPE_PRECISION (c2_type) > TYPE_PRECISION (from_type)
1830 0 : && (TYPE_UNSIGNED (from_type)
1831 0 : || TYPE_SIGN (c2_type) == TYPE_SIGN (from_type)))))
1832 : {
1833 587 : tree_code ncmp = cmp == GE_EXPR ? LE_EXPR : GT_EXPR;
1834 587 : widest_int c1 = wi::mask<widest_int>(TYPE_PRECISION (type) - 1, 0);
1835 587 : code = minmax_from_comparison (ncmp, captures[0], c1, wi::to_widest (captures[2]));
1836 587 : }
1837 587 : if (code == ERROR_MARK
1838 161900 : && INTEGRAL_TYPE_P (from_type)
1839 159589 : && int_fits_type_p (captures[2], from_type)
1840 159588 : && (types_match (c1_type, from_type)
1841 6904 : || (TYPE_PRECISION (c1_type) > TYPE_PRECISION (from_type)
1842 0 : && (TYPE_UNSIGNED (from_type)
1843 0 : || TYPE_SIGN (c1_type) == TYPE_SIGN (from_type))))
1844 153271 : && (types_match (c2_type, from_type)
1845 60902 : || (TYPE_PRECISION (c2_type) > TYPE_PRECISION (from_type)
1846 18808 : && (TYPE_UNSIGNED (from_type)
1847 691 : || TYPE_SIGN (c2_type) == TYPE_SIGN (from_type)))))
1848 : {
1849 109980 : if (cmp != EQ_EXPR)
1850 109968 : code = minmax_from_comparison (cmp, captures[0], captures[1], captures[0], captures[2]);
1851 12 : else if (int_fits_type_p (captures[1], from_type))
1852 : code = EQ_EXPR;
1853 : }
1854 161893 : if (code == MAX_EXPR
1855 : )
1856 : {
1857 19648 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail616;
1858 19648 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail616;
1859 19648 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail616;
1860 19648 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail616;
1861 19648 : {
1862 19648 : tree res_op0;
1863 19648 : {
1864 19648 : tree _o1[2], _r1;
1865 19648 : _o1[0] = captures[0];
1866 19648 : {
1867 19648 : tree _o2[1], _r2;
1868 19648 : _o2[0] = captures[2];
1869 19648 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
1870 : {
1871 308 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
1872 : }
1873 : else
1874 : _r2 = _o2[0];
1875 19648 : _o1[1] = _r2;
1876 : }
1877 19648 : _r1 = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1878 19648 : res_op0 = _r1;
1879 : }
1880 19648 : tree _r;
1881 19648 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1882 19648 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 507, __FILE__, __LINE__, true);
1883 19648 : return _r;
1884 : }
1885 : next_after_fail616:;
1886 : }
1887 : else
1888 : {
1889 142257 : if (code == MIN_EXPR
1890 : )
1891 : {
1892 258 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail617;
1893 258 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail617;
1894 258 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail617;
1895 258 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail617;
1896 258 : {
1897 258 : tree res_op0;
1898 258 : {
1899 258 : tree _o1[2], _r1;
1900 258 : _o1[0] = captures[0];
1901 258 : {
1902 258 : tree _o2[1], _r2;
1903 258 : _o2[0] = captures[2];
1904 258 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
1905 : {
1906 100 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
1907 : }
1908 : else
1909 : _r2 = _o2[0];
1910 258 : _o1[1] = _r2;
1911 : }
1912 258 : _r1 = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1913 258 : res_op0 = _r1;
1914 : }
1915 258 : tree _r;
1916 258 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1917 258 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 508, __FILE__, __LINE__, true);
1918 258 : return _r;
1919 : }
1920 : next_after_fail617:;
1921 : }
1922 : else
1923 : {
1924 141999 : if (code == EQ_EXPR
1925 : )
1926 : {
1927 12 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail618;
1928 12 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail618;
1929 12 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail618;
1930 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail618;
1931 12 : {
1932 12 : if (! tree_invariant_p (captures[1])) goto next_after_fail618;
1933 12 : tree res_op0;
1934 12 : {
1935 12 : tree _o1[3], _r1;
1936 12 : {
1937 12 : tree _o2[2], _r2;
1938 12 : _o2[0] = captures[0];
1939 12 : {
1940 12 : tree _o3[1], _r3;
1941 12 : _o3[0] = unshare_expr (captures[1]);
1942 12 : if (TREE_TYPE (_o3[0]) != TREE_TYPE (_o2[0]))
1943 : {
1944 0 : _r3 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o2[0]), _o3[0]);
1945 : }
1946 : else
1947 : _r3 = _o3[0];
1948 12 : _o2[1] = _r3;
1949 : }
1950 12 : _r2 = fold_build2_loc (loc, EQ_EXPR, boolean_type_node, _o2[0], _o2[1]);
1951 12 : _o1[0] = _r2;
1952 : }
1953 12 : {
1954 12 : tree _o2[1], _r2;
1955 12 : _o2[0] = captures[1];
1956 12 : if (TREE_TYPE (_o2[0]) != from_type)
1957 : {
1958 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, from_type, _o2[0]);
1959 : }
1960 : else
1961 : _r2 = _o2[0];
1962 12 : _o1[1] = _r2;
1963 : }
1964 12 : {
1965 12 : tree _o2[1], _r2;
1966 12 : _o2[0] = captures[2];
1967 12 : if (TREE_TYPE (_o2[0]) != from_type)
1968 : {
1969 7 : _r2 = fold_build1_loc (loc, NOP_EXPR, from_type, _o2[0]);
1970 : }
1971 : else
1972 : _r2 = _o2[0];
1973 12 : _o1[2] = _r2;
1974 : }
1975 12 : _r1 = fold_build3_loc (loc, COND_EXPR, TREE_TYPE (_o1[1]), _o1[0], _o1[1], _o1[2]);
1976 12 : res_op0 = _r1;
1977 : }
1978 12 : tree _r;
1979 12 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1980 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 509, __FILE__, __LINE__, true);
1981 12 : return _r;
1982 : }
1983 : next_after_fail618:;
1984 : }
1985 : }
1986 : }
1987 : }
1988 : return NULL_TREE;
1989 : }
1990 :
1991 : tree
1992 0 : generic_simplify_386 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1993 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1994 : const enum tree_code ARG_UNUSED (legt))
1995 : {
1996 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1997 0 : if (!HONOR_NANS (captures[0])
1998 : )
1999 : {
2000 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail669;
2001 0 : {
2002 0 : tree _r;
2003 0 : _r = constant_boolean_node (legt == LE_EXPR, type);
2004 0 : if (TREE_SIDE_EFFECTS (captures[0]))
2005 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2006 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2007 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2008 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 558, __FILE__, __LINE__, true);
2009 0 : return _r;
2010 : }
2011 0 : next_after_fail669:;
2012 : }
2013 : return NULL_TREE;
2014 : }
2015 :
2016 : tree
2017 0 : generic_simplify_394 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2018 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2019 : const enum tree_code ARG_UNUSED (cmp),
2020 : const enum tree_code ARG_UNUSED (cmp2))
2021 : {
2022 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2023 0 : if (tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[2]))
2024 0 : && TYPE_UNSIGNED (TREE_TYPE (captures[2])) && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
2025 0 : && wi::gt_p (wi::to_wide (captures[1]), 0, TYPE_SIGN (TREE_TYPE (captures[1])))
2026 : )
2027 : {
2028 0 : {
2029 0 : tree utype = TREE_TYPE (captures[2]);
2030 0 : wide_int denom = wi::to_wide (captures[1]);
2031 0 : wide_int right = wi::to_wide (captures[2]);
2032 0 : wide_int smax = wi::sdiv_trunc (wi::max_value (TREE_TYPE (captures[0])), denom);
2033 0 : wide_int smin = wi::sdiv_trunc (wi::min_value (TREE_TYPE (captures[0])), denom);
2034 0 : bool small = wi::leu_p (right, smax);
2035 0 : bool large = wi::geu_p (right, smin);
2036 0 : if (small || large
2037 : )
2038 : {
2039 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail678;
2040 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail678;
2041 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail678;
2042 0 : {
2043 0 : tree res_op0;
2044 0 : {
2045 0 : tree _o1[1], _r1;
2046 0 : _o1[0] = captures[0];
2047 0 : if (TREE_TYPE (_o1[0]) != utype)
2048 : {
2049 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, utype, _o1[0]);
2050 : }
2051 : else
2052 : _r1 = _o1[0];
2053 0 : res_op0 = _r1;
2054 : }
2055 0 : tree res_op1;
2056 0 : {
2057 0 : tree _o1[2], _r1;
2058 0 : _o1[0] = captures[2];
2059 0 : {
2060 0 : tree _o2[1], _r2;
2061 0 : _o2[0] = captures[1];
2062 0 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (res_op0))
2063 : {
2064 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o2[0]);
2065 : }
2066 : else
2067 : _r2 = _o2[0];
2068 0 : _o1[1] = _r2;
2069 : }
2070 0 : _r1 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2071 0 : res_op1 = _r1;
2072 : }
2073 0 : tree _r;
2074 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2075 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 567, __FILE__, __LINE__, true);
2076 0 : return _r;
2077 : }
2078 0 : next_after_fail678:;
2079 : }
2080 : else
2081 : {
2082 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail679;
2083 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail679;
2084 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail679;
2085 0 : {
2086 0 : tree res_op0;
2087 0 : res_op0 = captures[0];
2088 0 : tree res_op1;
2089 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
2090 0 : tree _r;
2091 0 : _r = fold_build2_loc (loc, cmp2, type, res_op0, res_op1);
2092 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 568, __FILE__, __LINE__, true);
2093 0 : return _r;
2094 : }
2095 0 : next_after_fail679:;
2096 : }
2097 0 : }
2098 : }
2099 : return NULL_TREE;
2100 : }
2101 :
2102 : tree
2103 0 : generic_simplify_410 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2104 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2105 : const enum tree_code ARG_UNUSED (cmp))
2106 : {
2107 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2108 0 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2109 0 : && TYPE_UNSIGNED (TREE_TYPE (captures[0]))
2110 : )
2111 : {
2112 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail732;
2113 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail732;
2114 0 : {
2115 0 : tree res_op0;
2116 0 : res_op0 = captures[1];
2117 0 : tree res_op1;
2118 0 : res_op1 = captures[0];
2119 0 : tree _r;
2120 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2121 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 586, __FILE__, __LINE__, true);
2122 0 : return _r;
2123 : }
2124 : next_after_fail732:;
2125 : }
2126 : return NULL_TREE;
2127 : }
2128 :
2129 : tree
2130 0 : generic_simplify_414 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2131 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2132 : const combined_fn ARG_UNUSED (logs),
2133 : const combined_fn ARG_UNUSED (exps),
2134 : const enum tree_code ARG_UNUSED (cmp))
2135 : {
2136 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2137 0 : if (flag_unsafe_math_optimizations
2138 : )
2139 : {
2140 0 : if (! HONOR_SIGN_DEPENDENT_ROUNDING (type)
2141 0 : && ! HONOR_NANS (type) && ! HONOR_INFINITIES (type)
2142 0 : && ! flag_trapping_math
2143 0 : && ! flag_errno_math
2144 : )
2145 : {
2146 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail736;
2147 0 : {
2148 0 : tree res_op0;
2149 0 : res_op0 = captures[1];
2150 0 : tree res_op1;
2151 0 : {
2152 0 : tree _o1[1], _r1;
2153 0 : _o1[0] = captures[2];
2154 0 : _r1 = maybe_build_call_expr_loc (loc, exps, TREE_TYPE (_o1[0]), 1, _o1[0]);
2155 0 : if (!_r1)
2156 0 : goto next_after_fail736;
2157 0 : if (EXPR_P (_r1))
2158 0 : goto next_after_fail736;
2159 0 : res_op1 = _r1;
2160 : }
2161 0 : tree _r;
2162 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2163 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 604, __FILE__, __LINE__, true);
2164 0 : return _r;
2165 : }
2166 : next_after_fail736:;
2167 : }
2168 : }
2169 : return NULL_TREE;
2170 : }
2171 :
2172 : tree
2173 330 : generic_simplify_422 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2174 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2175 : const enum tree_code ARG_UNUSED (shiftrotate))
2176 : {
2177 330 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2178 330 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail748;
2179 330 : {
2180 330 : tree _r;
2181 330 : _r = captures[0];
2182 330 : if (TREE_SIDE_EFFECTS (captures[1]))
2183 42 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2184 330 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 616, __FILE__, __LINE__, true);
2185 : return _r;
2186 : }
2187 0 : next_after_fail748:;
2188 0 : return NULL_TREE;
2189 : }
2190 :
2191 : tree
2192 18 : generic_simplify_426 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2193 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2194 : const enum tree_code ARG_UNUSED (bit_op),
2195 : const enum tree_code ARG_UNUSED (shift))
2196 : {
2197 18 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2198 18 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[2]))
2199 : )
2200 : {
2201 16 : {
2202 16 : tree mask = int_const_binop (shift, fold_convert (type, captures[3]), captures[4]);
2203 16 : if (mask
2204 : )
2205 : {
2206 16 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail755;
2207 16 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail755;
2208 16 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail755;
2209 16 : {
2210 16 : tree res_op0;
2211 16 : {
2212 16 : tree _o1[2], _r1;
2213 16 : {
2214 16 : tree _o2[1], _r2;
2215 16 : _o2[0] = captures[2];
2216 16 : if (TREE_TYPE (_o2[0]) != type)
2217 : {
2218 16 : _r2 = fold_build1_loc (loc, NOP_EXPR, type, _o2[0]);
2219 : }
2220 : else
2221 : _r2 = _o2[0];
2222 16 : _o1[0] = _r2;
2223 : }
2224 16 : _o1[1] = captures[4];
2225 16 : _r1 = fold_build2_loc (loc, shift, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2226 16 : res_op0 = _r1;
2227 : }
2228 16 : tree res_op1;
2229 16 : res_op1 = mask;
2230 16 : tree _r;
2231 16 : _r = fold_build2_loc (loc, bit_op, type, res_op0, res_op1);
2232 16 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 622, __FILE__, __LINE__, true);
2233 16 : return _r;
2234 : }
2235 : next_after_fail755:;
2236 : }
2237 : }
2238 : }
2239 : return NULL_TREE;
2240 : }
2241 :
2242 : tree
2243 2157 : generic_simplify_432 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2244 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2245 : const enum tree_code ARG_UNUSED (eqne))
2246 : {
2247 2157 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2248 2157 : if ((integer_zerop (captures[1]) || integer_onep (captures[1]))
2249 : )
2250 : {
2251 2155 : if ((eqne == EQ_EXPR) ^ integer_zerop (captures[1])
2252 : )
2253 : {
2254 1545 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail766;
2255 1545 : {
2256 1545 : tree res_op0;
2257 1545 : res_op0 = captures[0];
2258 1545 : tree _r;
2259 1545 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2260 1545 : if (TREE_SIDE_EFFECTS (captures[1]))
2261 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2262 1545 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 632, __FILE__, __LINE__, true);
2263 1545 : return _r;
2264 : }
2265 0 : next_after_fail766:;
2266 : }
2267 : else
2268 : {
2269 610 : if (types_match (type, TREE_TYPE (captures[0]))
2270 : )
2271 : {
2272 41 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail767;
2273 41 : {
2274 41 : tree res_op0;
2275 41 : res_op0 = captures[0];
2276 41 : tree res_op1;
2277 41 : res_op1 = build_one_cst (type);
2278 41 : tree _r;
2279 41 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
2280 41 : if (TREE_SIDE_EFFECTS (captures[1]))
2281 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2282 41 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 633, __FILE__, __LINE__, true);
2283 41 : return _r;
2284 : }
2285 0 : next_after_fail767:;
2286 : }
2287 : }
2288 : }
2289 : return NULL_TREE;
2290 : }
2291 :
2292 : tree
2293 0 : generic_simplify_440 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2294 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2295 : const combined_fn ARG_UNUSED (copysigns),
2296 : const combined_fn ARG_UNUSED (coss))
2297 : {
2298 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2299 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail787;
2300 0 : {
2301 0 : tree res_op0;
2302 0 : res_op0 = captures[0];
2303 0 : tree _r;
2304 0 : _r = maybe_build_call_expr_loc (loc, coss, type, 1, res_op0);
2305 0 : if (!_r)
2306 0 : goto next_after_fail787;
2307 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2308 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2309 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 641, __FILE__, __LINE__, true);
2310 : return _r;
2311 : }
2312 : next_after_fail787:;
2313 : return NULL_TREE;
2314 : }
2315 :
2316 : tree
2317 0 : generic_simplify_443 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2318 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2319 : const combined_fn ARG_UNUSED (copysigns),
2320 : const combined_fn ARG_UNUSED (pows))
2321 : {
2322 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2323 0 : {
2324 0 : HOST_WIDE_INT n;
2325 0 : if (real_isinteger (&TREE_REAL_CST (captures[2]), &n) && (n & 1) == 0
2326 : )
2327 : {
2328 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail790;
2329 0 : {
2330 0 : tree res_op0;
2331 0 : res_op0 = captures[0];
2332 0 : tree res_op1;
2333 0 : res_op1 = captures[2];
2334 0 : tree _r;
2335 0 : _r = maybe_build_call_expr_loc (loc, pows, type, 2, res_op0, res_op1);
2336 0 : if (!_r)
2337 0 : goto next_after_fail790;
2338 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2339 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2340 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 644, __FILE__, __LINE__, true);
2341 0 : return _r;
2342 : }
2343 0 : next_after_fail790:;
2344 : }
2345 : }
2346 0 : return NULL_TREE;
2347 : }
2348 :
2349 : tree
2350 0 : generic_simplify_445 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2351 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2352 : const combined_fn ARG_UNUSED (pow))
2353 : {
2354 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2355 0 : if (flag_unsafe_math_optimizations
2356 : )
2357 : {
2358 0 : if (! HONOR_INFINITIES (type)
2359 0 : && ! flag_trapping_math
2360 0 : && ! flag_errno_math
2361 : )
2362 : {
2363 0 : if (! HONOR_NANS (type) && ! HONOR_SIGNED_ZEROS (type)
2364 : )
2365 : {
2366 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail792;
2367 0 : {
2368 0 : tree _r;
2369 0 : _r = captures[0];
2370 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2371 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2372 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 646, __FILE__, __LINE__, true);
2373 0 : return _r;
2374 : }
2375 0 : next_after_fail792:;
2376 : }
2377 : }
2378 : }
2379 : return NULL_TREE;
2380 : }
2381 :
2382 : tree
2383 0 : generic_simplify_448 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2384 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2385 : const combined_fn ARG_UNUSED (copysigns),
2386 : const combined_fn ARG_UNUSED (hypots))
2387 : {
2388 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2389 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail795;
2390 0 : {
2391 0 : tree res_op0;
2392 0 : res_op0 = captures[0];
2393 0 : tree res_op1;
2394 0 : res_op1 = captures[2];
2395 0 : tree _r;
2396 0 : _r = maybe_build_call_expr_loc (loc, hypots, type, 2, res_op0, res_op1);
2397 0 : if (!_r)
2398 0 : goto next_after_fail795;
2399 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2400 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2401 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 649, __FILE__, __LINE__, true);
2402 : return _r;
2403 : }
2404 : next_after_fail795:;
2405 : return NULL_TREE;
2406 : }
2407 :
2408 : tree
2409 4932724 : generic_simplify_452 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2410 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2411 : {
2412 4932724 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2413 4932724 : {
2414 4932724 : bool wascmp;
2415 4932724 : if (types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
2416 4932724 : && bitwise_inverted_equal_p (captures[0], captures[1], wascmp)
2417 : )
2418 : {
2419 115 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail799;
2420 115 : {
2421 115 : tree _r;
2422 115 : _r = wascmp ? constant_boolean_node (false, type) : build_zero_cst (type);
2423 115 : if (TREE_SIDE_EFFECTS (captures[0]))
2424 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2425 115 : if (TREE_SIDE_EFFECTS (captures[1]))
2426 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2427 115 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 653, __FILE__, __LINE__, true);
2428 115 : return _r;
2429 : }
2430 0 : next_after_fail799:;
2431 : }
2432 : }
2433 4932609 : return NULL_TREE;
2434 : }
2435 :
2436 : tree
2437 354 : generic_simplify_461 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2438 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2439 : const enum tree_code ARG_UNUSED (bitop),
2440 : const enum tree_code ARG_UNUSED (op))
2441 : {
2442 354 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2443 354 : {
2444 354 : tree pmop[2];
2445 354 : tree utype = fold_bit_and_mask (TREE_TYPE (captures[1]), captures[5], op, captures[1], ERROR_MARK,
2446 : NULL_TREE, NULL_TREE, captures[2], bitop, captures[3],
2447 : captures[4], pmop);
2448 354 : if (utype
2449 : )
2450 : {
2451 353 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail808;
2452 353 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail808;
2453 353 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail808;
2454 353 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail808;
2455 353 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail808;
2456 353 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail808;
2457 353 : {
2458 353 : tree res_op0;
2459 353 : {
2460 353 : tree _o1[2], _r1;
2461 353 : {
2462 353 : tree _o2[2], _r2;
2463 353 : {
2464 353 : tree _o3[1], _r3;
2465 353 : _o3[0] = pmop[0];
2466 353 : if (TREE_TYPE (_o3[0]) != utype)
2467 : {
2468 14 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
2469 : }
2470 : else
2471 : _r3 = _o3[0];
2472 353 : _o2[0] = _r3;
2473 : }
2474 353 : {
2475 353 : tree _o3[1], _r3;
2476 353 : _o3[0] = pmop[1];
2477 353 : if (TREE_TYPE (_o3[0]) != utype)
2478 : {
2479 74 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
2480 : }
2481 : else
2482 : _r3 = _o3[0];
2483 353 : _o2[1] = _r3;
2484 : }
2485 353 : _r2 = fold_build2_loc (loc, op, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
2486 353 : _o1[0] = _r2;
2487 : }
2488 353 : {
2489 353 : tree _o2[1], _r2;
2490 353 : _o2[0] = captures[5];
2491 353 : if (TREE_TYPE (_o2[0]) != utype)
2492 : {
2493 14 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2494 : }
2495 : else
2496 : _r2 = _o2[0];
2497 353 : _o1[1] = _r2;
2498 : }
2499 353 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2500 353 : res_op0 = _r1;
2501 : }
2502 353 : tree _r;
2503 353 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2504 353 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 661, __FILE__, __LINE__, true);
2505 353 : return _r;
2506 : }
2507 1 : next_after_fail808:;
2508 : }
2509 : }
2510 1 : return NULL_TREE;
2511 : }
2512 :
2513 : tree
2514 202 : generic_simplify_476 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2515 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2516 : const enum tree_code ARG_UNUSED (code2),
2517 : const enum tree_code ARG_UNUSED (code1))
2518 : {
2519 202 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2520 202 : if ((TREE_CODE (captures[2]) == INTEGER_CST
2521 2 : && TREE_CODE (captures[5]) == INTEGER_CST)
2522 202 : || ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2523 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[2]))
2524 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, code2))
2525 0 : || POINTER_TYPE_P (TREE_TYPE (captures[2])))
2526 200 : && bitwise_equal_p (captures[2], captures[5]))
2527 : )
2528 : {
2529 2 : {
2530 2 : bool one_before = false;
2531 2 : bool one_after = false;
2532 2 : int cmp = 0;
2533 2 : bool allbits = true;
2534 2 : if (TREE_CODE (captures[2]) == INTEGER_CST
2535 2 : && TREE_CODE (captures[5]) == INTEGER_CST)
2536 : {
2537 2 : allbits = TYPE_PRECISION (TREE_TYPE (captures[2])) <= TYPE_PRECISION (TREE_TYPE (captures[5]));
2538 2 : auto t1 = wi::to_wide (fold_convert (TREE_TYPE (captures[5]), captures[2]));
2539 2 : auto t2 = wi::to_wide (captures[5]);
2540 2 : cmp = wi::cmp (t1, t2, TYPE_SIGN (TREE_TYPE (captures[5])));
2541 2 : if (cmp < 0
2542 2 : && t1 == t2 - 1)
2543 : one_before = true;
2544 2 : if (cmp > 0
2545 2 : && t1 == t2 + 1)
2546 : one_after = true;
2547 : }
2548 2 : bool val;
2549 2 : switch (code2)
2550 : {
2551 0 : case EQ_EXPR: val = (cmp == 0); break;
2552 2 : case NE_EXPR: val = (cmp != 0); break;
2553 0 : case LT_EXPR: val = (cmp < 0); break;
2554 0 : case GT_EXPR: val = (cmp > 0); break;
2555 0 : case LE_EXPR: val = (cmp <= 0); break;
2556 0 : case GE_EXPR: val = (cmp >= 0); break;
2557 0 : default: gcc_unreachable ();
2558 : }
2559 2 : if (code1 == EQ_EXPR && val
2560 : )
2561 : {
2562 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail831;
2563 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail831;
2564 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail831;
2565 0 : {
2566 0 : tree _r;
2567 0 : _r = captures[0];
2568 0 : if (TREE_SIDE_EFFECTS (captures[4]))
2569 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
2570 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 676, __FILE__, __LINE__, true);
2571 0 : return _r;
2572 : }
2573 : next_after_fail831:;
2574 : }
2575 : else
2576 : {
2577 2 : if (code1 == EQ_EXPR && !val
2578 : )
2579 : {
2580 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail832;
2581 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail832;
2582 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail832;
2583 0 : {
2584 0 : tree _r;
2585 0 : _r = constant_boolean_node (false, type);
2586 0 : if (TREE_SIDE_EFFECTS (captures[4]))
2587 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
2588 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 677, __FILE__, __LINE__, true);
2589 0 : return _r;
2590 : }
2591 : next_after_fail832:;
2592 : }
2593 : else
2594 : {
2595 2 : if (code1 == NE_EXPR && !val && allbits
2596 : )
2597 : {
2598 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail833;
2599 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail833;
2600 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail833;
2601 0 : {
2602 0 : tree _r;
2603 0 : _r = captures[3];
2604 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 678, __FILE__, __LINE__, true);
2605 0 : return _r;
2606 : }
2607 : next_after_fail833:;
2608 : }
2609 : else
2610 : {
2611 2 : if ((code1 == NE_EXPR
2612 2 : && code2 == GE_EXPR
2613 0 : && cmp == 0
2614 0 : && allbits)
2615 2 : && ((VECTOR_BOOLEAN_TYPE_P (type)
2616 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GT_EXPR))
2617 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
2618 : )
2619 : {
2620 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail834;
2621 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail834;
2622 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail834;
2623 0 : {
2624 0 : tree res_op0;
2625 0 : res_op0 = captures[4];
2626 0 : tree res_op1;
2627 0 : {
2628 0 : tree _o1[1], _r1;
2629 0 : _o1[0] = captures[2];
2630 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
2631 : {
2632 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
2633 : }
2634 : else
2635 : _r1 = _o1[0];
2636 0 : res_op1 = _r1;
2637 : }
2638 0 : tree _r;
2639 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
2640 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 679, __FILE__, __LINE__, true);
2641 0 : return _r;
2642 : }
2643 : next_after_fail834:;
2644 : }
2645 : else
2646 : {
2647 2 : if ((code1 == NE_EXPR
2648 2 : && code2 == LE_EXPR
2649 0 : && cmp == 0
2650 0 : && allbits)
2651 2 : && ((VECTOR_BOOLEAN_TYPE_P (type)
2652 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LT_EXPR))
2653 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
2654 : )
2655 : {
2656 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail835;
2657 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail835;
2658 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail835;
2659 0 : {
2660 0 : tree res_op0;
2661 0 : res_op0 = captures[4];
2662 0 : tree res_op1;
2663 0 : {
2664 0 : tree _o1[1], _r1;
2665 0 : _o1[0] = captures[2];
2666 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
2667 : {
2668 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
2669 : }
2670 : else
2671 : _r1 = _o1[0];
2672 0 : res_op1 = _r1;
2673 : }
2674 0 : tree _r;
2675 0 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
2676 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 680, __FILE__, __LINE__, true);
2677 0 : return _r;
2678 : }
2679 : next_after_fail835:;
2680 : }
2681 : else
2682 : {
2683 2 : if ((code1 == NE_EXPR
2684 2 : && code2 == GT_EXPR
2685 : && one_after
2686 0 : && allbits)
2687 2 : && ((VECTOR_BOOLEAN_TYPE_P (type)
2688 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GT_EXPR))
2689 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
2690 : )
2691 : {
2692 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail836;
2693 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail836;
2694 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail836;
2695 0 : {
2696 0 : tree res_op0;
2697 0 : res_op0 = captures[4];
2698 0 : tree res_op1;
2699 0 : {
2700 0 : tree _o1[1], _r1;
2701 0 : _o1[0] = captures[2];
2702 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
2703 : {
2704 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
2705 : }
2706 : else
2707 : _r1 = _o1[0];
2708 0 : res_op1 = _r1;
2709 : }
2710 0 : tree _r;
2711 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
2712 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 681, __FILE__, __LINE__, true);
2713 0 : return _r;
2714 : }
2715 : next_after_fail836:;
2716 : }
2717 : else
2718 : {
2719 2 : if ((code1 == NE_EXPR
2720 2 : && code2 == LT_EXPR
2721 : && one_before
2722 0 : && allbits)
2723 2 : && ((VECTOR_BOOLEAN_TYPE_P (type)
2724 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LT_EXPR))
2725 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
2726 : )
2727 : {
2728 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail837;
2729 0 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail837;
2730 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail837;
2731 0 : {
2732 0 : tree res_op0;
2733 0 : res_op0 = captures[4];
2734 0 : tree res_op1;
2735 0 : {
2736 0 : tree _o1[1], _r1;
2737 0 : _o1[0] = captures[2];
2738 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (res_op0))
2739 : {
2740 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0), _o1[0]);
2741 : }
2742 : else
2743 : _r1 = _o1[0];
2744 0 : res_op1 = _r1;
2745 : }
2746 0 : tree _r;
2747 0 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
2748 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 682, __FILE__, __LINE__, true);
2749 0 : return _r;
2750 : }
2751 : next_after_fail837:;
2752 : }
2753 : }
2754 : }
2755 : }
2756 : }
2757 : }
2758 : }
2759 : }
2760 : }
2761 : return NULL_TREE;
2762 : }
2763 :
2764 : tree
2765 29 : generic_simplify_507 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2766 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2767 : {
2768 29 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2769 29 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
2770 : )
2771 : {
2772 29 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail898;
2773 29 : {
2774 29 : tree res_op0;
2775 29 : {
2776 29 : tree _o1[2], _r1;
2777 29 : _o1[0] = captures[0];
2778 29 : {
2779 29 : tree _o2[1], _r2;
2780 29 : _o2[0] = captures[1];
2781 29 : _r2 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
2782 29 : _o1[1] = _r2;
2783 : }
2784 29 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2785 29 : res_op0 = _r1;
2786 : }
2787 29 : tree _r;
2788 29 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2789 29 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 712, __FILE__, __LINE__, true);
2790 29 : return _r;
2791 : }
2792 0 : next_after_fail898:;
2793 : }
2794 : return NULL_TREE;
2795 : }
2796 :
2797 : tree
2798 16 : generic_simplify_515 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2799 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2800 : {
2801 16 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2802 16 : if (ANY_INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_SANITIZED (type)
2803 : )
2804 : {
2805 16 : {
2806 16 : tree ptrdifftype = TREE_TYPE (captures[0]);
2807 16 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail907;
2808 16 : {
2809 16 : tree res_op0;
2810 16 : {
2811 16 : tree _o1[2], _r1;
2812 16 : _o1[0] = captures[2];
2813 16 : _o1[1] = captures[1];
2814 16 : _r1 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ptrdifftype, _o1[0], _o1[1]);
2815 16 : res_op0 = _r1;
2816 : }
2817 16 : tree _r;
2818 16 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2819 16 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 719, __FILE__, __LINE__, true);
2820 16 : return _r;
2821 : }
2822 0 : next_after_fail907:;
2823 : }
2824 : }
2825 : return NULL_TREE;
2826 : }
2827 :
2828 : tree
2829 0 : generic_simplify_522 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2830 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2831 : const enum tree_code ARG_UNUSED (minmax))
2832 : {
2833 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2834 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail915;
2835 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail915;
2836 0 : {
2837 0 : tree _r;
2838 0 : _r = captures[0];
2839 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 727, __FILE__, __LINE__, true);
2840 : return _r;
2841 : }
2842 : next_after_fail915:;
2843 : return NULL_TREE;
2844 : }
2845 :
2846 : tree
2847 47 : generic_simplify_530 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2848 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2849 : const enum tree_code ARG_UNUSED (minmax),
2850 : const enum tree_code ARG_UNUSED (cmp))
2851 : {
2852 47 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2853 47 : {
2854 47 : poly_int64 off0, off1;
2855 47 : tree base0, base1;
2856 47 : int equal = address_compare (cmp, TREE_TYPE (captures[0]), captures[1], captures[3], base0, base1,
2857 : off0, off1,
2858 : 1
2859 : );
2860 47 : if (equal == 1
2861 : )
2862 : {
2863 0 : if (minmax == MIN_EXPR
2864 : )
2865 : {
2866 0 : if (known_le (off0, off1)
2867 : )
2868 : {
2869 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail925;
2870 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail925;
2871 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail925;
2872 0 : {
2873 0 : tree _r;
2874 0 : _r = captures[0];
2875 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 736, __FILE__, __LINE__, true);
2876 0 : return _r;
2877 : }
2878 47 : next_after_fail925:;
2879 : }
2880 : else
2881 : {
2882 0 : if (known_gt (off0, off1)
2883 : )
2884 : {
2885 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail926;
2886 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail926;
2887 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail926;
2888 0 : {
2889 0 : tree _r;
2890 0 : _r = captures[2];
2891 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 737, __FILE__, __LINE__, true);
2892 0 : return _r;
2893 : }
2894 47 : next_after_fail926:;
2895 : }
2896 : }
2897 : }
2898 : else
2899 : {
2900 0 : if (known_ge (off0, off1)
2901 : )
2902 : {
2903 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail927;
2904 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail927;
2905 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail927;
2906 0 : {
2907 0 : tree _r;
2908 0 : _r = captures[0];
2909 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 738, __FILE__, __LINE__, true);
2910 0 : return _r;
2911 : }
2912 47 : next_after_fail927:;
2913 : }
2914 : else
2915 : {
2916 0 : if (known_lt (off0, off1)
2917 : )
2918 : {
2919 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail928;
2920 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail928;
2921 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail928;
2922 0 : {
2923 0 : tree _r;
2924 0 : _r = captures[2];
2925 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 739, __FILE__, __LINE__, true);
2926 0 : return _r;
2927 : }
2928 47 : next_after_fail928:;
2929 : }
2930 : }
2931 : }
2932 : }
2933 : }
2934 47 : return NULL_TREE;
2935 : }
2936 :
2937 : tree
2938 0 : generic_simplify_551 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2939 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
2940 : const combined_fn ARG_UNUSED (cond_len_op))
2941 : {
2942 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2943 0 : {
2944 0 : tree op_type = TREE_TYPE (captures[3]);
2945 0 : if (element_precision (type) == element_precision (op_type)
2946 : )
2947 : {
2948 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail958;
2949 0 : {
2950 0 : tree res_op0;
2951 0 : {
2952 0 : tree _o1[6], _r1;
2953 0 : _o1[0] = captures[0];
2954 0 : _o1[1] = captures[1];
2955 0 : _o1[2] = captures[2];
2956 0 : {
2957 0 : tree _o2[1], _r2;
2958 0 : _o2[0] = captures[6];
2959 0 : if (TREE_TYPE (_o2[0]) != op_type)
2960 : {
2961 0 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
2962 : }
2963 : else
2964 : _r2 = _o2[0];
2965 0 : _o1[3] = _r2;
2966 : }
2967 0 : _o1[4] = captures[4];
2968 0 : _o1[5] = captures[5];
2969 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]);
2970 0 : if (!_r1)
2971 0 : goto next_after_fail958;
2972 0 : res_op0 = _r1;
2973 : }
2974 0 : tree _r;
2975 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
2976 0 : if (TREE_SIDE_EFFECTS (captures[3]))
2977 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
2978 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 752, __FILE__, __LINE__, true);
2979 0 : return _r;
2980 : }
2981 : next_after_fail958:;
2982 : }
2983 : }
2984 : return NULL_TREE;
2985 : }
2986 :
2987 : tree
2988 0 : generic_simplify_561 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2989 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
2990 : const combined_fn ARG_UNUSED (bswap))
2991 : {
2992 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2993 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail971;
2994 0 : {
2995 0 : tree _r;
2996 0 : _r = captures[0];
2997 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 765, __FILE__, __LINE__, true);
2998 : return _r;
2999 : }
3000 0 : next_after_fail971:;
3001 0 : return NULL_TREE;
3002 : }
3003 :
3004 : tree
3005 0 : generic_simplify_568 (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 combined_fn ARG_UNUSED (ovf))
3008 : {
3009 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3010 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
3011 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
3012 0 : && TYPE_PRECISION (TREE_TYPE (captures[1])) > TYPE_PRECISION (TREE_TYPE (captures[2]))
3013 0 : && (!TYPE_UNSIGNED (TREE_TYPE (captures[1])) || TYPE_UNSIGNED (TREE_TYPE (captures[2])))
3014 : )
3015 : {
3016 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail978;
3017 0 : {
3018 0 : tree res_op0;
3019 0 : res_op0 = captures[0];
3020 0 : tree res_op1;
3021 0 : res_op1 = captures[2];
3022 0 : tree _r;
3023 0 : _r = maybe_build_call_expr_loc (loc, ovf, type, 2, res_op0, res_op1);
3024 0 : if (!_r)
3025 0 : goto next_after_fail978;
3026 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 772, __FILE__, __LINE__, true);
3027 0 : return _r;
3028 : }
3029 : next_after_fail978:;
3030 : }
3031 : return NULL_TREE;
3032 : }
3033 :
3034 : tree
3035 0 : generic_simplify_576 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3036 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3037 : const combined_fn ARG_UNUSED (fns))
3038 : {
3039 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3040 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail986;
3041 0 : {
3042 0 : tree _r;
3043 0 : _r = captures[0];
3044 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 780, __FILE__, __LINE__, true);
3045 : return _r;
3046 : }
3047 0 : next_after_fail986:;
3048 0 : return NULL_TREE;
3049 : }
3050 :
3051 : tree
3052 0 : generic_simplify_581 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3053 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
3054 : {
3055 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3056 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail991;
3057 0 : {
3058 0 : tree _r;
3059 0 : _r = captures[0];
3060 0 : if (TREE_SIDE_EFFECTS (captures[1]))
3061 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3062 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 785, __FILE__, __LINE__, true);
3063 : return _r;
3064 : }
3065 0 : next_after_fail991:;
3066 0 : return NULL_TREE;
3067 : }
3068 :
3069 : tree
3070 0 : generic_simplify_588 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3071 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3072 : const combined_fn ARG_UNUSED (rints))
3073 : {
3074 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3075 0 : if (canonicalize_math_p ()
3076 : )
3077 : {
3078 0 : if (!flag_errno_math
3079 : )
3080 : {
3081 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail998;
3082 0 : {
3083 0 : tree res_op0;
3084 0 : res_op0 = captures[0];
3085 0 : tree _r;
3086 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3087 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 792, __FILE__, __LINE__, true);
3088 0 : return _r;
3089 : }
3090 0 : next_after_fail998:;
3091 : }
3092 : }
3093 : return NULL_TREE;
3094 : }
3095 :
3096 : tree
3097 0 : generic_simplify_594 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3098 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
3099 : const combined_fn ARG_UNUSED (fmas))
3100 : {
3101 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3102 0 : if (canonicalize_math_after_vectorization_p ()
3103 : )
3104 : {
3105 : {
3106 : tree t = TREE_TYPE (captures[0]);
3107 : if ((!ANY_INTEGRAL_TYPE_P (type)
3108 : || TYPE_UNSIGNED (type)
3109 : || !TYPE_OVERFLOW_SANITIZED (type))
3110 : && (!ANY_INTEGRAL_TYPE_P (t)
3111 : || TYPE_UNSIGNED (t)
3112 : || !TYPE_OVERFLOW_SANITIZED (type))
3113 : )
3114 : {
3115 : {
3116 : tree utype = unsigned_type_for (type);
3117 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1004;
3118 : {
3119 : tree res_op0;
3120 : {
3121 : tree _o1[3], _r1;
3122 : {
3123 : tree _o2[1], _r2;
3124 : _o2[0] = captures[0];
3125 : if (TREE_TYPE (_o2[0]) != utype)
3126 : {
3127 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
3128 : }
3129 : else
3130 : _r2 = _o2[0];
3131 : _o1[0] = _r2;
3132 : }
3133 : {
3134 : tree _o2[1], _r2;
3135 : _o2[0] = captures[1];
3136 : if (TREE_TYPE (_o2[0]) != utype)
3137 : {
3138 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
3139 : }
3140 : else
3141 : _r2 = _o2[0];
3142 : _o1[1] = _r2;
3143 : }
3144 : {
3145 : tree _o2[1], _r2;
3146 : _o2[0] = captures[2];
3147 : if (TREE_TYPE (_o2[0]) != utype)
3148 : {
3149 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
3150 : }
3151 : else
3152 : _r2 = _o2[0];
3153 : _o1[2] = _r2;
3154 : }
3155 : _r1 = maybe_build_call_expr_loc (loc, CFN_FNMA, TREE_TYPE (_o1[0]), 3, _o1[0], _o1[1], _o1[2]);
3156 : if (!_r1)
3157 : goto next_after_fail1004;
3158 : res_op0 = _r1;
3159 : }
3160 : tree _r;
3161 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3162 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 798, __FILE__, __LINE__, true);
3163 : return _r;
3164 : }
3165 0 : next_after_fail1004:;
3166 : }
3167 : }
3168 : }
3169 : }
3170 0 : return NULL_TREE;
3171 : }
3172 :
3173 : tree
3174 0 : generic_simplify_616 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3175 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3176 : const combined_fn ARG_UNUSED (bswap),
3177 : const combined_fn ARG_UNUSED (popcount))
3178 : {
3179 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3180 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3181 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
3182 : )
3183 : {
3184 0 : {
3185 0 : tree type0 = TREE_TYPE (captures[0]);
3186 0 : tree type1 = TREE_TYPE (captures[1]);
3187 0 : unsigned int prec0 = TYPE_PRECISION (type0);
3188 0 : unsigned int prec1 = TYPE_PRECISION (type1);
3189 0 : if (prec0 == prec1 || (prec0 > prec1 && TYPE_UNSIGNED (type1))
3190 : )
3191 : {
3192 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1026;
3193 0 : {
3194 0 : tree res_op0;
3195 0 : {
3196 0 : tree _o1[1], _r1;
3197 0 : {
3198 0 : tree _o2[1], _r2;
3199 0 : _o2[0] = captures[2];
3200 0 : if (TREE_TYPE (_o2[0]) != type1)
3201 : {
3202 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, type1, _o2[0]);
3203 : }
3204 : else
3205 : _r2 = _o2[0];
3206 0 : _o1[0] = _r2;
3207 : }
3208 0 : if (TREE_TYPE (_o1[0]) != type0)
3209 : {
3210 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type0, _o1[0]);
3211 : }
3212 : else
3213 : _r1 = _o1[0];
3214 0 : res_op0 = _r1;
3215 : }
3216 0 : tree _r;
3217 0 : _r = maybe_build_call_expr_loc (loc, popcount, type, 1, res_op0);
3218 0 : if (!_r)
3219 0 : goto next_after_fail1026;
3220 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 814, __FILE__, __LINE__, true);
3221 0 : return _r;
3222 : }
3223 : next_after_fail1026:;
3224 : }
3225 : }
3226 : }
3227 : return NULL_TREE;
3228 : }
3229 :
3230 : tree
3231 2161745 : generic_simplify_ABS_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0)
3232 : {
3233 2161745 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3234 2161745 : switch (TREE_CODE (_p0))
3235 : {
3236 196587 : CASE_CONVERT:
3237 196587 : {
3238 196587 : tree _q20 = TREE_OPERAND (_p0, 0);
3239 196587 : {
3240 196587 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3241 393172 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3242 915 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
3243 841 : && element_precision (type) > element_precision (TREE_TYPE (captures[0]))
3244 196813 : && (!VECTOR_TYPE_P (type)
3245 0 : || target_supports_op_p (TREE_TYPE (captures[0]), ABSU_EXPR, optab_vector))
3246 : )
3247 : {
3248 226 : {
3249 226 : tree utype = unsigned_type_for (TREE_TYPE (captures[0]));
3250 226 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1040;
3251 226 : {
3252 226 : tree res_op0;
3253 226 : {
3254 226 : tree _o1[1], _r1;
3255 226 : _o1[0] = captures[0];
3256 226 : _r1 = fold_build1_loc (loc, ABSU_EXPR, utype, _o1[0]);
3257 226 : res_op0 = _r1;
3258 : }
3259 226 : tree _r;
3260 226 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3261 226 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 827, __FILE__, __LINE__, true);
3262 226 : return _r;
3263 : }
3264 0 : next_after_fail1040:;
3265 : }
3266 : }
3267 : }
3268 : break;
3269 : }
3270 12 : case ABS_EXPR:
3271 12 : {
3272 12 : tree _q20 = TREE_OPERAND (_p0, 0);
3273 12 : {
3274 12 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3275 12 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1041;
3276 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1041;
3277 12 : {
3278 12 : tree _r;
3279 12 : _r = captures[0];
3280 12 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 828, __FILE__, __LINE__, true);
3281 12 : return _r;
3282 : }
3283 0 : next_after_fail1041:;
3284 : }
3285 0 : break;
3286 : }
3287 57 : case NEGATE_EXPR:
3288 57 : {
3289 57 : tree _q20 = TREE_OPERAND (_p0, 0);
3290 57 : {
3291 57 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3292 57 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1042;
3293 57 : {
3294 57 : tree res_op0;
3295 57 : res_op0 = captures[0];
3296 57 : tree _r;
3297 57 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
3298 57 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 829, __FILE__, __LINE__, true);
3299 2161745 : return _r;
3300 : }
3301 0 : next_after_fail1042:;
3302 : }
3303 0 : break;
3304 : }
3305 317 : case PLUS_EXPR:
3306 317 : {
3307 317 : tree _q20 = TREE_OPERAND (_p0, 0);
3308 317 : tree _q21 = TREE_OPERAND (_p0, 1);
3309 317 : if (real_zerop (_q21))
3310 : {
3311 3 : {
3312 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3313 3 : tree res = generic_simplify_1 (loc, type, _p0, captures, PLUS_EXPR);
3314 3 : if (res) return res;
3315 : }
3316 : }
3317 : break;
3318 : }
3319 7853 : case MINUS_EXPR:
3320 7853 : {
3321 7853 : tree _q20 = TREE_OPERAND (_p0, 0);
3322 7853 : tree _q21 = TREE_OPERAND (_p0, 1);
3323 7853 : if (real_zerop (_q21))
3324 : {
3325 0 : {
3326 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3327 0 : tree res = generic_simplify_1 (loc, type, _p0, captures, MINUS_EXPR);
3328 0 : if (res) return res;
3329 : }
3330 : }
3331 : break;
3332 : }
3333 0 : case VEC_COND_EXPR:
3334 0 : {
3335 0 : tree _q20 = TREE_OPERAND (_p0, 0);
3336 0 : tree _q21 = TREE_OPERAND (_p0, 1);
3337 0 : tree _q22 = TREE_OPERAND (_p0, 2);
3338 0 : {
3339 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
3340 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1043;
3341 0 : {
3342 0 : tree res_op0;
3343 0 : res_op0 = captures[1];
3344 0 : tree res_op1;
3345 0 : {
3346 0 : tree _o1[1], _r1;
3347 0 : _o1[0] = captures[2];
3348 0 : _r1 = fold_build1_loc (loc, ABS_EXPR, type, _o1[0]);
3349 0 : if (EXPR_P (_r1))
3350 0 : goto next_after_fail1043;
3351 0 : res_op1 = _r1;
3352 : }
3353 0 : tree res_op2;
3354 0 : {
3355 0 : tree _o1[1], _r1;
3356 0 : _o1[0] = captures[3];
3357 0 : _r1 = fold_build1_loc (loc, ABS_EXPR, type, _o1[0]);
3358 0 : if (EXPR_P (_r1))
3359 0 : goto next_after_fail1043;
3360 0 : res_op2 = _r1;
3361 : }
3362 0 : tree _r;
3363 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
3364 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 830, __FILE__, __LINE__, true);
3365 0 : return _r;
3366 : }
3367 0 : next_after_fail1043:;
3368 : }
3369 0 : break;
3370 : }
3371 702 : case CALL_EXPR:
3372 702 : switch (get_call_combined_fn (_p0))
3373 : {
3374 0 : case CFN_BUILT_IN_COPYSIGNF16:
3375 0 : if (call_expr_nargs (_p0) == 2)
3376 : {
3377 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3378 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3379 0 : {
3380 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3381 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF16);
3382 0 : if (res) return res;
3383 : }
3384 : }
3385 : break;
3386 0 : case CFN_BUILT_IN_COPYSIGNF32:
3387 0 : if (call_expr_nargs (_p0) == 2)
3388 : {
3389 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3390 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3391 0 : {
3392 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3393 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF32);
3394 0 : if (res) return res;
3395 : }
3396 : }
3397 : break;
3398 0 : case CFN_BUILT_IN_COPYSIGNF64:
3399 0 : if (call_expr_nargs (_p0) == 2)
3400 : {
3401 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3402 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3403 0 : {
3404 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3405 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF64);
3406 0 : if (res) return res;
3407 : }
3408 : }
3409 : break;
3410 0 : case CFN_BUILT_IN_COPYSIGNF128X:
3411 0 : if (call_expr_nargs (_p0) == 2)
3412 : {
3413 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3414 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3415 0 : {
3416 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3417 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF128X);
3418 0 : if (res) return res;
3419 : }
3420 : }
3421 : break;
3422 0 : case CFN_BUILT_IN_COPYSIGNF128:
3423 0 : if (call_expr_nargs (_p0) == 2)
3424 : {
3425 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3426 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3427 0 : {
3428 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3429 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF128);
3430 0 : if (res) return res;
3431 : }
3432 : }
3433 : break;
3434 0 : case CFN_BUILT_IN_COPYSIGNF32X:
3435 0 : if (call_expr_nargs (_p0) == 2)
3436 : {
3437 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3438 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3439 0 : {
3440 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3441 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF32X);
3442 0 : if (res) return res;
3443 : }
3444 : }
3445 : break;
3446 0 : case CFN_BUILT_IN_COPYSIGNF64X:
3447 0 : if (call_expr_nargs (_p0) == 2)
3448 : {
3449 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3450 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3451 0 : {
3452 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3453 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF64X);
3454 0 : if (res) return res;
3455 : }
3456 : }
3457 : break;
3458 0 : case CFN_BUILT_IN_COPYSIGN:
3459 0 : if (call_expr_nargs (_p0) == 2)
3460 : {
3461 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3462 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3463 0 : {
3464 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3465 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGN);
3466 0 : if (res) return res;
3467 : }
3468 : }
3469 : break;
3470 1 : case CFN_BUILT_IN_COPYSIGNF:
3471 1 : if (call_expr_nargs (_p0) == 2)
3472 : {
3473 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3474 1 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3475 1 : {
3476 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3477 1 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNF);
3478 1 : if (res) return res;
3479 : }
3480 : }
3481 : break;
3482 0 : case CFN_BUILT_IN_COPYSIGNL:
3483 0 : if (call_expr_nargs (_p0) == 2)
3484 : {
3485 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3486 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3487 0 : {
3488 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3489 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_BUILT_IN_COPYSIGNL);
3490 0 : if (res) return res;
3491 : }
3492 : }
3493 : break;
3494 0 : case CFN_COPYSIGN:
3495 0 : if (call_expr_nargs (_p0) == 2)
3496 : {
3497 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
3498 0 : tree _q21 = CALL_EXPR_ARG (_p0, 1);
3499 0 : {
3500 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3501 0 : tree res = generic_simplify_2 (loc, type, _p0, captures, CFN_COPYSIGN);
3502 0 : if (res) return res;
3503 : }
3504 : }
3505 : break;
3506 : default:;
3507 : }
3508 : break;
3509 2161447 : default:;
3510 : }
3511 2161447 : if (tree_expr_nonnegative_p (_p0))
3512 : {
3513 548 : {
3514 548 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3515 548 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1044;
3516 548 : {
3517 548 : tree _r;
3518 548 : _r = captures[0];
3519 548 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 831, __FILE__, __LINE__, true);
3520 548 : return _r;
3521 : }
3522 0 : next_after_fail1044:;
3523 : }
3524 : }
3525 : return NULL_TREE;
3526 : }
3527 :
3528 : tree
3529 998904 : 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)
3530 : {
3531 998904 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3532 998904 : switch (TREE_CODE (_p0))
3533 : {
3534 102 : case MINUS_EXPR:
3535 102 : {
3536 102 : tree _q20 = TREE_OPERAND (_p0, 0);
3537 102 : tree _q21 = TREE_OPERAND (_p0, 1);
3538 102 : switch (TREE_CODE (_q21))
3539 : {
3540 22 : CASE_CONVERT:
3541 22 : {
3542 22 : tree _q40 = TREE_OPERAND (_q21, 0);
3543 22 : switch (TREE_CODE (_q40))
3544 : {
3545 0 : case LT_EXPR:
3546 0 : {
3547 0 : tree _q50 = TREE_OPERAND (_q40, 0);
3548 0 : tree _q51 = TREE_OPERAND (_q40, 1);
3549 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
3550 : {
3551 0 : if (integer_zerop (_q51))
3552 : {
3553 0 : switch (TREE_CODE (_p1))
3554 : {
3555 0 : case NEGATE_EXPR:
3556 0 : {
3557 0 : tree _q80 = TREE_OPERAND (_p1, 0);
3558 0 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
3559 : {
3560 0 : {
3561 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
3562 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3563 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
3564 : )
3565 : {
3566 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1163;
3567 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1163;
3568 0 : {
3569 0 : tree res_op0;
3570 0 : res_op0 = captures[0];
3571 0 : tree _r;
3572 0 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
3573 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 888, __FILE__, __LINE__, true);
3574 0 : return _r;
3575 : }
3576 0 : next_after_fail1163:;
3577 : }
3578 : }
3579 : }
3580 : break;
3581 : }
3582 : default:;
3583 : }
3584 : }
3585 : }
3586 : break;
3587 : }
3588 : default:;
3589 : }
3590 : break;
3591 : }
3592 : default:;
3593 : }
3594 : break;
3595 : }
3596 142 : case NEGATE_EXPR:
3597 142 : {
3598 142 : tree _q20 = TREE_OPERAND (_p0, 0);
3599 142 : switch (TREE_CODE (_p1))
3600 : {
3601 0 : case MINUS_EXPR:
3602 0 : {
3603 0 : tree _q40 = TREE_OPERAND (_p1, 0);
3604 0 : tree _q41 = TREE_OPERAND (_p1, 1);
3605 0 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
3606 : {
3607 0 : switch (TREE_CODE (_q41))
3608 : {
3609 0 : CASE_CONVERT:
3610 0 : {
3611 0 : tree _q70 = TREE_OPERAND (_q41, 0);
3612 0 : switch (TREE_CODE (_q70))
3613 : {
3614 0 : case LT_EXPR:
3615 0 : {
3616 0 : tree _q80 = TREE_OPERAND (_q70, 0);
3617 0 : tree _q81 = TREE_OPERAND (_q70, 1);
3618 0 : if ((_q80 == _q40 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q40, 0) && types_match (_q80, _q40)))
3619 : {
3620 0 : if (integer_zerop (_q81))
3621 : {
3622 0 : {
3623 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
3624 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3625 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
3626 : )
3627 : {
3628 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1164;
3629 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1164;
3630 0 : {
3631 0 : tree res_op0;
3632 0 : res_op0 = captures[0];
3633 0 : tree _r;
3634 0 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
3635 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 888, __FILE__, __LINE__, true);
3636 0 : return _r;
3637 : }
3638 0 : next_after_fail1164:;
3639 : }
3640 : }
3641 : }
3642 : }
3643 : break;
3644 : }
3645 : default:;
3646 : }
3647 : break;
3648 : }
3649 : default:;
3650 : }
3651 : }
3652 : break;
3653 : }
3654 : default:;
3655 : }
3656 : break;
3657 : }
3658 998904 : default:;
3659 : }
3660 998904 : if (integer_zerop (_p1))
3661 : {
3662 543 : {
3663 543 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3664 543 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1165;
3665 543 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1165;
3666 543 : {
3667 543 : tree res_op0;
3668 543 : res_op0 = captures[0];
3669 543 : tree _r;
3670 543 : _r = non_lvalue_loc (loc, res_op0);
3671 543 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 889, __FILE__, __LINE__, true);
3672 543 : return _r;
3673 : }
3674 : next_after_fail1165:;
3675 : }
3676 : }
3677 998361 : switch (TREE_CODE (_p0))
3678 : {
3679 2976 : case LSHIFT_EXPR:
3680 2976 : {
3681 2976 : tree _q20 = TREE_OPERAND (_p0, 0);
3682 2976 : tree _q21 = TREE_OPERAND (_p0, 1);
3683 2976 : switch (TREE_CODE (_p1))
3684 : {
3685 10 : case LSHIFT_EXPR:
3686 10 : {
3687 10 : tree _q50 = TREE_OPERAND (_p1, 0);
3688 10 : tree _q51 = TREE_OPERAND (_p1, 1);
3689 10 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
3690 : {
3691 1 : {
3692 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
3693 1 : tree res = generic_simplify_3 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3694 1 : if (res) return res;
3695 : }
3696 : }
3697 : break;
3698 : }
3699 : default:;
3700 : }
3701 : break;
3702 : }
3703 22302 : case RSHIFT_EXPR:
3704 22302 : {
3705 22302 : tree _q20 = TREE_OPERAND (_p0, 0);
3706 22302 : tree _q21 = TREE_OPERAND (_p0, 1);
3707 22302 : switch (TREE_CODE (_p1))
3708 : {
3709 20 : case RSHIFT_EXPR:
3710 20 : {
3711 20 : tree _q50 = TREE_OPERAND (_p1, 0);
3712 20 : tree _q51 = TREE_OPERAND (_p1, 1);
3713 20 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
3714 : {
3715 10 : {
3716 10 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
3717 10 : tree res = generic_simplify_4 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3718 10 : if (res) return res;
3719 : }
3720 : }
3721 : break;
3722 : }
3723 : default:;
3724 : }
3725 : break;
3726 : }
3727 3380 : case BIT_AND_EXPR:
3728 3380 : {
3729 3380 : tree _q20 = TREE_OPERAND (_p0, 0);
3730 3380 : tree _q21 = TREE_OPERAND (_p0, 1);
3731 3380 : switch (TREE_CODE (_p1))
3732 : {
3733 354 : case BIT_AND_EXPR:
3734 354 : {
3735 354 : tree _q50 = TREE_OPERAND (_p1, 0);
3736 354 : tree _q51 = TREE_OPERAND (_p1, 1);
3737 354 : {
3738 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51 };
3739 354 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3740 354 : if (res) return res;
3741 : }
3742 354 : {
3743 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q51, _q50 };
3744 354 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3745 354 : if (res) return res;
3746 : }
3747 354 : {
3748 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q50, _q51 };
3749 354 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3750 354 : if (res) return res;
3751 : }
3752 354 : {
3753 354 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q51, _q50 };
3754 354 : tree res = generic_simplify_5 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3755 354 : if (res) return res;
3756 : }
3757 354 : break;
3758 : }
3759 3380 : default:;
3760 : }
3761 3380 : switch (TREE_CODE (_q21))
3762 : {
3763 41 : case BIT_NOT_EXPR:
3764 41 : {
3765 41 : tree _q40 = TREE_OPERAND (_q21, 0);
3766 41 : switch (TREE_CODE (_p1))
3767 : {
3768 0 : case BIT_NOT_EXPR:
3769 0 : {
3770 0 : tree _q60 = TREE_OPERAND (_p1, 0);
3771 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
3772 : {
3773 0 : {
3774 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
3775 0 : tree res = generic_simplify_6 (loc, type, _p0, _p1, captures);
3776 0 : if (res) return res;
3777 : }
3778 : }
3779 : break;
3780 : }
3781 : default:;
3782 : }
3783 : break;
3784 : }
3785 3380 : default:;
3786 : }
3787 3380 : switch (TREE_CODE (_q20))
3788 : {
3789 90 : case BIT_NOT_EXPR:
3790 90 : {
3791 90 : tree _q30 = TREE_OPERAND (_q20, 0);
3792 90 : switch (TREE_CODE (_p1))
3793 : {
3794 0 : case BIT_NOT_EXPR:
3795 0 : {
3796 0 : tree _q60 = TREE_OPERAND (_p1, 0);
3797 0 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
3798 : {
3799 0 : {
3800 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q30 };
3801 0 : tree res = generic_simplify_6 (loc, type, _p0, _p1, captures);
3802 0 : if (res) return res;
3803 : }
3804 : }
3805 : break;
3806 : }
3807 90 : default:;
3808 : }
3809 90 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
3810 : {
3811 0 : {
3812 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q21 };
3813 0 : tree res = generic_simplify_7 (loc, type, _p0, _p1, captures);
3814 0 : if (res) return res;
3815 : }
3816 : }
3817 : break;
3818 : }
3819 3380 : default:;
3820 : }
3821 3380 : switch (TREE_CODE (_q21))
3822 : {
3823 41 : case BIT_NOT_EXPR:
3824 41 : {
3825 41 : tree _q40 = TREE_OPERAND (_q21, 0);
3826 41 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
3827 : {
3828 0 : {
3829 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q20 };
3830 0 : tree res = generic_simplify_7 (loc, type, _p0, _p1, captures);
3831 0 : if (res) return res;
3832 : }
3833 : }
3834 : break;
3835 : }
3836 : default:;
3837 : }
3838 : break;
3839 : }
3840 505 : case BIT_NOT_EXPR:
3841 505 : {
3842 505 : tree _q20 = TREE_OPERAND (_p0, 0);
3843 505 : switch (TREE_CODE (_p1))
3844 : {
3845 51 : case BIT_AND_EXPR:
3846 51 : {
3847 51 : tree _q40 = TREE_OPERAND (_p1, 0);
3848 51 : tree _q41 = TREE_OPERAND (_p1, 1);
3849 51 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
3850 : {
3851 0 : switch (TREE_CODE (_q41))
3852 : {
3853 0 : case BIT_NOT_EXPR:
3854 0 : {
3855 0 : tree _q60 = TREE_OPERAND (_q41, 0);
3856 0 : {
3857 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q20, _q60 };
3858 0 : tree res = generic_simplify_6 (loc, type, _p0, _p1, captures);
3859 0 : if (res) return res;
3860 : }
3861 0 : break;
3862 : }
3863 : default:;
3864 : }
3865 : }
3866 51 : switch (TREE_CODE (_q40))
3867 : {
3868 7 : case BIT_NOT_EXPR:
3869 7 : {
3870 7 : tree _q50 = TREE_OPERAND (_q40, 0);
3871 7 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
3872 : {
3873 0 : {
3874 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q20, _q50 };
3875 0 : tree res = generic_simplify_6 (loc, type, _p0, _p1, captures);
3876 0 : if (res) return res;
3877 : }
3878 : }
3879 : break;
3880 : }
3881 : default:;
3882 : }
3883 : break;
3884 : }
3885 : default:;
3886 : }
3887 : break;
3888 : }
3889 998350 : default:;
3890 : }
3891 998350 : switch (TREE_CODE (_p1))
3892 : {
3893 790 : case BIT_AND_EXPR:
3894 790 : {
3895 790 : tree _q30 = TREE_OPERAND (_p1, 0);
3896 790 : tree _q31 = TREE_OPERAND (_p1, 1);
3897 790 : switch (TREE_CODE (_q30))
3898 : {
3899 57 : case BIT_NOT_EXPR:
3900 57 : {
3901 57 : tree _q40 = TREE_OPERAND (_q30, 0);
3902 57 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
3903 : {
3904 0 : {
3905 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q31 };
3906 0 : tree res = generic_simplify_7 (loc, type, _p0, _p1, captures);
3907 0 : if (res) return res;
3908 : }
3909 : }
3910 : break;
3911 : }
3912 790 : default:;
3913 : }
3914 790 : switch (TREE_CODE (_q31))
3915 : {
3916 8 : case BIT_NOT_EXPR:
3917 8 : {
3918 8 : tree _q50 = TREE_OPERAND (_q31, 0);
3919 8 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
3920 : {
3921 0 : {
3922 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q30 };
3923 0 : tree res = generic_simplify_7 (loc, type, _p0, _p1, captures);
3924 0 : if (res) return res;
3925 : }
3926 : }
3927 : break;
3928 : }
3929 : default:;
3930 : }
3931 : break;
3932 : }
3933 998350 : default:;
3934 : }
3935 998350 : switch (TREE_CODE (_p0))
3936 : {
3937 21591 : case PLUS_EXPR:
3938 21591 : {
3939 21591 : tree _q20 = TREE_OPERAND (_p0, 0);
3940 21591 : tree _q21 = TREE_OPERAND (_p0, 1);
3941 21591 : if (integer_minus_onep (_q21))
3942 : {
3943 10450 : switch (TREE_CODE (_p1))
3944 : {
3945 11 : case NEGATE_EXPR:
3946 11 : {
3947 11 : tree _q50 = TREE_OPERAND (_p1, 0);
3948 11 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
3949 : {
3950 11 : {
3951 11 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3952 11 : tree res = generic_simplify_8 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3953 11 : if (res) return res;
3954 : }
3955 : }
3956 : break;
3957 : }
3958 : default:;
3959 : }
3960 : }
3961 : break;
3962 : }
3963 142 : case NEGATE_EXPR:
3964 142 : {
3965 142 : tree _q20 = TREE_OPERAND (_p0, 0);
3966 142 : switch (TREE_CODE (_p1))
3967 : {
3968 0 : case PLUS_EXPR:
3969 0 : {
3970 0 : tree _q40 = TREE_OPERAND (_p1, 0);
3971 0 : tree _q41 = TREE_OPERAND (_p1, 1);
3972 0 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
3973 : {
3974 0 : if (integer_minus_onep (_q41))
3975 : {
3976 0 : {
3977 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3978 0 : tree res = generic_simplify_9 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3979 0 : if (res) return res;
3980 : }
3981 : }
3982 : }
3983 : break;
3984 : }
3985 0 : case MINUS_EXPR:
3986 0 : {
3987 0 : tree _q40 = TREE_OPERAND (_p1, 0);
3988 0 : tree _q41 = TREE_OPERAND (_p1, 1);
3989 0 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
3990 : {
3991 0 : if (integer_onep (_q41))
3992 : {
3993 0 : {
3994 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
3995 0 : tree res = generic_simplify_10 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
3996 0 : if (res) return res;
3997 : }
3998 : }
3999 : }
4000 : break;
4001 : }
4002 : default:;
4003 : }
4004 : break;
4005 : }
4006 102 : case MINUS_EXPR:
4007 102 : {
4008 102 : tree _q20 = TREE_OPERAND (_p0, 0);
4009 102 : tree _q21 = TREE_OPERAND (_p0, 1);
4010 102 : if (integer_onep (_q21))
4011 : {
4012 0 : switch (TREE_CODE (_p1))
4013 : {
4014 0 : case NEGATE_EXPR:
4015 0 : {
4016 0 : tree _q50 = TREE_OPERAND (_p1, 0);
4017 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4018 : {
4019 0 : {
4020 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
4021 0 : tree res = generic_simplify_11 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4022 0 : if (res) return res;
4023 : }
4024 : }
4025 : break;
4026 : }
4027 : default:;
4028 : }
4029 : }
4030 : break;
4031 : }
4032 1310 : case BIT_IOR_EXPR:
4033 1310 : {
4034 1310 : tree _q20 = TREE_OPERAND (_p0, 0);
4035 1310 : tree _q21 = TREE_OPERAND (_p0, 1);
4036 1310 : switch (TREE_CODE (_p1))
4037 : {
4038 65 : case BIT_AND_EXPR:
4039 65 : {
4040 65 : tree _q50 = TREE_OPERAND (_p1, 0);
4041 65 : tree _q51 = TREE_OPERAND (_p1, 1);
4042 65 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4043 : {
4044 15 : {
4045 15 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4046 15 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4047 15 : if (res) return res;
4048 : }
4049 : }
4050 65 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4051 : {
4052 12 : {
4053 12 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
4054 12 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4055 12 : if (res) return res;
4056 : }
4057 : }
4058 65 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4059 : {
4060 3 : {
4061 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
4062 3 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4063 3 : if (res) return res;
4064 : }
4065 : }
4066 65 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4067 : {
4068 6 : {
4069 6 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
4070 6 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4071 6 : if (res) return res;
4072 : }
4073 : }
4074 : break;
4075 : }
4076 1310 : default:;
4077 : }
4078 1310 : switch (TREE_CODE (_q20))
4079 : {
4080 481 : case BIT_NOT_EXPR:
4081 481 : {
4082 481 : tree _q30 = TREE_OPERAND (_q20, 0);
4083 481 : {
4084 481 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _p1 };
4085 481 : tree res = generic_simplify_13 (loc, type, _p0, _p1, captures);
4086 481 : if (res) return res;
4087 : }
4088 480 : break;
4089 : }
4090 1309 : default:;
4091 : }
4092 1309 : switch (TREE_CODE (_q21))
4093 : {
4094 62 : case BIT_NOT_EXPR:
4095 62 : {
4096 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4097 62 : {
4098 62 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20, _p1 };
4099 62 : tree res = generic_simplify_13 (loc, type, _p0, _p1, captures);
4100 62 : if (res) return res;
4101 : }
4102 62 : break;
4103 : }
4104 : default:;
4105 : }
4106 : break;
4107 : }
4108 3380 : case BIT_AND_EXPR:
4109 3380 : {
4110 3380 : tree _q20 = TREE_OPERAND (_p0, 0);
4111 3380 : tree _q21 = TREE_OPERAND (_p0, 1);
4112 3380 : switch (TREE_CODE (_p1))
4113 : {
4114 74 : case BIT_IOR_EXPR:
4115 74 : {
4116 74 : tree _q50 = TREE_OPERAND (_p1, 0);
4117 74 : tree _q51 = TREE_OPERAND (_p1, 1);
4118 74 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4119 : {
4120 18 : {
4121 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q21, _q20 };
4122 18 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4123 18 : if (res) return res;
4124 : }
4125 : }
4126 74 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4127 : {
4128 9 : {
4129 9 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q20, _q21 };
4130 9 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4131 9 : if (res) return res;
4132 : }
4133 : }
4134 74 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4135 : {
4136 9 : {
4137 9 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q21, _q20 };
4138 9 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4139 9 : if (res) return res;
4140 : }
4141 : }
4142 74 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4143 : {
4144 18 : {
4145 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q20, _q21 };
4146 18 : tree res = generic_simplify_12 (loc, type, _p0, _p1, captures);
4147 18 : if (res) return res;
4148 : }
4149 : }
4150 : break;
4151 : }
4152 : default:;
4153 : }
4154 : break;
4155 : }
4156 998338 : default:;
4157 : }
4158 998338 : switch (TREE_CODE (_p1))
4159 : {
4160 521 : case BIT_IOR_EXPR:
4161 521 : {
4162 521 : tree _q30 = TREE_OPERAND (_p1, 0);
4163 521 : tree _q31 = TREE_OPERAND (_p1, 1);
4164 521 : switch (TREE_CODE (_q30))
4165 : {
4166 21 : case BIT_NOT_EXPR:
4167 21 : {
4168 21 : tree _q40 = TREE_OPERAND (_q30, 0);
4169 21 : {
4170 21 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _q31, _p0 };
4171 21 : tree res = generic_simplify_13 (loc, type, _p0, _p1, captures);
4172 21 : if (res) return res;
4173 : }
4174 21 : break;
4175 : }
4176 521 : default:;
4177 : }
4178 521 : switch (TREE_CODE (_q31))
4179 : {
4180 25 : case BIT_NOT_EXPR:
4181 25 : {
4182 25 : tree _q50 = TREE_OPERAND (_q31, 0);
4183 25 : {
4184 25 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q31, _q50, _q30, _p0 };
4185 25 : tree res = generic_simplify_13 (loc, type, _p0, _p1, captures);
4186 25 : if (res) return res;
4187 : }
4188 25 : break;
4189 : }
4190 : default:;
4191 : }
4192 : break;
4193 : }
4194 998338 : default:;
4195 : }
4196 998338 : switch (TREE_CODE (_p0))
4197 : {
4198 3380 : case BIT_AND_EXPR:
4199 3380 : {
4200 3380 : tree _q20 = TREE_OPERAND (_p0, 0);
4201 3380 : tree _q21 = TREE_OPERAND (_p0, 1);
4202 3380 : switch (TREE_CODE (_q20))
4203 : {
4204 90 : case BIT_NOT_EXPR:
4205 90 : {
4206 90 : tree _q30 = TREE_OPERAND (_q20, 0);
4207 90 : {
4208 90 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _p1 };
4209 90 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures);
4210 90 : if (res) return res;
4211 : }
4212 89 : break;
4213 : }
4214 3379 : default:;
4215 : }
4216 3379 : switch (TREE_CODE (_q21))
4217 : {
4218 41 : case BIT_NOT_EXPR:
4219 41 : {
4220 41 : tree _q40 = TREE_OPERAND (_q21, 0);
4221 41 : {
4222 41 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20, _p1 };
4223 41 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures);
4224 41 : if (res) return res;
4225 : }
4226 41 : break;
4227 : }
4228 : default:;
4229 : }
4230 : break;
4231 : }
4232 998337 : default:;
4233 : }
4234 998337 : switch (TREE_CODE (_p1))
4235 : {
4236 790 : case BIT_AND_EXPR:
4237 790 : {
4238 790 : tree _q30 = TREE_OPERAND (_p1, 0);
4239 790 : tree _q31 = TREE_OPERAND (_p1, 1);
4240 790 : switch (TREE_CODE (_q30))
4241 : {
4242 57 : case BIT_NOT_EXPR:
4243 57 : {
4244 57 : tree _q40 = TREE_OPERAND (_q30, 0);
4245 57 : {
4246 57 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _q31, _p0 };
4247 57 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures);
4248 57 : if (res) return res;
4249 : }
4250 57 : break;
4251 : }
4252 790 : default:;
4253 : }
4254 790 : switch (TREE_CODE (_q31))
4255 : {
4256 8 : case BIT_NOT_EXPR:
4257 8 : {
4258 8 : tree _q50 = TREE_OPERAND (_q31, 0);
4259 8 : {
4260 8 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q31, _q50, _q30, _p0 };
4261 8 : tree res = generic_simplify_14 (loc, type, _p0, _p1, captures);
4262 8 : if (res) return res;
4263 : }
4264 8 : break;
4265 : }
4266 : default:;
4267 : }
4268 : break;
4269 : }
4270 998337 : default:;
4271 : }
4272 998337 : switch (TREE_CODE (_p0))
4273 : {
4274 635943 : CASE_CONVERT:
4275 635943 : {
4276 635943 : tree _q20 = TREE_OPERAND (_p0, 0);
4277 635943 : switch (TREE_CODE (_p1))
4278 : {
4279 631867 : CASE_CONVERT:
4280 631867 : {
4281 631867 : tree _q40 = TREE_OPERAND (_p1, 0);
4282 631867 : {
4283 631867 : tree _q40_pops[1];
4284 631867 : if (tree_maybe_bit_not (_q40, _q40_pops))
4285 : {
4286 0 : tree _q50 = _q40_pops[0];
4287 0 : {
4288 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
4289 0 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4290 0 : if (res) return res;
4291 : }
4292 : }
4293 : }
4294 631867 : break;
4295 : }
4296 635943 : default:;
4297 : }
4298 635943 : {
4299 635943 : tree _q20_pops[1];
4300 635943 : if (tree_maybe_bit_not (_q20, _q20_pops))
4301 : {
4302 61165 : tree _q30 = _q20_pops[0];
4303 61165 : switch (TREE_CODE (_p1))
4304 : {
4305 61115 : CASE_CONVERT:
4306 61115 : {
4307 61115 : tree _q50 = TREE_OPERAND (_p1, 0);
4308 61115 : {
4309 61115 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
4310 61115 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4311 61115 : if (res) return res;
4312 : }
4313 61115 : break;
4314 : }
4315 : default:;
4316 : }
4317 : }
4318 : }
4319 635943 : break;
4320 : }
4321 998337 : default:;
4322 : }
4323 998337 : {
4324 998337 : tree _p1_pops[1];
4325 998337 : if (tree_maybe_bit_not (_p1, _p1_pops))
4326 : {
4327 9357 : tree _q30 = _p1_pops[0];
4328 9357 : {
4329 9357 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
4330 9357 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4331 9357 : if (res) return res;
4332 : }
4333 : }
4334 : }
4335 998337 : {
4336 998337 : tree _p0_pops[1];
4337 998337 : if (tree_maybe_bit_not (_p0, _p0_pops))
4338 : {
4339 1052 : tree _q20 = _p0_pops[0];
4340 1052 : {
4341 1052 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _q20 };
4342 1052 : tree res = generic_simplify_15 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4343 1052 : if (res) return res;
4344 : }
4345 : }
4346 : }
4347 998316 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
4348 : {
4349 149 : {
4350 149 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4351 149 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1166;
4352 149 : {
4353 149 : tree _r;
4354 149 : _r = build_zero_cst (type);
4355 149 : if (TREE_SIDE_EFFECTS (captures[0]))
4356 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4357 149 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 890, __FILE__, __LINE__, true);
4358 149 : return _r;
4359 : }
4360 0 : next_after_fail1166:;
4361 : }
4362 : }
4363 998167 : if (integer_all_onesp (_p1))
4364 : {
4365 1093 : {
4366 1093 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
4367 1093 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1167;
4368 1093 : {
4369 1093 : tree res_op0;
4370 1093 : res_op0 = captures[0];
4371 1093 : tree _r;
4372 1093 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
4373 1093 : if (TREE_SIDE_EFFECTS (captures[1]))
4374 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4375 1093 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
4376 1093 : return _r;
4377 : }
4378 0 : next_after_fail1167:;
4379 : }
4380 : }
4381 997074 : switch (TREE_CODE (_p0))
4382 : {
4383 1302 : case BIT_IOR_EXPR:
4384 1302 : {
4385 1302 : tree _q20 = TREE_OPERAND (_p0, 0);
4386 1302 : tree _q21 = TREE_OPERAND (_p0, 1);
4387 1302 : switch (TREE_CODE (_p1))
4388 : {
4389 179 : case BIT_IOR_EXPR:
4390 179 : {
4391 179 : tree _q50 = TREE_OPERAND (_p1, 0);
4392 179 : tree _q51 = TREE_OPERAND (_p1, 1);
4393 179 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4394 : {
4395 0 : switch (TREE_CODE (_q51))
4396 : {
4397 0 : case BIT_NOT_EXPR:
4398 0 : {
4399 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4400 0 : if ((_q70 == _q21 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q21, 0) && types_match (_q70, _q21)))
4401 : {
4402 0 : {
4403 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4404 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4405 0 : if (res) return res;
4406 : }
4407 : }
4408 : break;
4409 : }
4410 : default:;
4411 : }
4412 : }
4413 179 : switch (TREE_CODE (_q50))
4414 : {
4415 20 : case BIT_NOT_EXPR:
4416 20 : {
4417 20 : tree _q60 = TREE_OPERAND (_q50, 0);
4418 20 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
4419 : {
4420 2 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4421 : {
4422 1 : {
4423 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4424 1 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4425 1 : if (res) return res;
4426 : }
4427 : }
4428 : }
4429 19 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4430 : {
4431 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4432 : {
4433 0 : {
4434 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
4435 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4436 0 : if (res) return res;
4437 : }
4438 : }
4439 : }
4440 : break;
4441 : }
4442 178 : default:;
4443 : }
4444 178 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4445 : {
4446 0 : switch (TREE_CODE (_q51))
4447 : {
4448 0 : case BIT_NOT_EXPR:
4449 0 : {
4450 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4451 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4452 : {
4453 0 : {
4454 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
4455 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4456 0 : if (res) return res;
4457 : }
4458 : }
4459 : break;
4460 : }
4461 : default:;
4462 : }
4463 : }
4464 : break;
4465 : }
4466 1301 : default:;
4467 : }
4468 1301 : switch (TREE_CODE (_q21))
4469 : {
4470 62 : case BIT_NOT_EXPR:
4471 62 : {
4472 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4473 62 : switch (TREE_CODE (_p1))
4474 : {
4475 9 : case BIT_IOR_EXPR:
4476 9 : {
4477 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4478 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4479 9 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4480 : {
4481 0 : if ((_q61 == _q40 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q40, 0) && types_match (_q61, _q40)))
4482 : {
4483 0 : {
4484 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
4485 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4486 0 : if (res) return res;
4487 : }
4488 : }
4489 : }
4490 : break;
4491 : }
4492 : default:;
4493 : }
4494 : break;
4495 : }
4496 1301 : default:;
4497 : }
4498 1301 : switch (TREE_CODE (_q20))
4499 : {
4500 480 : case BIT_NOT_EXPR:
4501 480 : {
4502 480 : tree _q30 = TREE_OPERAND (_q20, 0);
4503 480 : switch (TREE_CODE (_p1))
4504 : {
4505 28 : case BIT_IOR_EXPR:
4506 28 : {
4507 28 : tree _q60 = TREE_OPERAND (_p1, 0);
4508 28 : tree _q61 = TREE_OPERAND (_p1, 1);
4509 28 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
4510 : {
4511 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
4512 : {
4513 0 : {
4514 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q30 };
4515 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4516 0 : if (res) return res;
4517 : }
4518 : }
4519 : }
4520 28 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
4521 : {
4522 9 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
4523 : {
4524 0 : {
4525 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q30 };
4526 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4527 0 : if (res) return res;
4528 : }
4529 : }
4530 9 : switch (TREE_CODE (_q61))
4531 : {
4532 0 : case BIT_NOT_EXPR:
4533 0 : {
4534 0 : tree _q80 = TREE_OPERAND (_q61, 0);
4535 0 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
4536 : {
4537 0 : {
4538 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q21 };
4539 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
4540 0 : if (res) return res;
4541 : }
4542 : }
4543 : break;
4544 : }
4545 : default:;
4546 : }
4547 : }
4548 28 : switch (TREE_CODE (_q60))
4549 : {
4550 1 : case BIT_NOT_EXPR:
4551 1 : {
4552 1 : tree _q70 = TREE_OPERAND (_q60, 0);
4553 1 : if ((_q70 == _q21 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q21, 0) && types_match (_q70, _q21)))
4554 : {
4555 1 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
4556 : {
4557 1 : {
4558 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q21 };
4559 1 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
4560 1 : if (res) return res;
4561 : }
4562 : }
4563 : }
4564 : break;
4565 : }
4566 : default:;
4567 : }
4568 : break;
4569 : }
4570 9 : case BIT_XOR_EXPR:
4571 9 : {
4572 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4573 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4574 9 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
4575 : {
4576 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
4577 : {
4578 0 : {
4579 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q21, _p1 };
4580 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
4581 0 : if (res) return res;
4582 : }
4583 : }
4584 : }
4585 : break;
4586 : }
4587 479 : default:;
4588 : }
4589 479 : {
4590 479 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q21, _p1 };
4591 479 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
4592 479 : if (res) return res;
4593 : }
4594 431 : break;
4595 : }
4596 1252 : default:;
4597 : }
4598 1252 : switch (TREE_CODE (_q21))
4599 : {
4600 62 : case BIT_NOT_EXPR:
4601 62 : {
4602 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4603 62 : switch (TREE_CODE (_p1))
4604 : {
4605 9 : case BIT_IOR_EXPR:
4606 9 : {
4607 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4608 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4609 9 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
4610 : {
4611 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
4612 : {
4613 0 : {
4614 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
4615 0 : tree res = generic_simplify_16 (loc, type, _p0, _p1, captures);
4616 0 : if (res) return res;
4617 : }
4618 : }
4619 : }
4620 : break;
4621 : }
4622 9 : case BIT_XOR_EXPR:
4623 9 : {
4624 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4625 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4626 9 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
4627 : {
4628 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
4629 : {
4630 0 : {
4631 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q40, _q20, _p1 };
4632 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
4633 0 : if (res) return res;
4634 : }
4635 : }
4636 : }
4637 : break;
4638 : }
4639 : default:;
4640 : }
4641 : break;
4642 : }
4643 1252 : default:;
4644 : }
4645 1252 : switch (TREE_CODE (_p1))
4646 : {
4647 65 : case BIT_AND_EXPR:
4648 65 : {
4649 65 : tree _q50 = TREE_OPERAND (_p1, 0);
4650 65 : tree _q51 = TREE_OPERAND (_p1, 1);
4651 65 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4652 : {
4653 6 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4654 : {
4655 0 : {
4656 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4657 0 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
4658 0 : if (res) return res;
4659 : }
4660 : }
4661 : }
4662 : break;
4663 : }
4664 36 : case BIT_XOR_EXPR:
4665 36 : {
4666 36 : tree _q50 = TREE_OPERAND (_p1, 0);
4667 36 : tree _q51 = TREE_OPERAND (_p1, 1);
4668 36 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4669 : {
4670 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4671 : {
4672 0 : {
4673 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4674 0 : tree res = generic_simplify_21 (loc, type, _p0, _p1, captures);
4675 0 : if (res) return res;
4676 : }
4677 : }
4678 : }
4679 : break;
4680 : }
4681 1252 : default:;
4682 : }
4683 1252 : switch (TREE_CODE (_q21))
4684 : {
4685 62 : case BIT_NOT_EXPR:
4686 62 : {
4687 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4688 62 : switch (TREE_CODE (_p1))
4689 : {
4690 9 : case BIT_IOR_EXPR:
4691 9 : {
4692 9 : tree _q60 = TREE_OPERAND (_p1, 0);
4693 9 : tree _q61 = TREE_OPERAND (_p1, 1);
4694 9 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
4695 : {
4696 0 : switch (TREE_CODE (_q61))
4697 : {
4698 0 : case BIT_NOT_EXPR:
4699 0 : {
4700 0 : tree _q80 = TREE_OPERAND (_q61, 0);
4701 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
4702 : {
4703 0 : {
4704 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
4705 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
4706 0 : if (res) return res;
4707 : }
4708 : }
4709 : break;
4710 : }
4711 : default:;
4712 : }
4713 : }
4714 9 : switch (TREE_CODE (_q60))
4715 : {
4716 0 : case BIT_NOT_EXPR:
4717 0 : {
4718 0 : tree _q70 = TREE_OPERAND (_q60, 0);
4719 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4720 : {
4721 0 : if ((_q61 == _q40 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q40, 0) && types_match (_q61, _q40)))
4722 : {
4723 0 : {
4724 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
4725 0 : tree res = generic_simplify_17 (loc, type, _p0, _p1, captures);
4726 0 : if (res) return res;
4727 : }
4728 : }
4729 : }
4730 : break;
4731 : }
4732 : default:;
4733 : }
4734 : break;
4735 : }
4736 : default:;
4737 : }
4738 : break;
4739 : }
4740 1252 : default:;
4741 : }
4742 1252 : switch (TREE_CODE (_p1))
4743 : {
4744 24 : CASE_CONVERT:
4745 24 : {
4746 24 : tree _q50 = TREE_OPERAND (_p1, 0);
4747 24 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
4748 : {
4749 0 : {
4750 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q20 };
4751 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
4752 0 : if (res) return res;
4753 : }
4754 : }
4755 24 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q21, 0))
4756 : {
4757 0 : {
4758 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q21 };
4759 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
4760 0 : if (res) return res;
4761 : }
4762 : }
4763 : break;
4764 : }
4765 1252 : default:;
4766 : }
4767 1252 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q20, 0))
4768 : {
4769 3 : {
4770 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q20 };
4771 3 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
4772 3 : if (res) return res;
4773 : }
4774 : }
4775 1249 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q21, 0))
4776 : {
4777 3 : {
4778 3 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q21 };
4779 3 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
4780 3 : if (res) return res;
4781 : }
4782 : }
4783 1246 : {
4784 1246 : tree _q20_pops[1];
4785 1246 : if (tree_nop_convert (_q20, _q20_pops))
4786 : {
4787 8 : tree _q30 = _q20_pops[0];
4788 8 : switch (TREE_CODE (_q30))
4789 : {
4790 8 : case BIT_NOT_EXPR:
4791 8 : {
4792 8 : tree _q40 = TREE_OPERAND (_q30, 0);
4793 8 : {
4794 8 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q21, _p1 };
4795 8 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
4796 8 : if (res) return res;
4797 : }
4798 0 : break;
4799 : }
4800 : default:;
4801 : }
4802 : }
4803 : }
4804 1238 : switch (TREE_CODE (_q21))
4805 : {
4806 62 : case BIT_NOT_EXPR:
4807 62 : {
4808 62 : tree _q40 = TREE_OPERAND (_q21, 0);
4809 62 : {
4810 62 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q20, _p1 };
4811 62 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
4812 62 : if (res) return res;
4813 : }
4814 54 : break;
4815 : }
4816 1230 : default:;
4817 : }
4818 1230 : {
4819 1230 : tree _q21_pops[1];
4820 1230 : if (tree_nop_convert (_q21, _q21_pops))
4821 : {
4822 0 : tree _q40 = _q21_pops[0];
4823 0 : switch (TREE_CODE (_q40))
4824 : {
4825 0 : case BIT_NOT_EXPR:
4826 0 : {
4827 0 : tree _q50 = TREE_OPERAND (_q40, 0);
4828 0 : {
4829 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q20, _p1 };
4830 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
4831 0 : if (res) return res;
4832 : }
4833 0 : break;
4834 : }
4835 : default:;
4836 : }
4837 : }
4838 : }
4839 1230 : break;
4840 : }
4841 3935 : case BIT_XOR_EXPR:
4842 3935 : {
4843 3935 : tree _q20 = TREE_OPERAND (_p0, 0);
4844 3935 : tree _q21 = TREE_OPERAND (_p0, 1);
4845 3935 : switch (TREE_CODE (_p1))
4846 : {
4847 203 : case BIT_IOR_EXPR:
4848 203 : {
4849 203 : tree _q50 = TREE_OPERAND (_p1, 0);
4850 203 : tree _q51 = TREE_OPERAND (_p1, 1);
4851 203 : switch (TREE_CODE (_q50))
4852 : {
4853 1 : case BIT_NOT_EXPR:
4854 1 : {
4855 1 : tree _q60 = TREE_OPERAND (_q50, 0);
4856 1 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4857 : {
4858 1 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4859 : {
4860 1 : {
4861 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q20, _q21, _p0 };
4862 1 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
4863 1 : if (res) return res;
4864 : }
4865 : }
4866 : }
4867 : break;
4868 : }
4869 202 : default:;
4870 : }
4871 202 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4872 : {
4873 0 : switch (TREE_CODE (_q51))
4874 : {
4875 0 : case BIT_NOT_EXPR:
4876 0 : {
4877 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4878 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4879 : {
4880 0 : {
4881 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q20, _q21, _p0 };
4882 0 : tree res = generic_simplify_18 (loc, type, _p0, _p1, captures);
4883 0 : if (res) return res;
4884 : }
4885 : }
4886 : break;
4887 : }
4888 : default:;
4889 : }
4890 : }
4891 202 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4892 : {
4893 1 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4894 : {
4895 0 : {
4896 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4897 0 : tree res = generic_simplify_21 (loc, type, _p0, _p1, captures);
4898 0 : if (res) return res;
4899 : }
4900 : }
4901 : }
4902 : break;
4903 : }
4904 41 : case BIT_AND_EXPR:
4905 41 : {
4906 41 : tree _q50 = TREE_OPERAND (_p1, 0);
4907 41 : tree _q51 = TREE_OPERAND (_p1, 1);
4908 41 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4909 : {
4910 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4911 : {
4912 0 : {
4913 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4914 0 : tree res = generic_simplify_23 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4915 0 : if (res) return res;
4916 : }
4917 : }
4918 : }
4919 : break;
4920 : }
4921 198 : CASE_CONVERT:
4922 198 : {
4923 198 : tree _q50 = TREE_OPERAND (_p1, 0);
4924 198 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q21, 0))
4925 : {
4926 0 : {
4927 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q21 };
4928 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
4929 0 : if (res) return res;
4930 : }
4931 : }
4932 198 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
4933 : {
4934 0 : {
4935 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q20 };
4936 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
4937 0 : if (res) return res;
4938 : }
4939 : }
4940 : break;
4941 : }
4942 3934 : default:;
4943 : }
4944 3934 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q21, 0))
4945 : {
4946 0 : {
4947 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q21 };
4948 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
4949 0 : if (res) return res;
4950 : }
4951 : }
4952 3934 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q20, 0))
4953 : {
4954 11 : {
4955 11 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q20 };
4956 11 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
4957 11 : if (res) return res;
4958 : }
4959 : }
4960 : break;
4961 : }
4962 3379 : case BIT_AND_EXPR:
4963 3379 : {
4964 3379 : tree _q20 = TREE_OPERAND (_p0, 0);
4965 3379 : tree _q21 = TREE_OPERAND (_p0, 1);
4966 3379 : switch (TREE_CODE (_p1))
4967 : {
4968 74 : case BIT_IOR_EXPR:
4969 74 : {
4970 74 : tree _q50 = TREE_OPERAND (_p1, 0);
4971 74 : tree _q51 = TREE_OPERAND (_p1, 1);
4972 74 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4973 : {
4974 18 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4975 : {
4976 0 : {
4977 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4978 0 : tree res = generic_simplify_20 (loc, type, _p0, _p1, captures);
4979 0 : if (res) return res;
4980 : }
4981 : }
4982 : }
4983 : break;
4984 : }
4985 30 : case BIT_XOR_EXPR:
4986 30 : {
4987 30 : tree _q50 = TREE_OPERAND (_p1, 0);
4988 30 : tree _q51 = TREE_OPERAND (_p1, 1);
4989 30 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4990 : {
4991 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4992 : {
4993 0 : {
4994 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4995 0 : tree res = generic_simplify_23 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
4996 0 : if (res) return res;
4997 : }
4998 : }
4999 : }
5000 : break;
5001 : }
5002 3379 : default:;
5003 : }
5004 3379 : switch (TREE_CODE (_q21))
5005 : {
5006 1554 : case INTEGER_CST:
5007 1554 : {
5008 1554 : switch (TREE_CODE (_p1))
5009 : {
5010 15 : CASE_CONVERT:
5011 15 : {
5012 15 : tree _q50 = TREE_OPERAND (_p1, 0);
5013 15 : switch (TREE_CODE (_q50))
5014 : {
5015 0 : case BIT_AND_EXPR:
5016 0 : {
5017 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5018 0 : tree _q61 = TREE_OPERAND (_q50, 1);
5019 0 : switch (TREE_CODE (_q61))
5020 : {
5021 0 : case INTEGER_CST:
5022 0 : {
5023 0 : {
5024 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50, _q60, _q61 };
5025 0 : tree res = generic_simplify_25 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5026 0 : if (res) return res;
5027 : }
5028 0 : break;
5029 : }
5030 : default:;
5031 : }
5032 : break;
5033 : }
5034 : default:;
5035 : }
5036 : break;
5037 : }
5038 210 : case BIT_AND_EXPR:
5039 210 : {
5040 210 : tree _q50 = TREE_OPERAND (_p1, 0);
5041 210 : tree _q51 = TREE_OPERAND (_p1, 1);
5042 210 : switch (TREE_CODE (_q51))
5043 : {
5044 210 : case INTEGER_CST:
5045 210 : {
5046 210 : {
5047 210 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50, _q51 };
5048 210 : tree res = generic_simplify_25 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5049 210 : if (res) return res;
5050 : }
5051 209 : break;
5052 : }
5053 : default:;
5054 : }
5055 : break;
5056 : }
5057 : default:;
5058 : }
5059 : break;
5060 : }
5061 : default:;
5062 : }
5063 : break;
5064 : }
5065 635786 : CASE_CONVERT:
5066 635786 : {
5067 635786 : tree _q20 = TREE_OPERAND (_p0, 0);
5068 635786 : switch (TREE_CODE (_q20))
5069 : {
5070 24 : case BIT_AND_EXPR:
5071 24 : {
5072 24 : tree _q30 = TREE_OPERAND (_q20, 0);
5073 24 : tree _q31 = TREE_OPERAND (_q20, 1);
5074 24 : switch (TREE_CODE (_q31))
5075 : {
5076 0 : case INTEGER_CST:
5077 0 : {
5078 0 : switch (TREE_CODE (_p1))
5079 : {
5080 0 : CASE_CONVERT:
5081 0 : {
5082 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5083 0 : switch (TREE_CODE (_q60))
5084 : {
5085 0 : case BIT_AND_EXPR:
5086 0 : {
5087 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5088 0 : tree _q71 = TREE_OPERAND (_q60, 1);
5089 0 : switch (TREE_CODE (_q71))
5090 : {
5091 0 : case INTEGER_CST:
5092 0 : {
5093 0 : {
5094 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q60, _q70, _q71 };
5095 0 : tree res = generic_simplify_25 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5096 0 : if (res) return res;
5097 : }
5098 0 : break;
5099 : }
5100 : default:;
5101 : }
5102 : break;
5103 : }
5104 : default:;
5105 : }
5106 : break;
5107 : }
5108 0 : case BIT_AND_EXPR:
5109 0 : {
5110 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5111 0 : tree _q61 = TREE_OPERAND (_p1, 1);
5112 0 : switch (TREE_CODE (_q61))
5113 : {
5114 0 : case INTEGER_CST:
5115 0 : {
5116 0 : {
5117 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _p1, _q60, _q61 };
5118 0 : tree res = generic_simplify_25 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
5119 0 : if (res) return res;
5120 : }
5121 0 : break;
5122 : }
5123 : default:;
5124 : }
5125 : break;
5126 : }
5127 : default:;
5128 : }
5129 : break;
5130 : }
5131 : default:;
5132 : }
5133 : break;
5134 : }
5135 24 : case BIT_IOR_EXPR:
5136 24 : {
5137 24 : tree _q30 = TREE_OPERAND (_q20, 0);
5138 24 : tree _q31 = TREE_OPERAND (_q20, 1);
5139 24 : switch (TREE_CODE (_p1))
5140 : {
5141 16 : CASE_CONVERT:
5142 16 : {
5143 16 : tree _q60 = TREE_OPERAND (_p1, 0);
5144 16 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q30, 0))
5145 : {
5146 0 : {
5147 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q30 };
5148 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5149 0 : if (res) return res;
5150 : }
5151 : }
5152 16 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q31, 0))
5153 : {
5154 0 : {
5155 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q31 };
5156 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5157 0 : if (res) return res;
5158 : }
5159 : }
5160 : break;
5161 : }
5162 24 : default:;
5163 : }
5164 24 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q30, 0))
5165 : {
5166 0 : {
5167 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q30 };
5168 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5169 0 : if (res) return res;
5170 : }
5171 : }
5172 24 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q31, 0))
5173 : {
5174 0 : {
5175 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q31 };
5176 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5177 0 : if (res) return res;
5178 : }
5179 : }
5180 : break;
5181 : }
5182 635786 : default:;
5183 : }
5184 635786 : switch (TREE_CODE (_p1))
5185 : {
5186 631860 : CASE_CONVERT:
5187 631860 : {
5188 631860 : tree _q40 = TREE_OPERAND (_p1, 0);
5189 631860 : switch (TREE_CODE (_q40))
5190 : {
5191 0 : case BIT_IOR_EXPR:
5192 0 : {
5193 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5194 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5195 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
5196 : {
5197 0 : {
5198 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
5199 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5200 0 : if (res) return res;
5201 : }
5202 : }
5203 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
5204 : {
5205 0 : {
5206 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q50, _q20 };
5207 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5208 0 : if (res) return res;
5209 : }
5210 : }
5211 : break;
5212 : }
5213 : default:;
5214 : }
5215 : break;
5216 : }
5217 26 : case BIT_IOR_EXPR:
5218 26 : {
5219 26 : tree _q40 = TREE_OPERAND (_p1, 0);
5220 26 : tree _q41 = TREE_OPERAND (_p1, 1);
5221 26 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _q20, 0))
5222 : {
5223 0 : {
5224 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q20 };
5225 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5226 0 : if (res) return res;
5227 : }
5228 : }
5229 26 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _q20, 0))
5230 : {
5231 0 : {
5232 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q20 };
5233 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5234 0 : if (res) return res;
5235 : }
5236 : }
5237 : break;
5238 : }
5239 : default:;
5240 : }
5241 : break;
5242 : }
5243 996989 : default:;
5244 : }
5245 996989 : switch (TREE_CODE (_p1))
5246 : {
5247 761894 : CASE_CONVERT:
5248 761894 : {
5249 761894 : tree _q30 = TREE_OPERAND (_p1, 0);
5250 761894 : switch (TREE_CODE (_q30))
5251 : {
5252 6 : case BIT_IOR_EXPR:
5253 6 : {
5254 6 : tree _q40 = TREE_OPERAND (_q30, 0);
5255 6 : tree _q41 = TREE_OPERAND (_q30, 1);
5256 6 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _p0, 0))
5257 : {
5258 0 : {
5259 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _p0 };
5260 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5261 0 : if (res) return res;
5262 : }
5263 : }
5264 6 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _p0, 0))
5265 : {
5266 0 : {
5267 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _p0 };
5268 0 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5269 0 : if (res) return res;
5270 : }
5271 : }
5272 : break;
5273 : }
5274 : default:;
5275 : }
5276 : break;
5277 : }
5278 518 : case BIT_IOR_EXPR:
5279 518 : {
5280 518 : tree _q30 = TREE_OPERAND (_p1, 0);
5281 518 : tree _q31 = TREE_OPERAND (_p1, 1);
5282 518 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || operand_equal_p (_q30, _p0, 0))
5283 : {
5284 1 : {
5285 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
5286 1 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5287 1 : if (res) return res;
5288 : }
5289 : }
5290 517 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || operand_equal_p (_q31, _p0, 0))
5291 : {
5292 1 : {
5293 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _p0 };
5294 1 : tree res = generic_simplify_22 (loc, type, _p0, _p1, captures);
5295 1 : if (res) return res;
5296 : }
5297 : }
5298 : break;
5299 : }
5300 996987 : default:;
5301 : }
5302 996987 : {
5303 996987 : tree _p0_pops[1];
5304 996987 : if (tree_nop_convert (_p0, _p0_pops))
5305 : {
5306 506893 : tree _q20 = _p0_pops[0];
5307 506893 : switch (TREE_CODE (_q20))
5308 : {
5309 16 : case BIT_IOR_EXPR:
5310 16 : {
5311 16 : tree _q30 = TREE_OPERAND (_q20, 0);
5312 16 : tree _q31 = TREE_OPERAND (_q20, 1);
5313 16 : {
5314 16 : tree _q30_pops[1];
5315 16 : if (tree_nop_convert (_q30, _q30_pops))
5316 : {
5317 0 : tree _q40 = _q30_pops[0];
5318 0 : switch (TREE_CODE (_q40))
5319 : {
5320 0 : case BIT_NOT_EXPR:
5321 0 : {
5322 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5323 0 : {
5324 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q31, _p1 };
5325 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5326 0 : if (res) return res;
5327 : }
5328 0 : break;
5329 : }
5330 : default:;
5331 : }
5332 : }
5333 : }
5334 16 : {
5335 16 : tree _q31_pops[1];
5336 16 : if (tree_nop_convert (_q31, _q31_pops))
5337 : {
5338 0 : tree _q50 = _q31_pops[0];
5339 0 : switch (TREE_CODE (_q50))
5340 : {
5341 0 : case BIT_NOT_EXPR:
5342 0 : {
5343 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5344 0 : {
5345 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q30, _p1 };
5346 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5347 0 : if (res) return res;
5348 : }
5349 0 : break;
5350 : }
5351 : default:;
5352 : }
5353 : }
5354 : }
5355 16 : switch (TREE_CODE (_q30))
5356 : {
5357 16 : case BIT_NOT_EXPR:
5358 16 : {
5359 16 : tree _q40 = TREE_OPERAND (_q30, 0);
5360 16 : {
5361 16 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q31, _p1 };
5362 16 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5363 16 : if (res) return res;
5364 : }
5365 0 : break;
5366 : }
5367 0 : default:;
5368 : }
5369 0 : switch (TREE_CODE (_q31))
5370 : {
5371 0 : case BIT_NOT_EXPR:
5372 0 : {
5373 0 : tree _q50 = TREE_OPERAND (_q31, 0);
5374 0 : {
5375 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q30, _p1 };
5376 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5377 0 : if (res) return res;
5378 : }
5379 0 : break;
5380 : }
5381 : default:;
5382 : }
5383 : break;
5384 : }
5385 : default:;
5386 : }
5387 : }
5388 : }
5389 996971 : switch (TREE_CODE (_p1))
5390 : {
5391 516 : case BIT_IOR_EXPR:
5392 516 : {
5393 516 : tree _q30 = TREE_OPERAND (_p1, 0);
5394 516 : tree _q31 = TREE_OPERAND (_p1, 1);
5395 516 : {
5396 516 : tree _q30_pops[1];
5397 516 : if (tree_nop_convert (_q30, _q30_pops))
5398 : {
5399 2 : tree _q40 = _q30_pops[0];
5400 2 : switch (TREE_CODE (_q40))
5401 : {
5402 0 : case BIT_NOT_EXPR:
5403 0 : {
5404 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5405 0 : {
5406 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q31, _p0 };
5407 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5408 0 : if (res) return res;
5409 : }
5410 0 : break;
5411 : }
5412 : default:;
5413 : }
5414 : }
5415 : }
5416 516 : {
5417 516 : tree _q31_pops[1];
5418 516 : if (tree_nop_convert (_q31, _q31_pops))
5419 : {
5420 2 : tree _q50 = _q31_pops[0];
5421 2 : switch (TREE_CODE (_q50))
5422 : {
5423 0 : case BIT_NOT_EXPR:
5424 0 : {
5425 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5426 0 : {
5427 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q30, _p0 };
5428 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5429 0 : if (res) return res;
5430 : }
5431 0 : break;
5432 : }
5433 : default:;
5434 : }
5435 : }
5436 : }
5437 516 : switch (TREE_CODE (_q30))
5438 : {
5439 18 : case BIT_NOT_EXPR:
5440 18 : {
5441 18 : tree _q40 = TREE_OPERAND (_q30, 0);
5442 18 : {
5443 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q31, _p0 };
5444 18 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5445 18 : if (res) return res;
5446 : }
5447 18 : break;
5448 : }
5449 516 : default:;
5450 : }
5451 516 : switch (TREE_CODE (_q31))
5452 : {
5453 25 : case BIT_NOT_EXPR:
5454 25 : {
5455 25 : tree _q50 = TREE_OPERAND (_q31, 0);
5456 25 : {
5457 25 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q30, _p0 };
5458 25 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5459 25 : if (res) return res;
5460 : }
5461 17 : break;
5462 : }
5463 : default:;
5464 : }
5465 : break;
5466 : }
5467 996963 : default:;
5468 : }
5469 996963 : {
5470 996963 : tree _p1_pops[1];
5471 996963 : if (tree_nop_convert (_p1, _p1_pops))
5472 : {
5473 635451 : tree _q30 = _p1_pops[0];
5474 635451 : switch (TREE_CODE (_q30))
5475 : {
5476 0 : case BIT_IOR_EXPR:
5477 0 : {
5478 0 : tree _q40 = TREE_OPERAND (_q30, 0);
5479 0 : tree _q41 = TREE_OPERAND (_q30, 1);
5480 0 : {
5481 0 : tree _q40_pops[1];
5482 0 : if (tree_nop_convert (_q40, _q40_pops))
5483 : {
5484 0 : tree _q50 = _q40_pops[0];
5485 0 : switch (TREE_CODE (_q50))
5486 : {
5487 0 : case BIT_NOT_EXPR:
5488 0 : {
5489 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5490 0 : {
5491 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q41, _p0 };
5492 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5493 0 : if (res) return res;
5494 : }
5495 0 : break;
5496 : }
5497 : default:;
5498 : }
5499 : }
5500 : }
5501 0 : {
5502 0 : tree _q41_pops[1];
5503 0 : if (tree_nop_convert (_q41, _q41_pops))
5504 : {
5505 0 : tree _q60 = _q41_pops[0];
5506 0 : switch (TREE_CODE (_q60))
5507 : {
5508 0 : case BIT_NOT_EXPR:
5509 0 : {
5510 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5511 0 : {
5512 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q70, _q40, _p0 };
5513 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5514 0 : if (res) return res;
5515 : }
5516 0 : break;
5517 : }
5518 : default:;
5519 : }
5520 : }
5521 : }
5522 0 : switch (TREE_CODE (_q40))
5523 : {
5524 0 : case BIT_NOT_EXPR:
5525 0 : {
5526 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5527 0 : {
5528 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q41, _p0 };
5529 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5530 0 : if (res) return res;
5531 : }
5532 0 : break;
5533 : }
5534 0 : default:;
5535 : }
5536 0 : switch (TREE_CODE (_q41))
5537 : {
5538 0 : case BIT_NOT_EXPR:
5539 0 : {
5540 0 : tree _q60 = TREE_OPERAND (_q41, 0);
5541 0 : {
5542 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q60, _q40, _p0 };
5543 0 : tree res = generic_simplify_19 (loc, type, _p0, _p1, captures);
5544 0 : if (res) return res;
5545 : }
5546 0 : break;
5547 : }
5548 : default:;
5549 : }
5550 : break;
5551 : }
5552 : default:;
5553 : }
5554 : }
5555 : }
5556 996963 : switch (TREE_CODE (_p0))
5557 : {
5558 635762 : CASE_CONVERT:
5559 635762 : {
5560 635762 : tree _q20 = TREE_OPERAND (_p0, 0);
5561 635762 : switch (TREE_CODE (_q20))
5562 : {
5563 50 : case BIT_NOT_EXPR:
5564 50 : {
5565 50 : tree _q30 = TREE_OPERAND (_q20, 0);
5566 50 : switch (TREE_CODE (_p1))
5567 : {
5568 0 : CASE_CONVERT:
5569 0 : {
5570 0 : tree _q50 = TREE_OPERAND (_p1, 0);
5571 0 : switch (TREE_CODE (_q50))
5572 : {
5573 0 : case BIT_NOT_EXPR:
5574 0 : {
5575 0 : tree _q60 = TREE_OPERAND (_q50, 0);
5576 0 : {
5577 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q60 };
5578 0 : tree res = generic_simplify_26 (loc, type, _p0, _p1, captures);
5579 0 : if (res) return res;
5580 : }
5581 0 : break;
5582 : }
5583 : default:;
5584 : }
5585 : break;
5586 : }
5587 0 : case BIT_NOT_EXPR:
5588 0 : {
5589 0 : tree _q50 = TREE_OPERAND (_p1, 0);
5590 0 : {
5591 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q50 };
5592 0 : tree res = generic_simplify_26 (loc, type, _p0, _p1, captures);
5593 0 : if (res) return res;
5594 : }
5595 0 : break;
5596 : }
5597 26 : case INTEGER_CST:
5598 26 : {
5599 26 : {
5600 26 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p1 };
5601 26 : tree res = generic_simplify_27 (loc, type, _p0, _p1, captures);
5602 26 : if (res) return res;
5603 : }
5604 24 : break;
5605 : }
5606 : default:;
5607 : }
5608 : break;
5609 : }
5610 : default:;
5611 : }
5612 : break;
5613 : }
5614 484 : case BIT_NOT_EXPR:
5615 484 : {
5616 484 : tree _q20 = TREE_OPERAND (_p0, 0);
5617 484 : switch (TREE_CODE (_p1))
5618 : {
5619 18 : CASE_CONVERT:
5620 18 : {
5621 18 : tree _q40 = TREE_OPERAND (_p1, 0);
5622 18 : switch (TREE_CODE (_q40))
5623 : {
5624 0 : case BIT_NOT_EXPR:
5625 0 : {
5626 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5627 0 : {
5628 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
5629 0 : tree res = generic_simplify_26 (loc, type, _p0, _p1, captures);
5630 0 : if (res) return res;
5631 : }
5632 0 : break;
5633 : }
5634 : default:;
5635 : }
5636 : break;
5637 : }
5638 10 : case BIT_NOT_EXPR:
5639 10 : {
5640 10 : tree _q40 = TREE_OPERAND (_p1, 0);
5641 10 : {
5642 10 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
5643 10 : tree res = generic_simplify_26 (loc, type, _p0, _p1, captures);
5644 10 : if (res) return res;
5645 : }
5646 0 : break;
5647 : }
5648 31 : case INTEGER_CST:
5649 31 : {
5650 31 : {
5651 31 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
5652 31 : tree res = generic_simplify_27 (loc, type, _p0, _p1, captures);
5653 31 : if (res) return res;
5654 : }
5655 0 : break;
5656 : }
5657 443 : default:;
5658 : }
5659 443 : {
5660 443 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _p1 };
5661 443 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
5662 443 : if (res) return res;
5663 : }
5664 0 : break;
5665 : }
5666 3376 : case BIT_AND_EXPR:
5667 3376 : {
5668 3376 : tree _q20 = TREE_OPERAND (_p0, 0);
5669 3376 : tree _q21 = TREE_OPERAND (_p0, 1);
5670 3376 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
5671 : {
5672 75 : {
5673 75 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
5674 75 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5675 75 : if (res) return res;
5676 : }
5677 : }
5678 3301 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
5679 : {
5680 3 : {
5681 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
5682 3 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5683 3 : if (res) return res;
5684 : }
5685 : }
5686 3298 : switch (TREE_CODE (_p1))
5687 : {
5688 353 : case BIT_AND_EXPR:
5689 353 : {
5690 353 : tree _q50 = TREE_OPERAND (_p1, 0);
5691 353 : tree _q51 = TREE_OPERAND (_p1, 1);
5692 353 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
5693 : {
5694 21 : {
5695 21 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q51, _q20 };
5696 21 : tree res = generic_simplify_30 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5697 21 : if (res) return res;
5698 : }
5699 : }
5700 332 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
5701 : {
5702 0 : {
5703 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q20 };
5704 0 : tree res = generic_simplify_30 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5705 0 : if (res) return res;
5706 : }
5707 : }
5708 332 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q21, 0))
5709 : {
5710 0 : {
5711 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q51, _q21 };
5712 0 : tree res = generic_simplify_30 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5713 0 : if (res) return res;
5714 : }
5715 : }
5716 332 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q21, 0))
5717 : {
5718 201 : {
5719 201 : tree captures[4] ATTRIBUTE_UNUSED = { _q21, _q20, _q50, _q21 };
5720 201 : tree res = generic_simplify_30 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5721 201 : if (res) return res;
5722 : }
5723 : }
5724 : break;
5725 : }
5726 : default:;
5727 : }
5728 : break;
5729 : }
5730 996177 : default:;
5731 : }
5732 996177 : switch (TREE_CODE (_p1))
5733 : {
5734 514 : case BIT_AND_EXPR:
5735 514 : {
5736 514 : tree _q30 = TREE_OPERAND (_p1, 0);
5737 514 : tree _q31 = TREE_OPERAND (_p1, 1);
5738 514 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
5739 : {
5740 0 : {
5741 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
5742 0 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5743 0 : if (res) return res;
5744 : }
5745 : }
5746 514 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
5747 : {
5748 1 : {
5749 1 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q31, _p0 };
5750 1 : tree res = generic_simplify_29 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5751 1 : if (res) return res;
5752 : }
5753 : }
5754 : break;
5755 : }
5756 996176 : default:;
5757 : }
5758 996176 : switch (TREE_CODE (_p0))
5759 : {
5760 635759 : CASE_CONVERT:
5761 635759 : {
5762 635759 : tree _q20 = TREE_OPERAND (_p0, 0);
5763 635759 : switch (TREE_CODE (_q20))
5764 : {
5765 24 : case BIT_AND_EXPR:
5766 24 : {
5767 24 : tree _q30 = TREE_OPERAND (_q20, 0);
5768 24 : tree _q31 = TREE_OPERAND (_q20, 1);
5769 24 : switch (TREE_CODE (_p1))
5770 : {
5771 8 : CASE_CONVERT:
5772 8 : {
5773 8 : tree _q60 = TREE_OPERAND (_p1, 0);
5774 8 : switch (TREE_CODE (_q60))
5775 : {
5776 0 : case BIT_AND_EXPR:
5777 0 : {
5778 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5779 0 : tree _q71 = TREE_OPERAND (_q60, 1);
5780 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || operand_equal_p (_q70, _q30, 0))
5781 : {
5782 0 : {
5783 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q71, _q30 };
5784 0 : tree res = generic_simplify_30 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5785 0 : if (res) return res;
5786 : }
5787 : }
5788 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || operand_equal_p (_q71, _q30, 0))
5789 : {
5790 0 : {
5791 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q70, _q30 };
5792 0 : tree res = generic_simplify_30 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5793 0 : if (res) return res;
5794 : }
5795 : }
5796 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || operand_equal_p (_q70, _q31, 0))
5797 : {
5798 0 : {
5799 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q31, _q30, _q71, _q31 };
5800 0 : tree res = generic_simplify_30 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5801 0 : if (res) return res;
5802 : }
5803 : }
5804 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || operand_equal_p (_q71, _q31, 0))
5805 : {
5806 0 : {
5807 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q31, _q30, _q70, _q31 };
5808 0 : tree res = generic_simplify_30 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR);
5809 0 : if (res) return res;
5810 : }
5811 : }
5812 : break;
5813 : }
5814 : default:;
5815 : }
5816 : break;
5817 : }
5818 : default:;
5819 : }
5820 : break;
5821 : }
5822 61229 : case BIT_XOR_EXPR:
5823 61229 : {
5824 61229 : tree _q30 = TREE_OPERAND (_q20, 0);
5825 61229 : tree _q31 = TREE_OPERAND (_q20, 1);
5826 61229 : switch (TREE_CODE (_p1))
5827 : {
5828 61163 : CASE_CONVERT:
5829 61163 : {
5830 61163 : tree _q60 = TREE_OPERAND (_p1, 0);
5831 61163 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q31, 0))
5832 : {
5833 0 : {
5834 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q31 };
5835 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5836 0 : if (res) return res;
5837 : }
5838 : }
5839 61163 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q30, 0))
5840 : {
5841 0 : {
5842 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q30 };
5843 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5844 0 : if (res) return res;
5845 : }
5846 : }
5847 : break;
5848 : }
5849 61229 : default:;
5850 : }
5851 61229 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q31, 0))
5852 : {
5853 0 : {
5854 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q31 };
5855 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5856 0 : if (res) return res;
5857 : }
5858 : }
5859 61229 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q30, 0))
5860 : {
5861 0 : {
5862 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q30 };
5863 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5864 0 : if (res) return res;
5865 : }
5866 : }
5867 : break;
5868 : }
5869 635759 : default:;
5870 : }
5871 635759 : switch (TREE_CODE (_p1))
5872 : {
5873 631844 : CASE_CONVERT:
5874 631844 : {
5875 631844 : tree _q40 = TREE_OPERAND (_p1, 0);
5876 631844 : switch (TREE_CODE (_q40))
5877 : {
5878 0 : case BIT_XOR_EXPR:
5879 0 : {
5880 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5881 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5882 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
5883 : {
5884 0 : {
5885 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
5886 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5887 0 : if (res) return res;
5888 : }
5889 : }
5890 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
5891 : {
5892 0 : {
5893 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q50, _q20 };
5894 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5895 0 : if (res) return res;
5896 : }
5897 : }
5898 : break;
5899 : }
5900 : default:;
5901 : }
5902 : break;
5903 : }
5904 2 : case BIT_XOR_EXPR:
5905 2 : {
5906 2 : tree _q40 = TREE_OPERAND (_p1, 0);
5907 2 : tree _q41 = TREE_OPERAND (_p1, 1);
5908 2 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _q20, 0))
5909 : {
5910 0 : {
5911 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q20 };
5912 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5913 0 : if (res) return res;
5914 : }
5915 : }
5916 2 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _q20, 0))
5917 : {
5918 0 : {
5919 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q20 };
5920 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5921 0 : if (res) return res;
5922 : }
5923 : }
5924 : break;
5925 : }
5926 : default:;
5927 : }
5928 : break;
5929 : }
5930 996176 : default:;
5931 : }
5932 996176 : switch (TREE_CODE (_p1))
5933 : {
5934 761860 : CASE_CONVERT:
5935 761860 : {
5936 761860 : tree _q30 = TREE_OPERAND (_p1, 0);
5937 761860 : switch (TREE_CODE (_q30))
5938 : {
5939 8 : case BIT_XOR_EXPR:
5940 8 : {
5941 8 : tree _q40 = TREE_OPERAND (_q30, 0);
5942 8 : tree _q41 = TREE_OPERAND (_q30, 1);
5943 8 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _p0, 0))
5944 : {
5945 0 : {
5946 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _p0 };
5947 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5948 0 : if (res) return res;
5949 : }
5950 : }
5951 8 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _p0, 0))
5952 : {
5953 0 : {
5954 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _p0 };
5955 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5956 0 : if (res) return res;
5957 : }
5958 : }
5959 : break;
5960 : }
5961 : default:;
5962 : }
5963 : break;
5964 : }
5965 78 : case BIT_XOR_EXPR:
5966 78 : {
5967 78 : tree _q30 = TREE_OPERAND (_p1, 0);
5968 78 : tree _q31 = TREE_OPERAND (_p1, 1);
5969 78 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || operand_equal_p (_q31, _p0, 0))
5970 : {
5971 0 : {
5972 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
5973 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5974 0 : if (res) return res;
5975 : }
5976 : }
5977 78 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || operand_equal_p (_q30, _p0, 0))
5978 : {
5979 0 : {
5980 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _p0 };
5981 0 : tree res = generic_simplify_24 (loc, type, _p0, _p1, captures);
5982 0 : if (res) return res;
5983 : }
5984 : }
5985 : break;
5986 : }
5987 996176 : default:;
5988 : }
5989 996176 : switch (TREE_CODE (_p0))
5990 : {
5991 635759 : CASE_CONVERT:
5992 635759 : {
5993 635759 : tree _q20 = TREE_OPERAND (_p0, 0);
5994 635759 : switch (TREE_CODE (_q20))
5995 : {
5996 61229 : case BIT_XOR_EXPR:
5997 61229 : {
5998 61229 : tree _q30 = TREE_OPERAND (_q20, 0);
5999 61229 : tree _q31 = TREE_OPERAND (_q20, 1);
6000 61229 : switch (TREE_CODE (_p1))
6001 : {
6002 61163 : CASE_CONVERT:
6003 61163 : {
6004 61163 : tree _q60 = TREE_OPERAND (_p1, 0);
6005 61163 : switch (TREE_CODE (_q60))
6006 : {
6007 0 : case BIT_XOR_EXPR:
6008 0 : {
6009 0 : tree _q70 = TREE_OPERAND (_q60, 0);
6010 0 : tree _q71 = TREE_OPERAND (_q60, 1);
6011 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
6012 : {
6013 0 : {
6014 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q71 };
6015 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6016 0 : if (res) return res;
6017 : }
6018 : }
6019 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
6020 : {
6021 0 : {
6022 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q70 };
6023 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6024 0 : if (res) return res;
6025 : }
6026 : }
6027 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
6028 : {
6029 0 : {
6030 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q71 };
6031 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6032 0 : if (res) return res;
6033 : }
6034 : }
6035 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
6036 : {
6037 0 : {
6038 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q70 };
6039 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6040 0 : if (res) return res;
6041 : }
6042 : }
6043 : break;
6044 : }
6045 : default:;
6046 : }
6047 : break;
6048 : }
6049 0 : case BIT_XOR_EXPR:
6050 0 : {
6051 0 : tree _q60 = TREE_OPERAND (_p1, 0);
6052 0 : tree _q61 = TREE_OPERAND (_p1, 1);
6053 0 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
6054 : {
6055 0 : {
6056 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q61 };
6057 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6058 0 : if (res) return res;
6059 : }
6060 : }
6061 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
6062 : {
6063 0 : {
6064 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q60 };
6065 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6066 0 : if (res) return res;
6067 : }
6068 : }
6069 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
6070 : {
6071 0 : {
6072 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q61 };
6073 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6074 0 : if (res) return res;
6075 : }
6076 : }
6077 0 : if ((_q61 == _q31 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q31, 0) && types_match (_q61, _q31)))
6078 : {
6079 0 : {
6080 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q60 };
6081 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6082 0 : if (res) return res;
6083 : }
6084 : }
6085 : break;
6086 : }
6087 : default:;
6088 : }
6089 : break;
6090 : }
6091 635759 : default:;
6092 : }
6093 635759 : switch (TREE_CODE (_p1))
6094 : {
6095 631844 : CASE_CONVERT:
6096 631844 : {
6097 631844 : tree _q40 = TREE_OPERAND (_p1, 0);
6098 631844 : {
6099 631844 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
6100 631844 : tree res = generic_simplify_32 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
6101 631844 : if (res) return res;
6102 : }
6103 543381 : break;
6104 : }
6105 547296 : default:;
6106 : }
6107 547296 : {
6108 547296 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
6109 547296 : tree res = generic_simplify_33 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
6110 547296 : if (res) return res;
6111 : }
6112 547188 : break;
6113 : }
6114 3923 : case BIT_XOR_EXPR:
6115 3923 : {
6116 3923 : tree _q20 = TREE_OPERAND (_p0, 0);
6117 3923 : tree _q21 = TREE_OPERAND (_p0, 1);
6118 3923 : switch (TREE_CODE (_p1))
6119 : {
6120 198 : CASE_CONVERT:
6121 198 : {
6122 198 : tree _q50 = TREE_OPERAND (_p1, 0);
6123 198 : switch (TREE_CODE (_q50))
6124 : {
6125 0 : case BIT_XOR_EXPR:
6126 0 : {
6127 0 : tree _q60 = TREE_OPERAND (_q50, 0);
6128 0 : tree _q61 = TREE_OPERAND (_q50, 1);
6129 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6130 : {
6131 0 : {
6132 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q61 };
6133 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6134 0 : if (res) return res;
6135 : }
6136 : }
6137 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
6138 : {
6139 0 : {
6140 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q60 };
6141 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6142 0 : if (res) return res;
6143 : }
6144 : }
6145 0 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
6146 : {
6147 0 : {
6148 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q61 };
6149 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6150 0 : if (res) return res;
6151 : }
6152 : }
6153 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
6154 : {
6155 0 : {
6156 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q60 };
6157 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6158 0 : if (res) return res;
6159 : }
6160 : }
6161 : break;
6162 : }
6163 : default:;
6164 : }
6165 : break;
6166 : }
6167 10 : case BIT_XOR_EXPR:
6168 10 : {
6169 10 : tree _q50 = TREE_OPERAND (_p1, 0);
6170 10 : tree _q51 = TREE_OPERAND (_p1, 1);
6171 10 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6172 : {
6173 0 : {
6174 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
6175 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6176 0 : if (res) return res;
6177 : }
6178 : }
6179 10 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6180 : {
6181 0 : {
6182 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
6183 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6184 0 : if (res) return res;
6185 : }
6186 : }
6187 10 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6188 : {
6189 0 : {
6190 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
6191 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6192 0 : if (res) return res;
6193 : }
6194 : }
6195 10 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6196 : {
6197 0 : {
6198 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
6199 0 : tree res = generic_simplify_31 (loc, type, _p0, _p1, captures);
6200 0 : if (res) return res;
6201 : }
6202 : }
6203 : break;
6204 : }
6205 : default:;
6206 : }
6207 : break;
6208 : }
6209 3076 : case BIT_AND_EXPR:
6210 3076 : {
6211 3076 : tree _q20 = TREE_OPERAND (_p0, 0);
6212 3076 : tree _q21 = TREE_OPERAND (_p0, 1);
6213 3076 : {
6214 3076 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6215 3076 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR, BIT_IOR_EXPR);
6216 3076 : if (res) return res;
6217 : }
6218 3076 : {
6219 3076 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _p1 };
6220 3076 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR, BIT_IOR_EXPR);
6221 3076 : if (res) return res;
6222 : }
6223 3076 : if (tree_truth_valued_p (_q20))
6224 : {
6225 0 : if (tree_truth_valued_p (_q21))
6226 : {
6227 0 : switch (TREE_CODE (_p1))
6228 : {
6229 0 : case EQ_EXPR:
6230 0 : {
6231 0 : tree _q50 = TREE_OPERAND (_p1, 0);
6232 0 : tree _q51 = TREE_OPERAND (_p1, 1);
6233 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6234 : {
6235 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
6236 : {
6237 0 : {
6238 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6239 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1168;
6240 0 : {
6241 0 : tree res_op0;
6242 0 : {
6243 0 : tree _o1[2], _r1;
6244 0 : _o1[0] = captures[0];
6245 0 : _o1[1] = captures[1];
6246 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
6247 0 : res_op0 = _r1;
6248 : }
6249 0 : tree _r;
6250 0 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
6251 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
6252 0 : return _r;
6253 : }
6254 0 : next_after_fail1168:;
6255 : }
6256 : }
6257 : }
6258 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6259 : {
6260 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
6261 : {
6262 0 : {
6263 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6264 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1169;
6265 0 : {
6266 0 : tree res_op0;
6267 0 : {
6268 0 : tree _o1[2], _r1;
6269 0 : _o1[0] = captures[0];
6270 0 : _o1[1] = captures[1];
6271 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
6272 0 : res_op0 = _r1;
6273 : }
6274 0 : tree _r;
6275 0 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
6276 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
6277 0 : return _r;
6278 : }
6279 0 : next_after_fail1169:;
6280 : }
6281 : }
6282 : }
6283 : break;
6284 : }
6285 : default:;
6286 : }
6287 : }
6288 : }
6289 : break;
6290 : }
6291 907605 : default:;
6292 : }
6293 907605 : switch (TREE_CODE (_p1))
6294 : {
6295 513 : case BIT_AND_EXPR:
6296 513 : {
6297 513 : tree _q30 = TREE_OPERAND (_p1, 0);
6298 513 : tree _q31 = TREE_OPERAND (_p1, 1);
6299 513 : {
6300 513 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
6301 513 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR, BIT_IOR_EXPR);
6302 513 : if (res) return res;
6303 : }
6304 513 : {
6305 513 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _p0 };
6306 513 : tree res = generic_simplify_34 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, BIT_AND_EXPR, BIT_IOR_EXPR);
6307 513 : if (res) return res;
6308 : }
6309 513 : break;
6310 : }
6311 907605 : default:;
6312 : }
6313 907605 : switch (TREE_CODE (_p0))
6314 : {
6315 3923 : case BIT_XOR_EXPR:
6316 3923 : {
6317 3923 : tree _q20 = TREE_OPERAND (_p0, 0);
6318 3923 : tree _q21 = TREE_OPERAND (_p0, 1);
6319 3923 : if (CONSTANT_CLASS_P (_q21))
6320 : {
6321 49 : if (CONSTANT_CLASS_P (_p1))
6322 : {
6323 30 : {
6324 30 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6325 30 : tree res = generic_simplify_35 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
6326 30 : if (res) return res;
6327 : }
6328 : }
6329 : }
6330 : break;
6331 : }
6332 70 : case COND_EXPR:
6333 70 : {
6334 70 : tree _q20 = TREE_OPERAND (_p0, 0);
6335 70 : tree _q21 = TREE_OPERAND (_p0, 1);
6336 70 : tree _q22 = TREE_OPERAND (_p0, 2);
6337 70 : if (integer_zerop (_q22))
6338 : {
6339 70 : switch (TREE_CODE (_p1))
6340 : {
6341 4 : case COND_EXPR:
6342 4 : {
6343 4 : tree _q60 = TREE_OPERAND (_p1, 0);
6344 4 : tree _q61 = TREE_OPERAND (_p1, 1);
6345 4 : tree _q62 = TREE_OPERAND (_p1, 2);
6346 4 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6347 : {
6348 0 : if (integer_zerop (_q61))
6349 : {
6350 0 : {
6351 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q62 };
6352 0 : const enum tree_code op = BIT_XOR_EXPR;
6353 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1170;
6354 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1170;
6355 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1170;
6356 0 : {
6357 0 : tree res_op0;
6358 0 : res_op0 = captures[1];
6359 0 : tree res_op1;
6360 0 : res_op1 = captures[2];
6361 0 : tree res_op2;
6362 0 : res_op2 = captures[4];
6363 0 : tree _r;
6364 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
6365 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
6366 0 : return _r;
6367 : }
6368 0 : next_after_fail1170:;
6369 : }
6370 : }
6371 : }
6372 : break;
6373 : }
6374 : default:;
6375 : }
6376 : }
6377 70 : if (integer_zerop (_q21))
6378 : {
6379 0 : switch (TREE_CODE (_p1))
6380 : {
6381 0 : case COND_EXPR:
6382 0 : {
6383 0 : tree _q60 = TREE_OPERAND (_p1, 0);
6384 0 : tree _q61 = TREE_OPERAND (_p1, 1);
6385 0 : tree _q62 = TREE_OPERAND (_p1, 2);
6386 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
6387 : {
6388 0 : if (integer_zerop (_q62))
6389 : {
6390 0 : {
6391 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q20, _q61, _p0, _q22 };
6392 0 : const enum tree_code op = BIT_XOR_EXPR;
6393 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1171;
6394 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1171;
6395 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1171;
6396 0 : {
6397 0 : tree res_op0;
6398 0 : res_op0 = captures[1];
6399 0 : tree res_op1;
6400 0 : res_op1 = captures[2];
6401 0 : tree res_op2;
6402 0 : res_op2 = captures[4];
6403 0 : tree _r;
6404 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
6405 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
6406 0 : return _r;
6407 : }
6408 0 : next_after_fail1171:;
6409 : }
6410 : }
6411 : }
6412 : break;
6413 : }
6414 : default:;
6415 : }
6416 : }
6417 70 : switch (TREE_CODE (_q20))
6418 : {
6419 0 : case LT_EXPR:
6420 0 : {
6421 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6422 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6423 0 : if (zerop (_q22))
6424 : {
6425 0 : switch (TREE_CODE (_p1))
6426 : {
6427 0 : case COND_EXPR:
6428 0 : {
6429 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6430 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6431 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6432 0 : switch (TREE_CODE (_q80))
6433 : {
6434 0 : case GE_EXPR:
6435 0 : {
6436 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6437 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6438 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6439 : {
6440 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6441 : {
6442 0 : if (zerop (_q82))
6443 : {
6444 0 : {
6445 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6446 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LT_EXPR, GE_EXPR);
6447 0 : if (res) return res;
6448 : }
6449 : }
6450 : }
6451 : }
6452 : break;
6453 : }
6454 : default:;
6455 : }
6456 : break;
6457 : }
6458 : default:;
6459 : }
6460 : }
6461 : break;
6462 : }
6463 38 : case LE_EXPR:
6464 38 : {
6465 38 : tree _q30 = TREE_OPERAND (_q20, 0);
6466 38 : tree _q31 = TREE_OPERAND (_q20, 1);
6467 38 : if (zerop (_q22))
6468 : {
6469 38 : switch (TREE_CODE (_p1))
6470 : {
6471 0 : case COND_EXPR:
6472 0 : {
6473 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6474 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6475 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6476 0 : switch (TREE_CODE (_q80))
6477 : {
6478 0 : case GT_EXPR:
6479 0 : {
6480 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6481 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6482 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6483 : {
6484 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6485 : {
6486 0 : if (zerop (_q82))
6487 : {
6488 0 : {
6489 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6490 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LE_EXPR, GT_EXPR);
6491 0 : if (res) return res;
6492 : }
6493 : }
6494 : }
6495 : }
6496 : break;
6497 : }
6498 : default:;
6499 : }
6500 : break;
6501 : }
6502 : default:;
6503 : }
6504 : }
6505 : break;
6506 : }
6507 0 : case EQ_EXPR:
6508 0 : {
6509 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6510 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6511 0 : if (zerop (_q22))
6512 : {
6513 0 : switch (TREE_CODE (_p1))
6514 : {
6515 0 : case COND_EXPR:
6516 0 : {
6517 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6518 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6519 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6520 0 : switch (TREE_CODE (_q80))
6521 : {
6522 0 : case NE_EXPR:
6523 0 : {
6524 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6525 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6526 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6527 : {
6528 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6529 : {
6530 0 : if (zerop (_q82))
6531 : {
6532 0 : {
6533 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6534 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, EQ_EXPR, NE_EXPR);
6535 0 : if (res) return res;
6536 : }
6537 : }
6538 : }
6539 : }
6540 : break;
6541 : }
6542 : default:;
6543 : }
6544 : break;
6545 : }
6546 : default:;
6547 : }
6548 : }
6549 : break;
6550 : }
6551 32 : case NE_EXPR:
6552 32 : {
6553 32 : tree _q30 = TREE_OPERAND (_q20, 0);
6554 32 : tree _q31 = TREE_OPERAND (_q20, 1);
6555 32 : if (zerop (_q22))
6556 : {
6557 32 : switch (TREE_CODE (_p1))
6558 : {
6559 4 : case COND_EXPR:
6560 4 : {
6561 4 : tree _q80 = TREE_OPERAND (_p1, 0);
6562 4 : tree _q81 = TREE_OPERAND (_p1, 1);
6563 4 : tree _q82 = TREE_OPERAND (_p1, 2);
6564 4 : switch (TREE_CODE (_q80))
6565 : {
6566 0 : case EQ_EXPR:
6567 0 : {
6568 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6569 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6570 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6571 : {
6572 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6573 : {
6574 0 : if (zerop (_q82))
6575 : {
6576 0 : {
6577 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6578 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, NE_EXPR, EQ_EXPR);
6579 0 : if (res) return res;
6580 : }
6581 : }
6582 : }
6583 : }
6584 : break;
6585 : }
6586 : default:;
6587 : }
6588 : break;
6589 : }
6590 : default:;
6591 : }
6592 : }
6593 : break;
6594 : }
6595 0 : case GE_EXPR:
6596 0 : {
6597 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6598 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6599 0 : if (zerop (_q22))
6600 : {
6601 0 : switch (TREE_CODE (_p1))
6602 : {
6603 0 : case COND_EXPR:
6604 0 : {
6605 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6606 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6607 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6608 0 : switch (TREE_CODE (_q80))
6609 : {
6610 0 : case LT_EXPR:
6611 0 : {
6612 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6613 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6614 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6615 : {
6616 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6617 : {
6618 0 : if (zerop (_q82))
6619 : {
6620 0 : {
6621 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6622 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GE_EXPR, LT_EXPR);
6623 0 : if (res) return res;
6624 : }
6625 : }
6626 : }
6627 : }
6628 : break;
6629 : }
6630 : default:;
6631 : }
6632 : break;
6633 : }
6634 : default:;
6635 : }
6636 : }
6637 : break;
6638 : }
6639 0 : case GT_EXPR:
6640 0 : {
6641 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6642 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6643 0 : if (zerop (_q22))
6644 : {
6645 0 : switch (TREE_CODE (_p1))
6646 : {
6647 0 : case COND_EXPR:
6648 0 : {
6649 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6650 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6651 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6652 0 : switch (TREE_CODE (_q80))
6653 : {
6654 0 : case LE_EXPR:
6655 0 : {
6656 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6657 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6658 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6659 : {
6660 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6661 : {
6662 0 : if (zerop (_q82))
6663 : {
6664 0 : {
6665 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6666 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GT_EXPR, LE_EXPR);
6667 0 : if (res) return res;
6668 : }
6669 : }
6670 : }
6671 : }
6672 : break;
6673 : }
6674 : default:;
6675 : }
6676 : break;
6677 : }
6678 : default:;
6679 : }
6680 : }
6681 : break;
6682 : }
6683 0 : case UNORDERED_EXPR:
6684 0 : {
6685 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6686 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6687 0 : if (zerop (_q22))
6688 : {
6689 0 : switch (TREE_CODE (_p1))
6690 : {
6691 0 : case COND_EXPR:
6692 0 : {
6693 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6694 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6695 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6696 0 : switch (TREE_CODE (_q80))
6697 : {
6698 0 : case ORDERED_EXPR:
6699 0 : {
6700 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6701 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6702 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6703 : {
6704 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6705 : {
6706 0 : if (zerop (_q82))
6707 : {
6708 0 : {
6709 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6710 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNORDERED_EXPR, ORDERED_EXPR);
6711 0 : if (res) return res;
6712 : }
6713 : }
6714 : }
6715 : }
6716 : break;
6717 : }
6718 : default:;
6719 : }
6720 : break;
6721 : }
6722 : default:;
6723 : }
6724 : }
6725 : break;
6726 : }
6727 0 : case ORDERED_EXPR:
6728 0 : {
6729 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6730 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6731 0 : if (zerop (_q22))
6732 : {
6733 0 : switch (TREE_CODE (_p1))
6734 : {
6735 0 : case COND_EXPR:
6736 0 : {
6737 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6738 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6739 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6740 0 : switch (TREE_CODE (_q80))
6741 : {
6742 0 : case UNORDERED_EXPR:
6743 0 : {
6744 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6745 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6746 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6747 : {
6748 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6749 : {
6750 0 : if (zerop (_q82))
6751 : {
6752 0 : {
6753 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6754 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, ORDERED_EXPR, UNORDERED_EXPR);
6755 0 : if (res) return res;
6756 : }
6757 : }
6758 : }
6759 : }
6760 : break;
6761 : }
6762 : default:;
6763 : }
6764 : break;
6765 : }
6766 : default:;
6767 : }
6768 : }
6769 : break;
6770 : }
6771 0 : case UNLT_EXPR:
6772 0 : {
6773 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6774 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6775 0 : if (zerop (_q22))
6776 : {
6777 0 : switch (TREE_CODE (_p1))
6778 : {
6779 0 : case COND_EXPR:
6780 0 : {
6781 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6782 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6783 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6784 0 : switch (TREE_CODE (_q80))
6785 : {
6786 0 : case GE_EXPR:
6787 0 : {
6788 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6789 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6790 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6791 : {
6792 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6793 : {
6794 0 : if (zerop (_q82))
6795 : {
6796 0 : {
6797 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6798 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLT_EXPR, GE_EXPR);
6799 0 : if (res) return res;
6800 : }
6801 : }
6802 : }
6803 : }
6804 : break;
6805 : }
6806 : default:;
6807 : }
6808 : break;
6809 : }
6810 : default:;
6811 : }
6812 : }
6813 : break;
6814 : }
6815 0 : case UNLE_EXPR:
6816 0 : {
6817 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6818 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6819 0 : if (zerop (_q22))
6820 : {
6821 0 : switch (TREE_CODE (_p1))
6822 : {
6823 0 : case COND_EXPR:
6824 0 : {
6825 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6826 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6827 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6828 0 : switch (TREE_CODE (_q80))
6829 : {
6830 0 : case GT_EXPR:
6831 0 : {
6832 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6833 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6834 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6835 : {
6836 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6837 : {
6838 0 : if (zerop (_q82))
6839 : {
6840 0 : {
6841 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6842 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLE_EXPR, GT_EXPR);
6843 0 : if (res) return res;
6844 : }
6845 : }
6846 : }
6847 : }
6848 : break;
6849 : }
6850 : default:;
6851 : }
6852 : break;
6853 : }
6854 : default:;
6855 : }
6856 : }
6857 : break;
6858 : }
6859 0 : case UNGT_EXPR:
6860 0 : {
6861 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6862 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6863 0 : if (zerop (_q22))
6864 : {
6865 0 : switch (TREE_CODE (_p1))
6866 : {
6867 0 : case COND_EXPR:
6868 0 : {
6869 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6870 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6871 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6872 0 : switch (TREE_CODE (_q80))
6873 : {
6874 0 : case LE_EXPR:
6875 0 : {
6876 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6877 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6878 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6879 : {
6880 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6881 : {
6882 0 : if (zerop (_q82))
6883 : {
6884 0 : {
6885 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6886 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGT_EXPR, LE_EXPR);
6887 0 : if (res) return res;
6888 : }
6889 : }
6890 : }
6891 : }
6892 : break;
6893 : }
6894 : default:;
6895 : }
6896 : break;
6897 : }
6898 : default:;
6899 : }
6900 : }
6901 : break;
6902 : }
6903 0 : case UNGE_EXPR:
6904 0 : {
6905 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6906 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6907 0 : if (zerop (_q22))
6908 : {
6909 0 : switch (TREE_CODE (_p1))
6910 : {
6911 0 : case COND_EXPR:
6912 0 : {
6913 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6914 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6915 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6916 0 : switch (TREE_CODE (_q80))
6917 : {
6918 0 : case LT_EXPR:
6919 0 : {
6920 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6921 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6922 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6923 : {
6924 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6925 : {
6926 0 : if (zerop (_q82))
6927 : {
6928 0 : {
6929 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6930 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGE_EXPR, LT_EXPR);
6931 0 : if (res) return res;
6932 : }
6933 : }
6934 : }
6935 : }
6936 : break;
6937 : }
6938 : default:;
6939 : }
6940 : break;
6941 : }
6942 : default:;
6943 : }
6944 : }
6945 : break;
6946 : }
6947 0 : case UNEQ_EXPR:
6948 0 : {
6949 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6950 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6951 0 : if (zerop (_q22))
6952 : {
6953 0 : switch (TREE_CODE (_p1))
6954 : {
6955 0 : case COND_EXPR:
6956 0 : {
6957 0 : tree _q80 = TREE_OPERAND (_p1, 0);
6958 0 : tree _q81 = TREE_OPERAND (_p1, 1);
6959 0 : tree _q82 = TREE_OPERAND (_p1, 2);
6960 0 : switch (TREE_CODE (_q80))
6961 : {
6962 0 : case LTGT_EXPR:
6963 0 : {
6964 0 : tree _q90 = TREE_OPERAND (_q80, 0);
6965 0 : tree _q91 = TREE_OPERAND (_q80, 1);
6966 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
6967 : {
6968 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
6969 : {
6970 0 : if (zerop (_q82))
6971 : {
6972 0 : {
6973 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
6974 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNEQ_EXPR, LTGT_EXPR);
6975 0 : if (res) return res;
6976 : }
6977 : }
6978 : }
6979 : }
6980 : break;
6981 : }
6982 : default:;
6983 : }
6984 : break;
6985 : }
6986 : default:;
6987 : }
6988 : }
6989 : break;
6990 : }
6991 0 : case LTGT_EXPR:
6992 0 : {
6993 0 : tree _q30 = TREE_OPERAND (_q20, 0);
6994 0 : tree _q31 = TREE_OPERAND (_q20, 1);
6995 0 : if (zerop (_q22))
6996 : {
6997 0 : switch (TREE_CODE (_p1))
6998 : {
6999 0 : case COND_EXPR:
7000 0 : {
7001 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7002 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7003 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7004 0 : switch (TREE_CODE (_q80))
7005 : {
7006 0 : case UNEQ_EXPR:
7007 0 : {
7008 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7009 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7010 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7011 : {
7012 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7013 : {
7014 0 : if (zerop (_q82))
7015 : {
7016 0 : {
7017 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q30, _q31, _q21, _q80, _q81 };
7018 0 : tree res = generic_simplify_37 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LTGT_EXPR, UNEQ_EXPR);
7019 0 : if (res) return res;
7020 : }
7021 : }
7022 : }
7023 : }
7024 : break;
7025 : }
7026 : default:;
7027 : }
7028 : break;
7029 : }
7030 : default:;
7031 : }
7032 : }
7033 : break;
7034 : }
7035 : default:;
7036 : }
7037 : break;
7038 : }
7039 1 : case VEC_COND_EXPR:
7040 1 : {
7041 1 : tree _q20 = TREE_OPERAND (_p0, 0);
7042 1 : tree _q21 = TREE_OPERAND (_p0, 1);
7043 1 : tree _q22 = TREE_OPERAND (_p0, 2);
7044 1 : if (integer_zerop (_q22))
7045 : {
7046 1 : switch (TREE_CODE (_p1))
7047 : {
7048 0 : case VEC_COND_EXPR:
7049 0 : {
7050 0 : tree _q60 = TREE_OPERAND (_p1, 0);
7051 0 : tree _q61 = TREE_OPERAND (_p1, 1);
7052 0 : tree _q62 = TREE_OPERAND (_p1, 2);
7053 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7054 : {
7055 0 : if (integer_zerop (_q61))
7056 : {
7057 0 : {
7058 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q62 };
7059 0 : const enum tree_code op = BIT_XOR_EXPR;
7060 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1172;
7061 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1172;
7062 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1172;
7063 0 : {
7064 0 : tree res_op0;
7065 0 : res_op0 = captures[1];
7066 0 : tree res_op1;
7067 0 : res_op1 = captures[2];
7068 0 : tree res_op2;
7069 0 : res_op2 = captures[4];
7070 0 : tree _r;
7071 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7072 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
7073 0 : return _r;
7074 : }
7075 0 : next_after_fail1172:;
7076 : }
7077 : }
7078 : }
7079 : break;
7080 : }
7081 : default:;
7082 : }
7083 : }
7084 1 : if (integer_zerop (_q21))
7085 : {
7086 0 : switch (TREE_CODE (_p1))
7087 : {
7088 0 : case VEC_COND_EXPR:
7089 0 : {
7090 0 : tree _q60 = TREE_OPERAND (_p1, 0);
7091 0 : tree _q61 = TREE_OPERAND (_p1, 1);
7092 0 : tree _q62 = TREE_OPERAND (_p1, 2);
7093 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7094 : {
7095 0 : if (integer_zerop (_q62))
7096 : {
7097 0 : {
7098 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p1, _q20, _q61, _p0, _q22 };
7099 0 : const enum tree_code op = BIT_XOR_EXPR;
7100 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1173;
7101 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1173;
7102 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1173;
7103 0 : {
7104 0 : tree res_op0;
7105 0 : res_op0 = captures[1];
7106 0 : tree res_op1;
7107 0 : res_op1 = captures[2];
7108 0 : tree res_op2;
7109 0 : res_op2 = captures[4];
7110 0 : tree _r;
7111 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7112 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 893, __FILE__, __LINE__, true);
7113 0 : return _r;
7114 : }
7115 0 : next_after_fail1173:;
7116 : }
7117 : }
7118 : }
7119 : break;
7120 : }
7121 : default:;
7122 : }
7123 : }
7124 1 : switch (TREE_CODE (_q20))
7125 : {
7126 0 : case LT_EXPR:
7127 0 : {
7128 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7129 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7130 0 : if (integer_zerop (_q22))
7131 : {
7132 0 : switch (TREE_CODE (_p1))
7133 : {
7134 0 : case VEC_COND_EXPR:
7135 0 : {
7136 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7137 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7138 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7139 0 : switch (TREE_CODE (_q80))
7140 : {
7141 0 : case GE_EXPR:
7142 0 : {
7143 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7144 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7145 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7146 : {
7147 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7148 : {
7149 0 : if (integer_zerop (_q82))
7150 : {
7151 0 : {
7152 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7153 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LT_EXPR, GE_EXPR);
7154 0 : if (res) return res;
7155 : }
7156 : }
7157 : }
7158 : }
7159 : break;
7160 : }
7161 : default:;
7162 : }
7163 : break;
7164 : }
7165 : default:;
7166 : }
7167 : }
7168 : break;
7169 : }
7170 0 : case LE_EXPR:
7171 0 : {
7172 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7173 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7174 0 : if (integer_zerop (_q22))
7175 : {
7176 0 : switch (TREE_CODE (_p1))
7177 : {
7178 0 : case VEC_COND_EXPR:
7179 0 : {
7180 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7181 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7182 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7183 0 : switch (TREE_CODE (_q80))
7184 : {
7185 0 : case GT_EXPR:
7186 0 : {
7187 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7188 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7189 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7190 : {
7191 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7192 : {
7193 0 : if (integer_zerop (_q82))
7194 : {
7195 0 : {
7196 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7197 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LE_EXPR, GT_EXPR);
7198 0 : if (res) return res;
7199 : }
7200 : }
7201 : }
7202 : }
7203 : break;
7204 : }
7205 : default:;
7206 : }
7207 : break;
7208 : }
7209 : default:;
7210 : }
7211 : }
7212 : break;
7213 : }
7214 0 : case EQ_EXPR:
7215 0 : {
7216 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7217 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7218 0 : if (integer_zerop (_q22))
7219 : {
7220 0 : switch (TREE_CODE (_p1))
7221 : {
7222 0 : case VEC_COND_EXPR:
7223 0 : {
7224 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7225 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7226 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7227 0 : switch (TREE_CODE (_q80))
7228 : {
7229 0 : case NE_EXPR:
7230 0 : {
7231 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7232 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7233 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7234 : {
7235 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7236 : {
7237 0 : if (integer_zerop (_q82))
7238 : {
7239 0 : {
7240 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7241 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, EQ_EXPR, NE_EXPR);
7242 0 : if (res) return res;
7243 : }
7244 : }
7245 : }
7246 : }
7247 : break;
7248 : }
7249 : default:;
7250 : }
7251 : break;
7252 : }
7253 : default:;
7254 : }
7255 : }
7256 : break;
7257 : }
7258 1 : case NE_EXPR:
7259 1 : {
7260 1 : tree _q30 = TREE_OPERAND (_q20, 0);
7261 1 : tree _q31 = TREE_OPERAND (_q20, 1);
7262 1 : if (integer_zerop (_q22))
7263 : {
7264 1 : switch (TREE_CODE (_p1))
7265 : {
7266 0 : case VEC_COND_EXPR:
7267 0 : {
7268 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7269 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7270 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7271 0 : switch (TREE_CODE (_q80))
7272 : {
7273 0 : case EQ_EXPR:
7274 0 : {
7275 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7276 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7277 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7278 : {
7279 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7280 : {
7281 0 : if (integer_zerop (_q82))
7282 : {
7283 0 : {
7284 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7285 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, NE_EXPR, EQ_EXPR);
7286 0 : if (res) return res;
7287 : }
7288 : }
7289 : }
7290 : }
7291 : break;
7292 : }
7293 : default:;
7294 : }
7295 : break;
7296 : }
7297 : default:;
7298 : }
7299 : }
7300 : break;
7301 : }
7302 0 : case GE_EXPR:
7303 0 : {
7304 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7305 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7306 0 : if (integer_zerop (_q22))
7307 : {
7308 0 : switch (TREE_CODE (_p1))
7309 : {
7310 0 : case VEC_COND_EXPR:
7311 0 : {
7312 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7313 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7314 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7315 0 : switch (TREE_CODE (_q80))
7316 : {
7317 0 : case LT_EXPR:
7318 0 : {
7319 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7320 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7321 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7322 : {
7323 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7324 : {
7325 0 : if (integer_zerop (_q82))
7326 : {
7327 0 : {
7328 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7329 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GE_EXPR, LT_EXPR);
7330 0 : if (res) return res;
7331 : }
7332 : }
7333 : }
7334 : }
7335 : break;
7336 : }
7337 : default:;
7338 : }
7339 : break;
7340 : }
7341 : default:;
7342 : }
7343 : }
7344 : break;
7345 : }
7346 0 : case GT_EXPR:
7347 0 : {
7348 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7349 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7350 0 : if (integer_zerop (_q22))
7351 : {
7352 0 : switch (TREE_CODE (_p1))
7353 : {
7354 0 : case VEC_COND_EXPR:
7355 0 : {
7356 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7357 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7358 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7359 0 : switch (TREE_CODE (_q80))
7360 : {
7361 0 : case LE_EXPR:
7362 0 : {
7363 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7364 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7365 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7366 : {
7367 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7368 : {
7369 0 : if (integer_zerop (_q82))
7370 : {
7371 0 : {
7372 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7373 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, GT_EXPR, LE_EXPR);
7374 0 : if (res) return res;
7375 : }
7376 : }
7377 : }
7378 : }
7379 : break;
7380 : }
7381 : default:;
7382 : }
7383 : break;
7384 : }
7385 : default:;
7386 : }
7387 : }
7388 : break;
7389 : }
7390 0 : case UNORDERED_EXPR:
7391 0 : {
7392 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7393 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7394 0 : if (integer_zerop (_q22))
7395 : {
7396 0 : switch (TREE_CODE (_p1))
7397 : {
7398 0 : case VEC_COND_EXPR:
7399 0 : {
7400 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7401 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7402 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7403 0 : switch (TREE_CODE (_q80))
7404 : {
7405 0 : case ORDERED_EXPR:
7406 0 : {
7407 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7408 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7409 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7410 : {
7411 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7412 : {
7413 0 : if (integer_zerop (_q82))
7414 : {
7415 0 : {
7416 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7417 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNORDERED_EXPR, ORDERED_EXPR);
7418 0 : if (res) return res;
7419 : }
7420 : }
7421 : }
7422 : }
7423 : break;
7424 : }
7425 : default:;
7426 : }
7427 : break;
7428 : }
7429 : default:;
7430 : }
7431 : }
7432 : break;
7433 : }
7434 0 : case ORDERED_EXPR:
7435 0 : {
7436 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7437 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7438 0 : if (integer_zerop (_q22))
7439 : {
7440 0 : switch (TREE_CODE (_p1))
7441 : {
7442 0 : case VEC_COND_EXPR:
7443 0 : {
7444 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7445 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7446 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7447 0 : switch (TREE_CODE (_q80))
7448 : {
7449 0 : case UNORDERED_EXPR:
7450 0 : {
7451 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7452 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7453 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7454 : {
7455 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7456 : {
7457 0 : if (integer_zerop (_q82))
7458 : {
7459 0 : {
7460 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7461 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, ORDERED_EXPR, UNORDERED_EXPR);
7462 0 : if (res) return res;
7463 : }
7464 : }
7465 : }
7466 : }
7467 : break;
7468 : }
7469 : default:;
7470 : }
7471 : break;
7472 : }
7473 : default:;
7474 : }
7475 : }
7476 : break;
7477 : }
7478 0 : case UNLT_EXPR:
7479 0 : {
7480 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7481 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7482 0 : if (integer_zerop (_q22))
7483 : {
7484 0 : switch (TREE_CODE (_p1))
7485 : {
7486 0 : case VEC_COND_EXPR:
7487 0 : {
7488 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7489 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7490 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7491 0 : switch (TREE_CODE (_q80))
7492 : {
7493 0 : case GE_EXPR:
7494 0 : {
7495 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7496 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7497 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7498 : {
7499 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7500 : {
7501 0 : if (integer_zerop (_q82))
7502 : {
7503 0 : {
7504 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7505 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLT_EXPR, GE_EXPR);
7506 0 : if (res) return res;
7507 : }
7508 : }
7509 : }
7510 : }
7511 : break;
7512 : }
7513 : default:;
7514 : }
7515 : break;
7516 : }
7517 : default:;
7518 : }
7519 : }
7520 : break;
7521 : }
7522 0 : case UNLE_EXPR:
7523 0 : {
7524 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7525 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7526 0 : if (integer_zerop (_q22))
7527 : {
7528 0 : switch (TREE_CODE (_p1))
7529 : {
7530 0 : case VEC_COND_EXPR:
7531 0 : {
7532 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7533 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7534 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7535 0 : switch (TREE_CODE (_q80))
7536 : {
7537 0 : case GT_EXPR:
7538 0 : {
7539 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7540 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7541 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7542 : {
7543 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7544 : {
7545 0 : if (integer_zerop (_q82))
7546 : {
7547 0 : {
7548 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7549 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNLE_EXPR, GT_EXPR);
7550 0 : if (res) return res;
7551 : }
7552 : }
7553 : }
7554 : }
7555 : break;
7556 : }
7557 : default:;
7558 : }
7559 : break;
7560 : }
7561 : default:;
7562 : }
7563 : }
7564 : break;
7565 : }
7566 0 : case UNGT_EXPR:
7567 0 : {
7568 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7569 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7570 0 : if (integer_zerop (_q22))
7571 : {
7572 0 : switch (TREE_CODE (_p1))
7573 : {
7574 0 : case VEC_COND_EXPR:
7575 0 : {
7576 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7577 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7578 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7579 0 : switch (TREE_CODE (_q80))
7580 : {
7581 0 : case LE_EXPR:
7582 0 : {
7583 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7584 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7585 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7586 : {
7587 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7588 : {
7589 0 : if (integer_zerop (_q82))
7590 : {
7591 0 : {
7592 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7593 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGT_EXPR, LE_EXPR);
7594 0 : if (res) return res;
7595 : }
7596 : }
7597 : }
7598 : }
7599 : break;
7600 : }
7601 : default:;
7602 : }
7603 : break;
7604 : }
7605 : default:;
7606 : }
7607 : }
7608 : break;
7609 : }
7610 0 : case UNGE_EXPR:
7611 0 : {
7612 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7613 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7614 0 : if (integer_zerop (_q22))
7615 : {
7616 0 : switch (TREE_CODE (_p1))
7617 : {
7618 0 : case VEC_COND_EXPR:
7619 0 : {
7620 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7621 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7622 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7623 0 : switch (TREE_CODE (_q80))
7624 : {
7625 0 : case LT_EXPR:
7626 0 : {
7627 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7628 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7629 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7630 : {
7631 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7632 : {
7633 0 : if (integer_zerop (_q82))
7634 : {
7635 0 : {
7636 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7637 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNGE_EXPR, LT_EXPR);
7638 0 : if (res) return res;
7639 : }
7640 : }
7641 : }
7642 : }
7643 : break;
7644 : }
7645 : default:;
7646 : }
7647 : break;
7648 : }
7649 : default:;
7650 : }
7651 : }
7652 : break;
7653 : }
7654 0 : case UNEQ_EXPR:
7655 0 : {
7656 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7657 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7658 0 : if (integer_zerop (_q22))
7659 : {
7660 0 : switch (TREE_CODE (_p1))
7661 : {
7662 0 : case VEC_COND_EXPR:
7663 0 : {
7664 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7665 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7666 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7667 0 : switch (TREE_CODE (_q80))
7668 : {
7669 0 : case LTGT_EXPR:
7670 0 : {
7671 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7672 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7673 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7674 : {
7675 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7676 : {
7677 0 : if (integer_zerop (_q82))
7678 : {
7679 0 : {
7680 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7681 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, UNEQ_EXPR, LTGT_EXPR);
7682 0 : if (res) return res;
7683 : }
7684 : }
7685 : }
7686 : }
7687 : break;
7688 : }
7689 : default:;
7690 : }
7691 : break;
7692 : }
7693 : default:;
7694 : }
7695 : }
7696 : break;
7697 : }
7698 0 : case LTGT_EXPR:
7699 0 : {
7700 0 : tree _q30 = TREE_OPERAND (_q20, 0);
7701 0 : tree _q31 = TREE_OPERAND (_q20, 1);
7702 0 : if (integer_zerop (_q22))
7703 : {
7704 0 : switch (TREE_CODE (_p1))
7705 : {
7706 0 : case VEC_COND_EXPR:
7707 0 : {
7708 0 : tree _q80 = TREE_OPERAND (_p1, 0);
7709 0 : tree _q81 = TREE_OPERAND (_p1, 1);
7710 0 : tree _q82 = TREE_OPERAND (_p1, 2);
7711 0 : switch (TREE_CODE (_q80))
7712 : {
7713 0 : case UNEQ_EXPR:
7714 0 : {
7715 0 : tree _q90 = TREE_OPERAND (_q80, 0);
7716 0 : tree _q91 = TREE_OPERAND (_q80, 1);
7717 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
7718 : {
7719 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
7720 : {
7721 0 : if (integer_zerop (_q82))
7722 : {
7723 0 : {
7724 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q80, _q81 };
7725 0 : tree res = generic_simplify_38 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LTGT_EXPR, UNEQ_EXPR);
7726 0 : if (res) return res;
7727 : }
7728 : }
7729 : }
7730 : }
7731 : break;
7732 : }
7733 : default:;
7734 : }
7735 : break;
7736 : }
7737 : default:;
7738 : }
7739 : }
7740 : break;
7741 : }
7742 : default:;
7743 : }
7744 : break;
7745 : }
7746 119 : case EQ_EXPR:
7747 119 : {
7748 119 : tree _q20 = TREE_OPERAND (_p0, 0);
7749 119 : tree _q21 = TREE_OPERAND (_p0, 1);
7750 119 : switch (TREE_CODE (_p1))
7751 : {
7752 0 : case BIT_AND_EXPR:
7753 0 : {
7754 0 : tree _q50 = TREE_OPERAND (_p1, 0);
7755 0 : tree _q51 = TREE_OPERAND (_p1, 1);
7756 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7757 : {
7758 0 : if (tree_truth_valued_p (_q50))
7759 : {
7760 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7761 : {
7762 0 : if (tree_truth_valued_p (_q51))
7763 : {
7764 0 : {
7765 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7766 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1174;
7767 0 : {
7768 0 : tree res_op0;
7769 0 : {
7770 0 : tree _o1[2], _r1;
7771 0 : _o1[0] = captures[0];
7772 0 : _o1[1] = captures[1];
7773 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
7774 0 : res_op0 = _r1;
7775 : }
7776 0 : tree _r;
7777 0 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
7778 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
7779 0 : return _r;
7780 : }
7781 0 : next_after_fail1174:;
7782 : }
7783 : }
7784 : }
7785 : }
7786 : }
7787 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7788 : {
7789 0 : if (tree_truth_valued_p (_q50))
7790 : {
7791 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7792 : {
7793 0 : if (tree_truth_valued_p (_q51))
7794 : {
7795 0 : {
7796 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
7797 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1175;
7798 0 : {
7799 0 : tree res_op0;
7800 0 : {
7801 0 : tree _o1[2], _r1;
7802 0 : _o1[0] = captures[0];
7803 0 : _o1[1] = captures[1];
7804 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
7805 0 : res_op0 = _r1;
7806 : }
7807 0 : tree _r;
7808 0 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
7809 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 892, __FILE__, __LINE__, true);
7810 0 : return _r;
7811 : }
7812 0 : next_after_fail1175:;
7813 : }
7814 : }
7815 : }
7816 : }
7817 : }
7818 : break;
7819 : }
7820 : default:;
7821 : }
7822 : break;
7823 : }
7824 907575 : default:;
7825 : }
7826 907575 : {
7827 907575 : tree _p0_pops[1];
7828 907575 : if (tree_logical_inverted_value (_p0, _p0_pops))
7829 : {
7830 52 : tree _q20 = _p0_pops[0];
7831 52 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
7832 : {
7833 4 : if (tree_truth_valued_p (_p1))
7834 : {
7835 4 : {
7836 4 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
7837 4 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
7838 4 : if (res) return res;
7839 : }
7840 : }
7841 : }
7842 : }
7843 : }
7844 907571 : {
7845 907571 : tree _p0_pops[1];
7846 907571 : if (tree_nop_convert (_p0, _p0_pops))
7847 : {
7848 506875 : tree _q20 = _p0_pops[0];
7849 506875 : switch (TREE_CODE (_q20))
7850 : {
7851 24 : case BIT_NOT_EXPR:
7852 24 : {
7853 24 : tree _q30 = TREE_OPERAND (_q20, 0);
7854 24 : {
7855 24 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _p1 };
7856 24 : tree res = generic_simplify_39 (loc, type, _p0, _p1, captures);
7857 24 : if (res) return res;
7858 : }
7859 0 : break;
7860 : }
7861 20 : case MULT_EXPR:
7862 20 : {
7863 20 : tree _q30 = TREE_OPERAND (_q20, 0);
7864 20 : tree _q31 = TREE_OPERAND (_q20, 1);
7865 20 : {
7866 20 : tree _q30_pops[1];
7867 20 : if (tree_nop_convert (_q30, _q30_pops))
7868 : {
7869 0 : tree _q40 = _q30_pops[0];
7870 0 : switch (TREE_CODE (_q31))
7871 : {
7872 0 : case INTEGER_CST:
7873 0 : {
7874 0 : switch (TREE_CODE (_p1))
7875 : {
7876 0 : case LSHIFT_EXPR:
7877 0 : {
7878 0 : tree _q70 = TREE_OPERAND (_p1, 0);
7879 0 : tree _q71 = TREE_OPERAND (_p1, 1);
7880 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
7881 : {
7882 0 : switch (TREE_CODE (_q71))
7883 : {
7884 0 : case INTEGER_CST:
7885 0 : {
7886 0 : {
7887 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31, _p1, _q71 };
7888 0 : tree res = generic_simplify_41 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
7889 0 : if (res) return res;
7890 : }
7891 0 : break;
7892 : }
7893 : default:;
7894 : }
7895 : }
7896 : break;
7897 : }
7898 0 : default:;
7899 : }
7900 0 : {
7901 0 : tree _p1_pops[1];
7902 0 : if (tree_nop_convert (_p1, _p1_pops))
7903 : {
7904 0 : tree _q70 = _p1_pops[0];
7905 0 : switch (TREE_CODE (_q70))
7906 : {
7907 0 : case MULT_EXPR:
7908 0 : {
7909 0 : tree _q80 = TREE_OPERAND (_q70, 0);
7910 0 : tree _q81 = TREE_OPERAND (_q70, 1);
7911 0 : {
7912 0 : tree _q80_pops[1];
7913 0 : if (tree_nop_convert (_q80, _q80_pops))
7914 : {
7915 0 : tree _q90 = _q80_pops[0];
7916 0 : switch (TREE_CODE (_q81))
7917 : {
7918 0 : case INTEGER_CST:
7919 0 : {
7920 0 : {
7921 0 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31, _p1, _q70, _q90, _q81 };
7922 0 : tree res = generic_simplify_40 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
7923 0 : if (res) return res;
7924 : }
7925 0 : break;
7926 : }
7927 : default:;
7928 : }
7929 : }
7930 : }
7931 0 : break;
7932 : }
7933 : default:;
7934 : }
7935 : }
7936 : }
7937 0 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
7938 : {
7939 0 : {
7940 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31 };
7941 0 : tree res = generic_simplify_42 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
7942 0 : if (res) return res;
7943 : }
7944 : }
7945 : break;
7946 : }
7947 : default:;
7948 : }
7949 : }
7950 : }
7951 20 : break;
7952 : }
7953 : default:;
7954 : }
7955 : }
7956 : }
7957 907547 : if (tree_truth_valued_p (_p0))
7958 : {
7959 137035 : {
7960 137035 : tree _p1_pops[1];
7961 137035 : if (tree_logical_inverted_value (_p1, _p1_pops))
7962 : {
7963 13 : tree _q30 = _p1_pops[0];
7964 13 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
7965 : {
7966 0 : {
7967 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
7968 0 : tree res = generic_simplify_36 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
7969 0 : if (res) return res;
7970 : }
7971 : }
7972 : }
7973 : }
7974 : }
7975 907547 : switch (TREE_CODE (_p1))
7976 : {
7977 288 : case BIT_NOT_EXPR:
7978 288 : {
7979 288 : tree _q30 = TREE_OPERAND (_p1, 0);
7980 288 : {
7981 288 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0 };
7982 288 : tree res = generic_simplify_28 (loc, type, _p0, _p1, captures);
7983 288 : if (res) return res;
7984 : }
7985 0 : break;
7986 : }
7987 907259 : default:;
7988 : }
7989 907259 : {
7990 907259 : tree _p1_pops[1];
7991 907259 : if (tree_nop_convert (_p1, _p1_pops))
7992 : {
7993 635442 : tree _q30 = _p1_pops[0];
7994 635442 : switch (TREE_CODE (_q30))
7995 : {
7996 0 : case BIT_NOT_EXPR:
7997 0 : {
7998 0 : tree _q40 = TREE_OPERAND (_q30, 0);
7999 0 : {
8000 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0 };
8001 0 : tree res = generic_simplify_39 (loc, type, _p0, _p1, captures);
8002 0 : if (res) return res;
8003 : }
8004 0 : break;
8005 : }
8006 : default:;
8007 : }
8008 : }
8009 : }
8010 907259 : switch (TREE_CODE (_p0))
8011 : {
8012 1131 : case BIT_IOR_EXPR:
8013 1131 : {
8014 1131 : tree _q20 = TREE_OPERAND (_p0, 0);
8015 1131 : tree _q21 = TREE_OPERAND (_p0, 1);
8016 1131 : switch (TREE_CODE (_q21))
8017 : {
8018 23 : case INTEGER_CST:
8019 23 : {
8020 23 : switch (TREE_CODE (_p1))
8021 : {
8022 23 : case INTEGER_CST:
8023 23 : {
8024 23 : {
8025 23 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
8026 23 : tree res = generic_simplify_43 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_XOR_EXPR);
8027 23 : if (res) return res;
8028 : }
8029 23 : break;
8030 : }
8031 : default:;
8032 : }
8033 : break;
8034 : }
8035 : default:;
8036 : }
8037 : break;
8038 : }
8039 90 : case LT_EXPR:
8040 90 : {
8041 90 : tree _q20 = TREE_OPERAND (_p0, 0);
8042 90 : tree _q21 = TREE_OPERAND (_p0, 1);
8043 90 : switch (TREE_CODE (_p1))
8044 : {
8045 0 : case GT_EXPR:
8046 0 : {
8047 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8048 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8049 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8050 : {
8051 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8052 : {
8053 0 : {
8054 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8055 0 : const enum tree_code cmp1 = LT_EXPR;
8056 0 : const enum tree_code cmp2 = GT_EXPR;
8057 0 : const enum tree_code rcmp = NE_EXPR;
8058 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8059 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8060 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8061 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8062 : )
8063 : {
8064 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1176;
8065 0 : {
8066 0 : tree res_op0;
8067 0 : res_op0 = captures[0];
8068 0 : tree res_op1;
8069 0 : res_op1 = captures[1];
8070 0 : tree _r;
8071 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8072 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8073 0 : return _r;
8074 : }
8075 0 : next_after_fail1176:;
8076 : }
8077 : }
8078 : }
8079 : }
8080 : break;
8081 : }
8082 0 : case EQ_EXPR:
8083 0 : {
8084 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8085 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8086 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8087 : {
8088 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8089 : {
8090 0 : {
8091 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8092 0 : const enum tree_code cmp1 = LT_EXPR;
8093 0 : const enum tree_code cmp2 = EQ_EXPR;
8094 0 : const enum tree_code rcmp = LE_EXPR;
8095 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8096 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8097 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8098 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8099 : )
8100 : {
8101 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1177;
8102 0 : {
8103 0 : tree res_op0;
8104 0 : res_op0 = captures[0];
8105 0 : tree res_op1;
8106 0 : res_op1 = captures[1];
8107 0 : tree _r;
8108 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8109 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8110 0 : return _r;
8111 : }
8112 0 : next_after_fail1177:;
8113 : }
8114 : }
8115 : }
8116 : }
8117 : break;
8118 : }
8119 0 : case NE_EXPR:
8120 0 : {
8121 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8122 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8123 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8124 : {
8125 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8126 : {
8127 0 : {
8128 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8129 0 : const enum tree_code cmp1 = LT_EXPR;
8130 0 : const enum tree_code cmp2 = NE_EXPR;
8131 0 : const enum tree_code rcmp = GT_EXPR;
8132 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8133 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8134 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8135 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8136 : )
8137 : {
8138 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1178;
8139 0 : {
8140 0 : tree res_op0;
8141 0 : res_op0 = captures[0];
8142 0 : tree res_op1;
8143 0 : res_op1 = captures[1];
8144 0 : tree _r;
8145 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8146 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8147 0 : return _r;
8148 : }
8149 0 : next_after_fail1178:;
8150 : }
8151 : }
8152 : }
8153 : }
8154 : break;
8155 : }
8156 : default:;
8157 : }
8158 : break;
8159 : }
8160 85 : case LE_EXPR:
8161 85 : {
8162 85 : tree _q20 = TREE_OPERAND (_p0, 0);
8163 85 : tree _q21 = TREE_OPERAND (_p0, 1);
8164 85 : switch (TREE_CODE (_p1))
8165 : {
8166 0 : case GE_EXPR:
8167 0 : {
8168 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8169 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8170 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8171 : {
8172 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8173 : {
8174 0 : {
8175 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8176 0 : const enum tree_code cmp1 = LE_EXPR;
8177 0 : const enum tree_code cmp2 = GE_EXPR;
8178 0 : const enum tree_code rcmp = NE_EXPR;
8179 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8180 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8181 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8182 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8183 : )
8184 : {
8185 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1179;
8186 0 : {
8187 0 : tree res_op0;
8188 0 : res_op0 = captures[0];
8189 0 : tree res_op1;
8190 0 : res_op1 = captures[1];
8191 0 : tree _r;
8192 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8193 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8194 0 : return _r;
8195 : }
8196 0 : next_after_fail1179:;
8197 : }
8198 : }
8199 : }
8200 : }
8201 : break;
8202 : }
8203 0 : case EQ_EXPR:
8204 0 : {
8205 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8206 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8207 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8208 : {
8209 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8210 : {
8211 0 : {
8212 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8213 0 : const enum tree_code cmp1 = LE_EXPR;
8214 0 : const enum tree_code cmp2 = EQ_EXPR;
8215 0 : const enum tree_code rcmp = LT_EXPR;
8216 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8217 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8218 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8219 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8220 : )
8221 : {
8222 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1180;
8223 0 : {
8224 0 : tree res_op0;
8225 0 : res_op0 = captures[0];
8226 0 : tree res_op1;
8227 0 : res_op1 = captures[1];
8228 0 : tree _r;
8229 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8230 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8231 0 : return _r;
8232 : }
8233 0 : next_after_fail1180:;
8234 : }
8235 : }
8236 : }
8237 : }
8238 : break;
8239 : }
8240 0 : case NE_EXPR:
8241 0 : {
8242 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8243 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8244 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8245 : {
8246 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8247 : {
8248 0 : {
8249 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8250 0 : const enum tree_code cmp1 = LE_EXPR;
8251 0 : const enum tree_code cmp2 = NE_EXPR;
8252 0 : const enum tree_code rcmp = GE_EXPR;
8253 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8254 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8255 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8256 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8257 : )
8258 : {
8259 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1181;
8260 0 : {
8261 0 : tree res_op0;
8262 0 : res_op0 = captures[0];
8263 0 : tree res_op1;
8264 0 : res_op1 = captures[1];
8265 0 : tree _r;
8266 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8267 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8268 0 : return _r;
8269 : }
8270 0 : next_after_fail1181:;
8271 : }
8272 : }
8273 : }
8274 : }
8275 : break;
8276 : }
8277 : default:;
8278 : }
8279 : break;
8280 : }
8281 100 : case GT_EXPR:
8282 100 : {
8283 100 : tree _q20 = TREE_OPERAND (_p0, 0);
8284 100 : tree _q21 = TREE_OPERAND (_p0, 1);
8285 100 : switch (TREE_CODE (_p1))
8286 : {
8287 0 : case GT_EXPR:
8288 0 : {
8289 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8290 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8291 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8292 : {
8293 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8294 : {
8295 0 : {
8296 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8297 0 : const enum tree_code cmp1 = LT_EXPR;
8298 0 : const enum tree_code cmp2 = GT_EXPR;
8299 0 : const enum tree_code rcmp = NE_EXPR;
8300 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8301 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8302 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8303 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8304 : )
8305 : {
8306 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1182;
8307 0 : {
8308 0 : tree res_op0;
8309 0 : res_op0 = captures[0];
8310 0 : tree res_op1;
8311 0 : res_op1 = captures[1];
8312 0 : tree _r;
8313 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8314 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8315 0 : return _r;
8316 : }
8317 0 : next_after_fail1182:;
8318 : }
8319 : }
8320 0 : {
8321 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8322 0 : const enum tree_code cmp1 = LT_EXPR;
8323 0 : const enum tree_code cmp2 = GT_EXPR;
8324 0 : const enum tree_code rcmp = NE_EXPR;
8325 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8326 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8327 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8328 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8329 : )
8330 : {
8331 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1183;
8332 0 : {
8333 0 : tree res_op0;
8334 0 : res_op0 = captures[0];
8335 0 : tree res_op1;
8336 0 : res_op1 = captures[1];
8337 0 : tree _r;
8338 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8339 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8340 0 : return _r;
8341 : }
8342 0 : next_after_fail1183:;
8343 : }
8344 : }
8345 : }
8346 : }
8347 : break;
8348 : }
8349 0 : case EQ_EXPR:
8350 0 : {
8351 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8352 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8353 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8354 : {
8355 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8356 : {
8357 0 : {
8358 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8359 0 : const enum tree_code cmp1 = LT_EXPR;
8360 0 : const enum tree_code cmp2 = EQ_EXPR;
8361 0 : const enum tree_code rcmp = LE_EXPR;
8362 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8363 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8364 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8365 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8366 : )
8367 : {
8368 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1184;
8369 0 : {
8370 0 : tree res_op0;
8371 0 : res_op0 = captures[0];
8372 0 : tree res_op1;
8373 0 : res_op1 = captures[1];
8374 0 : tree _r;
8375 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8376 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8377 0 : return _r;
8378 : }
8379 0 : next_after_fail1184:;
8380 : }
8381 : }
8382 : }
8383 : }
8384 : break;
8385 : }
8386 12 : case NE_EXPR:
8387 12 : {
8388 12 : tree _q50 = TREE_OPERAND (_p1, 0);
8389 12 : tree _q51 = TREE_OPERAND (_p1, 1);
8390 12 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8391 : {
8392 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8393 : {
8394 0 : {
8395 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8396 0 : const enum tree_code cmp1 = LT_EXPR;
8397 0 : const enum tree_code cmp2 = NE_EXPR;
8398 0 : const enum tree_code rcmp = GT_EXPR;
8399 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8400 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8401 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8402 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8403 : )
8404 : {
8405 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1185;
8406 0 : {
8407 0 : tree res_op0;
8408 0 : res_op0 = captures[0];
8409 0 : tree res_op1;
8410 0 : res_op1 = captures[1];
8411 0 : tree _r;
8412 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8413 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8414 0 : return _r;
8415 : }
8416 0 : next_after_fail1185:;
8417 : }
8418 : }
8419 : }
8420 : }
8421 : break;
8422 : }
8423 0 : case LT_EXPR:
8424 0 : {
8425 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8426 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8427 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8428 : {
8429 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8430 : {
8431 0 : {
8432 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8433 0 : const enum tree_code cmp1 = LT_EXPR;
8434 0 : const enum tree_code cmp2 = GT_EXPR;
8435 0 : const enum tree_code rcmp = NE_EXPR;
8436 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8437 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8438 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8439 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8440 : )
8441 : {
8442 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1186;
8443 0 : {
8444 0 : tree res_op0;
8445 0 : res_op0 = captures[0];
8446 0 : tree res_op1;
8447 0 : res_op1 = captures[1];
8448 0 : tree _r;
8449 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8450 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8451 0 : return _r;
8452 : }
8453 0 : next_after_fail1186:;
8454 : }
8455 : }
8456 : }
8457 : }
8458 : break;
8459 : }
8460 : default:;
8461 : }
8462 : break;
8463 : }
8464 62 : case GE_EXPR:
8465 62 : {
8466 62 : tree _q20 = TREE_OPERAND (_p0, 0);
8467 62 : tree _q21 = TREE_OPERAND (_p0, 1);
8468 62 : switch (TREE_CODE (_p1))
8469 : {
8470 1 : case GE_EXPR:
8471 1 : {
8472 1 : tree _q50 = TREE_OPERAND (_p1, 0);
8473 1 : tree _q51 = TREE_OPERAND (_p1, 1);
8474 1 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8475 : {
8476 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8477 : {
8478 0 : {
8479 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8480 0 : const enum tree_code cmp1 = LE_EXPR;
8481 0 : const enum tree_code cmp2 = GE_EXPR;
8482 0 : const enum tree_code rcmp = NE_EXPR;
8483 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8484 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8485 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8486 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8487 : )
8488 : {
8489 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1187;
8490 0 : {
8491 0 : tree res_op0;
8492 0 : res_op0 = captures[0];
8493 0 : tree res_op1;
8494 0 : res_op1 = captures[1];
8495 0 : tree _r;
8496 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8497 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8498 0 : return _r;
8499 : }
8500 0 : next_after_fail1187:;
8501 : }
8502 : }
8503 0 : {
8504 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8505 0 : const enum tree_code cmp1 = LE_EXPR;
8506 0 : const enum tree_code cmp2 = GE_EXPR;
8507 0 : const enum tree_code rcmp = NE_EXPR;
8508 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8509 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8510 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8511 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8512 : )
8513 : {
8514 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1188;
8515 0 : {
8516 0 : tree res_op0;
8517 0 : res_op0 = captures[0];
8518 0 : tree res_op1;
8519 0 : res_op1 = captures[1];
8520 0 : tree _r;
8521 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8522 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8523 0 : return _r;
8524 : }
8525 0 : next_after_fail1188:;
8526 : }
8527 : }
8528 : }
8529 : }
8530 : break;
8531 : }
8532 0 : case EQ_EXPR:
8533 0 : {
8534 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8535 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8536 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8537 : {
8538 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8539 : {
8540 0 : {
8541 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8542 0 : const enum tree_code cmp1 = LE_EXPR;
8543 0 : const enum tree_code cmp2 = EQ_EXPR;
8544 0 : const enum tree_code rcmp = LT_EXPR;
8545 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8546 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8547 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8548 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8549 : )
8550 : {
8551 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1189;
8552 0 : {
8553 0 : tree res_op0;
8554 0 : res_op0 = captures[0];
8555 0 : tree res_op1;
8556 0 : res_op1 = captures[1];
8557 0 : tree _r;
8558 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8559 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8560 0 : return _r;
8561 : }
8562 0 : next_after_fail1189:;
8563 : }
8564 : }
8565 : }
8566 : }
8567 : break;
8568 : }
8569 8 : case NE_EXPR:
8570 8 : {
8571 8 : tree _q50 = TREE_OPERAND (_p1, 0);
8572 8 : tree _q51 = TREE_OPERAND (_p1, 1);
8573 8 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8574 : {
8575 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8576 : {
8577 0 : {
8578 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
8579 0 : const enum tree_code cmp1 = LE_EXPR;
8580 0 : const enum tree_code cmp2 = NE_EXPR;
8581 0 : const enum tree_code rcmp = GE_EXPR;
8582 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8583 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8584 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8585 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8586 : )
8587 : {
8588 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1190;
8589 0 : {
8590 0 : tree res_op0;
8591 0 : res_op0 = captures[0];
8592 0 : tree res_op1;
8593 0 : res_op1 = captures[1];
8594 0 : tree _r;
8595 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8596 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8597 0 : return _r;
8598 : }
8599 0 : next_after_fail1190:;
8600 : }
8601 : }
8602 : }
8603 : }
8604 : break;
8605 : }
8606 0 : case LE_EXPR:
8607 0 : {
8608 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8609 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8610 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8611 : {
8612 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8613 : {
8614 0 : {
8615 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8616 0 : const enum tree_code cmp1 = LE_EXPR;
8617 0 : const enum tree_code cmp2 = GE_EXPR;
8618 0 : const enum tree_code rcmp = NE_EXPR;
8619 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8620 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8621 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8622 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8623 : )
8624 : {
8625 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1191;
8626 0 : {
8627 0 : tree res_op0;
8628 0 : res_op0 = captures[0];
8629 0 : tree res_op1;
8630 0 : res_op1 = captures[1];
8631 0 : tree _r;
8632 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8633 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8634 0 : return _r;
8635 : }
8636 0 : next_after_fail1191:;
8637 : }
8638 : }
8639 : }
8640 : }
8641 : break;
8642 : }
8643 : default:;
8644 : }
8645 : break;
8646 : }
8647 119 : case EQ_EXPR:
8648 119 : {
8649 119 : tree _q20 = TREE_OPERAND (_p0, 0);
8650 119 : tree _q21 = TREE_OPERAND (_p0, 1);
8651 119 : switch (TREE_CODE (_p1))
8652 : {
8653 0 : case LT_EXPR:
8654 0 : {
8655 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8656 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8657 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8658 : {
8659 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8660 : {
8661 0 : {
8662 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8663 0 : const enum tree_code cmp1 = LT_EXPR;
8664 0 : const enum tree_code cmp2 = EQ_EXPR;
8665 0 : const enum tree_code rcmp = LE_EXPR;
8666 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8667 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8668 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8669 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8670 : )
8671 : {
8672 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1192;
8673 0 : {
8674 0 : tree res_op0;
8675 0 : res_op0 = captures[0];
8676 0 : tree res_op1;
8677 0 : res_op1 = captures[1];
8678 0 : tree _r;
8679 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8680 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8681 0 : return _r;
8682 : }
8683 0 : next_after_fail1192:;
8684 : }
8685 : }
8686 : }
8687 : }
8688 : break;
8689 : }
8690 0 : case LE_EXPR:
8691 0 : {
8692 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8693 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8694 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8695 : {
8696 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8697 : {
8698 0 : {
8699 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8700 0 : const enum tree_code cmp1 = LE_EXPR;
8701 0 : const enum tree_code cmp2 = EQ_EXPR;
8702 0 : const enum tree_code rcmp = LT_EXPR;
8703 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8704 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8705 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8706 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8707 : )
8708 : {
8709 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1193;
8710 0 : {
8711 0 : tree res_op0;
8712 0 : res_op0 = captures[0];
8713 0 : tree res_op1;
8714 0 : res_op1 = captures[1];
8715 0 : tree _r;
8716 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8717 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8718 0 : return _r;
8719 : }
8720 0 : next_after_fail1193:;
8721 : }
8722 : }
8723 : }
8724 : }
8725 : break;
8726 : }
8727 0 : case GT_EXPR:
8728 0 : {
8729 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8730 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8731 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8732 : {
8733 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8734 : {
8735 0 : {
8736 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8737 0 : const enum tree_code cmp1 = LT_EXPR;
8738 0 : const enum tree_code cmp2 = EQ_EXPR;
8739 0 : const enum tree_code rcmp = LE_EXPR;
8740 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8741 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8742 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8743 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8744 : )
8745 : {
8746 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1194;
8747 0 : {
8748 0 : tree res_op0;
8749 0 : res_op0 = captures[0];
8750 0 : tree res_op1;
8751 0 : res_op1 = captures[1];
8752 0 : tree _r;
8753 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8754 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8755 0 : return _r;
8756 : }
8757 0 : next_after_fail1194:;
8758 : }
8759 : }
8760 : }
8761 : }
8762 : break;
8763 : }
8764 8 : case GE_EXPR:
8765 8 : {
8766 8 : tree _q50 = TREE_OPERAND (_p1, 0);
8767 8 : tree _q51 = TREE_OPERAND (_p1, 1);
8768 8 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8769 : {
8770 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8771 : {
8772 0 : {
8773 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8774 0 : const enum tree_code cmp1 = LE_EXPR;
8775 0 : const enum tree_code cmp2 = EQ_EXPR;
8776 0 : const enum tree_code rcmp = LT_EXPR;
8777 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8778 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8779 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8780 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8781 : )
8782 : {
8783 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1195;
8784 0 : {
8785 0 : tree res_op0;
8786 0 : res_op0 = captures[0];
8787 0 : tree res_op1;
8788 0 : res_op1 = captures[1];
8789 0 : tree _r;
8790 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8791 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8792 0 : return _r;
8793 : }
8794 0 : next_after_fail1195:;
8795 : }
8796 : }
8797 : }
8798 : }
8799 : break;
8800 : }
8801 : default:;
8802 : }
8803 : break;
8804 : }
8805 113 : case NE_EXPR:
8806 113 : {
8807 113 : tree _q20 = TREE_OPERAND (_p0, 0);
8808 113 : tree _q21 = TREE_OPERAND (_p0, 1);
8809 113 : switch (TREE_CODE (_p1))
8810 : {
8811 0 : case LT_EXPR:
8812 0 : {
8813 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8814 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8815 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8816 : {
8817 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8818 : {
8819 0 : {
8820 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8821 0 : const enum tree_code cmp1 = LT_EXPR;
8822 0 : const enum tree_code cmp2 = NE_EXPR;
8823 0 : const enum tree_code rcmp = GT_EXPR;
8824 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8825 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8826 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8827 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8828 : )
8829 : {
8830 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1196;
8831 0 : {
8832 0 : tree res_op0;
8833 0 : res_op0 = captures[0];
8834 0 : tree res_op1;
8835 0 : res_op1 = captures[1];
8836 0 : tree _r;
8837 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8838 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8839 0 : return _r;
8840 : }
8841 0 : next_after_fail1196:;
8842 : }
8843 : }
8844 : }
8845 : }
8846 : break;
8847 : }
8848 0 : case LE_EXPR:
8849 0 : {
8850 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8851 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8852 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8853 : {
8854 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8855 : {
8856 0 : {
8857 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8858 0 : const enum tree_code cmp1 = LE_EXPR;
8859 0 : const enum tree_code cmp2 = NE_EXPR;
8860 0 : const enum tree_code rcmp = GE_EXPR;
8861 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8862 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8863 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8864 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8865 : )
8866 : {
8867 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1197;
8868 0 : {
8869 0 : tree res_op0;
8870 0 : res_op0 = captures[0];
8871 0 : tree res_op1;
8872 0 : res_op1 = captures[1];
8873 0 : tree _r;
8874 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8875 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8876 0 : return _r;
8877 : }
8878 0 : next_after_fail1197:;
8879 : }
8880 : }
8881 : }
8882 : }
8883 : break;
8884 : }
8885 0 : case GT_EXPR:
8886 0 : {
8887 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8888 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8889 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8890 : {
8891 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8892 : {
8893 0 : {
8894 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8895 0 : const enum tree_code cmp1 = LT_EXPR;
8896 0 : const enum tree_code cmp2 = NE_EXPR;
8897 0 : const enum tree_code rcmp = GT_EXPR;
8898 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8899 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8900 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8901 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8902 : )
8903 : {
8904 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1198;
8905 0 : {
8906 0 : tree res_op0;
8907 0 : res_op0 = captures[0];
8908 0 : tree res_op1;
8909 0 : res_op1 = captures[1];
8910 0 : tree _r;
8911 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8912 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8913 0 : return _r;
8914 : }
8915 0 : next_after_fail1198:;
8916 : }
8917 : }
8918 : }
8919 : }
8920 : break;
8921 : }
8922 6 : case GE_EXPR:
8923 6 : {
8924 6 : tree _q50 = TREE_OPERAND (_p1, 0);
8925 6 : tree _q51 = TREE_OPERAND (_p1, 1);
8926 6 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8927 : {
8928 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8929 : {
8930 0 : {
8931 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8932 0 : const enum tree_code cmp1 = LE_EXPR;
8933 0 : const enum tree_code cmp2 = NE_EXPR;
8934 0 : const enum tree_code rcmp = GE_EXPR;
8935 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8936 0 : || POINTER_TYPE_P (TREE_TYPE (captures[0]))
8937 0 : || (VECTOR_TYPE_P (TREE_TYPE (captures[1]))
8938 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[0]), type, rcmp))
8939 : )
8940 : {
8941 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1199;
8942 0 : {
8943 0 : tree res_op0;
8944 0 : res_op0 = captures[0];
8945 0 : tree res_op1;
8946 0 : res_op1 = captures[1];
8947 0 : tree _r;
8948 0 : _r = fold_build2_loc (loc, rcmp, type, res_op0, res_op1);
8949 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
8950 0 : return _r;
8951 : }
8952 0 : next_after_fail1199:;
8953 : }
8954 : }
8955 : }
8956 : }
8957 : break;
8958 : }
8959 : default:;
8960 : }
8961 : break;
8962 : }
8963 524 : case MULT_EXPR:
8964 524 : {
8965 524 : tree _q20 = TREE_OPERAND (_p0, 0);
8966 524 : tree _q21 = TREE_OPERAND (_p0, 1);
8967 524 : switch (TREE_CODE (_q21))
8968 : {
8969 498 : case INTEGER_CST:
8970 498 : {
8971 498 : switch (TREE_CODE (_p1))
8972 : {
8973 12 : case MULT_EXPR:
8974 12 : {
8975 12 : tree _q50 = TREE_OPERAND (_p1, 0);
8976 12 : tree _q51 = TREE_OPERAND (_p1, 1);
8977 12 : switch (TREE_CODE (_q51))
8978 : {
8979 12 : case INTEGER_CST:
8980 12 : {
8981 12 : {
8982 12 : tree captures[8] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1, _p1, _q50, _q51 };
8983 12 : tree res = generic_simplify_44 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
8984 12 : if (res) return res;
8985 : }
8986 12 : break;
8987 : }
8988 : default:;
8989 : }
8990 : break;
8991 : }
8992 0 : case LSHIFT_EXPR:
8993 0 : {
8994 0 : tree _q50 = TREE_OPERAND (_p1, 0);
8995 0 : tree _q51 = TREE_OPERAND (_p1, 1);
8996 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8997 : {
8998 0 : switch (TREE_CODE (_q51))
8999 : {
9000 0 : case INTEGER_CST:
9001 0 : {
9002 0 : {
9003 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1, _q51 };
9004 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9005 0 : if (res) return res;
9006 : }
9007 0 : break;
9008 : }
9009 : default:;
9010 : }
9011 : }
9012 : break;
9013 : }
9014 498 : default:;
9015 : }
9016 498 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9017 : {
9018 18 : {
9019 18 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
9020 18 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9021 18 : if (res) return res;
9022 : }
9023 : }
9024 : break;
9025 : }
9026 524 : default:;
9027 : }
9028 524 : switch (TREE_CODE (_q20))
9029 : {
9030 0 : case BIT_XOR_EXPR:
9031 0 : {
9032 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9033 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9034 0 : if (tree_zero_one_valued_p (_q21))
9035 : {
9036 0 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
9037 : {
9038 0 : {
9039 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q21 };
9040 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
9041 0 : if (res) return res;
9042 : }
9043 : }
9044 0 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
9045 : {
9046 0 : {
9047 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q21 };
9048 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
9049 0 : if (res) return res;
9050 : }
9051 : }
9052 : }
9053 : break;
9054 : }
9055 524 : default:;
9056 : }
9057 524 : if (tree_zero_one_valued_p (_q20))
9058 : {
9059 8 : switch (TREE_CODE (_q21))
9060 : {
9061 2 : case BIT_XOR_EXPR:
9062 2 : {
9063 2 : tree _q40 = TREE_OPERAND (_q21, 0);
9064 2 : tree _q41 = TREE_OPERAND (_q21, 1);
9065 2 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
9066 : {
9067 2 : {
9068 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q20 };
9069 2 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
9070 2 : if (res) return res;
9071 : }
9072 : }
9073 0 : if ((_p1 == _q41 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q41, 0) && types_match (_p1, _q41)))
9074 : {
9075 0 : {
9076 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q20 };
9077 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
9078 0 : if (res) return res;
9079 : }
9080 : }
9081 : break;
9082 : }
9083 : default:;
9084 : }
9085 : }
9086 : break;
9087 : }
9088 2503 : case LSHIFT_EXPR:
9089 2503 : {
9090 2503 : tree _q20 = TREE_OPERAND (_p0, 0);
9091 2503 : tree _q21 = TREE_OPERAND (_p0, 1);
9092 2503 : switch (TREE_CODE (_q21))
9093 : {
9094 1122 : case INTEGER_CST:
9095 1122 : {
9096 1122 : switch (TREE_CODE (_p1))
9097 : {
9098 0 : case MULT_EXPR:
9099 0 : {
9100 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9101 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9102 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9103 : {
9104 0 : switch (TREE_CODE (_q51))
9105 : {
9106 0 : case INTEGER_CST:
9107 0 : {
9108 0 : {
9109 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _p1, _q20, _q51, _p0, _q21 };
9110 0 : tree res = generic_simplify_45 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9111 0 : if (res) return res;
9112 : }
9113 0 : break;
9114 : }
9115 : default:;
9116 : }
9117 : }
9118 : break;
9119 : }
9120 1122 : default:;
9121 : }
9122 1122 : {
9123 1122 : tree _p1_pops[1];
9124 1122 : if (tree_nop_convert (_p1, _p1_pops))
9125 : {
9126 23 : tree _q50 = _p1_pops[0];
9127 23 : switch (TREE_CODE (_q50))
9128 : {
9129 0 : case MULT_EXPR:
9130 0 : {
9131 0 : tree _q60 = TREE_OPERAND (_q50, 0);
9132 0 : tree _q61 = TREE_OPERAND (_q50, 1);
9133 0 : {
9134 0 : tree _q60_pops[1];
9135 0 : if (tree_nop_convert (_q60, _q60_pops))
9136 : {
9137 0 : tree _q70 = _q60_pops[0];
9138 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
9139 : {
9140 0 : switch (TREE_CODE (_q61))
9141 : {
9142 0 : case INTEGER_CST:
9143 0 : {
9144 0 : {
9145 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _q50, _q20, _q61, _p0, _q21 };
9146 0 : tree res = generic_simplify_41 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9147 0 : if (res) return res;
9148 : }
9149 0 : break;
9150 : }
9151 : default:;
9152 : }
9153 : }
9154 : }
9155 : }
9156 0 : break;
9157 : }
9158 : default:;
9159 : }
9160 : }
9161 : }
9162 1122 : break;
9163 : }
9164 : default:;
9165 : }
9166 : break;
9167 : }
9168 907257 : default:;
9169 : }
9170 907257 : switch (TREE_CODE (_p1))
9171 : {
9172 244 : case MULT_EXPR:
9173 244 : {
9174 244 : tree _q30 = TREE_OPERAND (_p1, 0);
9175 244 : tree _q31 = TREE_OPERAND (_p1, 1);
9176 244 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9177 : {
9178 0 : switch (TREE_CODE (_q31))
9179 : {
9180 0 : case INTEGER_CST:
9181 0 : {
9182 0 : {
9183 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _p0, _q31 };
9184 0 : tree res = generic_simplify_46 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9185 0 : if (res) return res;
9186 : }
9187 0 : break;
9188 : }
9189 : default:;
9190 : }
9191 : }
9192 : break;
9193 : }
9194 907257 : default:;
9195 : }
9196 907257 : {
9197 907257 : tree _p1_pops[1];
9198 907257 : if (tree_nop_convert (_p1, _p1_pops))
9199 : {
9200 635442 : tree _q30 = _p1_pops[0];
9201 635442 : switch (TREE_CODE (_q30))
9202 : {
9203 17 : case MULT_EXPR:
9204 17 : {
9205 17 : tree _q40 = TREE_OPERAND (_q30, 0);
9206 17 : tree _q41 = TREE_OPERAND (_q30, 1);
9207 17 : {
9208 17 : tree _q40_pops[1];
9209 17 : if (tree_nop_convert (_q40, _q40_pops))
9210 : {
9211 0 : tree _q50 = _q40_pops[0];
9212 0 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
9213 : {
9214 0 : switch (TREE_CODE (_q41))
9215 : {
9216 0 : case INTEGER_CST:
9217 0 : {
9218 0 : {
9219 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _p0, _q41 };
9220 0 : tree res = generic_simplify_42 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9221 0 : if (res) return res;
9222 : }
9223 0 : break;
9224 : }
9225 : default:;
9226 : }
9227 : }
9228 : }
9229 : }
9230 17 : break;
9231 : }
9232 : default:;
9233 : }
9234 : }
9235 : }
9236 907257 : switch (TREE_CODE (_p0))
9237 : {
9238 2503 : case LSHIFT_EXPR:
9239 2503 : {
9240 2503 : tree _q20 = TREE_OPERAND (_p0, 0);
9241 2503 : tree _q21 = TREE_OPERAND (_p0, 1);
9242 2503 : switch (TREE_CODE (_q21))
9243 : {
9244 1122 : case INTEGER_CST:
9245 1122 : {
9246 1122 : switch (TREE_CODE (_p1))
9247 : {
9248 9 : case LSHIFT_EXPR:
9249 9 : {
9250 9 : tree _q50 = TREE_OPERAND (_p1, 0);
9251 9 : tree _q51 = TREE_OPERAND (_p1, 1);
9252 9 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9253 : {
9254 3 : switch (TREE_CODE (_q51))
9255 : {
9256 3 : case INTEGER_CST:
9257 3 : {
9258 3 : {
9259 3 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
9260 3 : tree res = generic_simplify_48 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9261 3 : if (res) return res;
9262 : }
9263 1 : break;
9264 : }
9265 : default:;
9266 : }
9267 : }
9268 : break;
9269 : }
9270 1120 : default:;
9271 : }
9272 1120 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
9273 : {
9274 57 : {
9275 57 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
9276 57 : tree res = generic_simplify_49 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9277 57 : if (res) return res;
9278 : }
9279 : }
9280 : break;
9281 : }
9282 : default:;
9283 : }
9284 : break;
9285 : }
9286 907255 : default:;
9287 : }
9288 907255 : switch (TREE_CODE (_p1))
9289 : {
9290 1982 : case LSHIFT_EXPR:
9291 1982 : {
9292 1982 : tree _q30 = TREE_OPERAND (_p1, 0);
9293 1982 : tree _q31 = TREE_OPERAND (_p1, 1);
9294 1982 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9295 : {
9296 3 : switch (TREE_CODE (_q31))
9297 : {
9298 3 : case INTEGER_CST:
9299 3 : {
9300 3 : {
9301 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _p0, _q31 };
9302 3 : tree res = generic_simplify_49 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR);
9303 3 : if (res) return res;
9304 : }
9305 0 : break;
9306 : }
9307 : default:;
9308 : }
9309 : }
9310 : break;
9311 : }
9312 907252 : default:;
9313 : }
9314 907252 : switch (TREE_CODE (_p0))
9315 : {
9316 0 : case MIN_EXPR:
9317 0 : {
9318 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9319 0 : tree _q21 = TREE_OPERAND (_p0, 1);
9320 0 : switch (TREE_CODE (_p1))
9321 : {
9322 0 : case MAX_EXPR:
9323 0 : {
9324 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9325 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9326 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9327 : {
9328 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9329 : {
9330 0 : {
9331 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9332 0 : if (!HONOR_NANS (captures[0])
9333 : )
9334 : {
9335 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1200;
9336 0 : {
9337 0 : tree res_op0;
9338 0 : res_op0 = captures[0];
9339 0 : tree res_op1;
9340 0 : res_op1 = captures[1];
9341 0 : tree _r;
9342 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
9343 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 895, __FILE__, __LINE__, true);
9344 0 : return _r;
9345 : }
9346 0 : next_after_fail1200:;
9347 : }
9348 : }
9349 : }
9350 : }
9351 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9352 : {
9353 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9354 : {
9355 0 : {
9356 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
9357 0 : if (!HONOR_NANS (captures[0])
9358 : )
9359 : {
9360 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1201;
9361 0 : {
9362 0 : tree res_op0;
9363 0 : res_op0 = captures[0];
9364 0 : tree res_op1;
9365 0 : res_op1 = captures[1];
9366 0 : tree _r;
9367 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
9368 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 895, __FILE__, __LINE__, true);
9369 0 : return _r;
9370 : }
9371 0 : next_after_fail1201:;
9372 : }
9373 : }
9374 : }
9375 : }
9376 : break;
9377 : }
9378 : default:;
9379 : }
9380 : break;
9381 : }
9382 126 : case MAX_EXPR:
9383 126 : {
9384 126 : tree _q20 = TREE_OPERAND (_p0, 0);
9385 126 : tree _q21 = TREE_OPERAND (_p0, 1);
9386 126 : switch (TREE_CODE (_p1))
9387 : {
9388 0 : case MIN_EXPR:
9389 0 : {
9390 0 : tree _q50 = TREE_OPERAND (_p1, 0);
9391 0 : tree _q51 = TREE_OPERAND (_p1, 1);
9392 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9393 : {
9394 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
9395 : {
9396 0 : {
9397 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9398 0 : if (!HONOR_NANS (captures[0])
9399 : )
9400 : {
9401 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1202;
9402 0 : {
9403 0 : tree res_op0;
9404 0 : res_op0 = captures[0];
9405 0 : tree res_op1;
9406 0 : res_op1 = captures[1];
9407 0 : tree _r;
9408 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
9409 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 895, __FILE__, __LINE__, true);
9410 0 : return _r;
9411 : }
9412 0 : next_after_fail1202:;
9413 : }
9414 : }
9415 : }
9416 : }
9417 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
9418 : {
9419 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9420 : {
9421 0 : {
9422 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9423 0 : if (!HONOR_NANS (captures[0])
9424 : )
9425 : {
9426 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1203;
9427 0 : {
9428 0 : tree res_op0;
9429 0 : res_op0 = captures[0];
9430 0 : tree res_op1;
9431 0 : res_op1 = captures[1];
9432 0 : tree _r;
9433 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
9434 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 895, __FILE__, __LINE__, true);
9435 0 : return _r;
9436 : }
9437 0 : next_after_fail1203:;
9438 : }
9439 : }
9440 : }
9441 : }
9442 : break;
9443 : }
9444 : default:;
9445 : }
9446 : break;
9447 : }
9448 907252 : default:;
9449 : }
9450 907252 : switch (TREE_CODE (_p1))
9451 : {
9452 244 : case MULT_EXPR:
9453 244 : {
9454 244 : tree _q30 = TREE_OPERAND (_p1, 0);
9455 244 : tree _q31 = TREE_OPERAND (_p1, 1);
9456 244 : switch (TREE_CODE (_q30))
9457 : {
9458 0 : case BIT_XOR_EXPR:
9459 0 : {
9460 0 : tree _q40 = TREE_OPERAND (_q30, 0);
9461 0 : tree _q41 = TREE_OPERAND (_q30, 1);
9462 0 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
9463 : {
9464 0 : if (tree_zero_one_valued_p (_q31))
9465 : {
9466 0 : {
9467 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q31 };
9468 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
9469 0 : if (res) return res;
9470 : }
9471 : }
9472 : }
9473 0 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
9474 : {
9475 0 : if (tree_zero_one_valued_p (_q31))
9476 : {
9477 0 : {
9478 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q31 };
9479 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
9480 0 : if (res) return res;
9481 : }
9482 : }
9483 : }
9484 : break;
9485 : }
9486 244 : default:;
9487 : }
9488 244 : if (tree_zero_one_valued_p (_q30))
9489 : {
9490 17 : switch (TREE_CODE (_q31))
9491 : {
9492 0 : case BIT_XOR_EXPR:
9493 0 : {
9494 0 : tree _q50 = TREE_OPERAND (_q31, 0);
9495 0 : tree _q51 = TREE_OPERAND (_q31, 1);
9496 0 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
9497 : {
9498 0 : {
9499 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q51, _q30 };
9500 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
9501 0 : if (res) return res;
9502 : }
9503 : }
9504 0 : if ((_q51 == _p0 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _p0, 0) && types_match (_q51, _p0)))
9505 : {
9506 0 : {
9507 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q50, _q30 };
9508 0 : tree res = generic_simplify_47 (loc, type, _p0, _p1, captures);
9509 0 : if (res) return res;
9510 : }
9511 : }
9512 : break;
9513 : }
9514 : default:;
9515 : }
9516 : }
9517 : break;
9518 : }
9519 907252 : default:;
9520 : }
9521 907252 : switch (TREE_CODE (_p0))
9522 : {
9523 1 : case VEC_COND_EXPR:
9524 1 : {
9525 1 : tree _q20 = TREE_OPERAND (_p0, 0);
9526 1 : tree _q21 = TREE_OPERAND (_p0, 1);
9527 1 : tree _q22 = TREE_OPERAND (_p0, 2);
9528 1 : switch (TREE_CODE (_p1))
9529 : {
9530 0 : case VEC_COND_EXPR:
9531 0 : {
9532 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9533 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9534 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9535 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9536 : {
9537 0 : {
9538 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
9539 0 : if (VECTOR_TYPE_P (type)
9540 0 : && (TREE_CODE_CLASS (BIT_XOR_EXPR) != tcc_comparison
9541 : || types_match (type, TREE_TYPE (captures[2]))
9542 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9543 : || (optimize_vectors_before_lowering_p ()
9544 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9545 : )
9546 : {
9547 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1204;
9548 0 : {
9549 0 : tree res_op0;
9550 0 : res_op0 = captures[1];
9551 0 : tree res_op1;
9552 0 : {
9553 0 : tree _o1[2], _r1;
9554 0 : _o1[0] = captures[2];
9555 0 : _o1[1] = captures[5];
9556 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
9557 0 : if (EXPR_P (_r1))
9558 0 : goto next_after_fail1204;
9559 0 : res_op1 = _r1;
9560 : }
9561 0 : tree res_op2;
9562 0 : {
9563 0 : tree _o1[2], _r1;
9564 0 : _o1[0] = captures[3];
9565 0 : _o1[1] = captures[6];
9566 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
9567 0 : if (EXPR_P (_r1))
9568 0 : goto next_after_fail1204;
9569 0 : res_op2 = _r1;
9570 : }
9571 0 : tree _r;
9572 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9573 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 896, __FILE__, __LINE__, true);
9574 0 : return _r;
9575 : }
9576 0 : next_after_fail1204:;
9577 : }
9578 : }
9579 : }
9580 : break;
9581 : }
9582 1 : default:;
9583 : }
9584 1 : if (integer_minus_onep (_q21))
9585 : {
9586 1 : if (integer_zerop (_q22))
9587 : {
9588 1 : switch (TREE_CODE (_p1))
9589 : {
9590 0 : case VEC_COND_EXPR:
9591 0 : {
9592 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9593 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9594 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9595 0 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
9596 : {
9597 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
9598 : {
9599 0 : {
9600 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9601 0 : const enum tree_code lop = BIT_XOR_EXPR;
9602 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9603 : )
9604 : {
9605 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1205;
9606 0 : {
9607 0 : tree res_op0;
9608 0 : {
9609 0 : tree _o1[2], _r1;
9610 0 : _o1[0] = captures[0];
9611 0 : _o1[1] = captures[3];
9612 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9613 0 : res_op0 = _r1;
9614 : }
9615 0 : tree res_op1;
9616 0 : res_op1 = captures[1];
9617 0 : tree res_op2;
9618 0 : res_op2 = captures[2];
9619 0 : tree _r;
9620 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9621 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
9622 0 : return _r;
9623 : }
9624 0 : next_after_fail1205:;
9625 : }
9626 : }
9627 0 : {
9628 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9629 0 : const enum tree_code lop = BIT_XOR_EXPR;
9630 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9631 : )
9632 : {
9633 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1206;
9634 0 : {
9635 0 : tree res_op0;
9636 0 : {
9637 0 : tree _o1[2], _r1;
9638 0 : _o1[0] = captures[0];
9639 0 : _o1[1] = captures[3];
9640 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9641 0 : res_op0 = _r1;
9642 : }
9643 0 : tree res_op1;
9644 0 : res_op1 = captures[1];
9645 0 : tree res_op2;
9646 0 : res_op2 = captures[2];
9647 0 : tree _r;
9648 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9649 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
9650 0 : return _r;
9651 : }
9652 0 : next_after_fail1206:;
9653 : }
9654 : }
9655 0 : {
9656 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9657 0 : const enum tree_code lop = BIT_XOR_EXPR;
9658 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9659 : )
9660 : {
9661 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1207;
9662 0 : {
9663 0 : tree res_op0;
9664 0 : {
9665 0 : tree _o1[2], _r1;
9666 0 : _o1[0] = captures[0];
9667 0 : _o1[1] = captures[3];
9668 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9669 0 : res_op0 = _r1;
9670 : }
9671 0 : tree res_op1;
9672 0 : res_op1 = captures[1];
9673 0 : tree res_op2;
9674 0 : res_op2 = captures[2];
9675 0 : tree _r;
9676 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9677 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
9678 0 : return _r;
9679 : }
9680 0 : next_after_fail1207:;
9681 : }
9682 : }
9683 0 : {
9684 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9685 0 : const enum tree_code lop = BIT_XOR_EXPR;
9686 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9687 : )
9688 : {
9689 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1208;
9690 0 : {
9691 0 : tree res_op0;
9692 0 : {
9693 0 : tree _o1[2], _r1;
9694 0 : _o1[0] = captures[0];
9695 0 : _o1[1] = captures[3];
9696 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9697 0 : res_op0 = _r1;
9698 : }
9699 0 : tree res_op1;
9700 0 : res_op1 = captures[1];
9701 0 : tree res_op2;
9702 0 : res_op2 = captures[2];
9703 0 : tree _r;
9704 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9705 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
9706 0 : return _r;
9707 : }
9708 0 : next_after_fail1208:;
9709 : }
9710 : }
9711 0 : {
9712 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9713 0 : const enum tree_code lop = BIT_XOR_EXPR;
9714 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9715 : )
9716 : {
9717 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1209;
9718 0 : {
9719 0 : tree res_op0;
9720 0 : {
9721 0 : tree _o1[2], _r1;
9722 0 : _o1[0] = captures[0];
9723 0 : _o1[1] = captures[3];
9724 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9725 0 : res_op0 = _r1;
9726 : }
9727 0 : tree res_op1;
9728 0 : res_op1 = captures[1];
9729 0 : tree res_op2;
9730 0 : res_op2 = captures[2];
9731 0 : tree _r;
9732 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9733 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
9734 0 : return _r;
9735 : }
9736 0 : next_after_fail1209:;
9737 : }
9738 : }
9739 0 : {
9740 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9741 0 : const enum tree_code lop = BIT_XOR_EXPR;
9742 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9743 : )
9744 : {
9745 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1210;
9746 0 : {
9747 0 : tree res_op0;
9748 0 : {
9749 0 : tree _o1[2], _r1;
9750 0 : _o1[0] = captures[0];
9751 0 : _o1[1] = captures[3];
9752 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9753 0 : res_op0 = _r1;
9754 : }
9755 0 : tree res_op1;
9756 0 : res_op1 = captures[1];
9757 0 : tree res_op2;
9758 0 : res_op2 = captures[2];
9759 0 : tree _r;
9760 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9761 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
9762 0 : return _r;
9763 : }
9764 0 : next_after_fail1210:;
9765 : }
9766 : }
9767 0 : {
9768 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9769 0 : const enum tree_code lop = BIT_XOR_EXPR;
9770 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9771 : )
9772 : {
9773 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1211;
9774 0 : {
9775 0 : tree res_op0;
9776 0 : {
9777 0 : tree _o1[2], _r1;
9778 0 : _o1[0] = captures[0];
9779 0 : _o1[1] = captures[3];
9780 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9781 0 : res_op0 = _r1;
9782 : }
9783 0 : tree res_op1;
9784 0 : res_op1 = captures[1];
9785 0 : tree res_op2;
9786 0 : res_op2 = captures[2];
9787 0 : tree _r;
9788 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9789 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
9790 0 : return _r;
9791 : }
9792 0 : next_after_fail1211:;
9793 : }
9794 : }
9795 0 : {
9796 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9797 0 : const enum tree_code lop = BIT_XOR_EXPR;
9798 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9799 : )
9800 : {
9801 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1212;
9802 0 : {
9803 0 : tree res_op0;
9804 0 : {
9805 0 : tree _o1[2], _r1;
9806 0 : _o1[0] = captures[0];
9807 0 : _o1[1] = captures[3];
9808 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9809 0 : res_op0 = _r1;
9810 : }
9811 0 : tree res_op1;
9812 0 : res_op1 = captures[1];
9813 0 : tree res_op2;
9814 0 : res_op2 = captures[2];
9815 0 : tree _r;
9816 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9817 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
9818 0 : return _r;
9819 : }
9820 0 : next_after_fail1212:;
9821 : }
9822 : }
9823 0 : {
9824 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9825 0 : const enum tree_code lop = BIT_XOR_EXPR;
9826 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9827 : )
9828 : {
9829 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1213;
9830 0 : {
9831 0 : tree res_op0;
9832 0 : {
9833 0 : tree _o1[2], _r1;
9834 0 : _o1[0] = captures[0];
9835 0 : _o1[1] = captures[3];
9836 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9837 0 : res_op0 = _r1;
9838 : }
9839 0 : tree res_op1;
9840 0 : res_op1 = captures[1];
9841 0 : tree res_op2;
9842 0 : res_op2 = captures[2];
9843 0 : tree _r;
9844 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9845 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
9846 0 : return _r;
9847 : }
9848 0 : next_after_fail1213:;
9849 : }
9850 : }
9851 0 : {
9852 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9853 0 : const enum tree_code lop = BIT_XOR_EXPR;
9854 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9855 : )
9856 : {
9857 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1214;
9858 0 : {
9859 0 : tree res_op0;
9860 0 : {
9861 0 : tree _o1[2], _r1;
9862 0 : _o1[0] = captures[0];
9863 0 : _o1[1] = captures[3];
9864 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9865 0 : res_op0 = _r1;
9866 : }
9867 0 : tree res_op1;
9868 0 : res_op1 = captures[1];
9869 0 : tree res_op2;
9870 0 : res_op2 = captures[2];
9871 0 : tree _r;
9872 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9873 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
9874 0 : return _r;
9875 : }
9876 0 : next_after_fail1214:;
9877 : }
9878 : }
9879 0 : {
9880 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9881 0 : const enum tree_code lop = BIT_XOR_EXPR;
9882 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9883 : )
9884 : {
9885 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1215;
9886 0 : {
9887 0 : tree res_op0;
9888 0 : {
9889 0 : tree _o1[2], _r1;
9890 0 : _o1[0] = captures[0];
9891 0 : _o1[1] = captures[3];
9892 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9893 0 : res_op0 = _r1;
9894 : }
9895 0 : tree res_op1;
9896 0 : res_op1 = captures[1];
9897 0 : tree res_op2;
9898 0 : res_op2 = captures[2];
9899 0 : tree _r;
9900 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9901 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
9902 0 : return _r;
9903 : }
9904 0 : next_after_fail1215:;
9905 : }
9906 : }
9907 0 : {
9908 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9909 0 : const enum tree_code lop = BIT_XOR_EXPR;
9910 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9911 : )
9912 : {
9913 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1216;
9914 0 : {
9915 0 : tree res_op0;
9916 0 : {
9917 0 : tree _o1[2], _r1;
9918 0 : _o1[0] = captures[0];
9919 0 : _o1[1] = captures[3];
9920 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9921 0 : res_op0 = _r1;
9922 : }
9923 0 : tree res_op1;
9924 0 : res_op1 = captures[1];
9925 0 : tree res_op2;
9926 0 : res_op2 = captures[2];
9927 0 : tree _r;
9928 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9929 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
9930 0 : return _r;
9931 : }
9932 0 : next_after_fail1216:;
9933 : }
9934 : }
9935 0 : {
9936 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9937 0 : const enum tree_code lop = BIT_XOR_EXPR;
9938 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9939 : )
9940 : {
9941 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1217;
9942 0 : {
9943 0 : tree res_op0;
9944 0 : {
9945 0 : tree _o1[2], _r1;
9946 0 : _o1[0] = captures[0];
9947 0 : _o1[1] = captures[3];
9948 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9949 0 : res_op0 = _r1;
9950 : }
9951 0 : tree res_op1;
9952 0 : res_op1 = captures[1];
9953 0 : tree res_op2;
9954 0 : res_op2 = captures[2];
9955 0 : tree _r;
9956 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9957 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
9958 0 : return _r;
9959 : }
9960 0 : next_after_fail1217:;
9961 : }
9962 : }
9963 0 : {
9964 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9965 0 : const enum tree_code lop = BIT_XOR_EXPR;
9966 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9967 : )
9968 : {
9969 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1218;
9970 0 : {
9971 0 : tree res_op0;
9972 0 : {
9973 0 : tree _o1[2], _r1;
9974 0 : _o1[0] = captures[0];
9975 0 : _o1[1] = captures[3];
9976 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9977 0 : res_op0 = _r1;
9978 : }
9979 0 : tree res_op1;
9980 0 : res_op1 = captures[1];
9981 0 : tree res_op2;
9982 0 : res_op2 = captures[2];
9983 0 : tree _r;
9984 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9985 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
9986 0 : return _r;
9987 : }
9988 0 : next_after_fail1218:;
9989 : }
9990 : }
9991 0 : {
9992 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
9993 0 : const enum tree_code lop = BIT_XOR_EXPR;
9994 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
9995 : )
9996 : {
9997 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1219;
9998 0 : {
9999 0 : tree res_op0;
10000 0 : {
10001 0 : tree _o1[2], _r1;
10002 0 : _o1[0] = captures[0];
10003 0 : _o1[1] = captures[3];
10004 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10005 0 : res_op0 = _r1;
10006 : }
10007 0 : tree res_op1;
10008 0 : res_op1 = captures[1];
10009 0 : tree res_op2;
10010 0 : res_op2 = captures[2];
10011 0 : tree _r;
10012 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10013 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10014 0 : return _r;
10015 : }
10016 0 : next_after_fail1219:;
10017 : }
10018 : }
10019 0 : {
10020 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10021 0 : const enum tree_code lop = BIT_XOR_EXPR;
10022 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10023 : )
10024 : {
10025 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1220;
10026 0 : {
10027 0 : tree res_op0;
10028 0 : {
10029 0 : tree _o1[2], _r1;
10030 0 : _o1[0] = captures[0];
10031 0 : _o1[1] = captures[3];
10032 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10033 0 : res_op0 = _r1;
10034 : }
10035 0 : tree res_op1;
10036 0 : res_op1 = captures[1];
10037 0 : tree res_op2;
10038 0 : res_op2 = captures[2];
10039 0 : tree _r;
10040 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10041 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10042 0 : return _r;
10043 : }
10044 0 : next_after_fail1220:;
10045 : }
10046 : }
10047 0 : {
10048 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10049 0 : const enum tree_code lop = BIT_XOR_EXPR;
10050 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10051 : )
10052 : {
10053 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1221;
10054 0 : {
10055 0 : tree res_op0;
10056 0 : {
10057 0 : tree _o1[2], _r1;
10058 0 : _o1[0] = captures[0];
10059 0 : _o1[1] = captures[3];
10060 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10061 0 : res_op0 = _r1;
10062 : }
10063 0 : tree res_op1;
10064 0 : res_op1 = captures[1];
10065 0 : tree res_op2;
10066 0 : res_op2 = captures[2];
10067 0 : tree _r;
10068 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10069 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10070 0 : return _r;
10071 : }
10072 0 : next_after_fail1221:;
10073 : }
10074 : }
10075 0 : {
10076 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10077 0 : const enum tree_code lop = BIT_XOR_EXPR;
10078 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10079 : )
10080 : {
10081 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1222;
10082 0 : {
10083 0 : tree res_op0;
10084 0 : {
10085 0 : tree _o1[2], _r1;
10086 0 : _o1[0] = captures[0];
10087 0 : _o1[1] = captures[3];
10088 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10089 0 : res_op0 = _r1;
10090 : }
10091 0 : tree res_op1;
10092 0 : res_op1 = captures[1];
10093 0 : tree res_op2;
10094 0 : res_op2 = captures[2];
10095 0 : tree _r;
10096 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10097 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10098 0 : return _r;
10099 : }
10100 0 : next_after_fail1222:;
10101 : }
10102 : }
10103 0 : {
10104 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10105 0 : const enum tree_code lop = BIT_XOR_EXPR;
10106 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10107 : )
10108 : {
10109 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1223;
10110 0 : {
10111 0 : tree res_op0;
10112 0 : {
10113 0 : tree _o1[2], _r1;
10114 0 : _o1[0] = captures[0];
10115 0 : _o1[1] = captures[3];
10116 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10117 0 : res_op0 = _r1;
10118 : }
10119 0 : tree res_op1;
10120 0 : res_op1 = captures[1];
10121 0 : tree res_op2;
10122 0 : res_op2 = captures[2];
10123 0 : tree _r;
10124 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10125 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10126 0 : return _r;
10127 : }
10128 0 : next_after_fail1223:;
10129 : }
10130 : }
10131 0 : {
10132 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10133 0 : const enum tree_code lop = BIT_XOR_EXPR;
10134 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10135 : )
10136 : {
10137 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1224;
10138 0 : {
10139 0 : tree res_op0;
10140 0 : {
10141 0 : tree _o1[2], _r1;
10142 0 : _o1[0] = captures[0];
10143 0 : _o1[1] = captures[3];
10144 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10145 0 : res_op0 = _r1;
10146 : }
10147 0 : tree res_op1;
10148 0 : res_op1 = captures[1];
10149 0 : tree res_op2;
10150 0 : res_op2 = captures[2];
10151 0 : tree _r;
10152 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10153 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10154 0 : return _r;
10155 : }
10156 0 : next_after_fail1224:;
10157 : }
10158 : }
10159 0 : {
10160 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10161 0 : const enum tree_code lop = BIT_XOR_EXPR;
10162 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10163 : )
10164 : {
10165 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1225;
10166 0 : {
10167 0 : tree res_op0;
10168 0 : {
10169 0 : tree _o1[2], _r1;
10170 0 : _o1[0] = captures[0];
10171 0 : _o1[1] = captures[3];
10172 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10173 0 : res_op0 = _r1;
10174 : }
10175 0 : tree res_op1;
10176 0 : res_op1 = captures[1];
10177 0 : tree res_op2;
10178 0 : res_op2 = captures[2];
10179 0 : tree _r;
10180 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10181 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10182 0 : return _r;
10183 : }
10184 0 : next_after_fail1225:;
10185 : }
10186 : }
10187 0 : {
10188 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10189 0 : const enum tree_code lop = BIT_XOR_EXPR;
10190 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10191 : )
10192 : {
10193 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1226;
10194 0 : {
10195 0 : tree res_op0;
10196 0 : {
10197 0 : tree _o1[2], _r1;
10198 0 : _o1[0] = captures[0];
10199 0 : _o1[1] = captures[3];
10200 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10201 0 : res_op0 = _r1;
10202 : }
10203 0 : tree res_op1;
10204 0 : res_op1 = captures[1];
10205 0 : tree res_op2;
10206 0 : res_op2 = captures[2];
10207 0 : tree _r;
10208 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10209 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10210 0 : return _r;
10211 : }
10212 0 : next_after_fail1226:;
10213 : }
10214 : }
10215 0 : {
10216 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10217 0 : const enum tree_code lop = BIT_XOR_EXPR;
10218 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10219 : )
10220 : {
10221 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1227;
10222 0 : {
10223 0 : tree res_op0;
10224 0 : {
10225 0 : tree _o1[2], _r1;
10226 0 : _o1[0] = captures[0];
10227 0 : _o1[1] = captures[3];
10228 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10229 0 : res_op0 = _r1;
10230 : }
10231 0 : tree res_op1;
10232 0 : res_op1 = captures[1];
10233 0 : tree res_op2;
10234 0 : res_op2 = captures[2];
10235 0 : tree _r;
10236 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10237 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10238 0 : return _r;
10239 : }
10240 0 : next_after_fail1227:;
10241 : }
10242 : }
10243 0 : {
10244 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10245 0 : const enum tree_code lop = BIT_XOR_EXPR;
10246 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10247 : )
10248 : {
10249 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1228;
10250 0 : {
10251 0 : tree res_op0;
10252 0 : {
10253 0 : tree _o1[2], _r1;
10254 0 : _o1[0] = captures[0];
10255 0 : _o1[1] = captures[3];
10256 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10257 0 : res_op0 = _r1;
10258 : }
10259 0 : tree res_op1;
10260 0 : res_op1 = captures[1];
10261 0 : tree res_op2;
10262 0 : res_op2 = captures[2];
10263 0 : tree _r;
10264 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10265 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10266 0 : return _r;
10267 : }
10268 0 : next_after_fail1228:;
10269 : }
10270 : }
10271 0 : {
10272 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10273 0 : const enum tree_code lop = BIT_XOR_EXPR;
10274 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10275 : )
10276 : {
10277 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1229;
10278 0 : {
10279 0 : tree res_op0;
10280 0 : {
10281 0 : tree _o1[2], _r1;
10282 0 : _o1[0] = captures[0];
10283 0 : _o1[1] = captures[3];
10284 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10285 0 : res_op0 = _r1;
10286 : }
10287 0 : tree res_op1;
10288 0 : res_op1 = captures[1];
10289 0 : tree res_op2;
10290 0 : res_op2 = captures[2];
10291 0 : tree _r;
10292 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10293 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10294 0 : return _r;
10295 : }
10296 0 : next_after_fail1229:;
10297 : }
10298 : }
10299 0 : {
10300 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10301 0 : const enum tree_code lop = BIT_XOR_EXPR;
10302 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10303 : )
10304 : {
10305 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1230;
10306 0 : {
10307 0 : tree res_op0;
10308 0 : {
10309 0 : tree _o1[2], _r1;
10310 0 : _o1[0] = captures[0];
10311 0 : _o1[1] = captures[3];
10312 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10313 0 : res_op0 = _r1;
10314 : }
10315 0 : tree res_op1;
10316 0 : res_op1 = captures[1];
10317 0 : tree res_op2;
10318 0 : res_op2 = captures[2];
10319 0 : tree _r;
10320 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10321 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10322 0 : return _r;
10323 : }
10324 0 : next_after_fail1230:;
10325 : }
10326 : }
10327 0 : {
10328 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10329 0 : const enum tree_code lop = BIT_XOR_EXPR;
10330 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10331 : )
10332 : {
10333 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1231;
10334 0 : {
10335 0 : tree res_op0;
10336 0 : {
10337 0 : tree _o1[2], _r1;
10338 0 : _o1[0] = captures[0];
10339 0 : _o1[1] = captures[3];
10340 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10341 0 : res_op0 = _r1;
10342 : }
10343 0 : tree res_op1;
10344 0 : res_op1 = captures[1];
10345 0 : tree res_op2;
10346 0 : res_op2 = captures[2];
10347 0 : tree _r;
10348 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10349 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10350 0 : return _r;
10351 : }
10352 0 : next_after_fail1231:;
10353 : }
10354 : }
10355 0 : {
10356 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10357 0 : const enum tree_code lop = BIT_XOR_EXPR;
10358 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10359 : )
10360 : {
10361 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1232;
10362 0 : {
10363 0 : tree res_op0;
10364 0 : {
10365 0 : tree _o1[2], _r1;
10366 0 : _o1[0] = captures[0];
10367 0 : _o1[1] = captures[3];
10368 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10369 0 : res_op0 = _r1;
10370 : }
10371 0 : tree res_op1;
10372 0 : res_op1 = captures[1];
10373 0 : tree res_op2;
10374 0 : res_op2 = captures[2];
10375 0 : tree _r;
10376 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10377 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10378 0 : return _r;
10379 : }
10380 0 : next_after_fail1232:;
10381 : }
10382 : }
10383 0 : {
10384 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10385 0 : const enum tree_code lop = BIT_XOR_EXPR;
10386 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10387 : )
10388 : {
10389 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1233;
10390 0 : {
10391 0 : tree res_op0;
10392 0 : {
10393 0 : tree _o1[2], _r1;
10394 0 : _o1[0] = captures[0];
10395 0 : _o1[1] = captures[3];
10396 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10397 0 : res_op0 = _r1;
10398 : }
10399 0 : tree res_op1;
10400 0 : res_op1 = captures[1];
10401 0 : tree res_op2;
10402 0 : res_op2 = captures[2];
10403 0 : tree _r;
10404 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10405 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10406 0 : return _r;
10407 : }
10408 0 : next_after_fail1233:;
10409 : }
10410 : }
10411 0 : {
10412 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10413 0 : const enum tree_code lop = BIT_XOR_EXPR;
10414 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10415 : )
10416 : {
10417 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1234;
10418 0 : {
10419 0 : tree res_op0;
10420 0 : {
10421 0 : tree _o1[2], _r1;
10422 0 : _o1[0] = captures[0];
10423 0 : _o1[1] = captures[3];
10424 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10425 0 : res_op0 = _r1;
10426 : }
10427 0 : tree res_op1;
10428 0 : res_op1 = captures[1];
10429 0 : tree res_op2;
10430 0 : res_op2 = captures[2];
10431 0 : tree _r;
10432 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10433 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10434 0 : return _r;
10435 : }
10436 0 : next_after_fail1234:;
10437 : }
10438 : }
10439 0 : {
10440 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10441 0 : const enum tree_code lop = BIT_XOR_EXPR;
10442 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10443 : )
10444 : {
10445 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1235;
10446 0 : {
10447 0 : tree res_op0;
10448 0 : {
10449 0 : tree _o1[2], _r1;
10450 0 : _o1[0] = captures[0];
10451 0 : _o1[1] = captures[3];
10452 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10453 0 : res_op0 = _r1;
10454 : }
10455 0 : tree res_op1;
10456 0 : res_op1 = captures[1];
10457 0 : tree res_op2;
10458 0 : res_op2 = captures[2];
10459 0 : tree _r;
10460 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10461 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10462 0 : return _r;
10463 : }
10464 0 : next_after_fail1235:;
10465 : }
10466 : }
10467 0 : {
10468 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10469 0 : const enum tree_code lop = BIT_XOR_EXPR;
10470 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10471 : )
10472 : {
10473 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1236;
10474 0 : {
10475 0 : tree res_op0;
10476 0 : {
10477 0 : tree _o1[2], _r1;
10478 0 : _o1[0] = captures[0];
10479 0 : _o1[1] = captures[3];
10480 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10481 0 : res_op0 = _r1;
10482 : }
10483 0 : tree res_op1;
10484 0 : res_op1 = captures[1];
10485 0 : tree res_op2;
10486 0 : res_op2 = captures[2];
10487 0 : tree _r;
10488 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10489 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10490 0 : return _r;
10491 : }
10492 0 : next_after_fail1236:;
10493 : }
10494 : }
10495 0 : {
10496 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10497 0 : const enum tree_code lop = BIT_XOR_EXPR;
10498 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10499 : )
10500 : {
10501 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1237;
10502 0 : {
10503 0 : tree res_op0;
10504 0 : {
10505 0 : tree _o1[2], _r1;
10506 0 : _o1[0] = captures[0];
10507 0 : _o1[1] = captures[3];
10508 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10509 0 : res_op0 = _r1;
10510 : }
10511 0 : tree res_op1;
10512 0 : res_op1 = captures[1];
10513 0 : tree res_op2;
10514 0 : res_op2 = captures[2];
10515 0 : tree _r;
10516 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10517 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10518 0 : return _r;
10519 : }
10520 0 : next_after_fail1237:;
10521 : }
10522 : }
10523 0 : {
10524 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
10525 0 : const enum tree_code lop = BIT_XOR_EXPR;
10526 0 : if (target_supports_op_p (TREE_TYPE (captures[0]), lop, optab_vector)
10527 : )
10528 : {
10529 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1238;
10530 0 : {
10531 0 : tree res_op0;
10532 0 : {
10533 0 : tree _o1[2], _r1;
10534 0 : _o1[0] = captures[0];
10535 0 : _o1[1] = captures[3];
10536 0 : _r1 = fold_build2_loc (loc, lop, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10537 0 : res_op0 = _r1;
10538 : }
10539 0 : tree res_op1;
10540 0 : res_op1 = captures[1];
10541 0 : tree res_op2;
10542 0 : res_op2 = captures[2];
10543 0 : tree _r;
10544 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10545 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 897, __FILE__, __LINE__, true);
10546 0 : return _r;
10547 : }
10548 0 : next_after_fail1238:;
10549 : }
10550 : }
10551 : }
10552 : }
10553 : break;
10554 : }
10555 : default:;
10556 : }
10557 : }
10558 : }
10559 1 : {
10560 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
10561 1 : if (VECTOR_TYPE_P (type)
10562 1 : && (TREE_CODE_CLASS (BIT_XOR_EXPR) != tcc_comparison
10563 : || types_match (type, TREE_TYPE (captures[2]))
10564 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
10565 : || (optimize_vectors_before_lowering_p ()
10566 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
10567 : )
10568 : {
10569 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1239;
10570 1 : {
10571 1 : if (! tree_invariant_p (captures[4])) goto next_after_fail1239;
10572 0 : tree res_op0;
10573 0 : res_op0 = captures[1];
10574 0 : tree res_op1;
10575 0 : {
10576 0 : tree _o1[2], _r1;
10577 0 : _o1[0] = captures[2];
10578 0 : _o1[1] = unshare_expr (captures[4]);
10579 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
10580 0 : if (EXPR_P (_r1))
10581 0 : goto next_after_fail1239;
10582 0 : res_op1 = _r1;
10583 : }
10584 0 : tree res_op2;
10585 0 : {
10586 0 : tree _o1[2], _r1;
10587 0 : _o1[0] = captures[3];
10588 0 : _o1[1] = captures[4];
10589 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
10590 0 : if (EXPR_P (_r1))
10591 0 : goto next_after_fail1239;
10592 0 : res_op2 = _r1;
10593 : }
10594 0 : tree _r;
10595 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10596 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 898, __FILE__, __LINE__, true);
10597 0 : return _r;
10598 : }
10599 1 : next_after_fail1239:;
10600 : }
10601 : }
10602 1 : break;
10603 : }
10604 907252 : default:;
10605 : }
10606 907252 : switch (TREE_CODE (_p1))
10607 : {
10608 0 : case VEC_COND_EXPR:
10609 0 : {
10610 0 : tree _q30 = TREE_OPERAND (_p1, 0);
10611 0 : tree _q31 = TREE_OPERAND (_p1, 1);
10612 0 : tree _q32 = TREE_OPERAND (_p1, 2);
10613 0 : {
10614 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
10615 0 : if (VECTOR_TYPE_P (type)
10616 0 : && (TREE_CODE_CLASS (BIT_XOR_EXPR) != tcc_comparison
10617 : || types_match (type, TREE_TYPE (captures[3]))
10618 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
10619 : || (optimize_vectors_before_lowering_p ()
10620 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
10621 : )
10622 : {
10623 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1240;
10624 0 : {
10625 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail1240;
10626 0 : tree res_op0;
10627 0 : res_op0 = captures[2];
10628 0 : tree res_op1;
10629 0 : {
10630 0 : tree _o1[2], _r1;
10631 0 : _o1[0] = unshare_expr (captures[0]);
10632 0 : _o1[1] = captures[3];
10633 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
10634 0 : if (EXPR_P (_r1))
10635 0 : goto next_after_fail1240;
10636 0 : res_op1 = _r1;
10637 : }
10638 0 : tree res_op2;
10639 0 : {
10640 0 : tree _o1[2], _r1;
10641 0 : _o1[0] = captures[0];
10642 0 : _o1[1] = captures[4];
10643 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, type, _o1[0], _o1[1]);
10644 0 : if (EXPR_P (_r1))
10645 0 : goto next_after_fail1240;
10646 0 : res_op2 = _r1;
10647 : }
10648 0 : tree _r;
10649 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
10650 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 899, __FILE__, __LINE__, true);
10651 0 : return _r;
10652 : }
10653 0 : next_after_fail1240:;
10654 : }
10655 : }
10656 0 : break;
10657 : }
10658 907252 : default:;
10659 : }
10660 907252 : switch (TREE_CODE (_p0))
10661 : {
10662 90 : case LT_EXPR:
10663 90 : {
10664 90 : tree _q20 = TREE_OPERAND (_p0, 0);
10665 90 : tree _q21 = TREE_OPERAND (_p0, 1);
10666 90 : if (integer_truep (_p1))
10667 : {
10668 14 : {
10669 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10670 14 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, LT_EXPR, GE_EXPR, UNGE_EXPR);
10671 14 : if (res) return res;
10672 : }
10673 : }
10674 76 : if (integer_zerop (_q21))
10675 : {
10676 24 : switch (TREE_CODE (_p1))
10677 : {
10678 17 : case LT_EXPR:
10679 17 : {
10680 17 : tree _q50 = TREE_OPERAND (_p1, 0);
10681 17 : tree _q51 = TREE_OPERAND (_p1, 1);
10682 17 : if (integer_zerop (_q51))
10683 : {
10684 17 : {
10685 17 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q50 };
10686 17 : tree res = generic_simplify_51 (loc, type, _p0, _p1, captures, LT_EXPR);
10687 17 : if (res) return res;
10688 : }
10689 : }
10690 : break;
10691 : }
10692 0 : case GE_EXPR:
10693 0 : {
10694 0 : tree _q50 = TREE_OPERAND (_p1, 0);
10695 0 : tree _q51 = TREE_OPERAND (_p1, 1);
10696 0 : if (integer_zerop (_q51))
10697 : {
10698 0 : {
10699 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q50 };
10700 0 : tree res = generic_simplify_52 (loc, type, _p0, _p1, captures);
10701 0 : if (res) return res;
10702 : }
10703 : }
10704 : break;
10705 : }
10706 : default:;
10707 : }
10708 : }
10709 : break;
10710 : }
10711 85 : case LE_EXPR:
10712 85 : {
10713 85 : tree _q20 = TREE_OPERAND (_p0, 0);
10714 85 : tree _q21 = TREE_OPERAND (_p0, 1);
10715 85 : if (integer_truep (_p1))
10716 : {
10717 15 : {
10718 15 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10719 15 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, LE_EXPR, GT_EXPR, UNGT_EXPR);
10720 15 : if (res) return res;
10721 : }
10722 : }
10723 : break;
10724 : }
10725 119 : case EQ_EXPR:
10726 119 : {
10727 119 : tree _q20 = TREE_OPERAND (_p0, 0);
10728 119 : tree _q21 = TREE_OPERAND (_p0, 1);
10729 119 : if (integer_truep (_p1))
10730 : {
10731 14 : {
10732 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10733 14 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, EQ_EXPR, NE_EXPR, NE_EXPR);
10734 14 : if (res) return res;
10735 : }
10736 : }
10737 : break;
10738 : }
10739 113 : case NE_EXPR:
10740 113 : {
10741 113 : tree _q20 = TREE_OPERAND (_p0, 0);
10742 113 : tree _q21 = TREE_OPERAND (_p0, 1);
10743 113 : if (integer_truep (_p1))
10744 : {
10745 7 : {
10746 7 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10747 7 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, NE_EXPR, EQ_EXPR, EQ_EXPR);
10748 7 : if (res) return res;
10749 : }
10750 : }
10751 : break;
10752 : }
10753 62 : case GE_EXPR:
10754 62 : {
10755 62 : tree _q20 = TREE_OPERAND (_p0, 0);
10756 62 : tree _q21 = TREE_OPERAND (_p0, 1);
10757 62 : if (integer_truep (_p1))
10758 : {
10759 0 : {
10760 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10761 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, GE_EXPR, LT_EXPR, UNLT_EXPR);
10762 0 : if (res) return res;
10763 : }
10764 : }
10765 62 : if (integer_zerop (_q21))
10766 : {
10767 26 : switch (TREE_CODE (_p1))
10768 : {
10769 1 : case GE_EXPR:
10770 1 : {
10771 1 : tree _q50 = TREE_OPERAND (_p1, 0);
10772 1 : tree _q51 = TREE_OPERAND (_p1, 1);
10773 1 : if (integer_zerop (_q51))
10774 : {
10775 1 : {
10776 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q50 };
10777 1 : tree res = generic_simplify_51 (loc, type, _p0, _p1, captures, GE_EXPR);
10778 1 : if (res) return res;
10779 : }
10780 : }
10781 : break;
10782 : }
10783 5 : case LT_EXPR:
10784 5 : {
10785 5 : tree _q50 = TREE_OPERAND (_p1, 0);
10786 5 : tree _q51 = TREE_OPERAND (_p1, 1);
10787 5 : if (integer_zerop (_q51))
10788 : {
10789 5 : {
10790 5 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q50, _p0, _q20 };
10791 5 : tree res = generic_simplify_52 (loc, type, _p0, _p1, captures);
10792 5 : if (res) return res;
10793 : }
10794 : }
10795 : break;
10796 : }
10797 : default:;
10798 : }
10799 : }
10800 : break;
10801 : }
10802 100 : case GT_EXPR:
10803 100 : {
10804 100 : tree _q20 = TREE_OPERAND (_p0, 0);
10805 100 : tree _q21 = TREE_OPERAND (_p0, 1);
10806 100 : if (integer_truep (_p1))
10807 : {
10808 14 : {
10809 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10810 14 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, GT_EXPR, LE_EXPR, UNLE_EXPR);
10811 14 : if (res) return res;
10812 : }
10813 : }
10814 : break;
10815 : }
10816 0 : case UNORDERED_EXPR:
10817 0 : {
10818 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10819 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10820 0 : if (integer_truep (_p1))
10821 : {
10822 0 : {
10823 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10824 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR);
10825 0 : if (res) return res;
10826 : }
10827 : }
10828 : break;
10829 : }
10830 0 : case ORDERED_EXPR:
10831 0 : {
10832 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10833 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10834 0 : if (integer_truep (_p1))
10835 : {
10836 0 : {
10837 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10838 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR);
10839 0 : if (res) return res;
10840 : }
10841 : }
10842 : break;
10843 : }
10844 0 : case UNLT_EXPR:
10845 0 : {
10846 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10847 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10848 0 : if (integer_truep (_p1))
10849 : {
10850 0 : {
10851 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10852 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, UNLT_EXPR, GE_EXPR, GE_EXPR);
10853 0 : if (res) return res;
10854 : }
10855 : }
10856 : break;
10857 : }
10858 0 : case UNLE_EXPR:
10859 0 : {
10860 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10861 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10862 0 : if (integer_truep (_p1))
10863 : {
10864 0 : {
10865 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10866 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, UNLE_EXPR, GT_EXPR, GT_EXPR);
10867 0 : if (res) return res;
10868 : }
10869 : }
10870 : break;
10871 : }
10872 0 : case UNGT_EXPR:
10873 0 : {
10874 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10875 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10876 0 : if (integer_truep (_p1))
10877 : {
10878 0 : {
10879 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10880 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, UNGT_EXPR, LE_EXPR, LE_EXPR);
10881 0 : if (res) return res;
10882 : }
10883 : }
10884 : break;
10885 : }
10886 0 : case UNGE_EXPR:
10887 0 : {
10888 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10889 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10890 0 : if (integer_truep (_p1))
10891 : {
10892 0 : {
10893 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10894 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, UNGE_EXPR, LT_EXPR, LT_EXPR);
10895 0 : if (res) return res;
10896 : }
10897 : }
10898 : break;
10899 : }
10900 0 : case UNEQ_EXPR:
10901 0 : {
10902 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10903 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10904 0 : if (integer_truep (_p1))
10905 : {
10906 0 : {
10907 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10908 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR);
10909 0 : if (res) return res;
10910 : }
10911 : }
10912 : break;
10913 : }
10914 0 : case LTGT_EXPR:
10915 0 : {
10916 0 : tree _q20 = TREE_OPERAND (_p0, 0);
10917 0 : tree _q21 = TREE_OPERAND (_p0, 1);
10918 0 : if (integer_truep (_p1))
10919 : {
10920 0 : {
10921 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10922 0 : tree res = generic_simplify_50 (loc, type, _p0, _p1, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR);
10923 0 : if (res) return res;
10924 : }
10925 : }
10926 : break;
10927 : }
10928 7 : case VEC_PERM_EXPR:
10929 7 : {
10930 7 : tree _q20 = TREE_OPERAND (_p0, 0);
10931 7 : tree _q21 = TREE_OPERAND (_p0, 1);
10932 7 : tree _q22 = TREE_OPERAND (_p0, 2);
10933 7 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
10934 : {
10935 0 : switch (TREE_CODE (_p1))
10936 : {
10937 0 : case VEC_PERM_EXPR:
10938 0 : {
10939 0 : tree _q60 = TREE_OPERAND (_p1, 0);
10940 0 : tree _q61 = TREE_OPERAND (_p1, 1);
10941 0 : tree _q62 = TREE_OPERAND (_p1, 2);
10942 0 : if ((_q61 == _q60 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q60, 0) && types_match (_q61, _q60)))
10943 : {
10944 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
10945 : {
10946 0 : {
10947 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q22, _q60 };
10948 0 : if (VECTOR_INTEGER_TYPE_P (type)
10949 : )
10950 : {
10951 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1241;
10952 0 : {
10953 0 : tree res_op0;
10954 0 : {
10955 0 : tree _o1[2], _r1;
10956 0 : _o1[0] = captures[0];
10957 0 : _o1[1] = captures[2];
10958 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
10959 0 : captures[3] = _r1;
10960 : }
10961 0 : res_op0 = unshare_expr (captures[3]);
10962 0 : tree res_op1;
10963 0 : res_op1 = captures[3];
10964 0 : tree res_op2;
10965 0 : res_op2 = captures[1];
10966 0 : tree _r;
10967 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
10968 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 900, __FILE__, __LINE__, true);
10969 0 : return _r;
10970 : }
10971 0 : next_after_fail1241:;
10972 : }
10973 : }
10974 : }
10975 : }
10976 : break;
10977 : }
10978 : default:;
10979 : }
10980 : }
10981 : break;
10982 : }
10983 3247 : case CALL_EXPR:
10984 3247 : switch (get_call_combined_fn (_p0))
10985 : {
10986 1 : case CFN_PARITY:
10987 1 : if (call_expr_nargs (_p0) == 1)
10988 : {
10989 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
10990 1 : switch (TREE_CODE (_p1))
10991 : {
10992 1 : case CALL_EXPR:
10993 1 : switch (get_call_combined_fn (_p1))
10994 : {
10995 1 : case CFN_PARITY:
10996 1 : if (call_expr_nargs (_p1) == 1)
10997 : {
10998 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
10999 1 : {
11000 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11001 1 : tree res = generic_simplify_53 (loc, type, _p0, _p1, captures, CFN_PARITY);
11002 1 : if (res) return res;
11003 : }
11004 : }
11005 : break;
11006 : default:;
11007 : }
11008 : break;
11009 : default:;
11010 : }
11011 : }
11012 : break;
11013 1 : case CFN_BUILT_IN_PARITYL:
11014 1 : if (call_expr_nargs (_p0) == 1)
11015 : {
11016 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11017 1 : switch (TREE_CODE (_p1))
11018 : {
11019 1 : case CALL_EXPR:
11020 1 : switch (get_call_combined_fn (_p1))
11021 : {
11022 1 : case CFN_BUILT_IN_PARITYL:
11023 1 : if (call_expr_nargs (_p1) == 1)
11024 : {
11025 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11026 1 : {
11027 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11028 1 : tree res = generic_simplify_53 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITYL);
11029 1 : if (res) return res;
11030 : }
11031 : }
11032 : break;
11033 : default:;
11034 : }
11035 : break;
11036 : default:;
11037 : }
11038 : }
11039 : break;
11040 0 : case CFN_BUILT_IN_PARITYIMAX:
11041 0 : if (call_expr_nargs (_p0) == 1)
11042 : {
11043 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11044 0 : switch (TREE_CODE (_p1))
11045 : {
11046 0 : case CALL_EXPR:
11047 0 : switch (get_call_combined_fn (_p1))
11048 : {
11049 0 : case CFN_BUILT_IN_PARITYIMAX:
11050 0 : if (call_expr_nargs (_p1) == 1)
11051 : {
11052 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11053 0 : {
11054 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11055 0 : tree res = generic_simplify_53 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITYIMAX);
11056 0 : if (res) return res;
11057 : }
11058 : }
11059 : break;
11060 : default:;
11061 : }
11062 : break;
11063 : default:;
11064 : }
11065 : }
11066 : break;
11067 1 : case CFN_BUILT_IN_PARITY:
11068 1 : if (call_expr_nargs (_p0) == 1)
11069 : {
11070 1 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11071 1 : switch (TREE_CODE (_p1))
11072 : {
11073 1 : case CALL_EXPR:
11074 1 : switch (get_call_combined_fn (_p1))
11075 : {
11076 1 : case CFN_BUILT_IN_PARITY:
11077 1 : if (call_expr_nargs (_p1) == 1)
11078 : {
11079 1 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11080 1 : {
11081 1 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11082 1 : tree res = generic_simplify_53 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITY);
11083 1 : if (res) return res;
11084 : }
11085 : }
11086 : break;
11087 : default:;
11088 : }
11089 : break;
11090 : default:;
11091 : }
11092 : }
11093 : break;
11094 8 : case CFN_BUILT_IN_PARITYLL:
11095 8 : if (call_expr_nargs (_p0) == 1)
11096 : {
11097 8 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
11098 8 : switch (TREE_CODE (_p1))
11099 : {
11100 8 : case CALL_EXPR:
11101 8 : switch (get_call_combined_fn (_p1))
11102 : {
11103 8 : case CFN_BUILT_IN_PARITYLL:
11104 8 : if (call_expr_nargs (_p1) == 1)
11105 : {
11106 8 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
11107 8 : {
11108 8 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
11109 8 : tree res = generic_simplify_53 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_PARITYLL);
11110 8 : if (res) return res;
11111 : }
11112 : }
11113 : break;
11114 : default:;
11115 : }
11116 : break;
11117 : default:;
11118 : }
11119 : }
11120 : break;
11121 : default:;
11122 : }
11123 : break;
11124 : default:;
11125 : }
11126 : return NULL_TREE;
11127 : }
11128 :
11129 : tree
11130 39044732 : generic_simplify (location_t loc, enum tree_code code, const tree type ATTRIBUTE_UNUSED, tree _p0, tree _p1, tree _p2)
11131 : {
11132 39044732 : switch (code)
11133 : {
11134 12474785 : case COND_EXPR:
11135 12474785 : return generic_simplify_COND_EXPR (loc, code, type, _p0, _p1, _p2);
11136 393860 : case VEC_COND_EXPR:
11137 393860 : return generic_simplify_VEC_COND_EXPR (loc, code, type, _p0, _p1, _p2);
11138 764436 : case BIT_FIELD_REF:
11139 764436 : return generic_simplify_BIT_FIELD_REF (loc, code, type, _p0, _p1, _p2);
11140 14778 : case BIT_INSERT_EXPR:
11141 14778 : return generic_simplify_BIT_INSERT_EXPR (loc, code, type, _p0, _p1, _p2);
11142 776548 : case VEC_PERM_EXPR:
11143 776548 : return generic_simplify_VEC_PERM_EXPR (loc, code, type, _p0, _p1, _p2);
11144 : default:;
11145 : }
11146 : return NULL_TREE;
11147 : }
11148 :
11149 : tree
11150 0 : generic_simplify (location_t, enum tree_code,
11151 : const tree, tree, tree, tree, tree)
11152 : {
11153 0 : return NULL_TREE;
11154 : }
11155 :
11156 : tree
11157 0 : generic_simplify (location_t, enum tree_code,
11158 : const tree, tree, tree, tree, tree, tree)
11159 : {
11160 0 : return NULL_TREE;
11161 : }
11162 :
11163 : tree
11164 0 : generic_simplify (location_t, enum tree_code,
11165 : const tree, tree, tree, tree, tree, tree, tree)
11166 : {
11167 0 : return NULL_TREE;
11168 : }
11169 :
11170 : tree
11171 0 : generic_simplify (location_t, enum tree_code,
11172 : const tree, tree, tree, tree, tree, tree, tree, tree)
11173 : {
11174 0 : return NULL_TREE;
11175 : }
11176 : void
11177 18370 : generic_dump_logs (const char *file1, int line1_id, const char *file2, int line2, bool simplify)
11178 : {
11179 18370 : static int dbg_line_numbers[1116] = {
11180 : /* 0 */ 159, 162, 171, 173, 176, 179, 181, 187, 195, 193,
11181 : /* 10 */ 197, 199, 986, 988, 2187, 2193, 2195, 2198, 2203, 2206,
11182 : /* 20 */ 2454, 2458, 2460, 2462, 2464, 2466, 2468, 2470, 2497, 2513,
11183 : /* 30 */ 2521, 2503, 3121, 3123, 3125, 3132, 3129, 3139, 3141, 3148,
11184 : /* 40 */ 3145, 3356, 3366, 5766, 9211, 9232, 11657, 11660, 11665, 2154,
11185 : /* 50 */ 9031, 1361, 1365, 1525, 1540, 1545, 1592, 1593, 1597, 1598,
11186 : /* 60 */ 1640, 1665, 1670, 1762, 1895, 1985, 1905, 2049, 1915, 1920,
11187 : /* 70 */ 2043, 1928, 2095, 2037, 2056, 2062, 2734, 2069, 2083, 2129,
11188 : /* 80 */ 2346, 2412, 2435, 2446, 2449, 2481, 2592, 2624, 4393, 4406,
11189 : /* 90 */ 4416, 3198, 3200, 4771, 4430, 4442, 7174, 7176, 7241, 7249,
11190 : /* 100 */ 10568, 10574, 280, 307, 308, 519, 1355, 1878, 1933, 1996,
11191 : /* 110 */ 3888, 3826, 3931, 3932, 3936, 3937, 3947, 3951, 3955, 3970,
11192 : /* 120 */ 3973, 3977, 3903, 3906, 3911, 4057, 4063, 4069, 4249, 4250,
11193 : /* 130 */ 4279, 4300, 4319, 4759, 5665, 7105, 7190, 7192, 8659, 8734,
11194 : /* 140 */ 10400, 10447, 10461, 11684, 12109, 970, 976, 1505, 1514, 2014,
11195 : /* 150 */ 2005, 1952, 2760, 3839, 3879, 3884, 3885, 3893, 3894, 3897,
11196 : /* 160 */ 3914, 3989, 3992, 3996, 4077, 4099, 4137, 4148, 4187, 4202,
11197 : /* 170 */ 4765, 7115, 8739, 10457, 11688, 5108, 1491, 1500, 1530, 1535,
11198 : /* 180 */ 1577, 1562, 1569, 1619, 2091, 1624, 1631, 1660, 1786, 1885,
11199 : /* 190 */ 1890, 1900, 1910, 2024, 2111, 2121, 2123, 2382, 2387, 2392,
11200 : /* 200 */ 2398, 2399, 2421, 2575, 2604, 2606, 2611, 2613, 2753, 3412,
11201 : /* 210 */ 3427, 3445, 3645, 3646, 3647, 3655, 3663, 3672, 3681, 3713,
11202 : /* 220 */ 3714, 3719, 3720, 3725, 3730, 3734, 3789, 3803, 3417, 3436,
11203 : /* 230 */ 3438, 3422, 5114, 7778, 9609, 12207, 12222, 487, 493, 525,
11204 : /* 240 */ 1300, 1320, 1325, 2179, 2180, 2217, 2769, 2550, 5350, 5651,
11205 : /* 250 */ 5658, 5708, 5711, 5761, 8652, 9066, 8896, 8903, 9060, 9105,
11206 : /* 260 */ 9110, 355, 932, 1373, 3040, 2836, 2842, 2845, 2850, 2486,
11207 : /* 270 */ 2748, 2539, 2686, 2924, 2787, 2797, 2866, 2868, 2869, 2872,
11208 : /* 280 */ 2874, 2875, 2877, 2879, 2881, 2883, 2885, 2887, 2901, 2902,
11209 : /* 290 */ 2958, 3046, 3071, 2987, 3014, 3054, 3059, 3084, 3091, 3157,
11210 : /* 300 */ 3761, 4701, 4709, 4712, 4718, 4721, 4748, 5142, 5143, 5177,
11211 : /* 310 */ 5181, 5310, 5150, 5151, 5195, 5198, 5199, 5204, 5207, 5210,
11212 : /* 320 */ 5211, 5163, 5166, 5383, 5387, 5392, 5676, 5828, 5832, 7201,
11213 : /* 330 */ 7217, 7219, 7231, 7261, 7267, 7268, 7283, 7284, 7288, 7306,
11214 : /* 340 */ 7311, 7343, 7351, 7361, 7370, 7374, 7380, 7387, 7403, 7407,
11215 : /* 350 */ 7411, 7418, 7419, 7424, 7425, 7432, 7433, 7435, 7436, 7452,
11216 : /* 360 */ 7463, 7475, 7479, 7481, 7486, 7489, 7492, 7500, 7562, 7563,
11217 : /* 370 */ 7567, 7568, 7575, 7579, 7583, 7586, 7592, 7593, 7597, 7600,
11218 : /* 380 */ 7607, 7627, 7630, 7633, 7636, 7685, 7688, 7692, 7699, 7705,
11219 : /* 390 */ 7713, 7722, 7723, 7821, 7831, 7870, 7876, 7892, 7905, 7907,
11220 : /* 400 */ 7909, 7920, 7948, 7990, 7969, 7970, 7977, 7979, 7995, 8001,
11221 : /* 410 */ 8006, 8015, 8021, 8027, 8032, 8037, 8069, 8132, 8051, 8061,
11222 : /* 420 */ 8161, 8180, 8182, 8184, 8186, 8188, 8190, 8194, 8196, 8219,
11223 : /* 430 */ 8242, 8353, 8360, 8361, 8369, 8370, 8572, 9653, 9655, 9733,
11224 : /* 440 */ 9735, 9736, 9742, 9758, 9760, 9762, 9780, 9781, 10185, 10188,
11225 : /* 450 */ 10202, 10211, 10275, 10276, 10330, 10332, 10408, 10999, 11001, 11003,
11226 : /* 460 */ 11437, 7197, 7208, 7210, 7318, 499, 1273, 1294, 9016, 9021,
11227 : /* 470 */ 9026, 559, 560, 571, 576, 583, 592, 600, 609, 655,
11228 : /* 480 */ 658, 867, 1021, 1049, 1080, 620, 897, 901, 906, 912,
11229 : /* 490 */ 916, 924, 1013, 771, 781, 783, 785, 8646, 9071, 9093,
11230 : /* 500 */ 9076, 9081, 9086, 9100, 9134, 9139, 842, 6480, 6482, 6484,
11231 : /* 510 */ 6584, 6587, 6770, 6772, 6786, 6790, 6813, 6819, 6830, 6892,
11232 : /* 520 */ 6907, 4795, 4815, 4822, 4828, 4834, 4840, 6898, 4808, 4851,
11233 : /* 530 */ 4864, 6391, 6694, 6698, 6706, 7044, 9626, 9627, 7054, 10628,
11234 : /* 540 */ 10636, 12250, 8085, 8086, 8100, 8101, 854, 857, 1737, 2810,
11235 : /* 550 */ 2813, 2932, 2944, 3029, 2973, 3000, 3112, 3115, 4571, 4582,
11236 : /* 560 */ 4731, 4739, 5035, 7139, 8497, 7735, 7738, 7764, 7765, 8267,
11237 : /* 570 */ 8269, 8271, 8273, 8277, 8279, 8281, 8283, 8287, 8292, 8299,
11238 : /* 580 */ 8304, 8324, 8326, 8328, 8330, 8510, 8523, 8533, 8541, 8551,
11239 : /* 590 */ 8673, 8675, 9667, 9676, 9716, 10253, 10255, 10256, 10311, 10314,
11240 : /* 600 */ 10316, 2826, 7129, 7808, 8747, 8752, 11020, 11022, 11024, 11026,
11241 : /* 610 */ 11030, 959, 995, 1345, 4899, 4986, 4989, 4997, 5088, 5090,
11242 : /* 620 */ 5091, 5092, 5322, 4950, 4959, 5883, 5886, 5887, 5895, 2357,
11243 : /* 630 */ 2367, 2374, 3772, 3777, 4536, 4643, 9492, 9494, 9525, 9560,
11244 : /* 640 */ 12053, 1237, 8964, 8985, 1246, 8708, 8714, 9011, 9439, 1260,
11245 : /* 650 */ 1264, 9006, 9189, 1473, 1557, 1605, 1550, 1582, 1613, 1655,
11246 : /* 660 */ 1696, 1707, 1718, 1730, 2636, 1967, 1975, 1980, 2103, 2476,
11247 : /* 670 */ 2775, 3352, 3382, 3384, 3394, 3396, 3503, 3504, 3505, 3513,
11248 : /* 680 */ 3521, 3530, 3539, 3573, 3574, 3579, 3580, 3585, 3590, 3594,
11249 : /* 690 */ 3402, 3407, 3452, 4776, 5281, 5299, 5300, 5854, 5860, 5908,
11250 : /* 700 */ 7333, 7781, 9595, 9597, 10442, 1645, 1650, 2713, 1817, 2718,
11251 : /* 710 */ 5361, 2693, 2724, 2728, 5375, 4686, 7166, 7168, 2224, 2238,
11252 : /* 720 */ 2698, 3864, 2263, 2286, 2287, 10056, 4449, 4453, 4463, 4481,
11253 : /* 730 */ 4512, 4521, 4595, 4598, 4607, 4608, 4626, 4628, 4630, 4632,
11254 : /* 740 */ 4681, 9617, 4467, 4474, 4459, 4653, 4662, 4665, 11229, 11235,
11255 : /* 750 */ 11243, 11249, 11258, 11264, 11272, 11278, 11324, 11332, 4886, 5060,
11256 : /* 760 */ 5070, 8601, 8604, 8623, 5804, 5816, 5819, 5823, 8385, 7326,
11257 : /* 770 */ 7322, 8582, 8589, 8724, 8729, 8830, 8927, 8944, 8976, 8996,
11258 : /* 780 */ 9001, 9252, 9229, 9208, 9037, 9041, 9332, 9342, 9349, 9358,
11259 : /* 790 */ 9376, 9383, 9364, 9632, 9638, 10046, 10052, 10049, 10069, 10074,
11260 : /* 800 */ 10080, 10088, 10094, 10102, 10108, 10118, 10124, 10132, 10138, 10146,
11261 : /* 810 */ 10152, 10160, 10166, 10220, 10422, 10437, 10473, 10727, 10730, 10535,
11262 : /* 820 */ 10549, 10562, 11406, 11421, 11512, 11513, 12162, 219, 2135, 2145,
11263 : /* 830 */ 5940, 2163, 1187, 2647, 3333, 5403, 5405, 5415, 5532, 5543,
11264 : /* 840 */ 5556, 5579, 5589, 5598, 5610, 5636, 5950, 6397, 1814, 1828,
11265 : /* 850 */ 1835, 1866, 1873, 2491, 2741, 2140, 2158, 2167, 2233, 2269,
11266 : /* 860 */ 2275, 3851, 7092, 3859, 10128, 10084, 10142, 10156, 10170, 10098,
11267 : /* 870 */ 10112, 5420, 5430, 5439, 5466, 5476, 5482, 5961, 5491, 5488,
11268 : /* 880 */ 5774, 5782, 5790, 5794, 5777, 5785, 5798, 5810, 237, 263,
11269 : /* 890 */ 1770, 1775, 2706, 2560, 3749, 4561, 5979, 5988, 5999, 6008,
11270 : /* 900 */ 12068, 753, 5723, 5729, 5731, 3205, 3209, 268, 3226, 3230,
11271 : /* 910 */ 3261, 3269, 3242, 3256, 286, 323, 1509, 1823, 1940, 1947,
11272 : /* 920 */ 1957, 1962, 2244, 3277, 3289, 3283, 3295, 2255, 2953, 2981,
11273 : /* 930 */ 3008, 2992, 3019, 4111, 4083, 4158, 4167, 4210, 4221, 4976,
11274 : /* 940 */ 5736, 5747, 12034, 12035, 1742, 1747, 7771, 11383, 11387, 273,
11275 : /* 950 */ 326, 2962, 2965, 3302, 3309, 3316, 3322, 4120, 3327, 4176,
11276 : /* 960 */ 4230, 5739, 399, 330, 367, 376, 384, 458, 473, 481,
11277 : /* 970 */ 672, 712, 1030, 1225, 1230, 1328, 1331, 1465, 2545, 5752,
11278 : /* 980 */ 8681, 8687, 8878, 9128, 2667, 6187, 6197, 7838, 8417, 8477,
11279 : /* 990 */ 8478, 2657, 8411, 635, 638, 762, 791, 797, 803, 811,
11280 : /* 1000 */ 816, 821, 885, 889, 8693, 8699, 8335, 943, 1420, 4915,
11281 : /* 1010 */ 1409, 1412, 1444, 1455, 4892, 4981, 5121, 1479, 1677, 1752,
11282 : /* 1020 */ 1780, 2426, 5127, 5128, 7775, 12041, 4488, 4492, 4553, 4554,
11283 : /* 1030 */ 4674, 4499, 4503, 4544, 4545, 5041, 5771, 8393, 8395, 8402,
11284 : /* 1040 */ 8404, 7330, 6914, 4782, 6019, 4879, 6028, 6713, 6718, 6865,
11285 : /* 1050 */ 6867, 6873, 6882, 6883, 5926, 5928, 6920, 6923, 6932, 6936,
11286 : /* 1060 */ 6941, 6970, 6975, 7041, 6983, 6988, 7051, 8115, 8117, 7007,
11287 : /* 1070 */ 7008, 7009, 7064, 7031, 7032, 7033, 7079, 7080, 8146, 8151,
11288 : /* 1080 */ 6949, 5932, 5934, 6208, 6210, 9788, 9794, 9799, 9808, 9810,
11289 : /* 1090 */ 9830, 9875, 9878, 9879, 9911, 9917, 9919, 9920, 9976, 9977,
11290 : /* 1100 */ 9998, 10003, 10008, 10038, 11537, 11539, 11574, 11649, 11652, 11737,
11291 : /* 1110 */ 11672, 11678, 11806, 11808, 11870, 11872
11292 : };
11293 :
11294 27436 : fprintf (dump_file, "%s %s:%d, %s:%d\n",
11295 : simplify ? "Applying pattern" : "Matching expression", file1, dbg_line_numbers[line1_id], file2, line2);
11296 18370 : }
11297 :
11298 : #pragma GCC diagnostic pop
|
