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 1163496372 : tree_nop_convert (tree t, tree *res_ops)
11 : {
12 1163496372 : const tree type = TREE_TYPE (t);
13 1163496372 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 1163496372 : if (TREE_SIDE_EFFECTS (t)) return false;
15 1117240564 : switch (TREE_CODE (t))
16 : {
17 241620085 : CASE_CONVERT:
18 241620085 : {
19 241620085 : tree _p0 = TREE_OPERAND (t, 0);
20 241620085 : {
21 241620085 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
22 241620085 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
23 : )
24 : {
25 198184949 : {
26 198184949 : res_ops[0] = captures[0];
27 198184949 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 0, __FILE__, __LINE__, false);
28 198184949 : return true;
29 : }
30 : }
31 : }
32 : break;
33 : }
34 4597639 : case VIEW_CONVERT_EXPR:
35 4597639 : {
36 4597639 : tree _p0 = TREE_OPERAND (t, 0);
37 4597639 : {
38 4597639 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
39 3211908 : if (VECTOR_TYPE_P (type) && VECTOR_TYPE_P (TREE_TYPE (captures[0]))
40 3211890 : && known_eq (TYPE_VECTOR_SUBPARTS (type),
41 : TYPE_VECTOR_SUBPARTS (TREE_TYPE (captures[0])))
42 6818276 : && tree_nop_conversion_p (TREE_TYPE (type), TREE_TYPE (TREE_TYPE (captures[0])))
43 : )
44 : {
45 2220627 : {
46 2220627 : res_ops[0] = captures[0];
47 2220627 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1, __FILE__, __LINE__, false);
48 2220627 : return true;
49 : }
50 : }
51 : }
52 2377012 : break;
53 : }
54 : default:;
55 : }
56 : return false;
57 : }
58 :
59 : bool
60 92107326 : tree_with_known_nonzero_bits (tree t)
61 : {
62 92107326 : const tree type = TREE_TYPE (t);
63 92107326 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
64 92107326 : if (TREE_SIDE_EFFECTS (t)) return false;
65 86861063 : switch (TREE_CODE (t))
66 : {
67 277576 : case BIT_IOR_EXPR:
68 277576 : {
69 277576 : tree _p0 = TREE_OPERAND (t, 0);
70 277576 : tree _p1 = TREE_OPERAND (t, 1);
71 277576 : if (tree_with_known_nonzero_bits_1 (_p0))
72 : {
73 269962 : {
74 269962 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
75 269962 : {
76 269962 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 39, __FILE__, __LINE__, false);
77 269962 : return true;
78 : }
79 : }
80 : }
81 7614 : if (tree_with_known_nonzero_bits_1 (_p1))
82 : {
83 186 : {
84 186 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _p0 };
85 186 : {
86 186 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 39, __FILE__, __LINE__, false);
87 186 : return true;
88 : }
89 : }
90 : }
91 : break;
92 : }
93 86590915 : default:;
94 : }
95 86590915 : if (tree_with_known_nonzero_bits_1 (t))
96 : {
97 40204196 : {
98 40204196 : tree captures[1] ATTRIBUTE_UNUSED = { t };
99 40204196 : {
100 40204196 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 40, __FILE__, __LINE__, false);
101 40204196 : return true;
102 : }
103 : }
104 : }
105 : return false;
106 : }
107 :
108 : tree
109 15 : generic_simplify_4 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
110 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
111 : const enum tree_code ARG_UNUSED (op))
112 : {
113 15 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
114 15 : if (INTEGRAL_TYPE_P (type)
115 : )
116 : {
117 15 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail75;
118 15 : {
119 15 : tree res_op0;
120 15 : {
121 15 : tree _o1[2], _r1;
122 15 : _o1[0] = captures[1];
123 15 : _o1[1] = captures[4];
124 15 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
125 15 : res_op0 = _r1;
126 : }
127 15 : tree res_op1;
128 15 : res_op1 = captures[2];
129 15 : tree _r;
130 15 : _r = fold_build2_loc (loc, RSHIFT_EXPR, type, res_op0, res_op1);
131 15 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 52, __FILE__, __LINE__, true);
132 15 : return _r;
133 : }
134 0 : next_after_fail75:;
135 : }
136 : return NULL_TREE;
137 : }
138 :
139 : tree
140 90 : generic_simplify_12 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
141 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
142 : {
143 90 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
144 90 : {
145 90 : bool wascmp;
146 90 : if (bitwise_inverted_equal_p (captures[0], captures[2], wascmp)
147 90 : && (!wascmp || element_precision (type) == 1)
148 : )
149 : {
150 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail87;
151 0 : {
152 0 : tree _r;
153 0 : _r = captures[0];
154 0 : if (TREE_SIDE_EFFECTS (captures[1]))
155 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
156 0 : if (TREE_SIDE_EFFECTS (captures[2]))
157 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
158 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 60, __FILE__, __LINE__, true);
159 0 : return _r;
160 : }
161 0 : next_after_fail87:;
162 : }
163 : }
164 90 : return NULL_TREE;
165 : }
166 :
167 : tree
168 0 : generic_simplify_21 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
169 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
170 : {
171 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
172 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail96;
173 0 : {
174 0 : tree res_op0;
175 0 : res_op0 = captures[0];
176 0 : tree res_op1;
177 0 : res_op1 = captures[1];
178 0 : tree _r;
179 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
180 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 69, __FILE__, __LINE__, true);
181 : return _r;
182 : }
183 0 : next_after_fail96:;
184 0 : return NULL_TREE;
185 : }
186 :
187 : tree
188 113 : generic_simplify_29 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
189 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
190 : const enum tree_code ARG_UNUSED (opo),
191 : const enum tree_code ARG_UNUSED (opi))
192 : {
193 113 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
194 113 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail104;
195 113 : {
196 113 : tree res_op0;
197 113 : {
198 113 : tree _o1[1], _r1;
199 113 : _o1[0] = captures[1];
200 113 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
201 113 : res_op0 = _r1;
202 : }
203 113 : tree res_op1;
204 113 : res_op1 = captures[2];
205 113 : tree _r;
206 113 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
207 113 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 77, __FILE__, __LINE__, true);
208 : return _r;
209 : }
210 0 : next_after_fail104:;
211 0 : return NULL_TREE;
212 : }
213 :
214 : tree
215 268455 : generic_simplify_34 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
216 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
217 : const enum tree_code ARG_UNUSED (bitop),
218 : const enum tree_code ARG_UNUSED (rbitop),
219 : const enum tree_code ARG_UNUSED (resbitop))
220 : {
221 268455 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
222 268455 : {
223 268455 : bool wascmp;
224 268455 : if (bitwise_inverted_equal_p (captures[2], captures[0], wascmp)
225 268455 : && (!wascmp || element_precision (type) == 1)
226 : )
227 : {
228 13 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail109;
229 13 : {
230 13 : tree res_op0;
231 13 : res_op0 = captures[2];
232 13 : tree res_op1;
233 13 : res_op1 = captures[1];
234 13 : tree _r;
235 13 : _r = fold_build2_loc (loc, resbitop, type, res_op0, res_op1);
236 13 : if (TREE_SIDE_EFFECTS (captures[0]))
237 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
238 13 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 81, __FILE__, __LINE__, true);
239 13 : return _r;
240 : }
241 0 : next_after_fail109:;
242 : }
243 : }
244 268442 : return NULL_TREE;
245 : }
246 :
247 : tree
248 56 : generic_simplify_43 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
249 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
250 : const enum tree_code ARG_UNUSED (inner_op),
251 : const enum tree_code ARG_UNUSED (outer_op))
252 : {
253 56 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
254 56 : {
255 56 : bool fail = false;
256 56 : wide_int zero_mask_not;
257 56 : wide_int C0;
258 56 : wide_int cst_emit;
259 56 : if (TREE_CODE (captures[1]) == SSA_NAME)
260 0 : zero_mask_not = get_nonzero_bits (captures[1]);
261 : else
262 : fail = true;
263 56 : if (inner_op == BIT_XOR_EXPR)
264 : {
265 33 : C0 = wi::bit_and_not (wi::to_wide (captures[2]), wi::to_wide (captures[3]));
266 33 : cst_emit = C0 | wi::to_wide (captures[3]);
267 : }
268 : else
269 : {
270 23 : C0 = wi::to_wide (captures[2]);
271 23 : cst_emit = C0 ^ wi::to_wide (captures[3]);
272 : }
273 56 : if (!fail && (C0 & zero_mask_not) == 0
274 : )
275 : {
276 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail120;
277 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail120;
278 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail120;
279 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail120;
280 0 : {
281 0 : tree res_op0;
282 0 : res_op0 = captures[1];
283 0 : tree res_op1;
284 0 : res_op1 = wide_int_to_tree (type, cst_emit);
285 0 : tree _r;
286 0 : _r = fold_build2_loc (loc, outer_op, type, res_op0, res_op1);
287 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 91, __FILE__, __LINE__, true);
288 0 : return _r;
289 : }
290 56 : next_after_fail120:;
291 : }
292 : else
293 : {
294 56 : if (!fail && (wi::to_wide (captures[3]) & zero_mask_not) == 0
295 : )
296 : {
297 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail121;
298 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail121;
299 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail121;
300 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail121;
301 0 : {
302 0 : tree res_op0;
303 0 : res_op0 = captures[1];
304 0 : tree res_op1;
305 0 : res_op1 = wide_int_to_tree (type, cst_emit);
306 0 : tree _r;
307 0 : _r = fold_build2_loc (loc, inner_op, type, res_op0, res_op1);
308 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 92, __FILE__, __LINE__, true);
309 0 : return _r;
310 : }
311 56 : next_after_fail121:;
312 : }
313 : }
314 56 : }
315 56 : return NULL_TREE;
316 : }
317 :
318 : tree
319 7 : generic_simplify_57 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
320 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
321 : const enum tree_code ARG_UNUSED (op))
322 : {
323 7 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
324 7 : if (INTEGRAL_TYPE_P (type)
325 7 : && TYPE_OVERFLOW_WRAPS (type)
326 14 : && !TYPE_SATURATING (type)
327 : )
328 : {
329 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail138;
330 7 : {
331 7 : tree res_op0;
332 7 : {
333 7 : tree _o1[2], _r1;
334 7 : _o1[0] = captures[1];
335 7 : _o1[1] = captures[4];
336 7 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
337 7 : res_op0 = _r1;
338 : }
339 7 : tree res_op1;
340 7 : res_op1 = captures[2];
341 7 : tree _r;
342 7 : _r = fold_build2_loc (loc, LSHIFT_EXPR, type, res_op0, res_op1);
343 7 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 106, __FILE__, __LINE__, true);
344 7 : return _r;
345 : }
346 0 : next_after_fail138:;
347 : }
348 : return NULL_TREE;
349 : }
350 :
351 : tree
352 864 : generic_simplify_65 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
353 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
354 : {
355 864 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
356 864 : if (!TYPE_SATURATING (type)
357 : )
358 : {
359 864 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
360 1728 : && !FIXED_POINT_TYPE_P (type)
361 : )
362 : {
363 864 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail154;
364 864 : {
365 864 : tree res_op0;
366 864 : res_op0 = captures[2];
367 864 : tree res_op1;
368 864 : res_op1 = captures[1];
369 864 : tree _r;
370 864 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
371 864 : if (TREE_SIDE_EFFECTS (captures[0]))
372 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
373 864 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 122, __FILE__, __LINE__, true);
374 864 : return _r;
375 : }
376 0 : next_after_fail154:;
377 : }
378 : }
379 : return NULL_TREE;
380 : }
381 :
382 : tree
383 9692 : generic_simplify_72 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
384 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
385 : const enum tree_code ARG_UNUSED (plusminus))
386 : {
387 9692 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
388 9692 : if (!TYPE_SATURATING (type)
389 9692 : && (!FLOAT_TYPE_P (type) || flag_associative_math)
390 : )
391 : {
392 9526 : if (!ALL_FRACT_MODE_P (TYPE_MODE (type))
393 : )
394 : {
395 4 : if ((!ANY_INTEGRAL_TYPE_P (type)
396 9522 : || TYPE_OVERFLOW_WRAPS (type)
397 3305 : || (INTEGRAL_TYPE_P (type)
398 3305 : && ((tree_expr_nonzero_p (captures[0])
399 136 : && expr_not_equal_to (captures[0],
400 9662 : wi::minus_one (TYPE_PRECISION (type)),
401 : gimple_match_ctx (captures[1])))
402 : || (plusminus == PLUS_EXPR
403 3169 : ? expr_not_equal_to (captures[2],
404 9544 : wi::max_value (TYPE_PRECISION (type), SIGNED),
405 : gimple_match_ctx (captures[1]))
406 3151 : : (expr_not_equal_to (captures[2],
407 12677 : wi::min_value (TYPE_PRECISION (type), SIGNED),
408 : gimple_match_ctx (captures[1]))
409 3127 : && expr_not_equal_to (captures[2],
410 6254 : wi::min_value (TYPE_PRECISION (type), SIGNED)
411 18907 : + 1, gimple_match_ctx (captures[1])))))))
412 12695 : && single_use (captures[1])
413 : )
414 : {
415 9502 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail162;
416 9502 : {
417 9502 : tree res_op0;
418 9502 : {
419 9502 : tree _o1[2], _r1;
420 9502 : _o1[0] = build_one_cst (type);
421 9502 : _o1[1] = captures[2];
422 9502 : _r1 = fold_build2_loc (loc, plusminus, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
423 9502 : res_op0 = _r1;
424 : }
425 9502 : tree res_op1;
426 9502 : res_op1 = captures[0];
427 9502 : tree _r;
428 9502 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
429 9502 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 130, __FILE__, __LINE__, true);
430 9502 : return _r;
431 : }
432 0 : next_after_fail162:;
433 : }
434 : }
435 : }
436 : return NULL_TREE;
437 : }
438 :
439 : tree
440 0 : generic_simplify_84 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
441 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
442 : {
443 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
444 0 : if (TREE_CODE (captures[1]) == SSA_NAME && num_imm_uses (captures[1]) == 2
445 : )
446 : {
447 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail175;
448 0 : {
449 0 : if (! tree_invariant_p (captures[2])) goto next_after_fail175;
450 0 : tree res_op0;
451 0 : {
452 0 : tree _o1[2], _r1;
453 0 : {
454 0 : tree _o2[3], _r2;
455 0 : _o2[0] = unshare_expr (captures[2]);
456 0 : _o2[1] = captures[2];
457 0 : _o2[2] = captures[4];
458 0 : _r2 = fold_build3_loc (loc, VEC_PERM_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1], _o2[2]);
459 0 : _o1[0] = _r2;
460 : }
461 0 : _o1[1] = captures[3];
462 0 : _r1 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
463 0 : res_op0 = _r1;
464 : }
465 0 : tree res_op1;
466 0 : res_op1 = captures[5];
467 0 : tree _r;
468 0 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
469 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 143, __FILE__, __LINE__, true);
470 0 : return _r;
471 : }
472 : next_after_fail175:;
473 : }
474 : return NULL_TREE;
475 : }
476 :
477 : tree
478 1 : generic_simplify_91 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
479 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
480 : {
481 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
482 1 : if (!TYPE_OVERFLOW_SANITIZED (type) && !TYPE_OVERFLOW_TRAPS (type)
483 1 : && !TYPE_SATURATING (type) && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[0]))
484 1 : && !TYPE_OVERFLOW_TRAPS (TREE_TYPE (captures[0]))
485 2 : && !TYPE_SATURATING (TREE_TYPE (captures[0]))
486 : )
487 : {
488 1 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail182;
489 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail182;
490 1 : {
491 1 : tree res_op0;
492 1 : {
493 1 : tree _o1[1], _r1;
494 1 : {
495 1 : tree _o2[2], _r2;
496 1 : _o2[0] = captures[1];
497 1 : _o2[1] = captures[2];
498 1 : _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
499 1 : _o1[0] = _r2;
500 : }
501 1 : if (TREE_TYPE (_o1[0]) != type)
502 : {
503 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
504 : }
505 : else
506 : _r1 = _o1[0];
507 1 : res_op0 = _r1;
508 : }
509 1 : tree _r;
510 1 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
511 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 150, __FILE__, __LINE__, true);
512 1 : return _r;
513 : }
514 : next_after_fail182:;
515 : }
516 : return NULL_TREE;
517 : }
518 :
519 : tree
520 12242 : generic_simplify_103 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
521 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
522 : {
523 12242 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
524 12242 : if (!TYPE_SATURATING (type)
525 : )
526 : {
527 12242 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
528 24484 : && !FIXED_POINT_TYPE_P (type)
529 : )
530 : {
531 12242 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
532 12242 : || (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
533 3010 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1])))
534 : )
535 : {
536 12122 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail198;
537 12122 : {
538 12122 : tree res_op0;
539 12122 : res_op0 = captures[1];
540 12122 : tree _r;
541 12122 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
542 12122 : if (TREE_SIDE_EFFECTS (captures[2]))
543 15 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
544 12122 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 165, __FILE__, __LINE__, true);
545 12122 : return _r;
546 : }
547 0 : next_after_fail198:;
548 : }
549 : }
550 : }
551 : return NULL_TREE;
552 : }
553 :
554 : tree
555 2 : generic_simplify_108 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
556 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
557 : const combined_fn ARG_UNUSED (logs))
558 : {
559 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
560 2 : if (flag_unsafe_math_optimizations
561 : )
562 : {
563 2 : if (! HONOR_SIGN_DEPENDENT_ROUNDING (type)
564 2 : && ! HONOR_NANS (type) && ! HONOR_INFINITIES (type)
565 2 : && ! flag_trapping_math
566 4 : && ! flag_errno_math
567 : )
568 : {
569 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail205;
570 2 : {
571 2 : tree res_op0;
572 2 : {
573 2 : tree _o1[2], _r1;
574 2 : _o1[0] = captures[1];
575 2 : _o1[1] = captures[3];
576 2 : _r1 = fold_build2_loc (loc, RDIV_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
577 2 : res_op0 = _r1;
578 : }
579 2 : tree _r;
580 2 : _r = maybe_build_call_expr_loc (loc, logs, type, 1, res_op0);
581 2 : if (!_r)
582 0 : goto next_after_fail205;
583 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 172, __FILE__, __LINE__, true);
584 2 : return _r;
585 : }
586 : next_after_fail205:;
587 : }
588 : }
589 : return NULL_TREE;
590 : }
591 :
592 : tree
593 20379 : generic_simplify_115 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
594 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
595 : {
596 20379 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
597 20379 : {
598 20379 : bool wascmp;
599 20379 : if (bitwise_inverted_equal_p (captures[0], captures[2], wascmp)
600 20379 : && (!wascmp || element_precision (type) == 1)
601 : )
602 : {
603 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail212;
604 1 : {
605 1 : tree res_op0;
606 1 : res_op0 = captures[0];
607 1 : tree res_op1;
608 1 : {
609 1 : tree _o1[1], _r1;
610 1 : _o1[0] = captures[3];
611 1 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
612 1 : res_op1 = _r1;
613 : }
614 1 : tree _r;
615 1 : _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
616 1 : if (TREE_SIDE_EFFECTS (captures[2]))
617 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
618 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 179, __FILE__, __LINE__, true);
619 1 : return _r;
620 : }
621 0 : next_after_fail212:;
622 : }
623 : }
624 20378 : return NULL_TREE;
625 : }
626 :
627 : tree
628 2 : generic_simplify_124 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
629 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
630 : {
631 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
632 2 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail221;
633 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail221;
634 2 : {
635 2 : tree res_op0;
636 2 : res_op0 = captures[0];
637 2 : tree res_op1;
638 2 : res_op1 = captures[3];
639 2 : tree _r;
640 2 : _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
641 2 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 186, __FILE__, __LINE__, true);
642 : return _r;
643 : }
644 : next_after_fail221:;
645 : return NULL_TREE;
646 : }
647 :
648 : tree
649 0 : generic_simplify_135 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
650 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
651 : const enum tree_code ARG_UNUSED (op))
652 : {
653 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
654 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail232;
655 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail232;
656 0 : {
657 0 : tree _r;
658 0 : _r = captures[0];
659 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 183, __FILE__, __LINE__, true);
660 : return _r;
661 : }
662 : next_after_fail232:;
663 : return NULL_TREE;
664 : }
665 :
666 : tree
667 0 : generic_simplify_144 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
668 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
669 : const enum tree_code ARG_UNUSED (bitop),
670 : const enum tree_code ARG_UNUSED (rbitop))
671 : {
672 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
673 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail245;
674 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail245;
675 0 : {
676 0 : tree _r;
677 0 : _r = captures[2];
678 0 : if (TREE_SIDE_EFFECTS (captures[1]))
679 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
680 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 197, __FILE__, __LINE__, true);
681 : return _r;
682 : }
683 : next_after_fail245:;
684 : return NULL_TREE;
685 : }
686 :
687 : tree
688 0 : generic_simplify_150 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
689 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
690 : const enum tree_code ARG_UNUSED (op))
691 : {
692 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
693 0 : if (bitwise_equal_p (captures[4], captures[7])
694 : )
695 : {
696 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail252;
697 0 : {
698 0 : tree res_op0;
699 0 : {
700 0 : tree _o1[2], _r1;
701 0 : {
702 0 : tree _o2[2], _r2;
703 0 : _o2[0] = captures[5];
704 0 : {
705 0 : tree _o3[1], _r3;
706 0 : _o3[0] = captures[6];
707 0 : if (TREE_TYPE (_o3[0]) != TREE_TYPE (_o2[0]))
708 : {
709 0 : _r3 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o2[0]), _o3[0]);
710 : }
711 : else
712 : _r3 = _o3[0];
713 0 : _o2[1] = _r3;
714 : }
715 0 : _r2 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
716 0 : _o1[0] = _r2;
717 : }
718 0 : {
719 0 : tree _o2[1], _r2;
720 0 : _o2[0] = captures[4];
721 0 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o1[0]))
722 : {
723 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
724 : }
725 : else
726 : _r2 = _o2[0];
727 0 : _o1[1] = _r2;
728 : }
729 0 : _r1 = fold_build2_loc (loc, BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
730 0 : res_op0 = _r1;
731 : }
732 0 : tree _r;
733 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
734 0 : if (TREE_SIDE_EFFECTS (captures[7]))
735 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[7]), _r);
736 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 201, __FILE__, __LINE__, true);
737 0 : return _r;
738 : }
739 0 : next_after_fail252:;
740 : }
741 : return NULL_TREE;
742 : }
743 :
744 : tree
745 0 : generic_simplify_163 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
746 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
747 : {
748 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
749 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail287;
750 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail287;
751 0 : {
752 0 : tree _r;
753 0 : _r = captures[2];
754 0 : if (TREE_SIDE_EFFECTS (captures[1]))
755 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
756 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 208, __FILE__, __LINE__, true);
757 : return _r;
758 : }
759 : next_after_fail287:;
760 : return NULL_TREE;
761 : }
762 :
763 : tree
764 0 : generic_simplify_166 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
765 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
766 : const enum tree_code ARG_UNUSED (eqne))
767 : {
768 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
769 0 : if (eqne == EQ_EXPR
770 : )
771 : {
772 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail290;
773 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail290;
774 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail290;
775 0 : {
776 0 : tree _r;
777 0 : _r = captures[0];
778 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 230, __FILE__, __LINE__, true);
779 0 : return _r;
780 : }
781 : next_after_fail290:;
782 : }
783 : else
784 : {
785 0 : if (eqne == NE_EXPR
786 : )
787 : {
788 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail291;
789 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail291;
790 0 : {
791 0 : tree _r;
792 0 : _r = constant_boolean_node (true, type);
793 0 : if (TREE_SIDE_EFFECTS (captures[2]))
794 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
795 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 231, __FILE__, __LINE__, true);
796 0 : return _r;
797 : }
798 : next_after_fail291:;
799 : }
800 : }
801 : return NULL_TREE;
802 : }
803 :
804 : tree
805 8 : generic_simplify_172 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
806 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
807 : const enum tree_code ARG_UNUSED (eqne))
808 : {
809 8 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
810 8 : if (eqne == EQ_EXPR
811 : )
812 : {
813 4 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail309;
814 4 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail309;
815 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail309;
816 4 : {
817 4 : tree _r;
818 4 : _r = captures[0];
819 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 230, __FILE__, __LINE__, true);
820 4 : return _r;
821 : }
822 : next_after_fail309:;
823 : }
824 : else
825 : {
826 4 : if (eqne == NE_EXPR
827 : )
828 : {
829 4 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail310;
830 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail310;
831 4 : {
832 4 : tree _r;
833 4 : _r = constant_boolean_node (true, type);
834 4 : if (TREE_SIDE_EFFECTS (captures[2]))
835 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
836 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 231, __FILE__, __LINE__, true);
837 4 : return _r;
838 : }
839 : next_after_fail310:;
840 : }
841 : }
842 : return NULL_TREE;
843 : }
844 :
845 : tree
846 4 : generic_simplify_181 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
847 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
848 : const combined_fn ARG_UNUSED (COPYSIGN_ALL))
849 : {
850 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
851 4 : if (!tree_expr_maybe_nan_p (captures[0]) && !HONOR_SIGNED_ZEROS (type)
852 : )
853 : {
854 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail319;
855 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail319;
856 0 : {
857 0 : tree res_op0;
858 0 : res_op0 = captures[0];
859 0 : tree _r;
860 0 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
861 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 237, __FILE__, __LINE__, true);
862 0 : return _r;
863 : }
864 : next_after_fail319:;
865 : }
866 : return NULL_TREE;
867 : }
868 :
869 : tree
870 6423046 : generic_simplify_184 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
871 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
872 : const enum tree_code ARG_UNUSED (op))
873 : {
874 6423046 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
875 6423046 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail322;
876 6423046 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail322;
877 6423046 : {
878 6423046 : tree res_op0;
879 6423046 : res_op0 = captures[0];
880 6423046 : tree _r;
881 6423046 : _r = non_lvalue_loc (loc, res_op0);
882 6423046 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 239, __FILE__, __LINE__, true);
883 : return _r;
884 : }
885 : next_after_fail322:;
886 : return NULL_TREE;
887 : }
888 :
889 : tree
890 3 : generic_simplify_187 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
891 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
892 : {
893 3 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
894 3 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail325;
895 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail325;
896 3 : {
897 3 : tree _r;
898 3 : _r = build_zero_cst (type);
899 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 242, __FILE__, __LINE__, true);
900 : return _r;
901 : }
902 : next_after_fail325:;
903 : return NULL_TREE;
904 : }
905 :
906 : tree
907 1206 : generic_simplify_192 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
908 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
909 : const enum tree_code ARG_UNUSED (cmp))
910 : {
911 1206 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
912 1206 : if (fold_before_rtl_expansion_p ()
913 : )
914 : {
915 0 : if (INTEGRAL_TYPE_P (type)
916 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
917 : )
918 : {
919 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail332;
920 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail332;
921 0 : {
922 0 : tree res_op0;
923 0 : res_op0 = captures[0];
924 0 : tree res_op1;
925 0 : res_op1 = captures[3];
926 0 : tree res_op2;
927 0 : res_op2 = build_zero_cst (type);
928 0 : tree _r;
929 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
930 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 246, __FILE__, __LINE__, true);
931 0 : return _r;
932 : }
933 : next_after_fail332:;
934 : }
935 : }
936 : return NULL_TREE;
937 : }
938 :
939 : tree
940 5558 : generic_simplify_198 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
941 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
942 : const enum tree_code ARG_UNUSED (op))
943 : {
944 5558 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
945 5558 : {
946 5558 : poly_widest_int factor;
947 5558 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[2]))
948 5527 : && tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[2]))
949 11085 : && multiple_p (wi::to_poly_widest (captures[3]), wi::to_widest (captures[1]), &factor)
950 : )
951 : {
952 5481 : {
953 5481 : wi::overflow_type overflow;
954 5481 : wide_int mul;
955 5481 : if (types_match (type, TREE_TYPE (captures[2]))
956 5435 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[2]))
957 0 : && TREE_CODE (captures[2]) == INTEGER_CST
958 0 : && TREE_CODE (captures[3]) == INTEGER_CST
959 5481 : && (mul = wi::mul (wi::to_wide (captures[2]), wi::to_wide (captures[3]),
960 0 : TYPE_SIGN (type), &overflow),
961 0 : !overflow)
962 5481 : && (TYPE_UNSIGNED (type)
963 5481 : || known_eq (factor, 1)
964 0 : || (get_range_pos_neg (captures[0])
965 0 : | (((op == PLUS_EXPR) ^ (tree_int_cst_sgn (captures[2]) < 0))
966 0 : ? 1 : 2)) != 3)
967 : )
968 : {
969 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail338;
970 0 : {
971 0 : tree res_op0;
972 0 : {
973 0 : tree _o1[2], _r1;
974 0 : _o1[0] = captures[0];
975 0 : _o1[1] = wide_int_to_tree (type, factor);
976 0 : _r1 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
977 0 : res_op0 = _r1;
978 : }
979 0 : tree res_op1;
980 0 : res_op1 = wide_int_to_tree (type, mul);
981 0 : tree _r;
982 0 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
983 0 : if (TREE_SIDE_EFFECTS (captures[1]))
984 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
985 0 : if (TREE_SIDE_EFFECTS (captures[2]))
986 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
987 0 : if (TREE_SIDE_EFFECTS (captures[3]))
988 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
989 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 251, __FILE__, __LINE__, true);
990 0 : return _r;
991 : }
992 0 : next_after_fail338:;
993 : }
994 : else
995 : {
996 5481 : {
997 5481 : tree utype = unsigned_type_for (type);
998 5481 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail339;
999 5481 : {
1000 5481 : tree res_op0;
1001 5481 : {
1002 5481 : tree _o1[2], _r1;
1003 5481 : {
1004 5481 : tree _o2[2], _r2;
1005 5481 : {
1006 5481 : tree _o3[1], _r3;
1007 5481 : _o3[0] = captures[0];
1008 5481 : if (TREE_TYPE (_o3[0]) != utype)
1009 : {
1010 5481 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
1011 : }
1012 : else
1013 : _r3 = _o3[0];
1014 5481 : _o2[0] = _r3;
1015 : }
1016 5481 : _o2[1] = wide_int_to_tree (utype, factor);
1017 5481 : _r2 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
1018 5481 : _o1[0] = _r2;
1019 : }
1020 5481 : {
1021 5481 : tree _o2[2], _r2;
1022 5481 : {
1023 5481 : tree _o3[1], _r3;
1024 5481 : _o3[0] = captures[3];
1025 5481 : if (TREE_TYPE (_o3[0]) != utype)
1026 : {
1027 14 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
1028 : }
1029 : else
1030 : _r3 = _o3[0];
1031 5481 : _o2[0] = _r3;
1032 : }
1033 5481 : {
1034 5481 : tree _o3[1], _r3;
1035 5481 : _o3[0] = captures[2];
1036 5481 : if (TREE_TYPE (_o3[0]) != utype)
1037 : {
1038 46 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
1039 : }
1040 : else
1041 : _r3 = _o3[0];
1042 5481 : _o2[1] = _r3;
1043 : }
1044 5481 : _r2 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
1045 5481 : _o1[1] = _r2;
1046 : }
1047 5481 : _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1048 5481 : res_op0 = _r1;
1049 : }
1050 5481 : tree _r;
1051 5481 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1052 5481 : if (TREE_SIDE_EFFECTS (captures[1]))
1053 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1054 5481 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 252, __FILE__, __LINE__, true);
1055 5481 : return _r;
1056 : }
1057 0 : next_after_fail339:;
1058 : }
1059 : }
1060 0 : }
1061 : }
1062 5558 : }
1063 77 : return NULL_TREE;
1064 : }
1065 :
1066 : tree
1067 6 : generic_simplify_228 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1068 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1069 : const enum tree_code ARG_UNUSED (neeq))
1070 : {
1071 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1072 6 : {
1073 6 : poly_int64 diff; tree inner_type = TREE_TYPE (captures[1]);
1074 6 : if (ptr_difference_const (captures[0], captures[2], &diff)
1075 : )
1076 : {
1077 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail385;
1078 0 : {
1079 0 : tree res_op0;
1080 0 : {
1081 0 : tree _o1[2], _r1;
1082 0 : _o1[0] = build_int_cst_type (inner_type, diff);
1083 0 : _o1[1] = captures[1];
1084 0 : _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1085 0 : res_op0 = _r1;
1086 : }
1087 0 : tree res_op1;
1088 0 : res_op1 = captures[3];
1089 0 : tree _r;
1090 0 : _r = fold_build2_loc (loc, neeq, type, res_op0, res_op1);
1091 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1092 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1093 0 : if (TREE_SIDE_EFFECTS (captures[2]))
1094 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1095 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 296, __FILE__, __LINE__, true);
1096 0 : return _r;
1097 : }
1098 0 : next_after_fail385:;
1099 : }
1100 : }
1101 6 : return NULL_TREE;
1102 : }
1103 :
1104 : tree
1105 0 : generic_simplify_239 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1106 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1107 : const enum tree_code ARG_UNUSED (cmp),
1108 : const enum tree_code ARG_UNUSED (icmp))
1109 : {
1110 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1111 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1112 : )
1113 : {
1114 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail400;
1115 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail400;
1116 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail400;
1117 0 : {
1118 0 : tree res_op0;
1119 0 : res_op0 = captures[0];
1120 0 : tree res_op1;
1121 0 : res_op1 = wide_int_to_tree (TREE_TYPE (captures[0]),
1122 0 : wi::exact_log2 (wi::to_wide (captures[1])));
1123 0 : tree _r;
1124 0 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
1125 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 311, __FILE__, __LINE__, true);
1126 0 : return _r;
1127 : }
1128 : next_after_fail400:;
1129 : }
1130 : return NULL_TREE;
1131 : }
1132 :
1133 : tree
1134 0 : generic_simplify_243 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1135 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1136 : const enum tree_code ARG_UNUSED (rotate),
1137 : const enum tree_code ARG_UNUSED (invrot),
1138 : const enum tree_code ARG_UNUSED (cmp))
1139 : {
1140 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1141 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail412;
1142 0 : {
1143 0 : tree res_op0;
1144 0 : res_op0 = captures[0];
1145 0 : tree res_op1;
1146 0 : res_op1 = captures[2];
1147 0 : tree _r;
1148 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1149 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1150 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1151 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 323, __FILE__, __LINE__, true);
1152 : return _r;
1153 : }
1154 0 : next_after_fail412:;
1155 0 : return NULL_TREE;
1156 : }
1157 :
1158 : tree
1159 27 : generic_simplify_248 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1160 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1161 : const enum tree_code ARG_UNUSED (cmp),
1162 : const combined_fn ARG_UNUSED (bswap))
1163 : {
1164 27 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1165 27 : {
1166 27 : tree ctype = TREE_TYPE (captures[1]);
1167 27 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail417;
1168 27 : {
1169 27 : tree res_op0;
1170 27 : {
1171 27 : tree _o1[1], _r1;
1172 27 : _o1[0] = captures[0];
1173 27 : if (TREE_TYPE (_o1[0]) != ctype)
1174 : {
1175 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, ctype, _o1[0]);
1176 : }
1177 : else
1178 : _r1 = _o1[0];
1179 27 : res_op0 = _r1;
1180 : }
1181 27 : tree res_op1;
1182 27 : {
1183 27 : tree _o1[1], _r1;
1184 27 : _o1[0] = captures[1];
1185 27 : _r1 = maybe_build_call_expr_loc (loc, bswap, TREE_TYPE (_o1[0]), 1, _o1[0]);
1186 27 : if (!_r1)
1187 0 : goto next_after_fail417;
1188 27 : if (EXPR_P (_r1))
1189 27 : goto next_after_fail417;
1190 0 : res_op1 = _r1;
1191 : }
1192 0 : tree _r;
1193 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1194 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 328, __FILE__, __LINE__, true);
1195 : return _r;
1196 : }
1197 : next_after_fail417:;
1198 : }
1199 : return NULL_TREE;
1200 : }
1201 :
1202 : tree
1203 0 : generic_simplify_257 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1204 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1205 : const enum tree_code ARG_UNUSED (cmp))
1206 : {
1207 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1208 0 : if (single_use (captures[1]) && single_use (captures[3])
1209 : )
1210 : {
1211 0 : {
1212 0 : tree otype = TREE_TYPE (captures[0]);
1213 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail432;
1214 0 : {
1215 0 : tree res_op0;
1216 0 : {
1217 0 : tree _o1[1], _r1;
1218 0 : _o1[0] = captures[4];
1219 0 : if (TREE_TYPE (_o1[0]) != otype)
1220 : {
1221 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, otype, _o1[0]);
1222 : }
1223 : else
1224 : _r1 = _o1[0];
1225 0 : res_op0 = _r1;
1226 : }
1227 0 : tree res_op1;
1228 0 : {
1229 0 : tree _o1[1], _r1;
1230 0 : _o1[0] = captures[2];
1231 0 : if (TREE_TYPE (_o1[0]) != otype)
1232 : {
1233 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, otype, _o1[0]);
1234 : }
1235 : else
1236 : _r1 = _o1[0];
1237 0 : res_op1 = _r1;
1238 : }
1239 0 : tree _r;
1240 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1241 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 342, __FILE__, __LINE__, true);
1242 0 : return _r;
1243 : }
1244 0 : next_after_fail432:;
1245 : }
1246 : }
1247 0 : return NULL_TREE;
1248 : }
1249 :
1250 : tree
1251 22 : generic_simplify_263 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1252 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1253 : const combined_fn ARG_UNUSED (sq),
1254 : const enum tree_code ARG_UNUSED (cmp))
1255 : {
1256 22 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1257 22 : if (flag_unsafe_math_optimizations && ! flag_errno_math
1258 : )
1259 : {
1260 20 : if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (captures[1]))
1261 : )
1262 : {
1263 2 : if (cmp == EQ_EXPR || cmp == LT_EXPR || cmp == LE_EXPR
1264 : )
1265 : {
1266 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail452;
1267 1 : {
1268 1 : tree _r;
1269 1 : _r = constant_boolean_node (false, type);
1270 1 : if (TREE_SIDE_EFFECTS (captures[0]))
1271 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1272 1 : if (TREE_SIDE_EFFECTS (captures[1]))
1273 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1274 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 361, __FILE__, __LINE__, true);
1275 1 : return _r;
1276 : }
1277 0 : next_after_fail452:;
1278 0 : }
1279 : else
1280 : {
1281 1 : if (cmp == NE_EXPR || !HONOR_NANS (captures[0])
1282 : )
1283 : {
1284 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail453;
1285 1 : {
1286 1 : tree _r;
1287 1 : _r = constant_boolean_node (true, type);
1288 1 : if (TREE_SIDE_EFFECTS (captures[0]))
1289 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1290 1 : if (TREE_SIDE_EFFECTS (captures[1]))
1291 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1292 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 362, __FILE__, __LINE__, true);
1293 1 : return _r;
1294 : }
1295 0 : next_after_fail453:;
1296 : }
1297 : else
1298 : {
1299 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail454;
1300 0 : {
1301 0 : tree res_op0;
1302 0 : res_op0 = captures[0];
1303 0 : tree res_op1;
1304 0 : res_op1 = build_real (TREE_TYPE (captures[0]), dconst0);
1305 0 : tree _r;
1306 0 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
1307 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1308 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1309 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 363, __FILE__, __LINE__, true);
1310 0 : return _r;
1311 : }
1312 0 : next_after_fail454:;
1313 : }
1314 : }
1315 : }
1316 : else
1317 : {
1318 18 : if (real_equal (TREE_REAL_CST_PTR (captures[1]), &dconst0)
1319 : )
1320 : {
1321 0 : if (cmp == LT_EXPR
1322 : )
1323 : {
1324 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail455;
1325 0 : {
1326 0 : tree _r;
1327 0 : _r = constant_boolean_node (false, type);
1328 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1329 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1330 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1331 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1332 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 364, __FILE__, __LINE__, true);
1333 0 : return _r;
1334 : }
1335 0 : next_after_fail455:;
1336 : }
1337 : else
1338 : {
1339 0 : if (cmp == GE_EXPR && !HONOR_NANS (captures[0])
1340 : )
1341 : {
1342 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail456;
1343 0 : {
1344 0 : tree _r;
1345 0 : _r = constant_boolean_node (true, type);
1346 0 : if (TREE_SIDE_EFFECTS (captures[0]))
1347 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1348 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1349 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1350 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 365, __FILE__, __LINE__, true);
1351 0 : return _r;
1352 : }
1353 0 : next_after_fail456:;
1354 : }
1355 : else
1356 : {
1357 0 : if (cmp == LE_EXPR
1358 : )
1359 : {
1360 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail457;
1361 0 : {
1362 0 : tree res_op0;
1363 0 : res_op0 = captures[0];
1364 0 : tree res_op1;
1365 0 : res_op1 = captures[1];
1366 0 : tree _r;
1367 0 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
1368 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 366, __FILE__, __LINE__, true);
1369 0 : return _r;
1370 : }
1371 0 : next_after_fail457:;
1372 : }
1373 : else
1374 : {
1375 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail458;
1376 0 : {
1377 0 : tree res_op0;
1378 0 : res_op0 = captures[0];
1379 0 : tree res_op1;
1380 0 : res_op1 = captures[1];
1381 0 : tree _r;
1382 0 : _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1383 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 367, __FILE__, __LINE__, true);
1384 0 : return _r;
1385 : }
1386 0 : next_after_fail458:;
1387 : }
1388 : }
1389 : }
1390 : }
1391 : else
1392 : {
1393 18 : if ((cmp == LT_EXPR
1394 : || cmp == LE_EXPR
1395 : || cmp == GT_EXPR
1396 18 : || cmp == GE_EXPR)
1397 16 : && !REAL_VALUE_ISNAN (TREE_REAL_CST (captures[1]))
1398 34 : && !HONOR_SIGN_DEPENDENT_ROUNDING (TREE_TYPE (captures[0]))
1399 : )
1400 : {
1401 16 : {
1402 16 : REAL_VALUE_TYPE c2;
1403 16 : enum tree_code ncmp = cmp;
1404 16 : const real_format *fmt
1405 16 : = REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (captures[0])));
1406 32 : real_arithmetic (&c2, MULT_EXPR,
1407 16 : &TREE_REAL_CST (captures[1]), &TREE_REAL_CST (captures[1]));
1408 16 : real_convert (&c2, fmt, &c2);
1409 16 : if (!REAL_VALUE_ISINF (c2))
1410 : {
1411 13 : tree c3 = fold_const_call (CFN_SQRT, TREE_TYPE (captures[0]),
1412 13 : build_real (TREE_TYPE (captures[0]), c2));
1413 13 : if (c3 == NULL_TREE || TREE_CODE (c3) != REAL_CST)
1414 : ncmp = ERROR_MARK;
1415 13 : else if ((cmp == LT_EXPR || cmp == GE_EXPR)
1416 13 : && real_less (&TREE_REAL_CST (c3), &TREE_REAL_CST (captures[1])))
1417 4 : ncmp = cmp == LT_EXPR ? LE_EXPR : GT_EXPR;
1418 9 : else if ((cmp == LE_EXPR || cmp == GT_EXPR)
1419 13 : && real_less (&TREE_REAL_CST (captures[1]), &TREE_REAL_CST (c3)))
1420 1 : ncmp = cmp == LE_EXPR ? LT_EXPR : GE_EXPR;
1421 : else
1422 : {
1423 8 : REAL_VALUE_TYPE c2alt, tow;
1424 8 : if (cmp == LT_EXPR || cmp == GE_EXPR)
1425 5 : tow = dconst0;
1426 : else
1427 3 : tow = dconstinf;
1428 8 : real_nextafter (&c2alt, fmt, &c2, &tow);
1429 8 : real_convert (&c2alt, fmt, &c2alt);
1430 8 : if (REAL_VALUE_ISINF (c2alt))
1431 : ncmp = ERROR_MARK;
1432 : else
1433 : {
1434 8 : c3 = fold_const_call (CFN_SQRT, TREE_TYPE (captures[0]),
1435 8 : build_real (TREE_TYPE (captures[0]), c2alt));
1436 8 : if (c3 == NULL_TREE || TREE_CODE (c3) != REAL_CST)
1437 : ncmp = ERROR_MARK;
1438 8 : else if (real_equal (&TREE_REAL_CST (c3),
1439 8 : &TREE_REAL_CST (captures[1])))
1440 8 : c2 = c2alt;
1441 : }
1442 : }
1443 : }
1444 12 : if (cmp == GT_EXPR || cmp == GE_EXPR
1445 : )
1446 : {
1447 5 : if (REAL_VALUE_ISINF (c2)
1448 : )
1449 : {
1450 1 : if (HONOR_INFINITIES (captures[0])
1451 : )
1452 : {
1453 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail459;
1454 0 : {
1455 0 : tree res_op0;
1456 0 : res_op0 = captures[0];
1457 0 : tree res_op1;
1458 0 : res_op1 = build_real (TREE_TYPE (captures[0]), c2);
1459 0 : tree _r;
1460 0 : _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
1461 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1462 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1463 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 368, __FILE__, __LINE__, true);
1464 14 : return _r;
1465 : }
1466 0 : next_after_fail459:;
1467 : }
1468 : else
1469 : {
1470 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail460;
1471 1 : {
1472 1 : tree _r;
1473 1 : _r = constant_boolean_node (false, type);
1474 1 : if (TREE_SIDE_EFFECTS (captures[0]))
1475 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1476 1 : if (TREE_SIDE_EFFECTS (captures[1]))
1477 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1478 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 369, __FILE__, __LINE__, true);
1479 1 : return _r;
1480 : }
1481 0 : next_after_fail460:;
1482 : }
1483 : }
1484 : else
1485 : {
1486 4 : if (ncmp != ERROR_MARK
1487 : )
1488 : {
1489 4 : if (ncmp == GE_EXPR
1490 : )
1491 : {
1492 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail461;
1493 1 : {
1494 1 : tree res_op0;
1495 1 : res_op0 = captures[0];
1496 1 : tree res_op1;
1497 1 : res_op1 = build_real (TREE_TYPE (captures[0]), c2);
1498 1 : tree _r;
1499 1 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
1500 1 : if (TREE_SIDE_EFFECTS (captures[1]))
1501 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1502 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 370, __FILE__, __LINE__, true);
1503 1 : return _r;
1504 : }
1505 0 : next_after_fail461:;
1506 : }
1507 : else
1508 : {
1509 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail462;
1510 3 : {
1511 3 : tree res_op0;
1512 3 : res_op0 = captures[0];
1513 3 : tree res_op1;
1514 3 : res_op1 = build_real (TREE_TYPE (captures[0]), c2);
1515 3 : tree _r;
1516 3 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
1517 3 : if (TREE_SIDE_EFFECTS (captures[1]))
1518 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1519 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 371, __FILE__, __LINE__, true);
1520 3 : return _r;
1521 : }
1522 0 : next_after_fail462:;
1523 : }
1524 : }
1525 : }
1526 : }
1527 : else
1528 : {
1529 11 : if (REAL_VALUE_ISINF (c2)
1530 : )
1531 : {
1532 2 : if (! HONOR_NANS (captures[0]) && ! HONOR_INFINITIES (captures[0])
1533 : )
1534 : {
1535 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail463;
1536 1 : {
1537 1 : tree _r;
1538 1 : _r = constant_boolean_node (true, type);
1539 1 : if (TREE_SIDE_EFFECTS (captures[0]))
1540 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1541 1 : if (TREE_SIDE_EFFECTS (captures[1]))
1542 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1543 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 372, __FILE__, __LINE__, true);
1544 1 : return _r;
1545 : }
1546 0 : next_after_fail463:;
1547 : }
1548 : else
1549 : {
1550 1 : if (! HONOR_NANS (captures[0])
1551 : )
1552 : {
1553 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail464;
1554 0 : {
1555 0 : tree res_op0;
1556 0 : res_op0 = captures[0];
1557 0 : tree res_op1;
1558 0 : res_op1 = build_real (TREE_TYPE (captures[0]), c2);
1559 0 : tree _r;
1560 0 : _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
1561 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1562 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1563 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 373, __FILE__, __LINE__, true);
1564 0 : return _r;
1565 : }
1566 0 : next_after_fail464:;
1567 : }
1568 : else
1569 : {
1570 1 : if (! HONOR_INFINITIES (captures[0])
1571 : )
1572 : {
1573 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail465;
1574 0 : {
1575 0 : tree res_op0;
1576 0 : res_op0 = captures[0];
1577 0 : tree res_op1;
1578 0 : res_op1 = build_real (TREE_TYPE (captures[0]), dconst0);
1579 0 : tree _r;
1580 0 : _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
1581 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1582 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1583 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 374, __FILE__, __LINE__, true);
1584 0 : return _r;
1585 : }
1586 0 : next_after_fail465:;
1587 : }
1588 : else
1589 : {
1590 1 : if (1
1591 : )
1592 : {
1593 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail466;
1594 1 : {
1595 1 : if (! tree_invariant_p (captures[0])) goto next_after_fail466;
1596 0 : tree res_op0;
1597 0 : {
1598 0 : tree _o1[2], _r1;
1599 0 : _o1[0] = unshare_expr (captures[0]);
1600 0 : _o1[1] = build_real (TREE_TYPE (captures[0]), dconst0);
1601 0 : _r1 = fold_build2_loc (loc, GE_EXPR, type, _o1[0], _o1[1]);
1602 0 : res_op0 = _r1;
1603 : }
1604 0 : tree res_op1;
1605 0 : {
1606 0 : tree _o1[2], _r1;
1607 0 : _o1[0] = captures[0];
1608 0 : _o1[1] = build_real (TREE_TYPE (captures[0]), c2);
1609 0 : _r1 = fold_build2_loc (loc, NE_EXPR, type, _o1[0], _o1[1]);
1610 0 : res_op1 = _r1;
1611 : }
1612 0 : tree _r;
1613 0 : _r = fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type, res_op0, res_op1);
1614 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1615 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1616 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 375, __FILE__, __LINE__, true);
1617 0 : return _r;
1618 : }
1619 2 : next_after_fail466:;
1620 : }
1621 : }
1622 : }
1623 : }
1624 : }
1625 : else
1626 : {
1627 9 : if (ncmp != ERROR_MARK && ! HONOR_NANS (captures[0])
1628 : )
1629 : {
1630 8 : if (ncmp == LT_EXPR
1631 : )
1632 : {
1633 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail467;
1634 4 : {
1635 4 : tree res_op0;
1636 4 : res_op0 = captures[0];
1637 4 : tree res_op1;
1638 4 : res_op1 = build_real (TREE_TYPE (captures[0]), c2);
1639 4 : tree _r;
1640 4 : _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
1641 4 : if (TREE_SIDE_EFFECTS (captures[1]))
1642 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1643 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 376, __FILE__, __LINE__, true);
1644 4 : return _r;
1645 : }
1646 0 : next_after_fail467:;
1647 : }
1648 : else
1649 : {
1650 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail468;
1651 4 : {
1652 4 : tree res_op0;
1653 4 : res_op0 = captures[0];
1654 4 : tree res_op1;
1655 4 : res_op1 = build_real (TREE_TYPE (captures[0]), c2);
1656 4 : tree _r;
1657 4 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
1658 4 : if (TREE_SIDE_EFFECTS (captures[1]))
1659 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1660 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 377, __FILE__, __LINE__, true);
1661 4 : return _r;
1662 : }
1663 0 : next_after_fail468:;
1664 : }
1665 : }
1666 : else
1667 : {
1668 1 : if (ncmp != ERROR_MARK &&
1669 : 1
1670 : )
1671 : {
1672 1 : if (ncmp == LT_EXPR
1673 : )
1674 : {
1675 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail469;
1676 1 : {
1677 1 : if (! tree_invariant_p (captures[0])) goto next_after_fail469;
1678 0 : tree res_op0;
1679 0 : {
1680 0 : tree _o1[2], _r1;
1681 0 : _o1[0] = unshare_expr (captures[0]);
1682 0 : _o1[1] = build_real (TREE_TYPE (captures[0]), dconst0);
1683 0 : _r1 = fold_build2_loc (loc, GE_EXPR, type, _o1[0], _o1[1]);
1684 0 : res_op0 = _r1;
1685 : }
1686 0 : tree res_op1;
1687 0 : {
1688 0 : tree _o1[2], _r1;
1689 0 : _o1[0] = captures[0];
1690 0 : _o1[1] = build_real (TREE_TYPE (captures[0]), c2);
1691 0 : _r1 = fold_build2_loc (loc, LT_EXPR, type, _o1[0], _o1[1]);
1692 0 : res_op1 = _r1;
1693 : }
1694 0 : tree _r;
1695 0 : _r = fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type, res_op0, res_op1);
1696 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1697 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1698 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 378, __FILE__, __LINE__, true);
1699 0 : return _r;
1700 : }
1701 2 : next_after_fail469:;
1702 : }
1703 : else
1704 : {
1705 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail470;
1706 0 : {
1707 0 : if (! tree_invariant_p (captures[0])) goto next_after_fail470;
1708 0 : tree res_op0;
1709 0 : {
1710 0 : tree _o1[2], _r1;
1711 0 : _o1[0] = unshare_expr (captures[0]);
1712 0 : _o1[1] = build_real (TREE_TYPE (captures[0]), dconst0);
1713 0 : _r1 = fold_build2_loc (loc, GE_EXPR, type, _o1[0], _o1[1]);
1714 0 : res_op0 = _r1;
1715 : }
1716 0 : tree res_op1;
1717 0 : {
1718 0 : tree _o1[2], _r1;
1719 0 : _o1[0] = captures[0];
1720 0 : _o1[1] = build_real (TREE_TYPE (captures[0]), c2);
1721 0 : _r1 = fold_build2_loc (loc, LE_EXPR, type, _o1[0], _o1[1]);
1722 0 : res_op1 = _r1;
1723 : }
1724 0 : tree _r;
1725 0 : _r = fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type, res_op0, res_op1);
1726 0 : if (TREE_SIDE_EFFECTS (captures[1]))
1727 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1728 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 379, __FILE__, __LINE__, true);
1729 0 : return _r;
1730 : }
1731 2 : next_after_fail470:;
1732 : }
1733 : }
1734 : }
1735 : }
1736 : }
1737 : }
1738 : }
1739 : }
1740 : }
1741 : }
1742 : return NULL_TREE;
1743 : }
1744 :
1745 : tree
1746 6 : generic_simplify_337 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1747 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1748 : const combined_fn ARG_UNUSED (SIN),
1749 : const combined_fn ARG_UNUSED (COS),
1750 : const combined_fn ARG_UNUSED (TAN))
1751 : {
1752 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1753 6 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1754 : )
1755 : {
1756 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail609;
1757 6 : {
1758 6 : tree res_op0;
1759 6 : res_op0 = captures[1];
1760 6 : tree _r;
1761 6 : _r = maybe_build_call_expr_loc (loc, TAN, type, 1, res_op0);
1762 6 : if (!_r)
1763 0 : goto next_after_fail609;
1764 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 498, __FILE__, __LINE__, true);
1765 6 : return _r;
1766 : }
1767 : next_after_fail609:;
1768 : }
1769 : return NULL_TREE;
1770 : }
1771 :
1772 : tree
1773 24 : generic_simplify_344 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1774 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1775 : const combined_fn ARG_UNUSED (POW))
1776 : {
1777 24 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1778 24 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1779 : )
1780 : {
1781 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail616;
1782 6 : {
1783 6 : tree res_op0;
1784 6 : res_op0 = captures[0];
1785 6 : tree res_op1;
1786 6 : {
1787 6 : tree _o1[2], _r1;
1788 6 : _o1[0] = captures[2];
1789 6 : {
1790 6 : tree _o2[1], _r2;
1791 6 : _o2[0] = captures[3];
1792 6 : _r2 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
1793 6 : _o1[1] = _r2;
1794 : }
1795 6 : _r1 = maybe_build_call_expr_loc (loc, POW, TREE_TYPE (_o1[0]), 2, _o1[0], _o1[1]);
1796 6 : if (!_r1)
1797 0 : goto next_after_fail616;
1798 6 : res_op1 = _r1;
1799 : }
1800 6 : tree _r;
1801 6 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
1802 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 505, __FILE__, __LINE__, true);
1803 6 : return _r;
1804 : }
1805 : next_after_fail616:;
1806 : }
1807 : return NULL_TREE;
1808 : }
1809 :
1810 : tree
1811 0 : generic_simplify_353 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1812 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1813 : const enum tree_code ARG_UNUSED (cmp))
1814 : {
1815 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1816 0 : if (INTEGRAL_TYPE_P (type)
1817 : )
1818 : {
1819 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail631;
1820 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail631;
1821 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail631;
1822 0 : {
1823 0 : tree res_op0;
1824 0 : res_op0 = captures[0];
1825 0 : tree res_op1;
1826 0 : res_op1 = captures[1];
1827 0 : tree _r;
1828 0 : _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
1829 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 520, __FILE__, __LINE__, true);
1830 0 : return _r;
1831 : }
1832 : next_after_fail631:;
1833 : }
1834 : return NULL_TREE;
1835 : }
1836 :
1837 : tree
1838 0 : generic_simplify_357 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1839 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1840 : const enum tree_code ARG_UNUSED (op))
1841 : {
1842 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1843 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail635;
1844 0 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail635;
1845 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail635;
1846 0 : {
1847 0 : tree _r;
1848 0 : _r = captures[2];
1849 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 524, __FILE__, __LINE__, true);
1850 : return _r;
1851 : }
1852 : next_after_fail635:;
1853 : return NULL_TREE;
1854 : }
1855 :
1856 : tree
1857 51 : generic_simplify_362 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1858 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1859 : const enum tree_code ARG_UNUSED (op))
1860 : {
1861 51 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1862 51 : if (bitwise_equal_p (captures[0], captures[2])
1863 1 : && tree_expr_nonzero_p (captures[3])
1864 52 : && expr_no_side_effects_p (captures[2])
1865 : )
1866 : {
1867 1 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail640;
1868 1 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail640;
1869 1 : if (TREE_SIDE_EFFECTS (_p2)) goto next_after_fail640;
1870 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail640;
1871 1 : {
1872 1 : tree _r;
1873 1 : _r = captures[1];
1874 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 529, __FILE__, __LINE__, true);
1875 1 : return _r;
1876 : }
1877 : next_after_fail640:;
1878 : }
1879 : return NULL_TREE;
1880 : }
1881 :
1882 : tree
1883 6 : generic_simplify_369 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1884 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
1885 : const enum tree_code ARG_UNUSED (neeq),
1886 : const combined_fn ARG_UNUSED (sign))
1887 : {
1888 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1889 6 : if (neeq == NE_EXPR
1890 : )
1891 : {
1892 3 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail647;
1893 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail647;
1894 3 : {
1895 3 : tree res_op0;
1896 3 : res_op0 = captures[0];
1897 3 : tree _r;
1898 3 : _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
1899 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 536, __FILE__, __LINE__, true);
1900 3 : return _r;
1901 : }
1902 : next_after_fail647:;
1903 : }
1904 : else
1905 : {
1906 3 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail648;
1907 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail648;
1908 3 : {
1909 3 : tree res_op0;
1910 3 : {
1911 3 : tree _o1[1], _r1;
1912 3 : _o1[0] = captures[0];
1913 3 : _r1 = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
1914 3 : res_op0 = _r1;
1915 : }
1916 3 : tree _r;
1917 3 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
1918 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 537, __FILE__, __LINE__, true);
1919 3 : return _r;
1920 : }
1921 : next_after_fail648:;
1922 : }
1923 : return NULL_TREE;
1924 : }
1925 :
1926 : tree
1927 83965 : generic_simplify_382 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1928 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1929 : const enum tree_code ARG_UNUSED (op))
1930 : {
1931 83965 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1932 167930 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1933 83965 : && TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1934 167930 : && wi::only_sign_bit_p (wi::to_wide (captures[1]))
1935 : )
1936 : {
1937 5 : {
1938 5 : tree stype = signed_type_for (TREE_TYPE (captures[1]));
1939 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail665;
1940 5 : {
1941 5 : tree res_op0;
1942 5 : {
1943 5 : tree _o1[1], _r1;
1944 5 : _o1[0] = captures[0];
1945 5 : if (TREE_TYPE (_o1[0]) != stype)
1946 : {
1947 5 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
1948 : }
1949 : else
1950 : _r1 = _o1[0];
1951 5 : res_op0 = _r1;
1952 : }
1953 5 : tree res_op1;
1954 5 : {
1955 5 : tree _o1[1], _r1;
1956 5 : _o1[0] = captures[2];
1957 5 : if (TREE_TYPE (_o1[0]) != stype)
1958 : {
1959 5 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
1960 : }
1961 : else
1962 : _r1 = _o1[0];
1963 5 : res_op1 = _r1;
1964 : }
1965 5 : tree _r;
1966 5 : _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1967 5 : if (TREE_SIDE_EFFECTS (captures[1]))
1968 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1969 5 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 552, __FILE__, __LINE__, true);
1970 5 : return _r;
1971 : }
1972 0 : next_after_fail665:;
1973 : }
1974 : }
1975 : return NULL_TREE;
1976 : }
1977 :
1978 : tree
1979 9669325 : generic_simplify_392 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
1980 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
1981 : const enum tree_code ARG_UNUSED (cmp),
1982 : const enum tree_code ARG_UNUSED (acmp))
1983 : {
1984 9669325 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1985 9669325 : {
1986 9669325 : tree cst = uniform_integer_cst_p (captures[1]);
1987 9669325 : if (tree_int_cst_sgn (cst) == 1
1988 : )
1989 : {
1990 3949104 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail676;
1991 3949104 : {
1992 3949104 : tree res_op0;
1993 3949104 : res_op0 = captures[0];
1994 3949104 : tree res_op1;
1995 3949104 : res_op1 = build_uniform_cst (TREE_TYPE (captures[1]),
1996 3949104 : wide_int_to_tree (TREE_TYPE (cst),
1997 3949104 : wi::to_wide (cst) - 1));
1998 3949104 : tree _r;
1999 3949104 : _r = fold_build2_loc (loc, acmp, type, res_op0, res_op1);
2000 3949104 : if (TREE_SIDE_EFFECTS (captures[1]))
2001 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2002 3949104 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 563, __FILE__, __LINE__, true);
2003 3949104 : return _r;
2004 : }
2005 0 : next_after_fail676:;
2006 : }
2007 : }
2008 : return NULL_TREE;
2009 : }
2010 :
2011 : tree
2012 0 : generic_simplify_402 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2013 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2014 : const enum tree_code ARG_UNUSED (cmp),
2015 : const enum tree_code ARG_UNUSED (out))
2016 : {
2017 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2018 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[1]))
2019 0 : && types_match (TREE_TYPE (captures[1]), TREE_TYPE (captures[2]))
2020 : )
2021 : {
2022 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail718;
2023 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail718;
2024 0 : {
2025 0 : tree res_op0;
2026 0 : {
2027 0 : tree _o1[1], _r1;
2028 0 : _o1[0] = captures[0];
2029 0 : _r1 = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
2030 0 : res_op0 = _r1;
2031 : }
2032 0 : tree res_op1;
2033 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[1]));
2034 0 : tree _r;
2035 0 : _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
2036 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 588, __FILE__, __LINE__, true);
2037 0 : return _r;
2038 : }
2039 : next_after_fail718:;
2040 : }
2041 : return NULL_TREE;
2042 : }
2043 :
2044 : tree
2045 755562 : generic_simplify_408 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2046 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2047 : const enum tree_code ARG_UNUSED (cmp),
2048 : const enum tree_code ARG_UNUSED (icmp))
2049 : {
2050 755562 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2051 1508222 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2052 755562 : && TYPE_UNSIGNED (TREE_TYPE (captures[0]))
2053 335632 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > 1
2054 1846756 : && (wi::to_wide (captures[2])
2055 1762458 : == wi::max_value (TYPE_PRECISION (TREE_TYPE (captures[0])), SIGNED) - 1)
2056 : )
2057 : {
2058 4544 : {
2059 4544 : tree stype = signed_type_for (TREE_TYPE (captures[0]));
2060 4544 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail731;
2061 4544 : {
2062 4544 : tree res_op0;
2063 4544 : {
2064 4544 : tree _o1[1], _r1;
2065 4544 : _o1[0] = captures[0];
2066 4544 : if (TREE_TYPE (_o1[0]) != stype)
2067 : {
2068 4544 : _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
2069 : }
2070 : else
2071 : _r1 = _o1[0];
2072 4544 : res_op0 = _r1;
2073 : }
2074 4544 : tree res_op1;
2075 4544 : res_op1 = build_int_cst (stype, 0);
2076 4544 : tree _r;
2077 4544 : _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
2078 4544 : if (TREE_SIDE_EFFECTS (captures[1]))
2079 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2080 4544 : if (TREE_SIDE_EFFECTS (captures[2]))
2081 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2082 4544 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 601, __FILE__, __LINE__, true);
2083 4544 : return _r;
2084 : }
2085 0 : next_after_fail731:;
2086 : }
2087 : }
2088 : return NULL_TREE;
2089 : }
2090 :
2091 : tree
2092 0 : generic_simplify_414 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2093 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2094 : const enum tree_code ARG_UNUSED (cmp),
2095 : const enum tree_code ARG_UNUSED (out))
2096 : {
2097 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2098 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2])) && !VECTOR_TYPE_P (TREE_TYPE (captures[2]))
2099 : )
2100 : {
2101 0 : {
2102 0 : tree t = TREE_TYPE (captures[2]), cpx = build_complex_type (t);
2103 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail737;
2104 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail737;
2105 0 : {
2106 0 : tree res_op0;
2107 0 : {
2108 0 : tree _o1[1], _r1;
2109 0 : {
2110 0 : tree _o2[2], _r2;
2111 0 : _o2[0] = captures[2];
2112 0 : _o2[1] = captures[1];
2113 0 : _r2 = maybe_build_call_expr_loc (loc, CFN_MUL_OVERFLOW, cpx, 2, _o2[0], _o2[1]);
2114 0 : if (!_r2)
2115 0 : goto next_after_fail737;
2116 0 : _o1[0] = _r2;
2117 : }
2118 0 : _r1 = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
2119 0 : res_op0 = _r1;
2120 : }
2121 0 : tree res_op1;
2122 0 : res_op1 = build_zero_cst (t);
2123 0 : tree _r;
2124 0 : _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
2125 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 589, __FILE__, __LINE__, true);
2126 0 : return _r;
2127 : }
2128 : next_after_fail737:;
2129 : }
2130 : }
2131 : return NULL_TREE;
2132 : }
2133 :
2134 : tree
2135 387 : generic_simplify_420 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2136 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2137 : const enum tree_code ARG_UNUSED (shift),
2138 : const enum tree_code ARG_UNUSED (mod))
2139 : {
2140 387 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2141 387 : if (integer_pow2p (captures[3]) && tree_int_cst_sgn (captures[3]) > 0
2142 : )
2143 : {
2144 312 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail747;
2145 312 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail747;
2146 312 : {
2147 312 : tree res_op0;
2148 312 : res_op0 = captures[0];
2149 312 : tree res_op1;
2150 312 : {
2151 312 : tree _o1[2], _r1;
2152 312 : _o1[0] = captures[1];
2153 312 : {
2154 312 : tree _o2[2], _r2;
2155 312 : _o2[0] = captures[2];
2156 312 : _o2[1] = build_int_cst (TREE_TYPE (captures[2]),
2157 : 1);
2158 312 : _r2 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
2159 312 : _o1[1] = _r2;
2160 : }
2161 312 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2162 312 : res_op1 = _r1;
2163 : }
2164 312 : tree _r;
2165 312 : _r = fold_build2_loc (loc, shift, type, res_op0, res_op1);
2166 312 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 613, __FILE__, __LINE__, true);
2167 312 : return _r;
2168 : }
2169 : next_after_fail747:;
2170 : }
2171 : return NULL_TREE;
2172 : }
2173 :
2174 : tree
2175 271 : generic_simplify_431 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2176 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2177 : const combined_fn ARG_UNUSED (bswap))
2178 : {
2179 271 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2180 271 : if (BITS_PER_UNIT == 8
2181 : && CHAR_TYPE_SIZE == 8
2182 271 : && tree_fits_uhwi_p (captures[2])
2183 : )
2184 : {
2185 271 : {
2186 271 : unsigned HOST_WIDE_INT prec = TYPE_PRECISION (TREE_TYPE (captures[0]));
2187 271 : unsigned HOST_WIDE_INT bits = tree_to_uhwi (captures[2]);
2188 271 : tree st = TYPE_PRECISION (type) > prec ? TREE_TYPE (captures[0]) : type;
2189 271 : if (TYPE_PRECISION (type) > prec
2190 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
2191 0 : && TYPE_UNSIGNED (type)
2192 271 : && bits < prec && bits + 8 >= prec
2193 : )
2194 : {
2195 0 : {
2196 0 : tree nst = build_int_cst (integer_type_node, prec - 8);
2197 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail762;
2198 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail762;
2199 0 : {
2200 0 : tree res_op0;
2201 0 : {
2202 0 : tree _o1[1], _r1;
2203 0 : {
2204 0 : tree _o2[2], _r2;
2205 0 : {
2206 0 : tree _o3[1], _r3;
2207 0 : _o3[0] = captures[1];
2208 0 : if (TREE_TYPE (_o3[0]) != st)
2209 : {
2210 0 : _r3 = fold_build1_loc (loc, NOP_EXPR, st, _o3[0]);
2211 : }
2212 : else
2213 : _r3 = _o3[0];
2214 0 : _o2[0] = _r3;
2215 : }
2216 0 : _o2[1] = nst;
2217 0 : _r2 = fold_build2_loc (loc, LSHIFT_EXPR, st, _o2[0], _o2[1]);
2218 0 : _o1[0] = _r2;
2219 : }
2220 0 : if (TREE_TYPE (_o1[0]) != type)
2221 : {
2222 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2223 : }
2224 : else
2225 : _r1 = _o1[0];
2226 0 : res_op0 = _r1;
2227 : }
2228 0 : tree res_op1;
2229 0 : res_op1 = captures[2];
2230 0 : tree _r;
2231 0 : _r = fold_build2_loc (loc, RSHIFT_EXPR, type, res_op0, res_op1);
2232 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 626, __FILE__, __LINE__, true);
2233 0 : return _r;
2234 : }
2235 : next_after_fail762:;
2236 : }
2237 : }
2238 : else
2239 : {
2240 271 : if (bits + 8 == prec
2241 : )
2242 : {
2243 46 : if (TYPE_UNSIGNED (st)
2244 : )
2245 : {
2246 36 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail763;
2247 36 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail763;
2248 36 : {
2249 36 : tree res_op0;
2250 36 : {
2251 36 : tree _o1[1], _r1;
2252 36 : _o1[0] = captures[1];
2253 36 : if (TREE_TYPE (_o1[0]) != unsigned_char_type_node)
2254 : {
2255 36 : _r1 = fold_build1_loc (loc, NOP_EXPR, unsigned_char_type_node, _o1[0]);
2256 : }
2257 : else
2258 : _r1 = _o1[0];
2259 36 : res_op0 = _r1;
2260 : }
2261 36 : tree _r;
2262 36 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2263 36 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 627, __FILE__, __LINE__, true);
2264 36 : return _r;
2265 : }
2266 : next_after_fail763:;
2267 : }
2268 : else
2269 : {
2270 10 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail764;
2271 10 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail764;
2272 10 : {
2273 10 : tree res_op0;
2274 10 : {
2275 10 : tree _o1[1], _r1;
2276 10 : _o1[0] = captures[1];
2277 10 : if (TREE_TYPE (_o1[0]) != signed_char_type_node)
2278 : {
2279 10 : _r1 = fold_build1_loc (loc, NOP_EXPR, signed_char_type_node, _o1[0]);
2280 : }
2281 : else
2282 : _r1 = _o1[0];
2283 10 : res_op0 = _r1;
2284 : }
2285 10 : tree _r;
2286 10 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2287 10 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 628, __FILE__, __LINE__, true);
2288 10 : return _r;
2289 : }
2290 : next_after_fail764:;
2291 : }
2292 : }
2293 : else
2294 : {
2295 225 : if (bits < prec && bits + 8 > prec
2296 : )
2297 : {
2298 57 : {
2299 57 : tree nst = build_int_cst (integer_type_node, bits & 7);
2300 57 : tree bt = TYPE_UNSIGNED (st) ? unsigned_char_type_node
2301 57 : : signed_char_type_node;
2302 57 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail765;
2303 57 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail765;
2304 57 : {
2305 57 : tree res_op0;
2306 57 : {
2307 57 : tree _o1[2], _r1;
2308 57 : {
2309 57 : tree _o2[1], _r2;
2310 57 : _o2[0] = captures[1];
2311 57 : if (TREE_TYPE (_o2[0]) != bt)
2312 : {
2313 57 : _r2 = fold_build1_loc (loc, NOP_EXPR, bt, _o2[0]);
2314 : }
2315 : else
2316 : _r2 = _o2[0];
2317 57 : _o1[0] = _r2;
2318 : }
2319 57 : _o1[1] = nst;
2320 57 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, bt, _o1[0], _o1[1]);
2321 57 : res_op0 = _r1;
2322 : }
2323 57 : tree _r;
2324 57 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2325 57 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 629, __FILE__, __LINE__, true);
2326 57 : return _r;
2327 : }
2328 : next_after_fail765:;
2329 : }
2330 : }
2331 : }
2332 : }
2333 : }
2334 : }
2335 : return NULL_TREE;
2336 : }
2337 :
2338 : tree
2339 0 : generic_simplify_446 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2340 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2341 : const combined_fn ARG_UNUSED (pow))
2342 : {
2343 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2344 0 : if (flag_unsafe_math_optimizations
2345 : )
2346 : {
2347 0 : if (! HONOR_INFINITIES (type)
2348 0 : && ! flag_trapping_math
2349 0 : && ! flag_errno_math
2350 : )
2351 : {
2352 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail794;
2353 0 : {
2354 0 : tree res_op0;
2355 0 : res_op0 = captures[2];
2356 0 : tree res_op1;
2357 0 : {
2358 0 : tree _o1[1], _r1;
2359 0 : _o1[0] = captures[3];
2360 0 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2361 0 : res_op1 = _r1;
2362 : }
2363 0 : tree _r;
2364 0 : _r = maybe_build_call_expr_loc (loc, pow, type, 2, res_op0, res_op1);
2365 0 : if (!_r)
2366 0 : goto next_after_fail794;
2367 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2368 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2369 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 646, __FILE__, __LINE__, true);
2370 0 : return _r;
2371 : }
2372 : next_after_fail794:;
2373 : }
2374 : }
2375 : return NULL_TREE;
2376 : }
2377 :
2378 : tree
2379 0 : generic_simplify_449 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2380 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2381 : {
2382 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2383 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail797;
2384 0 : {
2385 0 : tree _r;
2386 0 : _r = captures[0];
2387 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2388 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2389 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 649, __FILE__, __LINE__, true);
2390 : return _r;
2391 : }
2392 0 : next_after_fail797:;
2393 0 : return NULL_TREE;
2394 : }
2395 :
2396 : tree
2397 0 : generic_simplify_453 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2398 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2399 : const combined_fn ARG_UNUSED (HYPOT))
2400 : {
2401 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2402 0 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
2403 : )
2404 : {
2405 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail801;
2406 0 : {
2407 0 : tree res_op0;
2408 0 : {
2409 0 : tree _o1[1], _r1;
2410 0 : _o1[0] = captures[0];
2411 0 : _r1 = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2412 0 : res_op0 = _r1;
2413 : }
2414 0 : tree res_op1;
2415 0 : res_op1 = build_real_truncate (type, dconst_sqrt2 ());
2416 0 : tree _r;
2417 0 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
2418 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 653, __FILE__, __LINE__, true);
2419 0 : return _r;
2420 : }
2421 0 : next_after_fail801:;
2422 : }
2423 : return NULL_TREE;
2424 : }
2425 :
2426 : tree
2427 129633 : generic_simplify_459 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2428 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2429 : {
2430 129633 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2431 129633 : {
2432 129633 : bool wascmp;
2433 129633 : if (bitwise_inverted_equal_p (captures[0], captures[1], wascmp)
2434 129633 : && (!wascmp || element_precision (type) == 1)
2435 : )
2436 : {
2437 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail807;
2438 1 : {
2439 1 : tree res_op0;
2440 1 : res_op0 = captures[0];
2441 1 : tree res_op1;
2442 1 : res_op1 = captures[2];
2443 1 : tree _r;
2444 1 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2445 1 : if (TREE_SIDE_EFFECTS (captures[1]))
2446 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2447 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 659, __FILE__, __LINE__, true);
2448 1 : return _r;
2449 : }
2450 0 : next_after_fail807:;
2451 : }
2452 : }
2453 129632 : return NULL_TREE;
2454 : }
2455 :
2456 : tree
2457 65 : generic_simplify_466 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2458 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2459 : {
2460 65 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2461 65 : if (INTEGRAL_TYPE_P (type)
2462 65 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2463 65 : && TREE_CODE (TREE_TYPE (captures[0])) != BOOLEAN_TYPE
2464 130 : && (!TYPE_UNSIGNED (TREE_TYPE (captures[0]))
2465 19 : || TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (captures[0])))
2466 : )
2467 : {
2468 65 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail814;
2469 65 : {
2470 65 : tree res_op0;
2471 65 : {
2472 65 : tree _o1[1], _r1;
2473 65 : _o1[0] = captures[0];
2474 65 : if (TREE_TYPE (_o1[0]) != type)
2475 : {
2476 20 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2477 : }
2478 : else
2479 : _r1 = _o1[0];
2480 65 : res_op0 = _r1;
2481 : }
2482 65 : tree res_op1;
2483 65 : res_op1 = captures[1];
2484 65 : tree _r;
2485 65 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
2486 65 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 665, __FILE__, __LINE__, true);
2487 65 : return _r;
2488 : }
2489 0 : next_after_fail814:;
2490 : }
2491 : return NULL_TREE;
2492 : }
2493 :
2494 : tree
2495 0 : generic_simplify_473 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2496 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2497 : const enum tree_code ARG_UNUSED (cmp))
2498 : {
2499 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2500 0 : if (fold_before_rtl_expansion_p ()
2501 : )
2502 : {
2503 0 : if (INTEGRAL_TYPE_P (type)
2504 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2505 : )
2506 : {
2507 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail821;
2508 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail821;
2509 0 : {
2510 0 : tree res_op0;
2511 0 : res_op0 = captures[0];
2512 0 : tree res_op1;
2513 0 : res_op1 = captures[3];
2514 0 : tree res_op2;
2515 0 : res_op2 = build_zero_cst (type);
2516 0 : tree _r;
2517 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
2518 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 671, __FILE__, __LINE__, true);
2519 0 : return _r;
2520 : }
2521 : next_after_fail821:;
2522 : }
2523 : }
2524 : return NULL_TREE;
2525 : }
2526 :
2527 : tree
2528 0 : generic_simplify_483 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2529 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2530 : {
2531 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2532 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail853;
2533 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail853;
2534 0 : {
2535 0 : tree _r;
2536 0 : _r = captures[2];
2537 0 : if (TREE_SIDE_EFFECTS (captures[1]))
2538 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2539 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 692, __FILE__, __LINE__, true);
2540 : return _r;
2541 : }
2542 : next_after_fail853:;
2543 : return NULL_TREE;
2544 : }
2545 :
2546 : tree
2547 4 : generic_simplify_488 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2548 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures))
2549 : {
2550 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2551 4 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail870;
2552 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail870;
2553 4 : {
2554 4 : tree _r;
2555 4 : _r = captures[2];
2556 4 : if (TREE_SIDE_EFFECTS (captures[1]))
2557 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2558 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 692, __FILE__, __LINE__, true);
2559 : return _r;
2560 : }
2561 : next_after_fail870:;
2562 : return NULL_TREE;
2563 : }
2564 :
2565 : tree
2566 66734 : generic_simplify_492 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2567 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2568 : const enum tree_code ARG_UNUSED (shift))
2569 : {
2570 66734 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2571 66734 : if (tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
2572 66734 : && TYPE_PRECISION (type) <= HOST_BITS_PER_WIDE_INT
2573 66618 : && tree_fits_uhwi_p (captures[4])
2574 66569 : && tree_to_uhwi (captures[4]) > 0
2575 133302 : && tree_to_uhwi (captures[4]) < TYPE_PRECISION (type)
2576 : )
2577 : {
2578 66568 : {
2579 66568 : unsigned int shiftc = tree_to_uhwi (captures[4]);
2580 66568 : unsigned HOST_WIDE_INT mask = TREE_INT_CST_LOW (captures[5]);
2581 66568 : unsigned HOST_WIDE_INT newmask, zerobits = 0;
2582 66568 : tree shift_type = TREE_TYPE (captures[2]);
2583 66568 : unsigned int prec;
2584 66568 : if (shift == LSHIFT_EXPR)
2585 28652 : zerobits = ((HOST_WIDE_INT_1U << shiftc) - 1);
2586 37916 : else if (shift == RSHIFT_EXPR
2587 37916 : && type_has_mode_precision_p (shift_type))
2588 : {
2589 37916 : prec = TYPE_PRECISION (TREE_TYPE (captures[2]));
2590 37916 : tree arg00 = captures[3];
2591 37916 : if (captures[2] != captures[3]
2592 37916 : && TYPE_UNSIGNED (TREE_TYPE (captures[3])))
2593 : {
2594 0 : tree inner_type = TREE_TYPE (captures[3]);
2595 0 : if (type_has_mode_precision_p (inner_type)
2596 0 : && TYPE_PRECISION (inner_type) < prec)
2597 : {
2598 0 : prec = TYPE_PRECISION (inner_type);
2599 0 : if (shiftc < prec)
2600 0 : shift_type = inner_type;
2601 : }
2602 : }
2603 37916 : zerobits = HOST_WIDE_INT_M1U;
2604 37916 : if (shiftc < prec)
2605 : {
2606 37916 : zerobits >>= HOST_BITS_PER_WIDE_INT - shiftc;
2607 37916 : zerobits <<= prec - shiftc;
2608 : }
2609 37916 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[2]))
2610 37916 : && prec == TYPE_PRECISION (TREE_TYPE (captures[2])))
2611 : {
2612 2896 : if ((mask & zerobits) == 0)
2613 2885 : shift_type = unsigned_type_for (TREE_TYPE (captures[2]));
2614 : else
2615 : zerobits = 0;
2616 : }
2617 : }
2618 66557 : if ((mask & zerobits) == mask
2619 : )
2620 : {
2621 3 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail876;
2622 3 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail876;
2623 3 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail876;
2624 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail876;
2625 3 : {
2626 3 : tree _r;
2627 3 : _r = build_int_cst (type, 0);
2628 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 695, __FILE__, __LINE__, true);
2629 3 : return _r;
2630 : }
2631 : next_after_fail876:;
2632 : }
2633 : else
2634 : {
2635 66565 : {
2636 66565 : newmask = mask | zerobits;
2637 66565 : if (newmask != mask && (newmask & (newmask + 1)) == 0
2638 : )
2639 : {
2640 : {
2641 18798 : for (prec = BITS_PER_UNIT;
2642 34708 : prec < HOST_BITS_PER_WIDE_INT; prec <<= 1)
2643 32466 : if (newmask == (HOST_WIDE_INT_1U << prec) - 1)
2644 : break;
2645 15910 : if (prec < HOST_BITS_PER_WIDE_INT
2646 2242 : || newmask == HOST_WIDE_INT_M1U
2647 : )
2648 : {
2649 13848 : {
2650 13848 : tree newmaskt = build_int_cst_type (TREE_TYPE (captures[5]), newmask);
2651 13848 : if (!tree_int_cst_equal (newmaskt, captures[5])
2652 : )
2653 : {
2654 13848 : if (shift_type != TREE_TYPE (captures[2])
2655 : )
2656 : {
2657 85 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail877;
2658 85 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail877;
2659 85 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail877;
2660 85 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail877;
2661 85 : {
2662 85 : tree res_op0;
2663 85 : {
2664 85 : tree _o1[1], _r1;
2665 85 : {
2666 85 : tree _o2[2], _r2;
2667 85 : {
2668 85 : tree _o3[1], _r3;
2669 85 : _o3[0] = captures[2];
2670 85 : if (TREE_TYPE (_o3[0]) != shift_type)
2671 : {
2672 85 : _r3 = fold_build1_loc (loc, NOP_EXPR, shift_type, _o3[0]);
2673 : }
2674 : else
2675 : _r3 = _o3[0];
2676 85 : _o2[0] = _r3;
2677 : }
2678 85 : _o2[1] = captures[4];
2679 85 : _r2 = fold_build2_loc (loc, shift, shift_type, _o2[0], _o2[1]);
2680 85 : _o1[0] = _r2;
2681 : }
2682 85 : if (TREE_TYPE (_o1[0]) != type)
2683 : {
2684 85 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2685 : }
2686 : else
2687 : _r1 = _o1[0];
2688 85 : res_op0 = _r1;
2689 : }
2690 85 : tree res_op1;
2691 85 : res_op1 = newmaskt;
2692 85 : tree _r;
2693 85 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2694 85 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 696, __FILE__, __LINE__, true);
2695 85 : return _r;
2696 : }
2697 : next_after_fail877:;
2698 : }
2699 : else
2700 : {
2701 13763 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail878;
2702 12635 : if (TREE_SIDE_EFFECTS (captures[5])) goto next_after_fail878;
2703 12635 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail878;
2704 12635 : {
2705 12635 : tree res_op0;
2706 12635 : res_op0 = captures[0];
2707 12635 : tree res_op1;
2708 12635 : res_op1 = newmaskt;
2709 12635 : tree _r;
2710 12635 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2711 12635 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 697, __FILE__, __LINE__, true);
2712 12635 : return _r;
2713 : }
2714 : next_after_fail878:;
2715 : }
2716 : }
2717 : }
2718 : }
2719 : }
2720 : }
2721 : }
2722 : }
2723 : }
2724 : }
2725 : return NULL_TREE;
2726 : }
2727 :
2728 : tree
2729 42 : generic_simplify_502 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2730 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2731 : {
2732 42 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2733 42 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail894;
2734 42 : {
2735 42 : tree res_op0;
2736 42 : res_op0 = captures[1];
2737 42 : tree res_op1;
2738 42 : {
2739 42 : tree _o1[1], _r1;
2740 42 : _o1[0] = captures[2];
2741 42 : _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2742 42 : res_op1 = _r1;
2743 : }
2744 42 : tree _r;
2745 42 : _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
2746 42 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 706, __FILE__, __LINE__, true);
2747 : return _r;
2748 : }
2749 0 : next_after_fail894:;
2750 0 : return NULL_TREE;
2751 : }
2752 :
2753 : tree
2754 31 : generic_simplify_507 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2755 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2756 : {
2757 31 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2758 31 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[2]))
2759 54 : && (element_precision (TREE_TYPE (captures[2]))
2760 23 : <= element_precision (TREE_TYPE (captures[3]))
2761 1 : || !TYPE_UNSIGNED (TREE_TYPE (captures[3])))
2762 : )
2763 : {
2764 22 : {
2765 22 : tree shift_type = TREE_TYPE (captures[2]);
2766 22 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail899;
2767 22 : {
2768 22 : tree res_op0;
2769 22 : {
2770 22 : tree _o1[2], _r1;
2771 22 : {
2772 22 : tree _o2[1], _r2;
2773 22 : _o2[0] = captures[3];
2774 22 : if (TREE_TYPE (_o2[0]) != shift_type)
2775 : {
2776 1 : _r2 = fold_build1_loc (loc, NOP_EXPR, shift_type, _o2[0]);
2777 : }
2778 : else
2779 : _r2 = _o2[0];
2780 22 : _o1[0] = _r2;
2781 : }
2782 22 : _o1[1] = captures[4];
2783 22 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2784 22 : res_op0 = _r1;
2785 : }
2786 22 : tree _r;
2787 22 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2788 22 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 711, __FILE__, __LINE__, true);
2789 22 : return _r;
2790 : }
2791 0 : next_after_fail899:;
2792 : }
2793 : }
2794 : return NULL_TREE;
2795 : }
2796 :
2797 : tree
2798 3786 : generic_simplify_519 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2799 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures))
2800 : {
2801 3786 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2802 3786 : if (!TYPE_SATURATING (type)
2803 : )
2804 : {
2805 3751 : if (!TYPE_OVERFLOW_SANITIZED (type)
2806 7524 : && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[0]))
2807 : )
2808 : {
2809 3773 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail912;
2810 3773 : {
2811 3773 : tree res_op0;
2812 3773 : {
2813 3773 : tree _o1[1], _r1;
2814 3773 : _o1[0] = captures[0];
2815 3773 : if (TREE_TYPE (_o1[0]) != type)
2816 : {
2817 31 : _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
2818 : }
2819 : else
2820 : _r1 = _o1[0];
2821 3773 : res_op0 = _r1;
2822 : }
2823 3773 : tree _r;
2824 3773 : _r = non_lvalue_loc (loc, res_op0);
2825 3773 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 722, __FILE__, __LINE__, true);
2826 3773 : return _r;
2827 : }
2828 0 : next_after_fail912:;
2829 : }
2830 : }
2831 : return NULL_TREE;
2832 : }
2833 :
2834 : tree
2835 0 : generic_simplify_526 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2836 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2837 : const enum tree_code ARG_UNUSED (minmax))
2838 : {
2839 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2840 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail920;
2841 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail920;
2842 0 : {
2843 0 : tree _r;
2844 0 : _r = captures[0];
2845 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 729, __FILE__, __LINE__, true);
2846 : return _r;
2847 : }
2848 : next_after_fail920:;
2849 : return NULL_TREE;
2850 : }
2851 :
2852 : tree
2853 0 : generic_simplify_534 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2854 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2855 : const enum tree_code ARG_UNUSED (minmax),
2856 : const enum tree_code ARG_UNUSED (cmp))
2857 : {
2858 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2859 0 : {
2860 0 : poly_int64 off0, off1;
2861 0 : tree base0, base1;
2862 0 : int equal = address_compare (cmp, TREE_TYPE (captures[0]), captures[1], captures[3], base0, base1,
2863 : off0, off1,
2864 : 1
2865 : );
2866 0 : if (equal == 1
2867 : )
2868 : {
2869 0 : if (minmax == MIN_EXPR
2870 : )
2871 : {
2872 0 : if (known_le (off0, off1)
2873 : )
2874 : {
2875 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail933;
2876 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail933;
2877 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail933;
2878 0 : {
2879 0 : tree _r;
2880 0 : _r = captures[0];
2881 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 738, __FILE__, __LINE__, true);
2882 0 : return _r;
2883 : }
2884 0 : next_after_fail933:;
2885 : }
2886 : else
2887 : {
2888 0 : if (known_gt (off0, off1)
2889 : )
2890 : {
2891 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail934;
2892 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail934;
2893 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail934;
2894 0 : {
2895 0 : tree _r;
2896 0 : _r = captures[2];
2897 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 739, __FILE__, __LINE__, true);
2898 0 : return _r;
2899 : }
2900 0 : next_after_fail934:;
2901 : }
2902 : }
2903 : }
2904 : else
2905 : {
2906 0 : if (known_ge (off0, off1)
2907 : )
2908 : {
2909 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail935;
2910 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail935;
2911 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail935;
2912 0 : {
2913 0 : tree _r;
2914 0 : _r = captures[0];
2915 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 740, __FILE__, __LINE__, true);
2916 0 : return _r;
2917 : }
2918 0 : next_after_fail935:;
2919 : }
2920 : else
2921 : {
2922 0 : if (known_lt (off0, off1)
2923 : )
2924 : {
2925 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail936;
2926 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail936;
2927 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail936;
2928 0 : {
2929 0 : tree _r;
2930 0 : _r = captures[2];
2931 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 741, __FILE__, __LINE__, true);
2932 0 : return _r;
2933 : }
2934 0 : next_after_fail936:;
2935 : }
2936 : }
2937 : }
2938 : }
2939 : }
2940 0 : return NULL_TREE;
2941 : }
2942 :
2943 : tree
2944 0 : generic_simplify_555 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2945 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures),
2946 : const combined_fn ARG_UNUSED (cond_len_op))
2947 : {
2948 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2949 0 : {
2950 0 : tree op_type = TREE_TYPE (captures[5]);
2951 0 : if (inverse_conditions_p (captures[0], captures[2])
2952 0 : && element_precision (type) == element_precision (op_type)
2953 : )
2954 : {
2955 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail963;
2956 0 : {
2957 0 : tree res_op0;
2958 0 : {
2959 0 : tree _o1[6], _r1;
2960 0 : _o1[0] = captures[2];
2961 0 : _o1[1] = captures[3];
2962 0 : _o1[2] = captures[4];
2963 0 : {
2964 0 : tree _o2[1], _r2;
2965 0 : _o2[0] = captures[1];
2966 0 : if (TREE_TYPE (_o2[0]) != op_type)
2967 : {
2968 0 : _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
2969 : }
2970 : else
2971 : _r2 = _o2[0];
2972 0 : _o1[3] = _r2;
2973 : }
2974 0 : _o1[4] = captures[6];
2975 0 : _o1[5] = captures[7];
2976 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]);
2977 0 : if (!_r1)
2978 0 : goto next_after_fail963;
2979 0 : res_op0 = _r1;
2980 : }
2981 0 : tree _r;
2982 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
2983 0 : if (TREE_SIDE_EFFECTS (captures[0]))
2984 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2985 0 : if (TREE_SIDE_EFFECTS (captures[5]))
2986 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
2987 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 755, __FILE__, __LINE__, true);
2988 0 : return _r;
2989 : }
2990 : next_after_fail963:;
2991 : }
2992 : }
2993 : return NULL_TREE;
2994 : }
2995 :
2996 : tree
2997 0 : generic_simplify_568 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
2998 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree *ARG_UNUSED (captures),
2999 : const enum tree_code ARG_UNUSED (cmp))
3000 : {
3001 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3002 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail979;
3003 0 : {
3004 0 : tree res_op0;
3005 0 : res_op0 = unshare_expr (captures[0]);
3006 0 : tree res_op1;
3007 0 : res_op1 = captures[0];
3008 0 : tree _r;
3009 0 : _r = fold_build2_loc (loc, UNORDERED_EXPR, type, res_op0, res_op1);
3010 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 771, __FILE__, __LINE__, true);
3011 : return _r;
3012 : }
3013 0 : next_after_fail979:;
3014 0 : return NULL_TREE;
3015 : }
3016 :
3017 : tree
3018 0 : generic_simplify_574 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3019 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3020 : const combined_fn ARG_UNUSED (logs),
3021 : const combined_fn ARG_UNUSED (pows))
3022 : {
3023 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3024 0 : if (flag_unsafe_math_optimizations
3025 : )
3026 : {
3027 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail985;
3028 0 : {
3029 0 : tree res_op0;
3030 0 : res_op0 = captures[1];
3031 0 : tree res_op1;
3032 0 : {
3033 0 : tree _o1[1], _r1;
3034 0 : _o1[0] = captures[0];
3035 0 : _r1 = maybe_build_call_expr_loc (loc, logs, TREE_TYPE (_o1[0]), 1, _o1[0]);
3036 0 : if (!_r1)
3037 0 : goto next_after_fail985;
3038 0 : res_op1 = _r1;
3039 : }
3040 0 : tree _r;
3041 0 : _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
3042 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 777, __FILE__, __LINE__, true);
3043 0 : return _r;
3044 : }
3045 : next_after_fail985:;
3046 : }
3047 : return NULL_TREE;
3048 : }
3049 :
3050 : tree
3051 0 : generic_simplify_582 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3052 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3053 : const combined_fn ARG_UNUSED (floors),
3054 : const combined_fn ARG_UNUSED (truncs))
3055 : {
3056 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3057 0 : if (canonicalize_math_p ()
3058 : )
3059 : {
3060 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail993;
3061 0 : {
3062 0 : tree res_op0;
3063 0 : res_op0 = captures[0];
3064 0 : tree _r;
3065 0 : _r = maybe_build_call_expr_loc (loc, truncs, type, 1, res_op0);
3066 0 : if (!_r)
3067 0 : goto next_after_fail993;
3068 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 785, __FILE__, __LINE__, true);
3069 0 : return _r;
3070 : }
3071 : next_after_fail993:;
3072 : }
3073 : return NULL_TREE;
3074 : }
3075 :
3076 : tree
3077 0 : generic_simplify_589 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3078 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3079 : const combined_fn ARG_UNUSED (ifn),
3080 : const combined_fn ARG_UNUSED (lfn),
3081 : const combined_fn ARG_UNUSED (llfn))
3082 : {
3083 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3084 0 : if (canonicalize_math_p ()
3085 : )
3086 : {
3087 0 : if (TYPE_PRECISION (integer_type_node)
3088 0 : == TYPE_PRECISION (long_integer_type_node)
3089 : )
3090 : {
3091 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1000;
3092 0 : {
3093 0 : tree res_op0;
3094 0 : res_op0 = captures[0];
3095 0 : tree _r;
3096 0 : _r = maybe_build_call_expr_loc (loc, lfn, type, 1, res_op0);
3097 0 : if (!_r)
3098 0 : goto next_after_fail1000;
3099 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 792, __FILE__, __LINE__, true);
3100 0 : return _r;
3101 : }
3102 : next_after_fail1000:;
3103 : }
3104 : }
3105 : return NULL_TREE;
3106 : }
3107 :
3108 : tree
3109 0 : generic_simplify_600 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3110 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree *ARG_UNUSED (captures))
3111 : {
3112 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3113 0 : if (canonicalize_math_after_vectorization_p ()
3114 : )
3115 : {
3116 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1011;
3117 : {
3118 : tree res_op0;
3119 : res_op0 = captures[0];
3120 : tree res_op1;
3121 : res_op1 = captures[1];
3122 : tree res_op2;
3123 : res_op2 = captures[2];
3124 : tree _r;
3125 : _r = maybe_build_call_expr_loc (loc, CFN_FMA, type, 3, res_op0, res_op1, res_op2);
3126 : if (!_r)
3127 : goto next_after_fail1011;
3128 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 803, __FILE__, __LINE__, true);
3129 : return _r;
3130 : }
3131 0 : next_after_fail1011:;
3132 : }
3133 0 : return NULL_TREE;
3134 : }
3135 :
3136 : tree
3137 0 : generic_simplify_609 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3138 : tree ARG_UNUSED (_p0), tree ARG_UNUSED (_p1), tree ARG_UNUSED (_p2), tree ARG_UNUSED (_p3), tree ARG_UNUSED (_p4), tree *ARG_UNUSED (captures))
3139 : {
3140 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3141 0 : if (canonicalize_math_after_vectorization_p ()
3142 : )
3143 : {
3144 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1020;
3145 : {
3146 : tree res_op0;
3147 : res_op0 = captures[0];
3148 : tree res_op1;
3149 : res_op1 = captures[1];
3150 : tree res_op2;
3151 : res_op2 = captures[2];
3152 : tree res_op3;
3153 : res_op3 = captures[3];
3154 : tree res_op4;
3155 : res_op4 = captures[4];
3156 : tree _r;
3157 : _r = maybe_build_call_expr_loc (loc, CFN_COND_FMS, type, 5, res_op0, res_op1, res_op2, res_op3, res_op4);
3158 : if (!_r)
3159 : goto next_after_fail1020;
3160 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 812, __FILE__, __LINE__, true);
3161 : return _r;
3162 : }
3163 0 : next_after_fail1020:;
3164 : }
3165 0 : return NULL_TREE;
3166 : }
3167 :
3168 : tree
3169 0 : generic_simplify_618 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3170 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3171 : const combined_fn ARG_UNUSED (POPCOUNT))
3172 : {
3173 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3174 0 : {
3175 0 : tree type0 = TREE_TYPE (captures[1]);
3176 0 : tree type2 = TREE_TYPE (captures[0]);
3177 0 : if (INTEGRAL_TYPE_P (type0)
3178 0 : && TYPE_PRECISION (type2) <= TYPE_PRECISION (type0)
3179 : )
3180 : {
3181 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1029;
3182 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1029;
3183 0 : {
3184 0 : tree res_op0;
3185 0 : {
3186 0 : tree _o1[2], _r1;
3187 0 : {
3188 0 : tree _o2[1], _r2;
3189 0 : _o2[0] = captures[2];
3190 0 : if (TREE_TYPE (_o2[0]) != type2)
3191 : {
3192 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, type2, _o2[0]);
3193 : }
3194 : else
3195 : _r2 = _o2[0];
3196 0 : _o1[0] = _r2;
3197 : }
3198 0 : _o1[1] = build_zero_cst (type2);
3199 0 : _r1 = fold_build2_loc (loc, NE_EXPR, boolean_type_node, _o1[0], _o1[1]);
3200 0 : res_op0 = _r1;
3201 : }
3202 0 : tree _r;
3203 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3204 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 818, __FILE__, __LINE__, true);
3205 0 : return _r;
3206 : }
3207 : next_after_fail1029:;
3208 : }
3209 : }
3210 : return NULL_TREE;
3211 : }
3212 :
3213 : tree
3214 0 : generic_simplify_627 (location_t ARG_UNUSED (loc), const tree ARG_UNUSED (type),
3215 : tree ARG_UNUSED (_p0), tree *ARG_UNUSED (captures),
3216 : const combined_fn ARG_UNUSED (reduc))
3217 : {
3218 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3219 0 : {
3220 0 : int i = single_nonzero_element (captures[1]);
3221 0 : if (i >= 0
3222 : )
3223 : {
3224 0 : {
3225 0 : tree elt = vector_cst_elt (captures[1], i);
3226 0 : tree elt_type = TREE_TYPE (elt);
3227 0 : unsigned int elt_bits = tree_to_uhwi (TYPE_SIZE (elt_type));
3228 0 : tree size = bitsize_int (elt_bits);
3229 0 : tree pos = bitsize_int (elt_bits * i);
3230 0 : if (compare_tree_int (TYPE_SIZE (type), elt_bits) == 0
3231 : )
3232 : {
3233 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1039;
3234 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1039;
3235 0 : {
3236 0 : tree res_op0;
3237 0 : {
3238 0 : tree _o1[2], _r1;
3239 0 : {
3240 0 : tree _o2[3], _r2;
3241 0 : _o2[0] = captures[0];
3242 0 : _o2[1] = size;
3243 0 : _o2[2] = pos;
3244 0 : _r2 = fold_build3_loc (loc, BIT_FIELD_REF, elt_type, _o2[0], _o2[1], _o2[2]);
3245 0 : _o1[0] = _r2;
3246 : }
3247 0 : _o1[1] = elt;
3248 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, elt_type, _o1[0], _o1[1]);
3249 0 : res_op0 = _r1;
3250 : }
3251 0 : tree _r;
3252 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3253 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 824, __FILE__, __LINE__, true);
3254 0 : return _r;
3255 : }
3256 : next_after_fail1039:;
3257 : }
3258 : }
3259 : }
3260 : }
3261 : return NULL_TREE;
3262 : }
3263 :
3264 : tree
3265 516002 : generic_simplify_FIX_TRUNC_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0)
3266 : {
3267 516002 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3268 516002 : {
3269 516002 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3270 1032004 : if ((
3271 :
3272 : && useless_type_conversion_p (type, TREE_TYPE (captures[0])))
3273 : || (
3274 : 1
3275 516002 : && type == TREE_TYPE (captures[0]))
3276 : )
3277 : {
3278 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1122;
3279 0 : {
3280 0 : tree _r;
3281 0 : _r = captures[0];
3282 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 839, __FILE__, __LINE__, true);
3283 0 : return _r;
3284 : }
3285 0 : next_after_fail1122:;
3286 : }
3287 : }
3288 516002 : switch (TREE_CODE (_p0))
3289 : {
3290 14982 : CASE_CONVERT:
3291 14982 : {
3292 14982 : tree _q20 = TREE_OPERAND (_p0, 0);
3293 14982 : {
3294 14982 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3295 14982 : {
3296 14982 : tree inside_type = TREE_TYPE (captures[1]);
3297 14982 : tree inter_type = TREE_TYPE (captures[0]);
3298 14982 : int inside_int = INTEGRAL_TYPE_P (inside_type);
3299 14982 : int inside_ptr = POINTER_TYPE_P (inside_type);
3300 14982 : int inside_float = FLOAT_TYPE_P (inside_type);
3301 14982 : int inside_vec = VECTOR_TYPE_P (inside_type);
3302 14982 : unsigned int inside_prec = element_precision (inside_type);
3303 14982 : int inside_unsignedp = TYPE_UNSIGNED (inside_type);
3304 14982 : int inter_int = INTEGRAL_TYPE_P (inter_type);
3305 14982 : int inter_ptr = POINTER_TYPE_P (inter_type);
3306 14982 : int inter_float = FLOAT_TYPE_P (inter_type);
3307 14982 : int inter_vec = VECTOR_TYPE_P (inter_type);
3308 14982 : unsigned int inter_prec = element_precision (inter_type);
3309 14982 : int inter_unsignedp = TYPE_UNSIGNED (inter_type);
3310 14982 : int final_int = INTEGRAL_TYPE_P (type);
3311 14982 : int final_ptr = POINTER_TYPE_P (type);
3312 14982 : int final_float = FLOAT_TYPE_P (type);
3313 14982 : int final_vec = VECTOR_TYPE_P (type);
3314 14982 : unsigned int final_prec = element_precision (type);
3315 14982 : int final_unsignedp = TYPE_UNSIGNED (type);
3316 14982 : if (((
3317 :
3318 : && useless_type_conversion_p (type, inside_type))
3319 : || (
3320 : 1
3321 14982 : && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
3322 0 : && (((inter_int || inter_ptr) && final_int)
3323 0 : || (inter_float && final_float))
3324 14982 : && inter_prec >= final_prec
3325 : )
3326 : {
3327 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1123;
3328 0 : {
3329 0 : tree res_op0;
3330 0 : res_op0 = captures[1];
3331 0 : tree _r;
3332 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3333 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 840, __FILE__, __LINE__, true);
3334 0 : return _r;
3335 : }
3336 0 : next_after_fail1123:;
3337 : }
3338 : else
3339 : {
3340 14982 : if (((inter_int && inside_int) || (inter_float && inside_float))
3341 14982 : && (final_int || final_float)
3342 14982 : && inter_prec >= inside_prec
3343 14764 : && (inter_float || inter_unsignedp == inside_unsignedp)
3344 : )
3345 : {
3346 14764 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1124;
3347 14764 : {
3348 14764 : tree res_op0;
3349 14764 : res_op0 = captures[1];
3350 14764 : tree _r;
3351 14764 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3352 14764 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 841, __FILE__, __LINE__, true);
3353 14764 : return _r;
3354 : }
3355 0 : next_after_fail1124:;
3356 0 : }
3357 : else
3358 : {
3359 218 : if (inside_int && inter_int && final_int
3360 0 : && ((inside_prec < inter_prec && inter_prec < final_prec
3361 0 : && inside_unsignedp && !inter_unsignedp)
3362 0 : || final_prec == inter_prec
3363 0 : || (inside_prec < inter_prec && inter_prec > final_prec
3364 0 : && !inside_unsignedp && inter_unsignedp))
3365 : )
3366 : {
3367 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1125;
3368 0 : {
3369 0 : tree res_op0;
3370 0 : res_op0 = captures[1];
3371 0 : tree _r;
3372 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3373 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 842, __FILE__, __LINE__, true);
3374 0 : return _r;
3375 : }
3376 0 : next_after_fail1125:;
3377 0 : }
3378 : else
3379 : {
3380 218 : if (! inside_float && ! inter_float && ! final_float
3381 : && ! inside_vec && ! inter_vec && ! final_vec
3382 0 : && (inter_prec >= inside_prec || inter_prec >= final_prec)
3383 0 : && ! (inside_int && inter_int
3384 0 : && inter_unsignedp != inside_unsignedp
3385 0 : && inter_prec < final_prec)
3386 0 : && ((inter_unsignedp && inter_prec > inside_prec)
3387 0 : == (final_unsignedp && final_prec > inter_prec))
3388 0 : && ! (inside_ptr && inter_prec != final_prec)
3389 0 : && ! (final_ptr && inside_prec != inter_prec)
3390 : )
3391 : {
3392 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1126;
3393 0 : {
3394 0 : tree res_op0;
3395 0 : res_op0 = captures[1];
3396 0 : tree _r;
3397 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3398 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 843, __FILE__, __LINE__, true);
3399 0 : return _r;
3400 : }
3401 0 : next_after_fail1126:;
3402 0 : }
3403 : else
3404 : {
3405 218 : if (inside_int && inter_int && final_int
3406 0 : && final_prec <= inside_prec
3407 0 : && inter_prec >= inside_prec
3408 : )
3409 : {
3410 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1127;
3411 0 : {
3412 0 : tree res_op0;
3413 0 : res_op0 = captures[1];
3414 0 : tree _r;
3415 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3416 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 844, __FILE__, __LINE__, true);
3417 0 : return _r;
3418 : }
3419 0 : next_after_fail1127:;
3420 0 : }
3421 : else
3422 : {
3423 : if (0
3424 : && final_int && inter_int && inside_int
3425 : && final_prec >= inside_prec
3426 : && inside_prec > inter_prec
3427 : && inter_unsignedp
3428 : )
3429 : {
3430 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1128;
3431 : {
3432 : tree res_op0;
3433 : {
3434 : tree _o1[2], _r1;
3435 : _o1[0] = captures[1];
3436 : _o1[1] = wide_int_to_tree
3437 : (inside_type,
3438 : wi::mask (inter_prec, false,
3439 : TYPE_PRECISION (inside_type)));
3440 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3441 : res_op0 = _r1;
3442 : }
3443 : tree _r;
3444 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3445 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 845, __FILE__, __LINE__, true);
3446 : return _r;
3447 : }
3448 : next_after_fail1128:;
3449 : }
3450 : else
3451 : {
3452 : if (0
3453 : && inside_int && inter_float && final_int &&
3454 : (unsigned) significand_size (TYPE_MODE (inter_type))
3455 : >= inside_prec - !inside_unsignedp
3456 : )
3457 : {
3458 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1129;
3459 : {
3460 : tree res_op0;
3461 : res_op0 = captures[1];
3462 : tree _r;
3463 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3464 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 846, __FILE__, __LINE__, true);
3465 : return _r;
3466 : }
3467 : next_after_fail1129:;
3468 : }
3469 : }
3470 : }
3471 : }
3472 : }
3473 : }
3474 : }
3475 : }
3476 : }
3477 218 : break;
3478 : }
3479 609 : case FLOAT_EXPR:
3480 609 : {
3481 609 : tree _q20 = TREE_OPERAND (_p0, 0);
3482 609 : {
3483 609 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
3484 609 : {
3485 609 : tree inside_type = TREE_TYPE (captures[1]);
3486 609 : tree inter_type = TREE_TYPE (captures[0]);
3487 609 : int inside_int = INTEGRAL_TYPE_P (inside_type);
3488 609 : int inside_ptr = POINTER_TYPE_P (inside_type);
3489 609 : int inside_float = FLOAT_TYPE_P (inside_type);
3490 609 : int inside_vec = VECTOR_TYPE_P (inside_type);
3491 609 : unsigned int inside_prec = element_precision (inside_type);
3492 609 : int inside_unsignedp = TYPE_UNSIGNED (inside_type);
3493 609 : int inter_int = INTEGRAL_TYPE_P (inter_type);
3494 609 : int inter_ptr = POINTER_TYPE_P (inter_type);
3495 609 : int inter_float = FLOAT_TYPE_P (inter_type);
3496 609 : int inter_vec = VECTOR_TYPE_P (inter_type);
3497 609 : unsigned int inter_prec = element_precision (inter_type);
3498 609 : int inter_unsignedp = TYPE_UNSIGNED (inter_type);
3499 609 : int final_int = INTEGRAL_TYPE_P (type);
3500 609 : int final_ptr = POINTER_TYPE_P (type);
3501 609 : int final_float = FLOAT_TYPE_P (type);
3502 609 : int final_vec = VECTOR_TYPE_P (type);
3503 609 : unsigned int final_prec = element_precision (type);
3504 609 : int final_unsignedp = TYPE_UNSIGNED (type);
3505 609 : if (((
3506 :
3507 : && useless_type_conversion_p (type, inside_type))
3508 : || (
3509 : 1
3510 609 : && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
3511 60 : && (((inter_int || inter_ptr) && final_int)
3512 60 : || (inter_float && final_float))
3513 609 : && inter_prec >= final_prec
3514 : )
3515 : {
3516 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1130;
3517 0 : {
3518 0 : tree res_op0;
3519 0 : res_op0 = captures[1];
3520 0 : tree _r;
3521 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3522 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 840, __FILE__, __LINE__, true);
3523 0 : return _r;
3524 : }
3525 0 : next_after_fail1130:;
3526 : }
3527 : else
3528 : {
3529 609 : if (((inter_int && inside_int) || (inter_float && inside_float))
3530 0 : && (final_int || final_float)
3531 0 : && inter_prec >= inside_prec
3532 0 : && (inter_float || inter_unsignedp == inside_unsignedp)
3533 : )
3534 : {
3535 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1131;
3536 0 : {
3537 0 : tree res_op0;
3538 0 : res_op0 = captures[1];
3539 0 : tree _r;
3540 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3541 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 841, __FILE__, __LINE__, true);
3542 0 : return _r;
3543 : }
3544 0 : next_after_fail1131:;
3545 0 : }
3546 : else
3547 : {
3548 609 : if (inside_int && inter_int && final_int
3549 0 : && ((inside_prec < inter_prec && inter_prec < final_prec
3550 0 : && inside_unsignedp && !inter_unsignedp)
3551 0 : || final_prec == inter_prec
3552 0 : || (inside_prec < inter_prec && inter_prec > final_prec
3553 0 : && !inside_unsignedp && inter_unsignedp))
3554 : )
3555 : {
3556 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1132;
3557 0 : {
3558 0 : tree res_op0;
3559 0 : res_op0 = captures[1];
3560 0 : tree _r;
3561 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3562 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 842, __FILE__, __LINE__, true);
3563 0 : return _r;
3564 : }
3565 0 : next_after_fail1132:;
3566 0 : }
3567 : else
3568 : {
3569 609 : if (! inside_float && ! inter_float && ! final_float
3570 : && ! inside_vec && ! inter_vec && ! final_vec
3571 0 : && (inter_prec >= inside_prec || inter_prec >= final_prec)
3572 0 : && ! (inside_int && inter_int
3573 0 : && inter_unsignedp != inside_unsignedp
3574 0 : && inter_prec < final_prec)
3575 0 : && ((inter_unsignedp && inter_prec > inside_prec)
3576 0 : == (final_unsignedp && final_prec > inter_prec))
3577 0 : && ! (inside_ptr && inter_prec != final_prec)
3578 0 : && ! (final_ptr && inside_prec != inter_prec)
3579 : )
3580 : {
3581 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1133;
3582 0 : {
3583 0 : tree res_op0;
3584 0 : res_op0 = captures[1];
3585 0 : tree _r;
3586 0 : _r = fold_build1_loc (loc, FIX_TRUNC_EXPR, type, res_op0);
3587 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 843, __FILE__, __LINE__, true);
3588 0 : return _r;
3589 : }
3590 0 : next_after_fail1133:;
3591 0 : }
3592 : else
3593 : {
3594 609 : if (inside_int && inter_int && final_int
3595 0 : && final_prec <= inside_prec
3596 0 : && inter_prec >= inside_prec
3597 : )
3598 : {
3599 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1134;
3600 0 : {
3601 0 : tree res_op0;
3602 0 : res_op0 = captures[1];
3603 0 : tree _r;
3604 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3605 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 844, __FILE__, __LINE__, true);
3606 0 : return _r;
3607 : }
3608 0 : next_after_fail1134:;
3609 0 : }
3610 : else
3611 : {
3612 : if (0
3613 : && final_int && inter_int && inside_int
3614 : && final_prec >= inside_prec
3615 : && inside_prec > inter_prec
3616 : && inter_unsignedp
3617 : )
3618 : {
3619 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1135;
3620 : {
3621 : tree res_op0;
3622 : {
3623 : tree _o1[2], _r1;
3624 : _o1[0] = captures[1];
3625 : _o1[1] = wide_int_to_tree
3626 : (inside_type,
3627 : wi::mask (inter_prec, false,
3628 : TYPE_PRECISION (inside_type)));
3629 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3630 : res_op0 = _r1;
3631 : }
3632 : tree _r;
3633 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3634 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 845, __FILE__, __LINE__, true);
3635 : return _r;
3636 : }
3637 : next_after_fail1135:;
3638 : }
3639 : else
3640 : {
3641 : if (0
3642 : && inside_int && inter_float && final_int &&
3643 : (unsigned) significand_size (TYPE_MODE (inter_type))
3644 : >= inside_prec - !inside_unsignedp
3645 : )
3646 : {
3647 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1136;
3648 : {
3649 : tree res_op0;
3650 : res_op0 = captures[1];
3651 : tree _r;
3652 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3653 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 846, __FILE__, __LINE__, true);
3654 : return _r;
3655 : }
3656 : next_after_fail1136:;
3657 : }
3658 : }
3659 : }
3660 : }
3661 : }
3662 : }
3663 : }
3664 : }
3665 : }
3666 609 : break;
3667 : }
3668 : default:;
3669 : }
3670 : return NULL_TREE;
3671 : }
3672 :
3673 : tree
3674 33446228 : generic_simplify_MINUS_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
3675 : {
3676 33446228 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3677 33446228 : if (integer_zerop (_p1))
3678 : {
3679 1999249 : {
3680 1999249 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3681 1999249 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1275;
3682 1999249 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1275;
3683 1999249 : {
3684 1999249 : tree res_op0;
3685 1999249 : res_op0 = captures[0];
3686 1999249 : tree _r;
3687 1999249 : _r = non_lvalue_loc (loc, res_op0);
3688 1999249 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 891, __FILE__, __LINE__, true);
3689 1999249 : return _r;
3690 : }
3691 : next_after_fail1275:;
3692 : }
3693 : }
3694 31446979 : if (real_zerop (_p1))
3695 : {
3696 1140 : {
3697 1140 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
3698 1140 : if (fold_real_zero_addition_p (type, captures[0], captures[1], 1)
3699 : )
3700 : {
3701 752 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1276;
3702 752 : {
3703 752 : tree res_op0;
3704 752 : res_op0 = captures[0];
3705 752 : tree _r;
3706 752 : _r = non_lvalue_loc (loc, res_op0);
3707 752 : if (TREE_SIDE_EFFECTS (captures[1]))
3708 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3709 752 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 916, __FILE__, __LINE__, true);
3710 752 : return _r;
3711 : }
3712 0 : next_after_fail1276:;
3713 : }
3714 : }
3715 : }
3716 31446227 : switch (TREE_CODE (_p0))
3717 : {
3718 2344266 : case PLUS_EXPR:
3719 2344266 : {
3720 2344266 : tree _q20 = TREE_OPERAND (_p0, 0);
3721 2344266 : tree _q21 = TREE_OPERAND (_p0, 1);
3722 2344266 : switch (TREE_CODE (_q21))
3723 : {
3724 154355 : case REAL_CST:
3725 154355 : {
3726 154355 : switch (TREE_CODE (_p1))
3727 : {
3728 11 : case REAL_CST:
3729 11 : {
3730 11 : {
3731 11 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
3732 11 : tree res = generic_simplify_55 (loc, type, _p0, _p1, captures, MINUS_EXPR, PLUS_EXPR);
3733 11 : if (res) return res;
3734 : }
3735 8 : break;
3736 : }
3737 : default:;
3738 : }
3739 : break;
3740 : }
3741 : default:;
3742 : }
3743 : break;
3744 : }
3745 1249343 : case MINUS_EXPR:
3746 1249343 : {
3747 1249343 : tree _q20 = TREE_OPERAND (_p0, 0);
3748 1249343 : tree _q21 = TREE_OPERAND (_p0, 1);
3749 1249343 : switch (TREE_CODE (_q21))
3750 : {
3751 97024 : case REAL_CST:
3752 97024 : {
3753 97024 : switch (TREE_CODE (_p1))
3754 : {
3755 40 : case REAL_CST:
3756 40 : {
3757 40 : {
3758 40 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
3759 40 : tree res = generic_simplify_55 (loc, type, _p0, _p1, captures, MINUS_EXPR, MINUS_EXPR);
3760 40 : if (res) return res;
3761 : }
3762 38 : break;
3763 : }
3764 : default:;
3765 : }
3766 : break;
3767 : }
3768 : default:;
3769 : }
3770 : break;
3771 : }
3772 31446222 : default:;
3773 : }
3774 31446222 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
3775 : {
3776 204119 : {
3777 204119 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
3778 203361 : if (!FLOAT_TYPE_P (type)
3779 204182 : || (!tree_expr_maybe_nan_p (captures[0])
3780 107 : && !tree_expr_maybe_infinite_p (captures[0])
3781 15 : && (!HONOR_SIGN_DEPENDENT_ROUNDING (type)
3782 1 : || !HONOR_SIGNED_ZEROS (type)))
3783 : )
3784 : {
3785 203312 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1277;
3786 203312 : {
3787 203312 : tree _r;
3788 203312 : _r = build_zero_cst (type);
3789 203312 : if (TREE_SIDE_EFFECTS (captures[0]))
3790 36 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3791 203312 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 917, __FILE__, __LINE__, true);
3792 203312 : return _r;
3793 : }
3794 0 : next_after_fail1277:;
3795 : }
3796 : }
3797 : }
3798 31242910 : switch (TREE_CODE (_p0))
3799 : {
3800 8677277 : CASE_CONVERT:
3801 8677277 : {
3802 8677277 : tree _q20 = TREE_OPERAND (_p0, 0);
3803 8677277 : switch (TREE_CODE (_p1))
3804 : {
3805 4330402 : CASE_CONVERT:
3806 4330402 : {
3807 4330402 : tree _q40 = TREE_OPERAND (_p1, 0);
3808 4330402 : switch (TREE_CODE (_q40))
3809 : {
3810 110510 : case MULT_EXPR:
3811 110510 : {
3812 110510 : tree _q50 = TREE_OPERAND (_q40, 0);
3813 110510 : tree _q51 = TREE_OPERAND (_q40, 1);
3814 110510 : switch (TREE_CODE (_q50))
3815 : {
3816 21 : case TRUNC_DIV_EXPR:
3817 21 : {
3818 21 : tree _q60 = TREE_OPERAND (_q50, 0);
3819 21 : tree _q61 = TREE_OPERAND (_q50, 1);
3820 21 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q20, 0))
3821 : {
3822 21 : if ((_q51 == _q61 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q61, 0))
3823 : {
3824 21 : {
3825 21 : tree captures[4] ATTRIBUTE_UNUSED = { _q60, _q61, _q20, _q61 };
3826 21 : tree res = generic_simplify_86 (loc, type, _p0, _p1, captures);
3827 21 : if (res) return res;
3828 : }
3829 : }
3830 : }
3831 : break;
3832 : }
3833 110489 : default:;
3834 : }
3835 110489 : switch (TREE_CODE (_q51))
3836 : {
3837 0 : case TRUNC_DIV_EXPR:
3838 0 : {
3839 0 : tree _q70 = TREE_OPERAND (_q51, 0);
3840 0 : tree _q71 = TREE_OPERAND (_q51, 1);
3841 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || operand_equal_p (_q70, _q20, 0))
3842 : {
3843 0 : if ((_q71 == _q50 && ! TREE_SIDE_EFFECTS (_q71)) || operand_equal_p (_q71, _q50, 0))
3844 : {
3845 0 : {
3846 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q70, _q71, _q20, _q50 };
3847 0 : tree res = generic_simplify_86 (loc, type, _p0, _p1, captures);
3848 0 : if (res) return res;
3849 : }
3850 : }
3851 : }
3852 : break;
3853 : }
3854 : default:;
3855 : }
3856 : break;
3857 : }
3858 : default:;
3859 : }
3860 : break;
3861 : }
3862 149764 : case MULT_EXPR:
3863 149764 : {
3864 149764 : tree _q40 = TREE_OPERAND (_p1, 0);
3865 149764 : tree _q41 = TREE_OPERAND (_p1, 1);
3866 149764 : switch (TREE_CODE (_q40))
3867 : {
3868 1837 : case TRUNC_DIV_EXPR:
3869 1837 : {
3870 1837 : tree _q50 = TREE_OPERAND (_q40, 0);
3871 1837 : tree _q51 = TREE_OPERAND (_q40, 1);
3872 1837 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
3873 : {
3874 10 : if ((_q41 == _q51 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _q51, 0))
3875 : {
3876 10 : {
3877 10 : tree captures[4] ATTRIBUTE_UNUSED = { _q50, _q51, _q20, _q51 };
3878 10 : tree res = generic_simplify_86 (loc, type, _p0, _p1, captures);
3879 10 : if (res) return res;
3880 : }
3881 : }
3882 : }
3883 : break;
3884 : }
3885 149754 : default:;
3886 : }
3887 149754 : switch (TREE_CODE (_q41))
3888 : {
3889 0 : case TRUNC_DIV_EXPR:
3890 0 : {
3891 0 : tree _q60 = TREE_OPERAND (_q41, 0);
3892 0 : tree _q61 = TREE_OPERAND (_q41, 1);
3893 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q20, 0))
3894 : {
3895 0 : if ((_q61 == _q40 && ! TREE_SIDE_EFFECTS (_q61)) || operand_equal_p (_q61, _q40, 0))
3896 : {
3897 0 : {
3898 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q60, _q61, _q20, _q40 };
3899 0 : tree res = generic_simplify_86 (loc, type, _p0, _p1, captures);
3900 0 : if (res) return res;
3901 : }
3902 : }
3903 : }
3904 : break;
3905 : }
3906 : default:;
3907 : }
3908 : break;
3909 : }
3910 : default:;
3911 : }
3912 : break;
3913 : }
3914 31242879 : default:;
3915 : }
3916 31242879 : switch (TREE_CODE (_p1))
3917 : {
3918 7690940 : CASE_CONVERT:
3919 7690940 : {
3920 7690940 : tree _q30 = TREE_OPERAND (_p1, 0);
3921 7690940 : switch (TREE_CODE (_q30))
3922 : {
3923 137726 : case MULT_EXPR:
3924 137726 : {
3925 137726 : tree _q40 = TREE_OPERAND (_q30, 0);
3926 137726 : tree _q41 = TREE_OPERAND (_q30, 1);
3927 137726 : switch (TREE_CODE (_q40))
3928 : {
3929 12 : case TRUNC_DIV_EXPR:
3930 12 : {
3931 12 : tree _q50 = TREE_OPERAND (_q40, 0);
3932 12 : tree _q51 = TREE_OPERAND (_q40, 1);
3933 12 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _p0, 0))
3934 : {
3935 2 : if ((_q41 == _q51 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _q51, 0))
3936 : {
3937 2 : {
3938 2 : tree captures[4] ATTRIBUTE_UNUSED = { _q50, _q51, _p0, _q51 };
3939 2 : tree res = generic_simplify_86 (loc, type, _p0, _p1, captures);
3940 2 : if (res) return res;
3941 : }
3942 : }
3943 : }
3944 : break;
3945 : }
3946 137724 : default:;
3947 : }
3948 137724 : switch (TREE_CODE (_q41))
3949 : {
3950 0 : case TRUNC_DIV_EXPR:
3951 0 : {
3952 0 : tree _q60 = TREE_OPERAND (_q41, 0);
3953 0 : tree _q61 = TREE_OPERAND (_q41, 1);
3954 0 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _p0, 0))
3955 : {
3956 0 : if ((_q61 == _q40 && ! TREE_SIDE_EFFECTS (_q61)) || operand_equal_p (_q61, _q40, 0))
3957 : {
3958 0 : {
3959 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q60, _q61, _p0, _q40 };
3960 0 : tree res = generic_simplify_86 (loc, type, _p0, _p1, captures);
3961 0 : if (res) return res;
3962 : }
3963 : }
3964 : }
3965 : break;
3966 : }
3967 : default:;
3968 : }
3969 : break;
3970 : }
3971 : default:;
3972 : }
3973 : break;
3974 : }
3975 2084938 : case MULT_EXPR:
3976 2084938 : {
3977 2084938 : tree _q30 = TREE_OPERAND (_p1, 0);
3978 2084938 : tree _q31 = TREE_OPERAND (_p1, 1);
3979 2084938 : switch (TREE_CODE (_q30))
3980 : {
3981 2360 : case TRUNC_DIV_EXPR:
3982 2360 : {
3983 2360 : tree _q40 = TREE_OPERAND (_q30, 0);
3984 2360 : tree _q41 = TREE_OPERAND (_q30, 1);
3985 2360 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _p0, 0))
3986 : {
3987 52 : if ((_q31 == _q41 && ! TREE_SIDE_EFFECTS (_q31)) || operand_equal_p (_q31, _q41, 0))
3988 : {
3989 52 : {
3990 52 : tree captures[4] ATTRIBUTE_UNUSED = { _q40, _q41, _p0, _q41 };
3991 52 : tree res = generic_simplify_86 (loc, type, _p0, _p1, captures);
3992 52 : if (res) return res;
3993 : }
3994 : }
3995 : }
3996 : break;
3997 : }
3998 2084886 : default:;
3999 : }
4000 2084886 : switch (TREE_CODE (_q31))
4001 : {
4002 0 : case TRUNC_DIV_EXPR:
4003 0 : {
4004 0 : tree _q50 = TREE_OPERAND (_q31, 0);
4005 0 : tree _q51 = TREE_OPERAND (_q31, 1);
4006 0 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _p0, 0))
4007 : {
4008 0 : if ((_q51 == _q30 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q30, 0))
4009 : {
4010 0 : {
4011 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q50, _q51, _p0, _q30 };
4012 0 : tree res = generic_simplify_86 (loc, type, _p0, _p1, captures);
4013 0 : if (res) return res;
4014 : }
4015 : }
4016 : }
4017 : break;
4018 : }
4019 : default:;
4020 : }
4021 : break;
4022 : }
4023 31242825 : default:;
4024 : }
4025 31242825 : switch (TREE_CODE (_p0))
4026 : {
4027 1914910 : case MULT_EXPR:
4028 1914910 : {
4029 1914910 : tree _q20 = TREE_OPERAND (_p0, 0);
4030 1914910 : tree _q21 = TREE_OPERAND (_p0, 1);
4031 1914910 : switch (TREE_CODE (_q21))
4032 : {
4033 595 : case PLUS_EXPR:
4034 595 : {
4035 595 : tree _q40 = TREE_OPERAND (_q21, 0);
4036 595 : tree _q41 = TREE_OPERAND (_q21, 1);
4037 595 : switch (TREE_CODE (_q40))
4038 : {
4039 0 : case TRUNC_DIV_EXPR:
4040 0 : {
4041 0 : tree _q50 = TREE_OPERAND (_q40, 0);
4042 0 : tree _q51 = TREE_OPERAND (_q40, 1);
4043 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4044 : {
4045 0 : if (integer_onep (_q41))
4046 : {
4047 0 : if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
4048 : {
4049 0 : {
4050 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q40, _q50 };
4051 0 : tree res = generic_simplify_87 (loc, type, _p0, _p1, captures);
4052 0 : if (res) return res;
4053 : }
4054 : }
4055 : }
4056 : }
4057 : break;
4058 : }
4059 : default:;
4060 : }
4061 : break;
4062 : }
4063 1914910 : default:;
4064 : }
4065 1914910 : switch (TREE_CODE (_q20))
4066 : {
4067 107298 : case PLUS_EXPR:
4068 107298 : {
4069 107298 : tree _q30 = TREE_OPERAND (_q20, 0);
4070 107298 : tree _q31 = TREE_OPERAND (_q20, 1);
4071 107298 : switch (TREE_CODE (_q30))
4072 : {
4073 1 : case TRUNC_DIV_EXPR:
4074 1 : {
4075 1 : tree _q40 = TREE_OPERAND (_q30, 0);
4076 1 : tree _q41 = TREE_OPERAND (_q30, 1);
4077 1 : if (integer_onep (_q31))
4078 : {
4079 1 : if ((_q21 == _q41 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q41, 0) && types_match (_q21, _q41)))
4080 : {
4081 1 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
4082 : {
4083 1 : {
4084 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q41, _q20, _q30, _q40 };
4085 1 : tree res = generic_simplify_87 (loc, type, _p0, _p1, captures);
4086 1 : if (res) return res;
4087 : }
4088 : }
4089 : }
4090 : }
4091 : break;
4092 : }
4093 : default:;
4094 : }
4095 : break;
4096 : }
4097 : default:;
4098 : }
4099 : break;
4100 : }
4101 1266 : case LSHIFT_EXPR:
4102 1266 : {
4103 1266 : tree _q20 = TREE_OPERAND (_p0, 0);
4104 1266 : tree _q21 = TREE_OPERAND (_p0, 1);
4105 1266 : switch (TREE_CODE (_p1))
4106 : {
4107 0 : case LSHIFT_EXPR:
4108 0 : {
4109 0 : tree _q50 = TREE_OPERAND (_p1, 0);
4110 0 : tree _q51 = TREE_OPERAND (_p1, 1);
4111 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4112 : {
4113 0 : {
4114 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
4115 0 : tree res = generic_simplify_57 (loc, type, _p0, _p1, captures, MINUS_EXPR);
4116 0 : if (res) return res;
4117 : }
4118 : }
4119 : break;
4120 : }
4121 : default:;
4122 : }
4123 : break;
4124 : }
4125 1191 : case BIT_AND_EXPR:
4126 1191 : {
4127 1191 : tree _q20 = TREE_OPERAND (_p0, 0);
4128 1191 : tree _q21 = TREE_OPERAND (_p0, 1);
4129 1191 : switch (TREE_CODE (_q21))
4130 : {
4131 0 : case BIT_NOT_EXPR:
4132 0 : {
4133 0 : tree _q40 = TREE_OPERAND (_q21, 0);
4134 0 : switch (TREE_CODE (_p1))
4135 : {
4136 0 : case BIT_AND_EXPR:
4137 0 : {
4138 0 : tree _q60 = TREE_OPERAND (_p1, 0);
4139 0 : tree _q61 = TREE_OPERAND (_p1, 1);
4140 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4141 : {
4142 0 : if ((_q61 == _q40 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q40, 0) && types_match (_q61, _q40)))
4143 : {
4144 0 : {
4145 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _p1 };
4146 0 : tree res = generic_simplify_88 (loc, type, _p0, _p1, captures);
4147 0 : if (res) return res;
4148 : }
4149 : }
4150 : }
4151 0 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
4152 : {
4153 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
4154 : {
4155 0 : {
4156 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _p1 };
4157 0 : tree res = generic_simplify_88 (loc, type, _p0, _p1, captures);
4158 0 : if (res) return res;
4159 : }
4160 : }
4161 : }
4162 : break;
4163 : }
4164 : default:;
4165 : }
4166 : break;
4167 : }
4168 1191 : default:;
4169 : }
4170 1191 : switch (TREE_CODE (_q20))
4171 : {
4172 27 : case BIT_NOT_EXPR:
4173 27 : {
4174 27 : tree _q30 = TREE_OPERAND (_q20, 0);
4175 27 : switch (TREE_CODE (_p1))
4176 : {
4177 21 : case BIT_AND_EXPR:
4178 21 : {
4179 21 : tree _q60 = TREE_OPERAND (_p1, 0);
4180 21 : tree _q61 = TREE_OPERAND (_p1, 1);
4181 21 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
4182 : {
4183 0 : if ((_q61 == _q30 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q30, 0) && types_match (_q61, _q30)))
4184 : {
4185 0 : {
4186 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q30, _p1 };
4187 0 : tree res = generic_simplify_88 (loc, type, _p0, _p1, captures);
4188 0 : if (res) return res;
4189 : }
4190 : }
4191 : }
4192 21 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
4193 : {
4194 21 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
4195 : {
4196 21 : {
4197 21 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q30, _p1 };
4198 21 : tree res = generic_simplify_88 (loc, type, _p0, _p1, captures);
4199 21 : if (res) return res;
4200 : }
4201 : }
4202 : }
4203 : break;
4204 : }
4205 : default:;
4206 : }
4207 : break;
4208 : }
4209 1170 : default:;
4210 : }
4211 1170 : switch (TREE_CODE (_q21))
4212 : {
4213 1130 : case INTEGER_CST:
4214 1130 : {
4215 1130 : switch (TREE_CODE (_p1))
4216 : {
4217 28 : case BIT_AND_EXPR:
4218 28 : {
4219 28 : tree _q50 = TREE_OPERAND (_p1, 0);
4220 28 : tree _q51 = TREE_OPERAND (_p1, 1);
4221 28 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4222 : {
4223 6 : switch (TREE_CODE (_q51))
4224 : {
4225 6 : case INTEGER_CST:
4226 6 : {
4227 6 : {
4228 6 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
4229 6 : if (~wi::to_wide (captures[2]) == wi::to_wide (captures[4])
4230 : )
4231 : {
4232 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1278;
4233 0 : {
4234 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1278;
4235 0 : tree res_op0;
4236 0 : {
4237 0 : tree _o1[2], _r1;
4238 0 : _o1[0] = captures[1];
4239 0 : _o1[1] = unshare_expr (captures[4]);
4240 0 : _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4241 0 : res_op0 = _r1;
4242 : }
4243 0 : tree res_op1;
4244 0 : res_op1 = captures[4];
4245 0 : tree _r;
4246 0 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
4247 0 : if (TREE_SIDE_EFFECTS (captures[2]))
4248 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4249 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 918, __FILE__, __LINE__, true);
4250 0 : return _r;
4251 : }
4252 6 : next_after_fail1278:;
4253 : }
4254 : }
4255 6 : break;
4256 : }
4257 : default:;
4258 : }
4259 : }
4260 : break;
4261 : }
4262 : default:;
4263 : }
4264 : break;
4265 : }
4266 1170 : default:;
4267 : }
4268 1170 : switch (TREE_CODE (_p1))
4269 : {
4270 31 : case BIT_AND_EXPR:
4271 31 : {
4272 31 : tree _q50 = TREE_OPERAND (_p1, 0);
4273 31 : tree _q51 = TREE_OPERAND (_p1, 1);
4274 31 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4275 : {
4276 6 : switch (TREE_CODE (_q51))
4277 : {
4278 0 : case BIT_NOT_EXPR:
4279 0 : {
4280 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4281 0 : if ((_q70 == _q21 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q21, 0) && types_match (_q70, _q21)))
4282 : {
4283 0 : {
4284 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
4285 0 : tree res = generic_simplify_89 (loc, type, _p0, _p1, captures);
4286 0 : if (res) return res;
4287 : }
4288 : }
4289 : break;
4290 : }
4291 : default:;
4292 : }
4293 : }
4294 31 : switch (TREE_CODE (_q50))
4295 : {
4296 0 : case BIT_NOT_EXPR:
4297 0 : {
4298 0 : tree _q60 = TREE_OPERAND (_q50, 0);
4299 0 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
4300 : {
4301 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
4302 : {
4303 0 : {
4304 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
4305 0 : tree res = generic_simplify_89 (loc, type, _p0, _p1, captures);
4306 0 : if (res) return res;
4307 : }
4308 : }
4309 : }
4310 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4311 : {
4312 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4313 : {
4314 0 : {
4315 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1 };
4316 0 : tree res = generic_simplify_89 (loc, type, _p0, _p1, captures);
4317 0 : if (res) return res;
4318 : }
4319 : }
4320 : }
4321 : break;
4322 : }
4323 31 : default:;
4324 : }
4325 31 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
4326 : {
4327 0 : switch (TREE_CODE (_q51))
4328 : {
4329 0 : case BIT_NOT_EXPR:
4330 0 : {
4331 0 : tree _q70 = TREE_OPERAND (_q51, 0);
4332 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4333 : {
4334 0 : {
4335 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1 };
4336 0 : tree res = generic_simplify_89 (loc, type, _p0, _p1, captures);
4337 0 : if (res) return res;
4338 : }
4339 : }
4340 : break;
4341 : }
4342 : default:;
4343 : }
4344 : }
4345 : break;
4346 : }
4347 2 : case PLUS_EXPR:
4348 2 : {
4349 2 : tree _q50 = TREE_OPERAND (_p1, 0);
4350 2 : tree _q51 = TREE_OPERAND (_p1, 1);
4351 2 : switch (TREE_CODE (_q50))
4352 : {
4353 2 : case BIT_IOR_EXPR:
4354 2 : {
4355 2 : tree _q60 = TREE_OPERAND (_q50, 0);
4356 2 : tree _q61 = TREE_OPERAND (_q50, 1);
4357 2 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
4358 : {
4359 2 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
4360 : {
4361 2 : if (integer_onep (_q51))
4362 : {
4363 2 : {
4364 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4365 2 : tree res = generic_simplify_90 (loc, type, _p0, _p1, captures);
4366 2 : if (res) return res;
4367 : }
4368 : }
4369 : }
4370 : }
4371 0 : if ((_q60 == _q21 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q21, 0) && types_match (_q60, _q21)))
4372 : {
4373 0 : if ((_q61 == _q20 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q20, 0) && types_match (_q61, _q20)))
4374 : {
4375 0 : if (integer_onep (_q51))
4376 : {
4377 0 : {
4378 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4379 0 : tree res = generic_simplify_90 (loc, type, _p0, _p1, captures);
4380 0 : if (res) return res;
4381 : }
4382 : }
4383 : }
4384 : }
4385 : break;
4386 : }
4387 0 : default:;
4388 : }
4389 0 : {
4390 0 : tree _q50_pops[1];
4391 0 : if (tree_nop_convert (_q50, _q50_pops))
4392 : {
4393 0 : tree _q60 = _q50_pops[0];
4394 0 : switch (TREE_CODE (_q60))
4395 : {
4396 0 : case BIT_IOR_EXPR:
4397 0 : {
4398 0 : tree _q70 = TREE_OPERAND (_q60, 0);
4399 0 : tree _q71 = TREE_OPERAND (_q60, 1);
4400 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4401 : {
4402 0 : if ((_q71 == _q21 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q21, 0) && types_match (_q71, _q21)))
4403 : {
4404 0 : if (integer_onep (_q51))
4405 : {
4406 0 : {
4407 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4408 0 : tree res = generic_simplify_90 (loc, type, _p0, _p1, captures);
4409 0 : if (res) return res;
4410 : }
4411 : }
4412 : }
4413 : }
4414 0 : if ((_q70 == _q21 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q21, 0) && types_match (_q70, _q21)))
4415 : {
4416 0 : if ((_q71 == _q20 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q20, 0) && types_match (_q71, _q20)))
4417 : {
4418 0 : if (integer_onep (_q51))
4419 : {
4420 0 : {
4421 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
4422 0 : tree res = generic_simplify_90 (loc, type, _p0, _p1, captures);
4423 0 : if (res) return res;
4424 : }
4425 : }
4426 : }
4427 : }
4428 : break;
4429 : }
4430 : default:;
4431 : }
4432 : }
4433 : }
4434 0 : break;
4435 : }
4436 1168 : default:;
4437 : }
4438 1168 : {
4439 1168 : tree _p1_pops[1];
4440 1168 : if (tree_nop_convert (_p1, _p1_pops))
4441 : {
4442 7 : tree _q50 = _p1_pops[0];
4443 7 : switch (TREE_CODE (_q50))
4444 : {
4445 0 : case PLUS_EXPR:
4446 0 : {
4447 0 : tree _q60 = TREE_OPERAND (_q50, 0);
4448 0 : tree _q61 = TREE_OPERAND (_q50, 1);
4449 0 : switch (TREE_CODE (_q60))
4450 : {
4451 0 : case BIT_IOR_EXPR:
4452 0 : {
4453 0 : tree _q70 = TREE_OPERAND (_q60, 0);
4454 0 : tree _q71 = TREE_OPERAND (_q60, 1);
4455 0 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
4456 : {
4457 0 : if ((_q71 == _q21 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q21, 0) && types_match (_q71, _q21)))
4458 : {
4459 0 : if (integer_onep (_q61))
4460 : {
4461 0 : {
4462 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4463 0 : tree res = generic_simplify_90 (loc, type, _p0, _p1, captures);
4464 0 : if (res) return res;
4465 : }
4466 : }
4467 : }
4468 : }
4469 0 : if ((_q70 == _q21 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q21, 0) && types_match (_q70, _q21)))
4470 : {
4471 0 : if ((_q71 == _q20 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q20, 0) && types_match (_q71, _q20)))
4472 : {
4473 0 : if (integer_onep (_q61))
4474 : {
4475 0 : {
4476 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4477 0 : tree res = generic_simplify_90 (loc, type, _p0, _p1, captures);
4478 0 : if (res) return res;
4479 : }
4480 : }
4481 : }
4482 : }
4483 : break;
4484 : }
4485 0 : default:;
4486 : }
4487 0 : {
4488 0 : tree _q60_pops[1];
4489 0 : if (tree_nop_convert (_q60, _q60_pops))
4490 : {
4491 0 : tree _q70 = _q60_pops[0];
4492 0 : switch (TREE_CODE (_q70))
4493 : {
4494 0 : case BIT_IOR_EXPR:
4495 0 : {
4496 0 : tree _q80 = TREE_OPERAND (_q70, 0);
4497 0 : tree _q81 = TREE_OPERAND (_q70, 1);
4498 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
4499 : {
4500 0 : if ((_q81 == _q21 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q21, 0) && types_match (_q81, _q21)))
4501 : {
4502 0 : if (integer_onep (_q61))
4503 : {
4504 0 : {
4505 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4506 0 : tree res = generic_simplify_90 (loc, type, _p0, _p1, captures);
4507 0 : if (res) return res;
4508 : }
4509 : }
4510 : }
4511 : }
4512 0 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
4513 : {
4514 0 : if ((_q81 == _q20 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q20, 0) && types_match (_q81, _q20)))
4515 : {
4516 0 : if (integer_onep (_q61))
4517 : {
4518 0 : {
4519 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
4520 0 : tree res = generic_simplify_90 (loc, type, _p0, _p1, captures);
4521 0 : if (res) return res;
4522 : }
4523 : }
4524 : }
4525 : }
4526 : break;
4527 : }
4528 : default:;
4529 : }
4530 : }
4531 : }
4532 0 : break;
4533 : }
4534 : default:;
4535 : }
4536 : }
4537 : }
4538 1168 : break;
4539 : }
4540 3257 : case BIT_NOT_EXPR:
4541 3257 : {
4542 3257 : tree _q20 = TREE_OPERAND (_p0, 0);
4543 3257 : switch (TREE_CODE (_p1))
4544 : {
4545 22 : case BIT_NOT_EXPR:
4546 22 : {
4547 22 : tree _q40 = TREE_OPERAND (_p1, 0);
4548 22 : {
4549 22 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
4550 22 : if (!TYPE_OVERFLOW_SANITIZED (type)
4551 : )
4552 : {
4553 9 : {
4554 9 : tree utype = unsigned_type_for (type);
4555 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1279;
4556 9 : {
4557 9 : tree res_op0;
4558 9 : {
4559 9 : tree _o1[2], _r1;
4560 9 : {
4561 9 : tree _o2[1], _r2;
4562 9 : _o2[0] = captures[1];
4563 9 : if (TREE_TYPE (_o2[0]) != utype)
4564 : {
4565 9 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
4566 : }
4567 : else
4568 : _r2 = _o2[0];
4569 9 : _o1[0] = _r2;
4570 : }
4571 9 : {
4572 9 : tree _o2[1], _r2;
4573 9 : _o2[0] = captures[0];
4574 9 : if (TREE_TYPE (_o2[0]) != utype)
4575 : {
4576 9 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
4577 : }
4578 : else
4579 : _r2 = _o2[0];
4580 9 : _o1[1] = _r2;
4581 : }
4582 9 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4583 9 : res_op0 = _r1;
4584 : }
4585 9 : tree _r;
4586 9 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4587 9 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 919, __FILE__, __LINE__, true);
4588 9 : return _r;
4589 : }
4590 0 : next_after_fail1279:;
4591 : }
4592 : }
4593 : }
4594 13 : break;
4595 : }
4596 : default:;
4597 : }
4598 : break;
4599 : }
4600 2342627 : case PLUS_EXPR:
4601 2342627 : {
4602 2342627 : tree _q20 = TREE_OPERAND (_p0, 0);
4603 2342627 : tree _q21 = TREE_OPERAND (_p0, 1);
4604 2342627 : switch (TREE_CODE (_p1))
4605 : {
4606 14 : case BIT_IOR_EXPR:
4607 14 : {
4608 14 : tree _q50 = TREE_OPERAND (_p1, 0);
4609 14 : tree _q51 = TREE_OPERAND (_p1, 1);
4610 14 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4611 : {
4612 13 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4613 : {
4614 13 : {
4615 13 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4616 13 : if (!TYPE_OVERFLOW_SANITIZED (type) && !TYPE_OVERFLOW_TRAPS (type)
4617 13 : && !TYPE_SATURATING (type)
4618 : )
4619 : {
4620 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1280;
4621 0 : {
4622 0 : tree res_op0;
4623 0 : res_op0 = captures[0];
4624 0 : tree res_op1;
4625 0 : res_op1 = captures[1];
4626 0 : tree _r;
4627 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
4628 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
4629 0 : return _r;
4630 : }
4631 0 : next_after_fail1280:;
4632 : }
4633 : }
4634 : }
4635 : }
4636 : break;
4637 : }
4638 82 : case BIT_AND_EXPR:
4639 82 : {
4640 82 : tree _q50 = TREE_OPERAND (_p1, 0);
4641 82 : tree _q51 = TREE_OPERAND (_p1, 1);
4642 82 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4643 : {
4644 25 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4645 : {
4646 13 : {
4647 13 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4648 13 : if (!TYPE_OVERFLOW_SANITIZED (type) && !TYPE_OVERFLOW_TRAPS (type)
4649 13 : && !TYPE_SATURATING (type)
4650 : )
4651 : {
4652 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1281;
4653 0 : {
4654 0 : tree res_op0;
4655 0 : res_op0 = captures[0];
4656 0 : tree res_op1;
4657 0 : res_op1 = captures[1];
4658 0 : tree _r;
4659 0 : _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
4660 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 921, __FILE__, __LINE__, true);
4661 0 : return _r;
4662 : }
4663 0 : next_after_fail1281:;
4664 : }
4665 : }
4666 : }
4667 : }
4668 : break;
4669 : }
4670 2342627 : default:;
4671 : }
4672 2342627 : switch (TREE_CODE (_q20))
4673 : {
4674 593 : case BIT_AND_EXPR:
4675 593 : {
4676 593 : tree _q30 = TREE_OPERAND (_q20, 0);
4677 593 : tree _q31 = TREE_OPERAND (_q20, 1);
4678 593 : if (integer_all_onesp (_q21))
4679 : {
4680 1 : switch (TREE_CODE (_p1))
4681 : {
4682 1 : case BIT_IOR_EXPR:
4683 1 : {
4684 1 : tree _q70 = TREE_OPERAND (_p1, 0);
4685 1 : tree _q71 = TREE_OPERAND (_p1, 1);
4686 1 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
4687 : {
4688 1 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
4689 : {
4690 1 : {
4691 1 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q31 };
4692 1 : tree res = generic_simplify_91 (loc, type, _p0, _p1, captures);
4693 1 : if (res) return res;
4694 : }
4695 : }
4696 : }
4697 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
4698 : {
4699 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
4700 : {
4701 0 : {
4702 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q31, _q30 };
4703 0 : tree res = generic_simplify_91 (loc, type, _p0, _p1, captures);
4704 0 : if (res) return res;
4705 : }
4706 : }
4707 : }
4708 : break;
4709 : }
4710 0 : default:;
4711 : }
4712 0 : {
4713 0 : tree _p1_pops[1];
4714 0 : if (tree_nop_convert (_p1, _p1_pops))
4715 : {
4716 0 : tree _q70 = _p1_pops[0];
4717 0 : switch (TREE_CODE (_q70))
4718 : {
4719 0 : case BIT_IOR_EXPR:
4720 0 : {
4721 0 : tree _q80 = TREE_OPERAND (_q70, 0);
4722 0 : tree _q81 = TREE_OPERAND (_q70, 1);
4723 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
4724 : {
4725 0 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
4726 : {
4727 0 : {
4728 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q31 };
4729 0 : tree res = generic_simplify_91 (loc, type, _p0, _p1, captures);
4730 0 : if (res) return res;
4731 : }
4732 : }
4733 : }
4734 0 : if ((_q80 == _q31 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q31, 0) && types_match (_q80, _q31)))
4735 : {
4736 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
4737 : {
4738 0 : {
4739 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q31, _q30 };
4740 0 : tree res = generic_simplify_91 (loc, type, _p0, _p1, captures);
4741 0 : if (res) return res;
4742 : }
4743 : }
4744 : }
4745 : break;
4746 : }
4747 : default:;
4748 : }
4749 : }
4750 : }
4751 : }
4752 : break;
4753 : }
4754 2342626 : default:;
4755 : }
4756 2342626 : {
4757 2342626 : tree _q20_pops[1];
4758 2342626 : if (tree_nop_convert (_q20, _q20_pops))
4759 : {
4760 548125 : tree _q30 = _q20_pops[0];
4761 548125 : switch (TREE_CODE (_q30))
4762 : {
4763 0 : case BIT_AND_EXPR:
4764 0 : {
4765 0 : tree _q40 = TREE_OPERAND (_q30, 0);
4766 0 : tree _q41 = TREE_OPERAND (_q30, 1);
4767 0 : if (integer_all_onesp (_q21))
4768 : {
4769 0 : switch (TREE_CODE (_p1))
4770 : {
4771 0 : case BIT_IOR_EXPR:
4772 0 : {
4773 0 : tree _q80 = TREE_OPERAND (_p1, 0);
4774 0 : tree _q81 = TREE_OPERAND (_p1, 1);
4775 0 : if ((_q80 == _q40 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q40, 0) && types_match (_q80, _q40)))
4776 : {
4777 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
4778 : {
4779 0 : {
4780 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q41 };
4781 0 : tree res = generic_simplify_91 (loc, type, _p0, _p1, captures);
4782 0 : if (res) return res;
4783 : }
4784 : }
4785 : }
4786 0 : if ((_q80 == _q41 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q41, 0) && types_match (_q80, _q41)))
4787 : {
4788 0 : if ((_q81 == _q40 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q40, 0) && types_match (_q81, _q40)))
4789 : {
4790 0 : {
4791 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q40 };
4792 0 : tree res = generic_simplify_91 (loc, type, _p0, _p1, captures);
4793 0 : if (res) return res;
4794 : }
4795 : }
4796 : }
4797 : break;
4798 : }
4799 0 : default:;
4800 : }
4801 0 : {
4802 0 : tree _p1_pops[1];
4803 0 : if (tree_nop_convert (_p1, _p1_pops))
4804 : {
4805 0 : tree _q80 = _p1_pops[0];
4806 0 : switch (TREE_CODE (_q80))
4807 : {
4808 0 : case BIT_IOR_EXPR:
4809 0 : {
4810 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4811 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4812 0 : if ((_q90 == _q40 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q40, 0) && types_match (_q90, _q40)))
4813 : {
4814 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
4815 : {
4816 0 : {
4817 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q41 };
4818 0 : tree res = generic_simplify_91 (loc, type, _p0, _p1, captures);
4819 0 : if (res) return res;
4820 : }
4821 : }
4822 : }
4823 0 : if ((_q90 == _q41 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q41, 0) && types_match (_q90, _q41)))
4824 : {
4825 0 : if ((_q91 == _q40 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q40, 0) && types_match (_q91, _q40)))
4826 : {
4827 0 : {
4828 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q40 };
4829 0 : tree res = generic_simplify_91 (loc, type, _p0, _p1, captures);
4830 0 : if (res) return res;
4831 : }
4832 : }
4833 : }
4834 : break;
4835 : }
4836 : default:;
4837 : }
4838 : }
4839 : }
4840 : }
4841 : break;
4842 : }
4843 : default:;
4844 : }
4845 : }
4846 : }
4847 2342626 : break;
4848 : }
4849 79 : case BIT_IOR_EXPR:
4850 79 : {
4851 79 : tree _q20 = TREE_OPERAND (_p0, 0);
4852 79 : tree _q21 = TREE_OPERAND (_p0, 1);
4853 79 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
4854 : {
4855 5 : {
4856 5 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
4857 5 : tree res = generic_simplify_92 (loc, type, _p0, _p1, captures);
4858 5 : if (res) return res;
4859 : }
4860 : }
4861 74 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
4862 : {
4863 0 : {
4864 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
4865 0 : tree res = generic_simplify_92 (loc, type, _p0, _p1, captures);
4866 0 : if (res) return res;
4867 : }
4868 : }
4869 74 : switch (TREE_CODE (_p1))
4870 : {
4871 0 : case BIT_XOR_EXPR:
4872 0 : {
4873 0 : tree _q50 = TREE_OPERAND (_p1, 0);
4874 0 : tree _q51 = TREE_OPERAND (_p1, 1);
4875 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4876 : {
4877 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4878 : {
4879 0 : {
4880 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4881 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1282;
4882 0 : {
4883 0 : tree res_op0;
4884 0 : res_op0 = captures[0];
4885 0 : tree res_op1;
4886 0 : res_op1 = captures[1];
4887 0 : tree _r;
4888 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
4889 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 922, __FILE__, __LINE__, true);
4890 0 : return _r;
4891 : }
4892 0 : next_after_fail1282:;
4893 : }
4894 : }
4895 : }
4896 : break;
4897 : }
4898 0 : case BIT_AND_EXPR:
4899 0 : {
4900 0 : tree _q50 = TREE_OPERAND (_p1, 0);
4901 0 : tree _q51 = TREE_OPERAND (_p1, 1);
4902 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
4903 : {
4904 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
4905 : {
4906 0 : {
4907 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4908 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1283;
4909 0 : {
4910 0 : tree res_op0;
4911 0 : res_op0 = captures[0];
4912 0 : tree res_op1;
4913 0 : res_op1 = captures[1];
4914 0 : tree _r;
4915 0 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
4916 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 923, __FILE__, __LINE__, true);
4917 0 : return _r;
4918 : }
4919 0 : next_after_fail1283:;
4920 : }
4921 : }
4922 : }
4923 : break;
4924 : }
4925 : default:;
4926 : }
4927 : break;
4928 : }
4929 31242786 : default:;
4930 : }
4931 31242786 : {
4932 31242786 : tree _p0_pops[1];
4933 31242786 : if (tree_nop_convert (_p0, _p0_pops))
4934 : {
4935 7526013 : tree _q20 = _p0_pops[0];
4936 7526013 : switch (TREE_CODE (_q20))
4937 : {
4938 1039617 : case PLUS_EXPR:
4939 1039617 : {
4940 1039617 : tree _q30 = TREE_OPERAND (_q20, 0);
4941 1039617 : tree _q31 = TREE_OPERAND (_q20, 1);
4942 1039617 : switch (TREE_CODE (_q30))
4943 : {
4944 8 : case BIT_AND_EXPR:
4945 8 : {
4946 8 : tree _q40 = TREE_OPERAND (_q30, 0);
4947 8 : tree _q41 = TREE_OPERAND (_q30, 1);
4948 8 : if (integer_all_onesp (_q31))
4949 : {
4950 0 : switch (TREE_CODE (_p1))
4951 : {
4952 0 : case BIT_IOR_EXPR:
4953 0 : {
4954 0 : tree _q80 = TREE_OPERAND (_p1, 0);
4955 0 : tree _q81 = TREE_OPERAND (_p1, 1);
4956 0 : if ((_q80 == _q40 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q40, 0) && types_match (_q80, _q40)))
4957 : {
4958 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
4959 : {
4960 0 : {
4961 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q40, _q41 };
4962 0 : tree res = generic_simplify_91 (loc, type, _p0, _p1, captures);
4963 0 : if (res) return res;
4964 : }
4965 : }
4966 : }
4967 0 : if ((_q80 == _q41 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q41, 0) && types_match (_q80, _q41)))
4968 : {
4969 0 : if ((_q81 == _q40 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q40, 0) && types_match (_q81, _q40)))
4970 : {
4971 0 : {
4972 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q41, _q40 };
4973 0 : tree res = generic_simplify_91 (loc, type, _p0, _p1, captures);
4974 0 : if (res) return res;
4975 : }
4976 : }
4977 : }
4978 : break;
4979 : }
4980 0 : default:;
4981 : }
4982 0 : {
4983 0 : tree _p1_pops[1];
4984 0 : if (tree_nop_convert (_p1, _p1_pops))
4985 : {
4986 0 : tree _q80 = _p1_pops[0];
4987 0 : switch (TREE_CODE (_q80))
4988 : {
4989 0 : case BIT_IOR_EXPR:
4990 0 : {
4991 0 : tree _q90 = TREE_OPERAND (_q80, 0);
4992 0 : tree _q91 = TREE_OPERAND (_q80, 1);
4993 0 : if ((_q90 == _q40 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q40, 0) && types_match (_q90, _q40)))
4994 : {
4995 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
4996 : {
4997 0 : {
4998 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q40, _q41 };
4999 0 : tree res = generic_simplify_91 (loc, type, _p0, _p1, captures);
5000 0 : if (res) return res;
5001 : }
5002 : }
5003 : }
5004 0 : if ((_q90 == _q41 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q41, 0) && types_match (_q90, _q41)))
5005 : {
5006 0 : if ((_q91 == _q40 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q40, 0) && types_match (_q91, _q40)))
5007 : {
5008 0 : {
5009 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q41, _q40 };
5010 0 : tree res = generic_simplify_91 (loc, type, _p0, _p1, captures);
5011 0 : if (res) return res;
5012 : }
5013 : }
5014 : }
5015 : break;
5016 : }
5017 : default:;
5018 : }
5019 : }
5020 : }
5021 : }
5022 : break;
5023 : }
5024 1039617 : default:;
5025 : }
5026 1039617 : {
5027 1039617 : tree _q30_pops[1];
5028 1039617 : if (tree_nop_convert (_q30, _q30_pops))
5029 : {
5030 41553 : tree _q40 = _q30_pops[0];
5031 41553 : switch (TREE_CODE (_q40))
5032 : {
5033 0 : case BIT_AND_EXPR:
5034 0 : {
5035 0 : tree _q50 = TREE_OPERAND (_q40, 0);
5036 0 : tree _q51 = TREE_OPERAND (_q40, 1);
5037 0 : if (integer_all_onesp (_q31))
5038 : {
5039 0 : switch (TREE_CODE (_p1))
5040 : {
5041 0 : case BIT_IOR_EXPR:
5042 0 : {
5043 0 : tree _q90 = TREE_OPERAND (_p1, 0);
5044 0 : tree _q91 = TREE_OPERAND (_p1, 1);
5045 0 : if ((_q90 == _q50 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q50, 0) && types_match (_q90, _q50)))
5046 : {
5047 0 : if ((_q91 == _q51 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q51, 0) && types_match (_q91, _q51)))
5048 : {
5049 0 : {
5050 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q50, _q51 };
5051 0 : tree res = generic_simplify_91 (loc, type, _p0, _p1, captures);
5052 0 : if (res) return res;
5053 : }
5054 : }
5055 : }
5056 0 : if ((_q90 == _q51 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q51, 0) && types_match (_q90, _q51)))
5057 : {
5058 0 : if ((_q91 == _q50 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q50, 0) && types_match (_q91, _q50)))
5059 : {
5060 0 : {
5061 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q51, _q50 };
5062 0 : tree res = generic_simplify_91 (loc, type, _p0, _p1, captures);
5063 0 : if (res) return res;
5064 : }
5065 : }
5066 : }
5067 : break;
5068 : }
5069 0 : default:;
5070 : }
5071 0 : {
5072 0 : tree _p1_pops[1];
5073 0 : if (tree_nop_convert (_p1, _p1_pops))
5074 : {
5075 0 : tree _q90 = _p1_pops[0];
5076 0 : switch (TREE_CODE (_q90))
5077 : {
5078 0 : case BIT_IOR_EXPR:
5079 0 : {
5080 0 : tree _q100 = TREE_OPERAND (_q90, 0);
5081 0 : tree _q101 = TREE_OPERAND (_q90, 1);
5082 0 : if ((_q100 == _q50 && ! TREE_SIDE_EFFECTS (_q100)) || (operand_equal_p (_q100, _q50, 0) && types_match (_q100, _q50)))
5083 : {
5084 0 : if ((_q101 == _q51 && ! TREE_SIDE_EFFECTS (_q101)) || (operand_equal_p (_q101, _q51, 0) && types_match (_q101, _q51)))
5085 : {
5086 0 : {
5087 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q50, _q51 };
5088 0 : tree res = generic_simplify_91 (loc, type, _p0, _p1, captures);
5089 0 : if (res) return res;
5090 : }
5091 : }
5092 : }
5093 0 : if ((_q100 == _q51 && ! TREE_SIDE_EFFECTS (_q100)) || (operand_equal_p (_q100, _q51, 0) && types_match (_q100, _q51)))
5094 : {
5095 0 : if ((_q101 == _q50 && ! TREE_SIDE_EFFECTS (_q101)) || (operand_equal_p (_q101, _q50, 0) && types_match (_q101, _q50)))
5096 : {
5097 0 : {
5098 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q51, _q50 };
5099 0 : tree res = generic_simplify_91 (loc, type, _p0, _p1, captures);
5100 0 : if (res) return res;
5101 : }
5102 : }
5103 : }
5104 : break;
5105 : }
5106 : default:;
5107 : }
5108 : }
5109 : }
5110 : }
5111 : break;
5112 : }
5113 : default:;
5114 : }
5115 : }
5116 : }
5117 1039617 : break;
5118 : }
5119 14 : case BIT_AND_EXPR:
5120 14 : {
5121 14 : tree _q30 = TREE_OPERAND (_q20, 0);
5122 14 : tree _q31 = TREE_OPERAND (_q20, 1);
5123 14 : switch (TREE_CODE (_p1))
5124 : {
5125 0 : case PLUS_EXPR:
5126 0 : {
5127 0 : tree _q60 = TREE_OPERAND (_p1, 0);
5128 0 : tree _q61 = TREE_OPERAND (_p1, 1);
5129 0 : switch (TREE_CODE (_q60))
5130 : {
5131 0 : case BIT_IOR_EXPR:
5132 0 : {
5133 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5134 0 : tree _q71 = TREE_OPERAND (_q60, 1);
5135 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
5136 : {
5137 0 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
5138 : {
5139 0 : if (integer_onep (_q61))
5140 : {
5141 0 : {
5142 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
5143 0 : tree res = generic_simplify_90 (loc, type, _p0, _p1, captures);
5144 0 : if (res) return res;
5145 : }
5146 : }
5147 : }
5148 : }
5149 0 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q31, 0) && types_match (_q70, _q31)))
5150 : {
5151 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
5152 : {
5153 0 : if (integer_onep (_q61))
5154 : {
5155 0 : {
5156 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
5157 0 : tree res = generic_simplify_90 (loc, type, _p0, _p1, captures);
5158 0 : if (res) return res;
5159 : }
5160 : }
5161 : }
5162 : }
5163 : break;
5164 : }
5165 0 : default:;
5166 : }
5167 0 : {
5168 0 : tree _q60_pops[1];
5169 0 : if (tree_nop_convert (_q60, _q60_pops))
5170 : {
5171 0 : tree _q70 = _q60_pops[0];
5172 0 : switch (TREE_CODE (_q70))
5173 : {
5174 0 : case BIT_IOR_EXPR:
5175 0 : {
5176 0 : tree _q80 = TREE_OPERAND (_q70, 0);
5177 0 : tree _q81 = TREE_OPERAND (_q70, 1);
5178 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
5179 : {
5180 0 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
5181 : {
5182 0 : if (integer_onep (_q61))
5183 : {
5184 0 : {
5185 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
5186 0 : tree res = generic_simplify_90 (loc, type, _p0, _p1, captures);
5187 0 : if (res) return res;
5188 : }
5189 : }
5190 : }
5191 : }
5192 0 : if ((_q80 == _q31 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q31, 0) && types_match (_q80, _q31)))
5193 : {
5194 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
5195 : {
5196 0 : if (integer_onep (_q61))
5197 : {
5198 0 : {
5199 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
5200 0 : tree res = generic_simplify_90 (loc, type, _p0, _p1, captures);
5201 0 : if (res) return res;
5202 : }
5203 : }
5204 : }
5205 : }
5206 : break;
5207 : }
5208 : default:;
5209 : }
5210 : }
5211 : }
5212 0 : break;
5213 : }
5214 14 : default:;
5215 : }
5216 14 : {
5217 14 : tree _p1_pops[1];
5218 14 : if (tree_nop_convert (_p1, _p1_pops))
5219 : {
5220 14 : tree _q60 = _p1_pops[0];
5221 14 : switch (TREE_CODE (_q60))
5222 : {
5223 0 : case PLUS_EXPR:
5224 0 : {
5225 0 : tree _q70 = TREE_OPERAND (_q60, 0);
5226 0 : tree _q71 = TREE_OPERAND (_q60, 1);
5227 0 : switch (TREE_CODE (_q70))
5228 : {
5229 0 : case BIT_IOR_EXPR:
5230 0 : {
5231 0 : tree _q80 = TREE_OPERAND (_q70, 0);
5232 0 : tree _q81 = TREE_OPERAND (_q70, 1);
5233 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
5234 : {
5235 0 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
5236 : {
5237 0 : if (integer_onep (_q71))
5238 : {
5239 0 : {
5240 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q60 };
5241 0 : tree res = generic_simplify_90 (loc, type, _p0, _p1, captures);
5242 0 : if (res) return res;
5243 : }
5244 : }
5245 : }
5246 : }
5247 0 : if ((_q80 == _q31 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q31, 0) && types_match (_q80, _q31)))
5248 : {
5249 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
5250 : {
5251 0 : if (integer_onep (_q71))
5252 : {
5253 0 : {
5254 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q60 };
5255 0 : tree res = generic_simplify_90 (loc, type, _p0, _p1, captures);
5256 0 : if (res) return res;
5257 : }
5258 : }
5259 : }
5260 : }
5261 : break;
5262 : }
5263 0 : default:;
5264 : }
5265 0 : {
5266 0 : tree _q70_pops[1];
5267 0 : if (tree_nop_convert (_q70, _q70_pops))
5268 : {
5269 0 : tree _q80 = _q70_pops[0];
5270 0 : switch (TREE_CODE (_q80))
5271 : {
5272 0 : case BIT_IOR_EXPR:
5273 0 : {
5274 0 : tree _q90 = TREE_OPERAND (_q80, 0);
5275 0 : tree _q91 = TREE_OPERAND (_q80, 1);
5276 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
5277 : {
5278 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
5279 : {
5280 0 : if (integer_onep (_q71))
5281 : {
5282 0 : {
5283 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q60 };
5284 0 : tree res = generic_simplify_90 (loc, type, _p0, _p1, captures);
5285 0 : if (res) return res;
5286 : }
5287 : }
5288 : }
5289 : }
5290 0 : if ((_q90 == _q31 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q31, 0) && types_match (_q90, _q31)))
5291 : {
5292 0 : if ((_q91 == _q30 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q30, 0) && types_match (_q91, _q30)))
5293 : {
5294 0 : if (integer_onep (_q71))
5295 : {
5296 0 : {
5297 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q60 };
5298 0 : tree res = generic_simplify_90 (loc, type, _p0, _p1, captures);
5299 0 : if (res) return res;
5300 : }
5301 : }
5302 : }
5303 : }
5304 : break;
5305 : }
5306 : default:;
5307 : }
5308 : }
5309 : }
5310 0 : break;
5311 : }
5312 : default:;
5313 : }
5314 : }
5315 : }
5316 14 : break;
5317 : }
5318 : default:;
5319 : }
5320 : }
5321 : }
5322 31242786 : if (tree_negate_expr_p (_p1))
5323 : {
5324 7776614 : {
5325 7776614 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
5326 7776614 : if (!FIXED_POINT_TYPE_P (type)
5327 : )
5328 : {
5329 7776614 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1284;
5330 7776614 : {
5331 7776614 : tree res_op0;
5332 7776614 : res_op0 = captures[0];
5333 7776614 : tree res_op1;
5334 7776614 : {
5335 7776614 : tree _o1[1], _r1;
5336 7776614 : _o1[0] = captures[1];
5337 7776614 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
5338 7776614 : res_op1 = _r1;
5339 : }
5340 7776614 : tree _r;
5341 7776614 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
5342 7776614 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
5343 7776614 : return _r;
5344 : }
5345 0 : next_after_fail1284:;
5346 : }
5347 : }
5348 : }
5349 23466172 : switch (TREE_CODE (_p0))
5350 : {
5351 5194290 : CASE_CONVERT:
5352 5194290 : {
5353 5194290 : tree _q20 = TREE_OPERAND (_p0, 0);
5354 5194290 : switch (TREE_CODE (_p1))
5355 : {
5356 4330381 : CASE_CONVERT:
5357 4330381 : {
5358 4330381 : tree _q40 = TREE_OPERAND (_p1, 0);
5359 4330381 : switch (TREE_CODE (_q40))
5360 : {
5361 15 : case BIT_AND_EXPR:
5362 15 : {
5363 15 : tree _q50 = TREE_OPERAND (_q40, 0);
5364 15 : tree _q51 = TREE_OPERAND (_q40, 1);
5365 15 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
5366 : {
5367 0 : {
5368 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q50, _p1, _q40, _q51, _q20 };
5369 0 : tree res = generic_simplify_93 (loc, type, _p0, _p1, captures);
5370 0 : if (res) return res;
5371 : }
5372 : }
5373 15 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
5374 : {
5375 1 : {
5376 1 : tree captures[5] ATTRIBUTE_UNUSED = { _q51, _p1, _q40, _q50, _q20 };
5377 1 : tree res = generic_simplify_93 (loc, type, _p0, _p1, captures);
5378 1 : if (res) return res;
5379 : }
5380 : }
5381 : break;
5382 : }
5383 : default:;
5384 : }
5385 : break;
5386 : }
5387 5349 : case BIT_AND_EXPR:
5388 5349 : {
5389 5349 : tree _q40 = TREE_OPERAND (_p1, 0);
5390 5349 : tree _q41 = TREE_OPERAND (_p1, 1);
5391 5349 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _q20, 0))
5392 : {
5393 0 : {
5394 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q40, _p1, _p1, _q41, _q20 };
5395 0 : tree res = generic_simplify_94 (loc, type, _p0, _p1, captures);
5396 0 : if (res) return res;
5397 : }
5398 : }
5399 5349 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _q20, 0))
5400 : {
5401 21 : {
5402 21 : tree captures[5] ATTRIBUTE_UNUSED = { _q41, _p1, _p1, _q40, _q20 };
5403 21 : tree res = generic_simplify_94 (loc, type, _p0, _p1, captures);
5404 21 : if (res) return res;
5405 : }
5406 : }
5407 : break;
5408 : }
5409 5194268 : default:;
5410 : }
5411 5194268 : switch (TREE_CODE (_q20))
5412 : {
5413 118064 : case ADDR_EXPR:
5414 118064 : {
5415 118064 : switch (TREE_CODE (_p1))
5416 : {
5417 109563 : CASE_CONVERT:
5418 109563 : {
5419 109563 : tree _q40 = TREE_OPERAND (_p1, 0);
5420 109563 : switch (TREE_CODE (_q40))
5421 : {
5422 32190 : case POINTER_PLUS_EXPR:
5423 32190 : {
5424 32190 : tree _q50 = TREE_OPERAND (_q40, 0);
5425 32190 : tree _q51 = TREE_OPERAND (_q40, 1);
5426 32190 : {
5427 32190 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q50, _q51 };
5428 32190 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
5429 : )
5430 : {
5431 32190 : {
5432 32190 : poly_int64 diff;
5433 32190 : if (ptr_difference_const (captures[0], captures[1], &diff)
5434 : )
5435 : {
5436 16537 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1285;
5437 16537 : {
5438 16537 : tree res_op0;
5439 16537 : res_op0 = build_int_cst_type (type, diff);
5440 16537 : tree res_op1;
5441 16537 : {
5442 16537 : tree _o1[1], _r1;
5443 16537 : _o1[0] = captures[2];
5444 16537 : if (TREE_TYPE (_o1[0]) != type)
5445 : {
5446 16537 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
5447 : }
5448 : else
5449 : _r1 = _o1[0];
5450 16537 : res_op1 = _r1;
5451 : }
5452 16537 : tree _r;
5453 16537 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
5454 16537 : if (TREE_SIDE_EFFECTS (captures[0]))
5455 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
5456 16537 : if (TREE_SIDE_EFFECTS (captures[1]))
5457 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5458 16537 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 925, __FILE__, __LINE__, true);
5459 16537 : return _r;
5460 : }
5461 0 : next_after_fail1285:;
5462 : }
5463 : }
5464 : }
5465 : }
5466 15653 : break;
5467 : }
5468 93026 : default:;
5469 : }
5470 93026 : {
5471 93026 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
5472 93026 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
5473 : )
5474 : {
5475 93026 : {
5476 93026 : poly_int64 diff;
5477 93026 : if (ptr_difference_const (captures[0], captures[1], &diff)
5478 : )
5479 : {
5480 57056 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1286;
5481 57056 : {
5482 57056 : tree _r;
5483 57056 : _r = build_int_cst_type (type, diff);
5484 57056 : if (TREE_SIDE_EFFECTS (captures[0]))
5485 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
5486 57056 : if (TREE_SIDE_EFFECTS (captures[1]))
5487 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5488 57056 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 926, __FILE__, __LINE__, true);
5489 57056 : return _r;
5490 : }
5491 0 : next_after_fail1286:;
5492 : }
5493 : }
5494 : }
5495 : }
5496 35970 : break;
5497 : }
5498 : default:;
5499 : }
5500 : break;
5501 : }
5502 107761 : case POINTER_PLUS_EXPR:
5503 107761 : {
5504 107761 : tree _q30 = TREE_OPERAND (_q20, 0);
5505 107761 : tree _q31 = TREE_OPERAND (_q20, 1);
5506 107761 : switch (TREE_CODE (_p1))
5507 : {
5508 106687 : CASE_CONVERT:
5509 106687 : {
5510 106687 : tree _q60 = TREE_OPERAND (_p1, 0);
5511 106687 : switch (TREE_CODE (_q60))
5512 : {
5513 5783 : case ADDR_EXPR:
5514 5783 : {
5515 5783 : {
5516 5783 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q60 };
5517 5783 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
5518 : )
5519 : {
5520 5783 : {
5521 5783 : poly_int64 diff;
5522 5783 : if (ptr_difference_const (captures[0], captures[2], &diff)
5523 : )
5524 : {
5525 997 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1287;
5526 997 : {
5527 997 : tree res_op0;
5528 997 : {
5529 997 : tree _o1[1], _r1;
5530 997 : _o1[0] = captures[1];
5531 997 : if (TREE_TYPE (_o1[0]) != type)
5532 : {
5533 928 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
5534 : }
5535 : else
5536 : _r1 = _o1[0];
5537 997 : res_op0 = _r1;
5538 : }
5539 997 : tree res_op1;
5540 997 : res_op1 = build_int_cst_type (type, diff);
5541 997 : tree _r;
5542 997 : _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
5543 997 : if (TREE_SIDE_EFFECTS (captures[0]))
5544 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
5545 997 : if (TREE_SIDE_EFFECTS (captures[2]))
5546 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
5547 997 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
5548 997 : return _r;
5549 : }
5550 0 : next_after_fail1287:;
5551 : }
5552 : }
5553 : }
5554 : }
5555 4786 : break;
5556 : }
5557 : default:;
5558 : }
5559 : break;
5560 : }
5561 : default:;
5562 : }
5563 : break;
5564 : }
5565 5119678 : default:;
5566 : }
5567 5119678 : switch (TREE_CODE (_p1))
5568 : {
5569 4255790 : CASE_CONVERT:
5570 4255790 : {
5571 4255790 : tree _q40 = TREE_OPERAND (_p1, 0);
5572 4255790 : switch (TREE_CODE (_q40))
5573 : {
5574 49479 : case ADDR_EXPR:
5575 49479 : {
5576 49479 : {
5577 49479 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
5578 49479 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
5579 : )
5580 : {
5581 49458 : {
5582 49458 : poly_int64 diff;
5583 49458 : if (ptr_difference_const (captures[0], captures[1], &diff)
5584 : )
5585 : {
5586 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1288;
5587 0 : {
5588 0 : tree _r;
5589 0 : _r = build_int_cst_type (type, diff);
5590 0 : if (TREE_SIDE_EFFECTS (captures[0]))
5591 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
5592 0 : if (TREE_SIDE_EFFECTS (captures[1]))
5593 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5594 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 928, __FILE__, __LINE__, true);
5595 0 : return _r;
5596 : }
5597 0 : next_after_fail1288:;
5598 : }
5599 : }
5600 : }
5601 : }
5602 49479 : break;
5603 : }
5604 : default:;
5605 : }
5606 : break;
5607 : }
5608 : default:;
5609 : }
5610 : break;
5611 : }
5612 23391560 : default:;
5613 : }
5614 23391560 : if (integer_onep (_p0))
5615 : {
5616 105963 : switch (TREE_CODE (_p1))
5617 : {
5618 27705 : case SSA_NAME:
5619 27705 : {
5620 27705 : {
5621 27705 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
5622 27705 : if (INTEGRAL_TYPE_P (type)
5623 27705 : && ssa_name_has_boolean_range (captures[1])
5624 : )
5625 : {
5626 226 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1289;
5627 226 : {
5628 226 : tree res_op0;
5629 226 : res_op0 = captures[1];
5630 226 : tree res_op1;
5631 226 : res_op1 = captures[0];
5632 226 : tree _r;
5633 226 : _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
5634 226 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 929, __FILE__, __LINE__, true);
5635 226 : return _r;
5636 : }
5637 0 : next_after_fail1289:;
5638 : }
5639 : }
5640 27479 : break;
5641 : }
5642 : default:;
5643 : }
5644 : }
5645 23391334 : switch (TREE_CODE (_p1))
5646 : {
5647 7616347 : CASE_CONVERT:
5648 7616347 : {
5649 7616347 : tree _q30 = TREE_OPERAND (_p1, 0);
5650 7616347 : switch (TREE_CODE (_q30))
5651 : {
5652 14 : case BIT_AND_EXPR:
5653 14 : {
5654 14 : tree _q40 = TREE_OPERAND (_q30, 0);
5655 14 : tree _q41 = TREE_OPERAND (_q30, 1);
5656 14 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _p0, 0))
5657 : {
5658 0 : {
5659 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q40, _p1, _q30, _q41, _p0 };
5660 0 : tree res = generic_simplify_93 (loc, type, _p0, _p1, captures);
5661 0 : if (res) return res;
5662 : }
5663 : }
5664 14 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _p0, 0))
5665 : {
5666 0 : {
5667 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q41, _p1, _q30, _q40, _p0 };
5668 0 : tree res = generic_simplify_93 (loc, type, _p0, _p1, captures);
5669 0 : if (res) return res;
5670 : }
5671 : }
5672 : break;
5673 : }
5674 : default:;
5675 : }
5676 : break;
5677 : }
5678 7495 : case BIT_AND_EXPR:
5679 7495 : {
5680 7495 : tree _q30 = TREE_OPERAND (_p1, 0);
5681 7495 : tree _q31 = TREE_OPERAND (_p1, 1);
5682 7495 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || operand_equal_p (_q30, _p0, 0))
5683 : {
5684 217 : {
5685 217 : tree captures[5] ATTRIBUTE_UNUSED = { _q30, _p1, _p1, _q31, _p0 };
5686 217 : tree res = generic_simplify_94 (loc, type, _p0, _p1, captures);
5687 217 : if (res) return res;
5688 : }
5689 : }
5690 7278 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || operand_equal_p (_q31, _p0, 0))
5691 : {
5692 38 : {
5693 38 : tree captures[5] ATTRIBUTE_UNUSED = { _q31, _p1, _p1, _q30, _p0 };
5694 38 : tree res = generic_simplify_94 (loc, type, _p0, _p1, captures);
5695 38 : if (res) return res;
5696 : }
5697 : }
5698 : break;
5699 : }
5700 23391079 : default:;
5701 : }
5702 23391079 : switch (TREE_CODE (_p0))
5703 : {
5704 1794999 : case PLUS_EXPR:
5705 1794999 : {
5706 1794999 : tree _q20 = TREE_OPERAND (_p0, 0);
5707 1794999 : tree _q21 = TREE_OPERAND (_p0, 1);
5708 1794999 : switch (TREE_CODE (_p1))
5709 : {
5710 482924 : case PLUS_EXPR:
5711 482924 : {
5712 482924 : tree _q50 = TREE_OPERAND (_p1, 0);
5713 482924 : tree _q51 = TREE_OPERAND (_p1, 1);
5714 482924 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5715 : {
5716 178061 : {
5717 178061 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5718 356122 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
5719 356122 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5720 40239 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
5721 : )
5722 : {
5723 178055 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1290;
5724 178055 : {
5725 178055 : tree res_op0;
5726 178055 : res_op0 = captures[0];
5727 178055 : tree res_op1;
5728 178055 : res_op1 = captures[2];
5729 178055 : tree _r;
5730 178055 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
5731 178055 : if (TREE_SIDE_EFFECTS (captures[1]))
5732 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5733 178055 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 930, __FILE__, __LINE__, true);
5734 178055 : return _r;
5735 : }
5736 0 : next_after_fail1290:;
5737 : }
5738 : }
5739 : }
5740 304869 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
5741 : {
5742 600 : {
5743 600 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5744 1200 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
5745 1200 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5746 490 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
5747 : )
5748 : {
5749 600 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1291;
5750 600 : {
5751 600 : tree res_op0;
5752 600 : res_op0 = captures[0];
5753 600 : tree res_op1;
5754 600 : res_op1 = captures[2];
5755 600 : tree _r;
5756 600 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
5757 600 : if (TREE_SIDE_EFFECTS (captures[1]))
5758 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5759 600 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 930, __FILE__, __LINE__, true);
5760 600 : return _r;
5761 : }
5762 0 : next_after_fail1291:;
5763 : }
5764 : }
5765 : }
5766 304269 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
5767 : {
5768 479 : {
5769 479 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
5770 958 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
5771 958 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5772 390 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
5773 : )
5774 : {
5775 479 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1292;
5776 479 : {
5777 479 : tree res_op0;
5778 479 : res_op0 = captures[0];
5779 479 : tree res_op1;
5780 479 : res_op1 = captures[2];
5781 479 : tree _r;
5782 479 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
5783 479 : if (TREE_SIDE_EFFECTS (captures[1]))
5784 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5785 479 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 930, __FILE__, __LINE__, true);
5786 479 : return _r;
5787 : }
5788 0 : next_after_fail1292:;
5789 : }
5790 : }
5791 : }
5792 303790 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5793 : {
5794 174767 : {
5795 174767 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
5796 349534 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
5797 349534 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5798 141656 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
5799 : )
5800 : {
5801 174767 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1293;
5802 174767 : {
5803 174767 : tree res_op0;
5804 174767 : res_op0 = captures[0];
5805 174767 : tree res_op1;
5806 174767 : res_op1 = captures[2];
5807 174767 : tree _r;
5808 174767 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
5809 174767 : if (TREE_SIDE_EFFECTS (captures[1]))
5810 2 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5811 174767 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 930, __FILE__, __LINE__, true);
5812 174767 : return _r;
5813 : }
5814 0 : next_after_fail1293:;
5815 : }
5816 : }
5817 : }
5818 : break;
5819 : }
5820 : default:;
5821 : }
5822 : break;
5823 : }
5824 987631 : case MINUS_EXPR:
5825 987631 : {
5826 987631 : tree _q20 = TREE_OPERAND (_p0, 0);
5827 987631 : tree _q21 = TREE_OPERAND (_p0, 1);
5828 987631 : switch (TREE_CODE (_p1))
5829 : {
5830 3919 : case MINUS_EXPR:
5831 3919 : {
5832 3919 : tree _q50 = TREE_OPERAND (_p1, 0);
5833 3919 : tree _q51 = TREE_OPERAND (_p1, 1);
5834 3919 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5835 : {
5836 3877 : {
5837 3877 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
5838 7754 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
5839 7754 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5840 0 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
5841 : )
5842 : {
5843 3877 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1294;
5844 3877 : {
5845 3877 : tree res_op0;
5846 3877 : res_op0 = captures[0];
5847 3877 : tree res_op1;
5848 3877 : res_op1 = captures[2];
5849 3877 : tree _r;
5850 3877 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
5851 3877 : if (TREE_SIDE_EFFECTS (captures[1]))
5852 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5853 3877 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 931, __FILE__, __LINE__, true);
5854 3877 : return _r;
5855 : }
5856 0 : next_after_fail1294:;
5857 : }
5858 : }
5859 : }
5860 42 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5861 : {
5862 0 : {
5863 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
5864 0 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
5865 0 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
5866 0 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1])))
5867 : )
5868 : {
5869 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1295;
5870 0 : {
5871 0 : tree res_op0;
5872 0 : res_op0 = captures[2];
5873 0 : tree res_op1;
5874 0 : res_op1 = captures[1];
5875 0 : tree _r;
5876 0 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
5877 0 : if (TREE_SIDE_EFFECTS (captures[0]))
5878 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
5879 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 932, __FILE__, __LINE__, true);
5880 0 : return _r;
5881 : }
5882 0 : next_after_fail1295:;
5883 : }
5884 : }
5885 : }
5886 : break;
5887 : }
5888 : default:;
5889 : }
5890 : break;
5891 : }
5892 59 : case POINTER_DIFF_EXPR:
5893 59 : {
5894 59 : tree _q20 = TREE_OPERAND (_p0, 0);
5895 59 : tree _q21 = TREE_OPERAND (_p0, 1);
5896 59 : switch (TREE_CODE (_p1))
5897 : {
5898 0 : case POINTER_DIFF_EXPR:
5899 0 : {
5900 0 : tree _q50 = TREE_OPERAND (_p1, 0);
5901 0 : tree _q51 = TREE_OPERAND (_p1, 1);
5902 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
5903 : {
5904 0 : {
5905 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
5906 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5907 0 : && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[2]))
5908 : )
5909 : {
5910 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1296;
5911 0 : {
5912 0 : tree res_op0;
5913 0 : res_op0 = captures[1];
5914 0 : tree res_op1;
5915 0 : res_op1 = captures[3];
5916 0 : tree _r;
5917 0 : _r = fold_build2_loc (loc, POINTER_DIFF_EXPR, type, res_op0, res_op1);
5918 0 : if (TREE_SIDE_EFFECTS (captures[2]))
5919 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
5920 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 933, __FILE__, __LINE__, true);
5921 0 : return _r;
5922 : }
5923 0 : next_after_fail1296:;
5924 : }
5925 : }
5926 : }
5927 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
5928 : {
5929 0 : {
5930 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
5931 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
5932 0 : && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[1]))
5933 : )
5934 : {
5935 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1297;
5936 0 : {
5937 0 : tree res_op0;
5938 0 : res_op0 = captures[3];
5939 0 : tree res_op1;
5940 0 : res_op1 = captures[2];
5941 0 : tree _r;
5942 0 : _r = fold_build2_loc (loc, POINTER_DIFF_EXPR, type, res_op0, res_op1);
5943 0 : if (TREE_SIDE_EFFECTS (captures[1]))
5944 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5945 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 934, __FILE__, __LINE__, true);
5946 0 : return _r;
5947 : }
5948 0 : next_after_fail1297:;
5949 : }
5950 : }
5951 : }
5952 : break;
5953 : }
5954 : default:;
5955 : }
5956 : break;
5957 : }
5958 23033301 : default:;
5959 : }
5960 23033301 : switch (TREE_CODE (_p1))
5961 : {
5962 7616347 : CASE_CONVERT:
5963 7616347 : {
5964 7616347 : tree _q30 = TREE_OPERAND (_p1, 0);
5965 7616347 : switch (TREE_CODE (_q30))
5966 : {
5967 2605 : case NEGATE_EXPR:
5968 2605 : {
5969 2605 : tree _q40 = TREE_OPERAND (_q30, 0);
5970 2605 : {
5971 2605 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
5972 2605 : tree res = generic_simplify_95 (loc, type, _p0, _p1, captures);
5973 2605 : if (res) return res;
5974 : }
5975 2597 : break;
5976 : }
5977 : default:;
5978 : }
5979 : break;
5980 : }
5981 45 : case NEGATE_EXPR:
5982 45 : {
5983 45 : tree _q30 = TREE_OPERAND (_p1, 0);
5984 45 : {
5985 45 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
5986 45 : tree res = generic_simplify_95 (loc, type, _p0, _p1, captures);
5987 45 : if (res) return res;
5988 : }
5989 40 : break;
5990 : }
5991 23033288 : default:;
5992 : }
5993 23033288 : switch (TREE_CODE (_p0))
5994 : {
5995 1441098 : case PLUS_EXPR:
5996 1441098 : {
5997 1441098 : tree _q20 = TREE_OPERAND (_p0, 0);
5998 1441098 : tree _q21 = TREE_OPERAND (_p0, 1);
5999 1441098 : {
6000 1441098 : tree _q20_pops[1];
6001 1441098 : if (tree_nop_convert (_q20, _q20_pops))
6002 : {
6003 335433 : tree _q30 = _q20_pops[0];
6004 335433 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
6005 : {
6006 393 : {
6007 393 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q21 };
6008 393 : tree res = generic_simplify_96 (loc, type, _p0, _p1, captures);
6009 393 : if (res) return res;
6010 : }
6011 : }
6012 : }
6013 : }
6014 1440705 : {
6015 1440705 : tree _q21_pops[1];
6016 1440705 : if (tree_nop_convert (_q21, _q21_pops))
6017 : {
6018 498211 : tree _q40 = _q21_pops[0];
6019 498211 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
6020 : {
6021 79 : {
6022 79 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
6023 79 : tree res = generic_simplify_96 (loc, type, _p0, _p1, captures);
6024 79 : if (res) return res;
6025 : }
6026 : }
6027 : }
6028 : }
6029 1440626 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
6030 : {
6031 54818 : {
6032 54818 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6033 54818 : tree res = generic_simplify_96 (loc, type, _p0, _p1, captures);
6034 54818 : if (res) return res;
6035 : }
6036 : }
6037 1385808 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
6038 : {
6039 1891 : {
6040 1891 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
6041 1891 : tree res = generic_simplify_96 (loc, type, _p0, _p1, captures);
6042 1891 : if (res) return res;
6043 : }
6044 : }
6045 : break;
6046 : }
6047 983754 : case MINUS_EXPR:
6048 983754 : {
6049 983754 : tree _q20 = TREE_OPERAND (_p0, 0);
6050 983754 : tree _q21 = TREE_OPERAND (_p0, 1);
6051 983754 : {
6052 983754 : tree _q20_pops[1];
6053 983754 : if (tree_nop_convert (_q20, _q20_pops))
6054 : {
6055 86336 : tree _q30 = _q20_pops[0];
6056 86336 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
6057 : {
6058 0 : {
6059 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q21 };
6060 0 : tree res = generic_simplify_97 (loc, type, _p0, _p1, captures);
6061 0 : if (res) return res;
6062 : }
6063 : }
6064 : }
6065 : }
6066 983754 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
6067 : {
6068 170 : {
6069 170 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
6070 170 : tree res = generic_simplify_97 (loc, type, _p0, _p1, captures);
6071 170 : if (res) return res;
6072 : }
6073 : }
6074 : break;
6075 : }
6076 22975948 : default:;
6077 : }
6078 22975948 : {
6079 22975948 : tree _p0_pops[1];
6080 22975948 : if (tree_nop_convert (_p0, _p0_pops))
6081 : {
6082 4508745 : tree _q20 = _p0_pops[0];
6083 4508745 : switch (TREE_CODE (_q20))
6084 : {
6085 360300 : case PLUS_EXPR:
6086 360300 : {
6087 360300 : tree _q30 = TREE_OPERAND (_q20, 0);
6088 360300 : tree _q31 = TREE_OPERAND (_q20, 1);
6089 360300 : {
6090 360300 : tree _q30_pops[1];
6091 360300 : if (tree_nop_convert (_q30, _q30_pops))
6092 : {
6093 28584 : tree _q40 = _q30_pops[0];
6094 28584 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
6095 : {
6096 574 : {
6097 574 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q31 };
6098 574 : tree res = generic_simplify_96 (loc, type, _p0, _p1, captures);
6099 574 : if (res) return res;
6100 : }
6101 : }
6102 : }
6103 : }
6104 359726 : {
6105 359726 : tree _q31_pops[1];
6106 359726 : if (tree_nop_convert (_q31, _q31_pops))
6107 : {
6108 2723 : tree _q50 = _q31_pops[0];
6109 2723 : if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
6110 : {
6111 52 : {
6112 52 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
6113 52 : tree res = generic_simplify_96 (loc, type, _p0, _p1, captures);
6114 52 : if (res) return res;
6115 : }
6116 : }
6117 : }
6118 : }
6119 359674 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
6120 : {
6121 12 : {
6122 12 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
6123 12 : tree res = generic_simplify_96 (loc, type, _p0, _p1, captures);
6124 12 : if (res) return res;
6125 : }
6126 : }
6127 359662 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
6128 : {
6129 0 : {
6130 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q30 };
6131 0 : tree res = generic_simplify_96 (loc, type, _p0, _p1, captures);
6132 0 : if (res) return res;
6133 : }
6134 : }
6135 : break;
6136 : }
6137 812 : case MINUS_EXPR:
6138 812 : {
6139 812 : tree _q30 = TREE_OPERAND (_q20, 0);
6140 812 : tree _q31 = TREE_OPERAND (_q20, 1);
6141 812 : {
6142 812 : tree _q30_pops[1];
6143 812 : if (tree_nop_convert (_q30, _q30_pops))
6144 : {
6145 0 : tree _q40 = _q30_pops[0];
6146 0 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
6147 : {
6148 0 : {
6149 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q31 };
6150 0 : tree res = generic_simplify_97 (loc, type, _p0, _p1, captures);
6151 0 : if (res) return res;
6152 : }
6153 : }
6154 : }
6155 : }
6156 812 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
6157 : {
6158 0 : {
6159 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
6160 0 : tree res = generic_simplify_97 (loc, type, _p0, _p1, captures);
6161 0 : if (res) return res;
6162 : }
6163 : }
6164 : break;
6165 : }
6166 : default:;
6167 : }
6168 : }
6169 : }
6170 22975310 : switch (TREE_CODE (_p1))
6171 : {
6172 1290115 : case PLUS_EXPR:
6173 1290115 : {
6174 1290115 : tree _q30 = TREE_OPERAND (_p1, 0);
6175 1290115 : tree _q31 = TREE_OPERAND (_p1, 1);
6176 1290115 : {
6177 1290115 : tree _q30_pops[1];
6178 1290115 : if (tree_nop_convert (_q30, _q30_pops))
6179 : {
6180 340732 : tree _q40 = _q30_pops[0];
6181 340732 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
6182 : {
6183 71 : {
6184 71 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
6185 71 : tree res = generic_simplify_98 (loc, type, _p0, _p1, captures);
6186 71 : if (res) return res;
6187 : }
6188 : }
6189 : }
6190 : }
6191 1290044 : {
6192 1290044 : tree _q31_pops[1];
6193 1290044 : if (tree_nop_convert (_q31, _q31_pops))
6194 : {
6195 74242 : tree _q50 = _q31_pops[0];
6196 74242 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
6197 : {
6198 0 : {
6199 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
6200 0 : tree res = generic_simplify_98 (loc, type, _p0, _p1, captures);
6201 0 : if (res) return res;
6202 : }
6203 : }
6204 : }
6205 : }
6206 1290044 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
6207 : {
6208 41694 : {
6209 41694 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
6210 41694 : tree res = generic_simplify_98 (loc, type, _p0, _p1, captures);
6211 41694 : if (res) return res;
6212 : }
6213 : }
6214 1248350 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
6215 : {
6216 1587 : {
6217 1587 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
6218 1587 : tree res = generic_simplify_98 (loc, type, _p0, _p1, captures);
6219 1587 : if (res) return res;
6220 : }
6221 : }
6222 : break;
6223 : }
6224 84074 : case MINUS_EXPR:
6225 84074 : {
6226 84074 : tree _q30 = TREE_OPERAND (_p1, 0);
6227 84074 : tree _q31 = TREE_OPERAND (_p1, 1);
6228 84074 : {
6229 84074 : tree _q30_pops[1];
6230 84074 : if (tree_nop_convert (_q30, _q30_pops))
6231 : {
6232 61 : tree _q40 = _q30_pops[0];
6233 61 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
6234 : {
6235 0 : {
6236 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
6237 0 : tree res = generic_simplify_99 (loc, type, _p0, _p1, captures);
6238 0 : if (res) return res;
6239 : }
6240 : }
6241 : }
6242 : }
6243 84074 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
6244 : {
6245 353 : {
6246 353 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
6247 353 : tree res = generic_simplify_99 (loc, type, _p0, _p1, captures);
6248 353 : if (res) return res;
6249 : }
6250 : }
6251 : break;
6252 : }
6253 22931605 : default:;
6254 : }
6255 22931605 : {
6256 22931605 : tree _p1_pops[1];
6257 22931605 : if (tree_nop_convert (_p1, _p1_pops))
6258 : {
6259 6906371 : tree _q30 = _p1_pops[0];
6260 6906371 : switch (TREE_CODE (_q30))
6261 : {
6262 678907 : case PLUS_EXPR:
6263 678907 : {
6264 678907 : tree _q40 = TREE_OPERAND (_q30, 0);
6265 678907 : tree _q41 = TREE_OPERAND (_q30, 1);
6266 678907 : {
6267 678907 : tree _q40_pops[1];
6268 678907 : if (tree_nop_convert (_q40, _q40_pops))
6269 : {
6270 60563 : tree _q50 = _q40_pops[0];
6271 60563 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
6272 : {
6273 163 : {
6274 163 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
6275 163 : tree res = generic_simplify_98 (loc, type, _p0, _p1, captures);
6276 163 : if (res) return res;
6277 : }
6278 : }
6279 : }
6280 : }
6281 678744 : {
6282 678744 : tree _q41_pops[1];
6283 678744 : if (tree_nop_convert (_q41, _q41_pops))
6284 : {
6285 20149 : tree _q60 = _q41_pops[0];
6286 20149 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
6287 : {
6288 0 : {
6289 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
6290 0 : tree res = generic_simplify_98 (loc, type, _p0, _p1, captures);
6291 0 : if (res) return res;
6292 : }
6293 : }
6294 : }
6295 : }
6296 678744 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
6297 : {
6298 7 : {
6299 7 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
6300 7 : tree res = generic_simplify_98 (loc, type, _p0, _p1, captures);
6301 7 : if (res) return res;
6302 : }
6303 : }
6304 678737 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
6305 : {
6306 0 : {
6307 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
6308 0 : tree res = generic_simplify_98 (loc, type, _p0, _p1, captures);
6309 0 : if (res) return res;
6310 : }
6311 : }
6312 : break;
6313 : }
6314 7656 : case MINUS_EXPR:
6315 7656 : {
6316 7656 : tree _q40 = TREE_OPERAND (_q30, 0);
6317 7656 : tree _q41 = TREE_OPERAND (_q30, 1);
6318 7656 : {
6319 7656 : tree _q40_pops[1];
6320 7656 : if (tree_nop_convert (_q40, _q40_pops))
6321 : {
6322 6814 : tree _q50 = _q40_pops[0];
6323 6814 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
6324 : {
6325 0 : {
6326 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
6327 0 : tree res = generic_simplify_99 (loc, type, _p0, _p1, captures);
6328 0 : if (res) return res;
6329 : }
6330 : }
6331 : }
6332 : }
6333 7656 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
6334 : {
6335 2 : {
6336 2 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
6337 2 : tree res = generic_simplify_99 (loc, type, _p0, _p1, captures);
6338 2 : if (res) return res;
6339 : }
6340 : }
6341 : break;
6342 : }
6343 : default:;
6344 : }
6345 : }
6346 : }
6347 22931433 : switch (TREE_CODE (_p0))
6348 : {
6349 1383928 : case PLUS_EXPR:
6350 1383928 : {
6351 1383928 : tree _q20 = TREE_OPERAND (_p0, 0);
6352 1383928 : tree _q21 = TREE_OPERAND (_p0, 1);
6353 1383928 : switch (TREE_CODE (_p1))
6354 : {
6355 112 : case MINUS_EXPR:
6356 112 : {
6357 112 : tree _q50 = TREE_OPERAND (_p1, 0);
6358 112 : tree _q51 = TREE_OPERAND (_p1, 1);
6359 112 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
6360 : {
6361 0 : {
6362 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
6363 0 : tree res = generic_simplify_100 (loc, type, _p0, _p1, captures);
6364 0 : if (res) return res;
6365 : }
6366 : }
6367 112 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
6368 : {
6369 0 : {
6370 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
6371 0 : tree res = generic_simplify_100 (loc, type, _p0, _p1, captures);
6372 0 : if (res) return res;
6373 : }
6374 : }
6375 : break;
6376 : }
6377 1383928 : default:;
6378 : }
6379 1383928 : if (CONSTANT_CLASS_P (_q21))
6380 : {
6381 576503 : if (CONSTANT_CLASS_P (_p1))
6382 : {
6383 13 : {
6384 13 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6385 13 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, PLUS_EXPR, MINUS_EXPR, MINUS_EXPR);
6386 13 : if (res) return res;
6387 : }
6388 : }
6389 : }
6390 : break;
6391 : }
6392 983581 : case MINUS_EXPR:
6393 983581 : {
6394 983581 : tree _q20 = TREE_OPERAND (_p0, 0);
6395 983581 : tree _q21 = TREE_OPERAND (_p0, 1);
6396 983581 : if (CONSTANT_CLASS_P (_q21))
6397 : {
6398 96998 : if (CONSTANT_CLASS_P (_p1))
6399 : {
6400 12 : {
6401 12 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6402 12 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, MINUS_EXPR, PLUS_EXPR, MINUS_EXPR);
6403 12 : if (res) return res;
6404 : }
6405 : }
6406 : }
6407 983581 : if (CONSTANT_CLASS_P (_q20))
6408 : {
6409 2941 : if (CONSTANT_CLASS_P (_p1))
6410 : {
6411 1 : {
6412 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
6413 1 : tree res = generic_simplify_64 (loc, type, _p0, _p1, captures, MINUS_EXPR);
6414 1 : if (res) return res;
6415 : }
6416 : }
6417 : }
6418 : break;
6419 : }
6420 5101506 : CASE_CONVERT:
6421 5101506 : {
6422 5101506 : tree _q20 = TREE_OPERAND (_p0, 0);
6423 5101506 : switch (TREE_CODE (_p1))
6424 : {
6425 4255778 : CASE_CONVERT:
6426 4255778 : {
6427 4255778 : tree _q40 = TREE_OPERAND (_p1, 0);
6428 4255778 : {
6429 4255778 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
6430 4255778 : tree res = generic_simplify_68 (loc, type, _p0, _p1, captures, MINUS_EXPR);
6431 4255778 : if (res) return res;
6432 : }
6433 4245342 : break;
6434 : }
6435 5091070 : default:;
6436 : }
6437 5091070 : switch (TREE_CODE (_q20))
6438 : {
6439 272 : case NEGATE_EXPR:
6440 272 : {
6441 272 : tree _q30 = TREE_OPERAND (_q20, 0);
6442 272 : if (integer_each_onep (_p1))
6443 : {
6444 0 : {
6445 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
6446 0 : tree res = generic_simplify_102 (loc, type, _p0, _p1, captures);
6447 0 : if (res) return res;
6448 : }
6449 : }
6450 : break;
6451 : }
6452 414302 : case PLUS_EXPR:
6453 414302 : {
6454 414302 : tree _q30 = TREE_OPERAND (_q20, 0);
6455 414302 : tree _q31 = TREE_OPERAND (_q20, 1);
6456 414302 : switch (TREE_CODE (_p1))
6457 : {
6458 397296 : CASE_CONVERT:
6459 397296 : {
6460 397296 : tree _q60 = TREE_OPERAND (_p1, 0);
6461 397296 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q30, 0))
6462 : {
6463 6629 : {
6464 6629 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q30 };
6465 6629 : tree res = generic_simplify_103 (loc, type, _p0, _p1, captures);
6466 6629 : if (res) return res;
6467 : }
6468 : }
6469 390787 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q31, 0))
6470 : {
6471 22 : {
6472 22 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q31 };
6473 22 : tree res = generic_simplify_103 (loc, type, _p0, _p1, captures);
6474 22 : if (res) return res;
6475 : }
6476 : }
6477 : break;
6478 : }
6479 407771 : default:;
6480 : }
6481 407771 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q30, 0))
6482 : {
6483 4247 : {
6484 4247 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q30 };
6485 4247 : tree res = generic_simplify_103 (loc, type, _p0, _p1, captures);
6486 4247 : if (res) return res;
6487 : }
6488 : }
6489 403524 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q31, 0))
6490 : {
6491 1344 : {
6492 1344 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _q30, _q31 };
6493 1344 : tree res = generic_simplify_103 (loc, type, _p0, _p1, captures);
6494 1344 : if (res) return res;
6495 : }
6496 : }
6497 : break;
6498 : }
6499 106764 : case POINTER_PLUS_EXPR:
6500 106764 : {
6501 106764 : tree _q30 = TREE_OPERAND (_q20, 0);
6502 106764 : tree _q31 = TREE_OPERAND (_q20, 1);
6503 106764 : switch (TREE_CODE (_p1))
6504 : {
6505 105690 : CASE_CONVERT:
6506 105690 : {
6507 105690 : tree _q60 = TREE_OPERAND (_p1, 0);
6508 105690 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || operand_equal_p (_q60, _q30, 0))
6509 : {
6510 12222 : {
6511 12222 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q30 };
6512 12222 : if (!TYPE_SATURATING (type)
6513 : )
6514 : {
6515 12222 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
6516 24444 : && !FIXED_POINT_TYPE_P (type)
6517 : )
6518 : {
6519 12222 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
6520 12222 : || (POINTER_TYPE_P (TREE_TYPE (captures[0]))
6521 0 : && TREE_CODE (captures[1]) == INTEGER_CST
6522 0 : && tree_int_cst_sign_bit (captures[1]) == 0)
6523 : )
6524 : {
6525 12222 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1298;
6526 12222 : {
6527 12222 : tree res_op0;
6528 12222 : res_op0 = captures[1];
6529 12222 : tree _r;
6530 12222 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
6531 12222 : if (TREE_SIDE_EFFECTS (captures[2]))
6532 11 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
6533 12222 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 935, __FILE__, __LINE__, true);
6534 12222 : return _r;
6535 : }
6536 0 : next_after_fail1298:;
6537 : }
6538 : }
6539 : }
6540 : }
6541 : }
6542 : break;
6543 : }
6544 : default:;
6545 : }
6546 : break;
6547 : }
6548 5066726 : default:;
6549 : }
6550 5066726 : switch (TREE_CODE (_p1))
6551 : {
6552 4221126 : CASE_CONVERT:
6553 4221126 : {
6554 4221126 : tree _q40 = TREE_OPERAND (_p1, 0);
6555 4221126 : switch (TREE_CODE (_q40))
6556 : {
6557 499648 : case PLUS_EXPR:
6558 499648 : {
6559 499648 : tree _q50 = TREE_OPERAND (_q40, 0);
6560 499648 : tree _q51 = TREE_OPERAND (_q40, 1);
6561 499648 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
6562 : {
6563 2145 : {
6564 2145 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
6565 2145 : tree res = generic_simplify_104 (loc, type, _p0, _p1, captures);
6566 2145 : if (res) return res;
6567 : }
6568 : }
6569 497576 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || operand_equal_p (_q51, _q20, 0))
6570 : {
6571 18 : {
6572 18 : tree captures[3] ATTRIBUTE_UNUSED = { _q51, _q50, _q20 };
6573 18 : tree res = generic_simplify_104 (loc, type, _p0, _p1, captures);
6574 18 : if (res) return res;
6575 : }
6576 : }
6577 : break;
6578 : }
6579 : default:;
6580 : }
6581 : break;
6582 : }
6583 : default:;
6584 : }
6585 : break;
6586 : }
6587 144260 : case NEGATE_EXPR:
6588 144260 : {
6589 144260 : tree _q20 = TREE_OPERAND (_p0, 0);
6590 144260 : if (integer_each_onep (_p1))
6591 : {
6592 41 : {
6593 41 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
6594 41 : tree res = generic_simplify_102 (loc, type, _p0, _p1, captures);
6595 41 : if (res) return res;
6596 : }
6597 : }
6598 : break;
6599 : }
6600 22894522 : default:;
6601 : }
6602 22894522 : {
6603 22894522 : tree _p0_pops[1];
6604 22894522 : if (tree_nop_convert (_p0, _p0_pops))
6605 : {
6606 4459740 : tree _q20 = _p0_pops[0];
6607 4459740 : switch (TREE_CODE (_q20))
6608 : {
6609 343953 : case PLUS_EXPR:
6610 343953 : {
6611 343953 : tree _q30 = TREE_OPERAND (_q20, 0);
6612 343953 : tree _q31 = TREE_OPERAND (_q20, 1);
6613 343953 : if (CONSTANT_CLASS_P (_q31))
6614 : {
6615 337059 : if (CONSTANT_CLASS_P (_p1))
6616 : {
6617 27 : {
6618 27 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
6619 27 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, PLUS_EXPR, MINUS_EXPR, MINUS_EXPR);
6620 27 : if (res) return res;
6621 : }
6622 : }
6623 : }
6624 : break;
6625 : }
6626 812 : case MINUS_EXPR:
6627 812 : {
6628 812 : tree _q30 = TREE_OPERAND (_q20, 0);
6629 812 : tree _q31 = TREE_OPERAND (_q20, 1);
6630 812 : if (CONSTANT_CLASS_P (_q31))
6631 : {
6632 0 : if (CONSTANT_CLASS_P (_p1))
6633 : {
6634 0 : {
6635 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
6636 0 : tree res = generic_simplify_63 (loc, type, _p0, _p1, captures, MINUS_EXPR, PLUS_EXPR, MINUS_EXPR);
6637 0 : if (res) return res;
6638 : }
6639 : }
6640 : }
6641 812 : if (CONSTANT_CLASS_P (_q30))
6642 : {
6643 34 : if (CONSTANT_CLASS_P (_p1))
6644 : {
6645 0 : {
6646 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
6647 0 : tree res = generic_simplify_64 (loc, type, _p0, _p1, captures, MINUS_EXPR);
6648 0 : if (res) return res;
6649 : }
6650 : }
6651 : }
6652 : break;
6653 : }
6654 : default:;
6655 : }
6656 : }
6657 : }
6658 22894495 : if (CONSTANT_CLASS_P (_p0))
6659 : {
6660 5571335 : switch (TREE_CODE (_p1))
6661 : {
6662 823 : case MINUS_EXPR:
6663 823 : {
6664 823 : tree _q30 = TREE_OPERAND (_p1, 0);
6665 823 : tree _q31 = TREE_OPERAND (_p1, 1);
6666 823 : if (CONSTANT_CLASS_P (_q30))
6667 : {
6668 639 : {
6669 639 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q31 };
6670 639 : tree res = generic_simplify_101 (loc, type, _p0, _p1, captures);
6671 639 : if (res) return res;
6672 : }
6673 : }
6674 : break;
6675 : }
6676 5570705 : default:;
6677 : }
6678 5570705 : {
6679 5570705 : tree _p1_pops[1];
6680 5570705 : if (tree_nop_convert (_p1, _p1_pops))
6681 : {
6682 1871301 : tree _q30 = _p1_pops[0];
6683 1871301 : switch (TREE_CODE (_q30))
6684 : {
6685 7305 : case MINUS_EXPR:
6686 7305 : {
6687 7305 : tree _q40 = TREE_OPERAND (_q30, 0);
6688 7305 : tree _q41 = TREE_OPERAND (_q30, 1);
6689 7305 : if (CONSTANT_CLASS_P (_q40))
6690 : {
6691 25 : {
6692 25 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q40, _q41 };
6693 25 : tree res = generic_simplify_101 (loc, type, _p0, _p1, captures);
6694 25 : if (res) return res;
6695 : }
6696 : }
6697 : break;
6698 : }
6699 : default:;
6700 : }
6701 : }
6702 : }
6703 : }
6704 22893840 : if (integer_all_onesp (_p0))
6705 : {
6706 1186640 : {
6707 1186640 : tree captures[1] ATTRIBUTE_UNUSED = { _p1 };
6708 1186640 : if (!TYPE_SATURATING (type)
6709 : )
6710 : {
6711 1186640 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
6712 2373280 : && !FIXED_POINT_TYPE_P (type)
6713 : )
6714 : {
6715 1186640 : if (TREE_CODE (type) != COMPLEX_TYPE
6716 : )
6717 : {
6718 1186638 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1299;
6719 1186638 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1299;
6720 1186638 : {
6721 1186638 : tree res_op0;
6722 1186638 : res_op0 = captures[0];
6723 1186638 : tree _r;
6724 1186638 : _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
6725 1186638 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 936, __FILE__, __LINE__, true);
6726 1186638 : return _r;
6727 : }
6728 : next_after_fail1299:;
6729 : }
6730 : }
6731 : }
6732 : }
6733 : }
6734 21707202 : switch (TREE_CODE (_p1))
6735 : {
6736 7235523 : CASE_CONVERT:
6737 7235523 : {
6738 7235523 : tree _q30 = TREE_OPERAND (_p1, 0);
6739 7235523 : switch (TREE_CODE (_q30))
6740 : {
6741 685298 : case PLUS_EXPR:
6742 685298 : {
6743 685298 : tree _q40 = TREE_OPERAND (_q30, 0);
6744 685298 : tree _q41 = TREE_OPERAND (_q30, 1);
6745 685298 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || operand_equal_p (_q40, _p0, 0))
6746 : {
6747 24 : {
6748 24 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _p0 };
6749 24 : tree res = generic_simplify_104 (loc, type, _p0, _p1, captures);
6750 24 : if (res) return res;
6751 : }
6752 : }
6753 685274 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || operand_equal_p (_q41, _p0, 0))
6754 : {
6755 8361 : {
6756 8361 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _p0 };
6757 8361 : tree res = generic_simplify_104 (loc, type, _p0, _p1, captures);
6758 8361 : if (res) return res;
6759 : }
6760 : }
6761 : break;
6762 : }
6763 : default:;
6764 : }
6765 : break;
6766 : }
6767 21699004 : default:;
6768 : }
6769 21699004 : switch (TREE_CODE (_p0))
6770 : {
6771 5064585 : CASE_CONVERT:
6772 5064585 : {
6773 5064585 : tree _q20 = TREE_OPERAND (_p0, 0);
6774 5064585 : switch (TREE_CODE (_p1))
6775 : {
6776 4219012 : CASE_CONVERT:
6777 4219012 : {
6778 4219012 : tree _q40 = TREE_OPERAND (_p1, 0);
6779 4219012 : switch (TREE_CODE (_q40))
6780 : {
6781 391657 : case POINTER_PLUS_EXPR:
6782 391657 : {
6783 391657 : tree _q50 = TREE_OPERAND (_q40, 0);
6784 391657 : tree _q51 = TREE_OPERAND (_q40, 1);
6785 391657 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || operand_equal_p (_q50, _q20, 0))
6786 : {
6787 2102 : {
6788 2102 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
6789 2102 : if (!TYPE_SATURATING (type)
6790 : )
6791 : {
6792 2102 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
6793 4204 : && !FIXED_POINT_TYPE_P (type)
6794 : )
6795 : {
6796 2102 : if (INTEGRAL_TYPE_P (type)
6797 2102 : && TYPE_OVERFLOW_UNDEFINED (type)
6798 0 : && TREE_CODE (captures[1]) != INTEGER_CST
6799 2102 : && element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
6800 : )
6801 : {
6802 0 : {
6803 0 : tree utype = unsigned_type_for (type);
6804 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1300;
6805 0 : {
6806 0 : tree res_op0;
6807 0 : {
6808 0 : tree _o1[1], _r1;
6809 0 : {
6810 0 : tree _o2[1], _r2;
6811 0 : _o2[0] = captures[1];
6812 0 : if (TREE_TYPE (_o2[0]) != utype)
6813 : {
6814 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
6815 : }
6816 : else
6817 : _r2 = _o2[0];
6818 0 : _o1[0] = _r2;
6819 : }
6820 0 : _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
6821 0 : res_op0 = _r1;
6822 : }
6823 0 : tree _r;
6824 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
6825 0 : if (TREE_SIDE_EFFECTS (captures[2]))
6826 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
6827 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 937, __FILE__, __LINE__, true);
6828 0 : return _r;
6829 : }
6830 0 : next_after_fail1300:;
6831 : }
6832 : }
6833 : else
6834 : {
6835 2102 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
6836 2102 : || (POINTER_TYPE_P (TREE_TYPE (captures[0]))
6837 0 : && TREE_CODE (captures[1]) == INTEGER_CST
6838 0 : && tree_int_cst_sign_bit (captures[1]) == 0)
6839 : )
6840 : {
6841 2102 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1301;
6842 2102 : {
6843 2102 : tree res_op0;
6844 2102 : {
6845 2102 : tree _o1[1], _r1;
6846 2102 : _o1[0] = captures[1];
6847 2102 : if (TREE_TYPE (_o1[0]) != type)
6848 : {
6849 2098 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
6850 : }
6851 : else
6852 : _r1 = _o1[0];
6853 2102 : res_op0 = _r1;
6854 : }
6855 2102 : tree _r;
6856 2102 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
6857 2102 : if (TREE_SIDE_EFFECTS (captures[2]))
6858 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
6859 2102 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 938, __FILE__, __LINE__, true);
6860 2102 : return _r;
6861 : }
6862 0 : next_after_fail1301:;
6863 : }
6864 : }
6865 : }
6866 : }
6867 : }
6868 : }
6869 : break;
6870 : }
6871 : default:;
6872 : }
6873 : break;
6874 : }
6875 5062483 : default:;
6876 : }
6877 5062483 : switch (TREE_CODE (_q20))
6878 : {
6879 402153 : case PLUS_EXPR:
6880 402153 : {
6881 402153 : tree _q30 = TREE_OPERAND (_q20, 0);
6882 402153 : tree _q31 = TREE_OPERAND (_q20, 1);
6883 402153 : switch (TREE_CODE (_p1))
6884 : {
6885 385302 : CASE_CONVERT:
6886 385302 : {
6887 385302 : tree _q60 = TREE_OPERAND (_p1, 0);
6888 385302 : switch (TREE_CODE (_q60))
6889 : {
6890 209851 : case PLUS_EXPR:
6891 209851 : {
6892 209851 : tree _q70 = TREE_OPERAND (_q60, 0);
6893 209851 : tree _q71 = TREE_OPERAND (_q60, 1);
6894 209851 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || operand_equal_p (_q70, _q30, 0))
6895 : {
6896 5420 : {
6897 5420 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q71, _q30 };
6898 5420 : tree res = generic_simplify_105 (loc, type, _p0, _p1, captures);
6899 5420 : if (res) return res;
6900 : }
6901 : }
6902 204431 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || operand_equal_p (_q71, _q30, 0))
6903 : {
6904 70 : {
6905 70 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q70, _q30 };
6906 70 : tree res = generic_simplify_105 (loc, type, _p0, _p1, captures);
6907 70 : if (res) return res;
6908 : }
6909 : }
6910 204361 : if ((_q70 == _q31 && ! TREE_SIDE_EFFECTS (_q70)) || operand_equal_p (_q70, _q31, 0))
6911 : {
6912 90 : {
6913 90 : tree captures[4] ATTRIBUTE_UNUSED = { _q31, _q30, _q71, _q31 };
6914 90 : tree res = generic_simplify_105 (loc, type, _p0, _p1, captures);
6915 90 : if (res) return res;
6916 : }
6917 : }
6918 204271 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || operand_equal_p (_q71, _q31, 0))
6919 : {
6920 153356 : {
6921 153356 : tree captures[4] ATTRIBUTE_UNUSED = { _q31, _q30, _q70, _q31 };
6922 153356 : tree res = generic_simplify_105 (loc, type, _p0, _p1, captures);
6923 153356 : if (res) return res;
6924 : }
6925 : }
6926 : break;
6927 : }
6928 : default:;
6929 : }
6930 : break;
6931 : }
6932 : default:;
6933 : }
6934 : break;
6935 : }
6936 94542 : case POINTER_PLUS_EXPR:
6937 94542 : {
6938 94542 : tree _q30 = TREE_OPERAND (_q20, 0);
6939 94542 : tree _q31 = TREE_OPERAND (_q20, 1);
6940 94542 : switch (TREE_CODE (_p1))
6941 : {
6942 93468 : CASE_CONVERT:
6943 93468 : {
6944 93468 : tree _q60 = TREE_OPERAND (_p1, 0);
6945 93468 : switch (TREE_CODE (_q60))
6946 : {
6947 55413 : case POINTER_PLUS_EXPR:
6948 55413 : {
6949 55413 : tree _q70 = TREE_OPERAND (_q60, 0);
6950 55413 : tree _q71 = TREE_OPERAND (_q60, 1);
6951 55413 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || operand_equal_p (_q70, _q30, 0))
6952 : {
6953 11618 : {
6954 11618 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q71, _q30 };
6955 11618 : if (!TYPE_SATURATING (type)
6956 : )
6957 : {
6958 11618 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
6959 23236 : && !FIXED_POINT_TYPE_P (type)
6960 : )
6961 : {
6962 11618 : if (INTEGRAL_TYPE_P (type)
6963 11618 : && TYPE_OVERFLOW_UNDEFINED (type)
6964 11618 : && element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
6965 : )
6966 : {
6967 0 : {
6968 0 : tree utype = unsigned_type_for (type);
6969 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1302;
6970 0 : {
6971 0 : tree res_op0;
6972 0 : {
6973 0 : tree _o1[2], _r1;
6974 0 : {
6975 0 : tree _o2[1], _r2;
6976 0 : _o2[0] = captures[1];
6977 0 : if (TREE_TYPE (_o2[0]) != utype)
6978 : {
6979 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
6980 : }
6981 : else
6982 : _r2 = _o2[0];
6983 0 : _o1[0] = _r2;
6984 : }
6985 0 : {
6986 0 : tree _o2[1], _r2;
6987 0 : _o2[0] = captures[2];
6988 0 : if (TREE_TYPE (_o2[0]) != utype)
6989 : {
6990 0 : _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
6991 : }
6992 : else
6993 : _r2 = _o2[0];
6994 0 : _o1[1] = _r2;
6995 : }
6996 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
6997 0 : res_op0 = _r1;
6998 : }
6999 0 : tree _r;
7000 0 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
7001 0 : if (TREE_SIDE_EFFECTS (captures[3]))
7002 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
7003 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 939, __FILE__, __LINE__, true);
7004 0 : return _r;
7005 : }
7006 0 : next_after_fail1302:;
7007 : }
7008 : }
7009 : else
7010 : {
7011 11618 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[1]))
7012 11618 : || (POINTER_TYPE_P (TREE_TYPE (captures[0]))
7013 0 : && TREE_CODE (captures[1]) == INTEGER_CST
7014 0 : && tree_int_cst_sign_bit (captures[1]) == 0
7015 0 : && TREE_CODE (captures[2]) == INTEGER_CST
7016 0 : && tree_int_cst_sign_bit (captures[2]) == 0)
7017 : )
7018 : {
7019 11618 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1303;
7020 11618 : {
7021 11618 : tree res_op0;
7022 11618 : {
7023 11618 : tree _o1[1], _r1;
7024 11618 : _o1[0] = captures[1];
7025 11618 : if (TREE_TYPE (_o1[0]) != type)
7026 : {
7027 11565 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
7028 : }
7029 : else
7030 : _r1 = _o1[0];
7031 11618 : res_op0 = _r1;
7032 : }
7033 11618 : tree res_op1;
7034 11618 : {
7035 11618 : tree _o1[1], _r1;
7036 11618 : _o1[0] = captures[2];
7037 11618 : if (TREE_TYPE (_o1[0]) != type)
7038 : {
7039 11565 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
7040 : }
7041 : else
7042 : _r1 = _o1[0];
7043 11618 : res_op1 = _r1;
7044 : }
7045 11618 : tree _r;
7046 11618 : _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
7047 11618 : if (TREE_SIDE_EFFECTS (captures[3]))
7048 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
7049 11618 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 940, __FILE__, __LINE__, true);
7050 11618 : return _r;
7051 : }
7052 0 : next_after_fail1303:;
7053 : }
7054 : }
7055 : }
7056 : }
7057 : }
7058 : }
7059 : break;
7060 : }
7061 : default:;
7062 : }
7063 : break;
7064 : }
7065 : default:;
7066 : }
7067 : break;
7068 : }
7069 : default:;
7070 : }
7071 : break;
7072 : }
7073 1529275 : case MULT_EXPR:
7074 1529275 : {
7075 1529275 : tree _q20 = TREE_OPERAND (_p0, 0);
7076 1529275 : tree _q21 = TREE_OPERAND (_p0, 1);
7077 1529275 : switch (TREE_CODE (_p1))
7078 : {
7079 718951 : case MULT_EXPR:
7080 718951 : {
7081 718951 : tree _q50 = TREE_OPERAND (_p1, 0);
7082 718951 : tree _q51 = TREE_OPERAND (_p1, 1);
7083 718951 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7084 : {
7085 3901 : {
7086 3901 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
7087 3901 : tree res = generic_simplify_71 (loc, type, _p0, _p1, captures, MINUS_EXPR);
7088 3901 : if (res) return res;
7089 : }
7090 : }
7091 717722 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7092 : {
7093 17285 : {
7094 17285 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
7095 17285 : tree res = generic_simplify_71 (loc, type, _p0, _p1, captures, MINUS_EXPR);
7096 17285 : if (res) return res;
7097 : }
7098 : }
7099 700437 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7100 : {
7101 35392 : {
7102 35392 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q51 };
7103 35392 : tree res = generic_simplify_71 (loc, type, _p0, _p1, captures, MINUS_EXPR);
7104 35392 : if (res) return res;
7105 : }
7106 : }
7107 665120 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7108 : {
7109 220421 : {
7110 220421 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q50 };
7111 220421 : tree res = generic_simplify_71 (loc, type, _p0, _p1, captures, MINUS_EXPR);
7112 220421 : if (res) return res;
7113 : }
7114 : }
7115 : break;
7116 : }
7117 : default:;
7118 : }
7119 : break;
7120 : }
7121 21274127 : default:;
7122 : }
7123 21274127 : switch (TREE_CODE (_p1))
7124 : {
7125 1795528 : case MULT_EXPR:
7126 1795528 : {
7127 1795528 : tree _q30 = TREE_OPERAND (_p1, 0);
7128 1795528 : tree _q31 = TREE_OPERAND (_p1, 1);
7129 1795528 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
7130 : {
7131 3876 : {
7132 3876 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
7133 3876 : tree res = generic_simplify_72 (loc, type, _p0, _p1, captures, MINUS_EXPR);
7134 3876 : if (res) return res;
7135 : }
7136 : }
7137 1791696 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
7138 : {
7139 1970 : {
7140 1970 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q30 };
7141 1970 : tree res = generic_simplify_72 (loc, type, _p0, _p1, captures, MINUS_EXPR);
7142 1970 : if (res) return res;
7143 : }
7144 : }
7145 : break;
7146 : }
7147 21268424 : default:;
7148 : }
7149 21268424 : switch (TREE_CODE (_p0))
7150 : {
7151 1260398 : case MULT_EXPR:
7152 1260398 : {
7153 1260398 : tree _q20 = TREE_OPERAND (_p0, 0);
7154 1260398 : tree _q21 = TREE_OPERAND (_p0, 1);
7155 1260398 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
7156 : {
7157 65661 : {
7158 65661 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
7159 65661 : tree res = generic_simplify_73 (loc, type, _p0, _p1, captures, MINUS_EXPR);
7160 65661 : if (res) return res;
7161 : }
7162 : }
7163 1195029 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
7164 : {
7165 632 : {
7166 632 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
7167 632 : tree res = generic_simplify_73 (loc, type, _p0, _p1, captures, MINUS_EXPR);
7168 632 : if (res) return res;
7169 : }
7170 : }
7171 : break;
7172 : }
7173 21202956 : default:;
7174 : }
7175 21202956 : switch (TREE_CODE (_p1))
7176 : {
7177 1789825 : case MULT_EXPR:
7178 1789825 : {
7179 1789825 : tree _q30 = TREE_OPERAND (_p1, 0);
7180 1789825 : tree _q31 = TREE_OPERAND (_p1, 1);
7181 1789825 : switch (TREE_CODE (_q30))
7182 : {
7183 78518 : case MINUS_EXPR:
7184 78518 : {
7185 78518 : tree _q40 = TREE_OPERAND (_q30, 0);
7186 78518 : tree _q41 = TREE_OPERAND (_q30, 1);
7187 78518 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
7188 : {
7189 19 : if (tree_zero_one_valued_p (_q31))
7190 : {
7191 0 : {
7192 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q31 };
7193 0 : tree res = generic_simplify_106 (loc, type, _p0, _p1, captures);
7194 0 : if (res) return res;
7195 : }
7196 : }
7197 : }
7198 : break;
7199 : }
7200 1789825 : default:;
7201 : }
7202 1789825 : if (tree_zero_one_valued_p (_q30))
7203 : {
7204 1228 : switch (TREE_CODE (_q31))
7205 : {
7206 9 : case MINUS_EXPR:
7207 9 : {
7208 9 : tree _q50 = TREE_OPERAND (_q31, 0);
7209 9 : tree _q51 = TREE_OPERAND (_q31, 1);
7210 9 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
7211 : {
7212 9 : {
7213 9 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q51, _q30 };
7214 9 : tree res = generic_simplify_106 (loc, type, _p0, _p1, captures);
7215 9 : if (res) return res;
7216 : }
7217 : }
7218 : break;
7219 : }
7220 : default:;
7221 : }
7222 : }
7223 : break;
7224 : }
7225 21202954 : default:;
7226 : }
7227 21202954 : switch (TREE_CODE (_p0))
7228 : {
7229 92 : case BIT_AND_EXPR:
7230 92 : {
7231 92 : tree _q20 = TREE_OPERAND (_p0, 0);
7232 92 : tree _q21 = TREE_OPERAND (_p0, 1);
7233 92 : switch (TREE_CODE (_q21))
7234 : {
7235 67 : case INTEGER_CST:
7236 67 : {
7237 67 : switch (TREE_CODE (_p1))
7238 : {
7239 28 : case BIT_AND_EXPR:
7240 28 : {
7241 28 : tree _q50 = TREE_OPERAND (_p1, 0);
7242 28 : tree _q51 = TREE_OPERAND (_p1, 1);
7243 28 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7244 : {
7245 6 : if (integer_pow2p (_q51))
7246 : {
7247 6 : {
7248 6 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
7249 12 : if (INTEGRAL_TYPE_P (type)
7250 12 : && TYPE_PRECISION (type) <= MAX_FIXED_MODE_SIZE
7251 12 : && wi::to_wide (captures[1]) + 1 == wi::to_wide (captures[2])
7252 : )
7253 : {
7254 4 : {
7255 4 : int width = wi::exact_log2 (wi::to_wide (captures[2])) + 1;
7256 4 : tree ntype = NULL_TREE;
7257 4 : if (width > 0 && width < TYPE_PRECISION (type))
7258 4 : ntype = build_nonstandard_integer_type (width, SIGNED);
7259 4 : if (ntype && type_has_mode_precision_p (ntype)
7260 : )
7261 : {
7262 4 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1304;
7263 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1304;
7264 4 : {
7265 4 : tree res_op0;
7266 4 : {
7267 4 : tree _o1[1], _r1;
7268 4 : _o1[0] = captures[0];
7269 4 : if (TREE_TYPE (_o1[0]) != ntype)
7270 : {
7271 4 : _r1 = fold_build1_loc (loc, NOP_EXPR, ntype, _o1[0]);
7272 : }
7273 : else
7274 : _r1 = _o1[0];
7275 4 : res_op0 = _r1;
7276 : }
7277 4 : tree _r;
7278 4 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
7279 4 : if (TREE_SIDE_EFFECTS (captures[1]))
7280 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
7281 4 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 941, __FILE__, __LINE__, true);
7282 4 : return _r;
7283 : }
7284 2 : next_after_fail1304:;
7285 : }
7286 : }
7287 : }
7288 : }
7289 : }
7290 : }
7291 : break;
7292 : }
7293 : default:;
7294 : }
7295 : break;
7296 : }
7297 : default:;
7298 : }
7299 : break;
7300 : }
7301 0 : case VEC_COND_EXPR:
7302 0 : {
7303 0 : tree _q20 = TREE_OPERAND (_p0, 0);
7304 0 : tree _q21 = TREE_OPERAND (_p0, 1);
7305 0 : tree _q22 = TREE_OPERAND (_p0, 2);
7306 0 : switch (TREE_CODE (_p1))
7307 : {
7308 0 : case VEC_COND_EXPR:
7309 0 : {
7310 0 : tree _q60 = TREE_OPERAND (_p1, 0);
7311 0 : tree _q61 = TREE_OPERAND (_p1, 1);
7312 0 : tree _q62 = TREE_OPERAND (_p1, 2);
7313 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7314 : {
7315 0 : {
7316 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
7317 0 : if (VECTOR_TYPE_P (type)
7318 0 : && (TREE_CODE_CLASS (MINUS_EXPR) != tcc_comparison
7319 : || types_match (type, TREE_TYPE (captures[2]))
7320 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
7321 : || (optimize_vectors_before_lowering_p ()
7322 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
7323 : )
7324 : {
7325 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1305;
7326 0 : {
7327 0 : tree res_op0;
7328 0 : res_op0 = captures[1];
7329 0 : tree res_op1;
7330 0 : {
7331 0 : tree _o1[2], _r1;
7332 0 : _o1[0] = captures[2];
7333 0 : _o1[1] = captures[5];
7334 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, type, _o1[0], _o1[1]);
7335 0 : if (EXPR_P (_r1))
7336 0 : goto next_after_fail1305;
7337 0 : res_op1 = _r1;
7338 : }
7339 0 : tree res_op2;
7340 0 : {
7341 0 : tree _o1[2], _r1;
7342 0 : _o1[0] = captures[3];
7343 0 : _o1[1] = captures[6];
7344 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, type, _o1[0], _o1[1]);
7345 0 : if (EXPR_P (_r1))
7346 0 : goto next_after_fail1305;
7347 0 : res_op2 = _r1;
7348 : }
7349 0 : tree _r;
7350 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7351 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 898, __FILE__, __LINE__, true);
7352 0 : return _r;
7353 : }
7354 0 : next_after_fail1305:;
7355 : }
7356 : }
7357 : }
7358 : break;
7359 : }
7360 0 : default:;
7361 : }
7362 0 : {
7363 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
7364 0 : if (VECTOR_TYPE_P (type)
7365 0 : && (TREE_CODE_CLASS (MINUS_EXPR) != tcc_comparison
7366 : || types_match (type, TREE_TYPE (captures[2]))
7367 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
7368 : || (optimize_vectors_before_lowering_p ()
7369 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
7370 : )
7371 : {
7372 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1306;
7373 0 : {
7374 0 : if (! tree_invariant_p (captures[4])) goto next_after_fail1306;
7375 0 : tree res_op0;
7376 0 : res_op0 = captures[1];
7377 0 : tree res_op1;
7378 0 : {
7379 0 : tree _o1[2], _r1;
7380 0 : _o1[0] = captures[2];
7381 0 : _o1[1] = unshare_expr (captures[4]);
7382 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, type, _o1[0], _o1[1]);
7383 0 : if (EXPR_P (_r1))
7384 0 : goto next_after_fail1306;
7385 0 : res_op1 = _r1;
7386 : }
7387 0 : tree res_op2;
7388 0 : {
7389 0 : tree _o1[2], _r1;
7390 0 : _o1[0] = captures[3];
7391 0 : _o1[1] = captures[4];
7392 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, type, _o1[0], _o1[1]);
7393 0 : if (EXPR_P (_r1))
7394 0 : goto next_after_fail1306;
7395 0 : res_op2 = _r1;
7396 : }
7397 0 : tree _r;
7398 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7399 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 900, __FILE__, __LINE__, true);
7400 0 : return _r;
7401 : }
7402 0 : next_after_fail1306:;
7403 : }
7404 : }
7405 0 : break;
7406 : }
7407 21202950 : default:;
7408 : }
7409 21202950 : if (integer_zerop (_p0))
7410 : {
7411 304296 : {
7412 304296 : tree captures[1] ATTRIBUTE_UNUSED = { _p1 };
7413 304296 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1307;
7414 304296 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1307;
7415 304296 : {
7416 304296 : tree res_op0;
7417 304296 : res_op0 = captures[0];
7418 304296 : tree _r;
7419 304296 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
7420 304296 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 942, __FILE__, __LINE__, true);
7421 304296 : return _r;
7422 : }
7423 : next_after_fail1307:;
7424 : }
7425 : }
7426 20898654 : if (real_zerop (_p0))
7427 : {
7428 182 : {
7429 182 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
7430 182 : if (fold_real_zero_addition_p (type, captures[1], captures[0], 0)
7431 : )
7432 : {
7433 55 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1308;
7434 55 : {
7435 55 : tree res_op0;
7436 55 : res_op0 = captures[1];
7437 55 : tree _r;
7438 55 : _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
7439 55 : if (TREE_SIDE_EFFECTS (captures[0]))
7440 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
7441 55 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 943, __FILE__, __LINE__, true);
7442 55 : return _r;
7443 : }
7444 0 : next_after_fail1308:;
7445 : }
7446 : }
7447 : }
7448 20898599 : switch (TREE_CODE (_p1))
7449 : {
7450 4 : case VEC_COND_EXPR:
7451 4 : {
7452 4 : tree _q30 = TREE_OPERAND (_p1, 0);
7453 4 : tree _q31 = TREE_OPERAND (_p1, 1);
7454 4 : tree _q32 = TREE_OPERAND (_p1, 2);
7455 4 : {
7456 4 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
7457 4 : if (VECTOR_TYPE_P (type)
7458 4 : && (TREE_CODE_CLASS (MINUS_EXPR) != tcc_comparison
7459 : || types_match (type, TREE_TYPE (captures[3]))
7460 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
7461 : || (optimize_vectors_before_lowering_p ()
7462 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
7463 : )
7464 : {
7465 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1309;
7466 4 : {
7467 4 : if (! tree_invariant_p (captures[0])) goto next_after_fail1309;
7468 0 : tree res_op0;
7469 0 : res_op0 = captures[2];
7470 0 : tree res_op1;
7471 0 : {
7472 0 : tree _o1[2], _r1;
7473 0 : _o1[0] = unshare_expr (captures[0]);
7474 0 : _o1[1] = captures[3];
7475 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, type, _o1[0], _o1[1]);
7476 0 : if (EXPR_P (_r1))
7477 0 : goto next_after_fail1309;
7478 0 : res_op1 = _r1;
7479 : }
7480 0 : tree res_op2;
7481 0 : {
7482 0 : tree _o1[2], _r1;
7483 0 : _o1[0] = captures[0];
7484 0 : _o1[1] = captures[4];
7485 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, type, _o1[0], _o1[1]);
7486 0 : if (EXPR_P (_r1))
7487 0 : goto next_after_fail1309;
7488 0 : res_op2 = _r1;
7489 : }
7490 0 : tree _r;
7491 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
7492 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 901, __FILE__, __LINE__, true);
7493 0 : return _r;
7494 : }
7495 4 : next_after_fail1309:;
7496 : }
7497 : }
7498 4 : if (integer_each_onep (_q31))
7499 : {
7500 0 : if (integer_zerop (_q32))
7501 : {
7502 0 : {
7503 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
7504 0 : tree res = generic_simplify_107 (loc, type, _p0, _p1, captures);
7505 0 : if (res) return res;
7506 : }
7507 : }
7508 : }
7509 : break;
7510 : }
7511 121148 : case VIEW_CONVERT_EXPR:
7512 121148 : {
7513 121148 : tree _q30 = TREE_OPERAND (_p1, 0);
7514 121148 : switch (TREE_CODE (_q30))
7515 : {
7516 0 : case VEC_COND_EXPR:
7517 0 : {
7518 0 : tree _q40 = TREE_OPERAND (_q30, 0);
7519 0 : tree _q41 = TREE_OPERAND (_q30, 1);
7520 0 : tree _q42 = TREE_OPERAND (_q30, 2);
7521 0 : if (integer_each_onep (_q41))
7522 : {
7523 0 : if (integer_zerop (_q42))
7524 : {
7525 0 : {
7526 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q30, _q40, _q41, _q42 };
7527 0 : tree res = generic_simplify_107 (loc, type, _p0, _p1, captures);
7528 0 : if (res) return res;
7529 : }
7530 : }
7531 : }
7532 : break;
7533 : }
7534 : default:;
7535 : }
7536 : break;
7537 : }
7538 20898599 : default:;
7539 : }
7540 20898599 : switch (TREE_CODE (_p0))
7541 : {
7542 116501 : case RDIV_EXPR:
7543 116501 : {
7544 116501 : tree _q20 = TREE_OPERAND (_p0, 0);
7545 116501 : tree _q21 = TREE_OPERAND (_p0, 1);
7546 116501 : switch (TREE_CODE (_p1))
7547 : {
7548 19493 : case RDIV_EXPR:
7549 19493 : {
7550 19493 : tree _q50 = TREE_OPERAND (_p1, 0);
7551 19493 : tree _q51 = TREE_OPERAND (_p1, 1);
7552 19493 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7553 : {
7554 19473 : {
7555 19473 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
7556 19473 : tree res = generic_simplify_79 (loc, type, _p0, _p1, captures, MINUS_EXPR);
7557 19473 : if (res) return res;
7558 : }
7559 : }
7560 : break;
7561 : }
7562 : default:;
7563 : }
7564 : break;
7565 : }
7566 1383928 : case PLUS_EXPR:
7567 1383928 : {
7568 1383928 : tree _q20 = TREE_OPERAND (_p0, 0);
7569 1383928 : tree _q21 = TREE_OPERAND (_p0, 1);
7570 1383928 : switch (TREE_CODE (_q20))
7571 : {
7572 59601 : case CALL_EXPR:
7573 59601 : switch (get_call_combined_fn (_q20))
7574 : {
7575 4 : case CFN_BUILT_IN_POPCOUNT:
7576 4 : if (call_expr_nargs (_q20) == 1)
7577 : {
7578 4 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
7579 4 : switch (TREE_CODE (_q21))
7580 : {
7581 4 : case CALL_EXPR:
7582 4 : switch (get_call_combined_fn (_q21))
7583 : {
7584 4 : case CFN_BUILT_IN_POPCOUNT:
7585 4 : if (call_expr_nargs (_q21) == 1)
7586 : {
7587 4 : tree _q50 = CALL_EXPR_ARG (_q21, 0);
7588 4 : switch (TREE_CODE (_p1))
7589 : {
7590 4 : case CALL_EXPR:
7591 4 : switch (get_call_combined_fn (_p1))
7592 : {
7593 4 : case CFN_BUILT_IN_POPCOUNT:
7594 4 : if (call_expr_nargs (_p1) == 1)
7595 : {
7596 4 : tree _q70 = CALL_EXPR_ARG (_p1, 0);
7597 4 : switch (TREE_CODE (_q70))
7598 : {
7599 2 : case BIT_AND_EXPR:
7600 2 : {
7601 2 : tree _q80 = TREE_OPERAND (_q70, 0);
7602 2 : tree _q81 = TREE_OPERAND (_q70, 1);
7603 2 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7604 : {
7605 1 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7606 : {
7607 1 : {
7608 1 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7609 1 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNT);
7610 1 : if (res) return res;
7611 : }
7612 : }
7613 : }
7614 1 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
7615 : {
7616 1 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
7617 : {
7618 1 : {
7619 1 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7620 1 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNT);
7621 1 : if (res) return res;
7622 : }
7623 : }
7624 : }
7625 : break;
7626 : }
7627 2 : case BIT_IOR_EXPR:
7628 2 : {
7629 2 : tree _q80 = TREE_OPERAND (_q70, 0);
7630 2 : tree _q81 = TREE_OPERAND (_q70, 1);
7631 2 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7632 : {
7633 1 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7634 : {
7635 1 : {
7636 1 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7637 1 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNT);
7638 1 : if (res) return res;
7639 : }
7640 : }
7641 : }
7642 1 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
7643 : {
7644 1 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
7645 : {
7646 1 : {
7647 1 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7648 1 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNT);
7649 1 : if (res) return res;
7650 : }
7651 : }
7652 : }
7653 : break;
7654 : }
7655 : default:;
7656 : }
7657 : }
7658 : break;
7659 : default:;
7660 : }
7661 : break;
7662 : default:;
7663 : }
7664 : }
7665 : break;
7666 : default:;
7667 : }
7668 : break;
7669 : default:;
7670 : }
7671 : }
7672 : break;
7673 0 : case CFN_BUILT_IN_POPCOUNTLL:
7674 0 : if (call_expr_nargs (_q20) == 1)
7675 : {
7676 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
7677 0 : switch (TREE_CODE (_q21))
7678 : {
7679 0 : case CALL_EXPR:
7680 0 : switch (get_call_combined_fn (_q21))
7681 : {
7682 0 : case CFN_BUILT_IN_POPCOUNTLL:
7683 0 : if (call_expr_nargs (_q21) == 1)
7684 : {
7685 0 : tree _q50 = CALL_EXPR_ARG (_q21, 0);
7686 0 : switch (TREE_CODE (_p1))
7687 : {
7688 0 : case CALL_EXPR:
7689 0 : switch (get_call_combined_fn (_p1))
7690 : {
7691 0 : case CFN_BUILT_IN_POPCOUNTLL:
7692 0 : if (call_expr_nargs (_p1) == 1)
7693 : {
7694 0 : tree _q70 = CALL_EXPR_ARG (_p1, 0);
7695 0 : switch (TREE_CODE (_q70))
7696 : {
7697 0 : case BIT_AND_EXPR:
7698 0 : {
7699 0 : tree _q80 = TREE_OPERAND (_q70, 0);
7700 0 : tree _q81 = TREE_OPERAND (_q70, 1);
7701 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7702 : {
7703 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7704 : {
7705 0 : {
7706 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7707 0 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTLL);
7708 0 : if (res) return res;
7709 : }
7710 : }
7711 : }
7712 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
7713 : {
7714 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
7715 : {
7716 0 : {
7717 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7718 0 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTLL);
7719 0 : if (res) return res;
7720 : }
7721 : }
7722 : }
7723 : break;
7724 : }
7725 0 : case BIT_IOR_EXPR:
7726 0 : {
7727 0 : tree _q80 = TREE_OPERAND (_q70, 0);
7728 0 : tree _q81 = TREE_OPERAND (_q70, 1);
7729 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7730 : {
7731 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7732 : {
7733 0 : {
7734 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7735 0 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTLL);
7736 0 : if (res) return res;
7737 : }
7738 : }
7739 : }
7740 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
7741 : {
7742 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
7743 : {
7744 0 : {
7745 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7746 0 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTLL);
7747 0 : if (res) return res;
7748 : }
7749 : }
7750 : }
7751 : break;
7752 : }
7753 : default:;
7754 : }
7755 : }
7756 : break;
7757 : default:;
7758 : }
7759 : break;
7760 : default:;
7761 : }
7762 : }
7763 : break;
7764 : default:;
7765 : }
7766 : break;
7767 : default:;
7768 : }
7769 : }
7770 : break;
7771 0 : case CFN_POPCOUNT:
7772 0 : if (call_expr_nargs (_q20) == 1)
7773 : {
7774 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
7775 0 : switch (TREE_CODE (_q21))
7776 : {
7777 0 : case CALL_EXPR:
7778 0 : switch (get_call_combined_fn (_q21))
7779 : {
7780 0 : case CFN_POPCOUNT:
7781 0 : if (call_expr_nargs (_q21) == 1)
7782 : {
7783 0 : tree _q50 = CALL_EXPR_ARG (_q21, 0);
7784 0 : switch (TREE_CODE (_p1))
7785 : {
7786 0 : case CALL_EXPR:
7787 0 : switch (get_call_combined_fn (_p1))
7788 : {
7789 0 : case CFN_POPCOUNT:
7790 0 : if (call_expr_nargs (_p1) == 1)
7791 : {
7792 0 : tree _q70 = CALL_EXPR_ARG (_p1, 0);
7793 0 : switch (TREE_CODE (_q70))
7794 : {
7795 0 : case BIT_AND_EXPR:
7796 0 : {
7797 0 : tree _q80 = TREE_OPERAND (_q70, 0);
7798 0 : tree _q81 = TREE_OPERAND (_q70, 1);
7799 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7800 : {
7801 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7802 : {
7803 0 : {
7804 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7805 0 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_POPCOUNT);
7806 0 : if (res) return res;
7807 : }
7808 : }
7809 : }
7810 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
7811 : {
7812 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
7813 : {
7814 0 : {
7815 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7816 0 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_POPCOUNT);
7817 0 : if (res) return res;
7818 : }
7819 : }
7820 : }
7821 : break;
7822 : }
7823 0 : case BIT_IOR_EXPR:
7824 0 : {
7825 0 : tree _q80 = TREE_OPERAND (_q70, 0);
7826 0 : tree _q81 = TREE_OPERAND (_q70, 1);
7827 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7828 : {
7829 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7830 : {
7831 0 : {
7832 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7833 0 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_POPCOUNT);
7834 0 : if (res) return res;
7835 : }
7836 : }
7837 : }
7838 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
7839 : {
7840 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
7841 : {
7842 0 : {
7843 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7844 0 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_POPCOUNT);
7845 0 : if (res) return res;
7846 : }
7847 : }
7848 : }
7849 : break;
7850 : }
7851 : default:;
7852 : }
7853 : }
7854 : break;
7855 : default:;
7856 : }
7857 : break;
7858 : default:;
7859 : }
7860 : }
7861 : break;
7862 : default:;
7863 : }
7864 : break;
7865 : default:;
7866 : }
7867 : }
7868 : break;
7869 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
7870 0 : if (call_expr_nargs (_q20) == 1)
7871 : {
7872 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
7873 0 : switch (TREE_CODE (_q21))
7874 : {
7875 0 : case CALL_EXPR:
7876 0 : switch (get_call_combined_fn (_q21))
7877 : {
7878 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
7879 0 : if (call_expr_nargs (_q21) == 1)
7880 : {
7881 0 : tree _q50 = CALL_EXPR_ARG (_q21, 0);
7882 0 : switch (TREE_CODE (_p1))
7883 : {
7884 0 : case CALL_EXPR:
7885 0 : switch (get_call_combined_fn (_p1))
7886 : {
7887 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
7888 0 : if (call_expr_nargs (_p1) == 1)
7889 : {
7890 0 : tree _q70 = CALL_EXPR_ARG (_p1, 0);
7891 0 : switch (TREE_CODE (_q70))
7892 : {
7893 0 : case BIT_AND_EXPR:
7894 0 : {
7895 0 : tree _q80 = TREE_OPERAND (_q70, 0);
7896 0 : tree _q81 = TREE_OPERAND (_q70, 1);
7897 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7898 : {
7899 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7900 : {
7901 0 : {
7902 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7903 0 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
7904 0 : if (res) return res;
7905 : }
7906 : }
7907 : }
7908 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
7909 : {
7910 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
7911 : {
7912 0 : {
7913 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7914 0 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
7915 0 : if (res) return res;
7916 : }
7917 : }
7918 : }
7919 : break;
7920 : }
7921 0 : case BIT_IOR_EXPR:
7922 0 : {
7923 0 : tree _q80 = TREE_OPERAND (_q70, 0);
7924 0 : tree _q81 = TREE_OPERAND (_q70, 1);
7925 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7926 : {
7927 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7928 : {
7929 0 : {
7930 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7931 0 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
7932 0 : if (res) return res;
7933 : }
7934 : }
7935 : }
7936 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
7937 : {
7938 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
7939 : {
7940 0 : {
7941 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
7942 0 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTIMAX);
7943 0 : if (res) return res;
7944 : }
7945 : }
7946 : }
7947 : break;
7948 : }
7949 : default:;
7950 : }
7951 : }
7952 : break;
7953 : default:;
7954 : }
7955 : break;
7956 : default:;
7957 : }
7958 : }
7959 : break;
7960 : default:;
7961 : }
7962 : break;
7963 : default:;
7964 : }
7965 : }
7966 : break;
7967 0 : case CFN_BUILT_IN_POPCOUNTL:
7968 0 : if (call_expr_nargs (_q20) == 1)
7969 : {
7970 0 : tree _q30 = CALL_EXPR_ARG (_q20, 0);
7971 0 : switch (TREE_CODE (_q21))
7972 : {
7973 0 : case CALL_EXPR:
7974 0 : switch (get_call_combined_fn (_q21))
7975 : {
7976 0 : case CFN_BUILT_IN_POPCOUNTL:
7977 0 : if (call_expr_nargs (_q21) == 1)
7978 : {
7979 0 : tree _q50 = CALL_EXPR_ARG (_q21, 0);
7980 0 : switch (TREE_CODE (_p1))
7981 : {
7982 0 : case CALL_EXPR:
7983 0 : switch (get_call_combined_fn (_p1))
7984 : {
7985 0 : case CFN_BUILT_IN_POPCOUNTL:
7986 0 : if (call_expr_nargs (_p1) == 1)
7987 : {
7988 0 : tree _q70 = CALL_EXPR_ARG (_p1, 0);
7989 0 : switch (TREE_CODE (_q70))
7990 : {
7991 0 : case BIT_AND_EXPR:
7992 0 : {
7993 0 : tree _q80 = TREE_OPERAND (_q70, 0);
7994 0 : tree _q81 = TREE_OPERAND (_q70, 1);
7995 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
7996 : {
7997 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
7998 : {
7999 0 : {
8000 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
8001 0 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTL);
8002 0 : if (res) return res;
8003 : }
8004 : }
8005 : }
8006 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
8007 : {
8008 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
8009 : {
8010 0 : {
8011 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
8012 0 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, BIT_IOR_EXPR, CFN_BUILT_IN_POPCOUNTL);
8013 0 : if (res) return res;
8014 : }
8015 : }
8016 : }
8017 : break;
8018 : }
8019 0 : case BIT_IOR_EXPR:
8020 0 : {
8021 0 : tree _q80 = TREE_OPERAND (_q70, 0);
8022 0 : tree _q81 = TREE_OPERAND (_q70, 1);
8023 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
8024 : {
8025 0 : if ((_q81 == _q50 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q50, 0) && types_match (_q81, _q50)))
8026 : {
8027 0 : {
8028 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
8029 0 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTL);
8030 0 : if (res) return res;
8031 : }
8032 : }
8033 : }
8034 0 : if ((_q80 == _q50 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q50, 0) && types_match (_q80, _q50)))
8035 : {
8036 0 : if ((_q81 == _q30 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q30, 0) && types_match (_q81, _q30)))
8037 : {
8038 0 : {
8039 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50, _p1, _q70 };
8040 0 : tree res = generic_simplify_109 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, BIT_AND_EXPR, CFN_BUILT_IN_POPCOUNTL);
8041 0 : if (res) return res;
8042 : }
8043 : }
8044 : }
8045 : break;
8046 : }
8047 : default:;
8048 : }
8049 : }
8050 : break;
8051 : default:;
8052 : }
8053 : break;
8054 : default:;
8055 : }
8056 : }
8057 : break;
8058 : default:;
8059 : }
8060 : break;
8061 : default:;
8062 : }
8063 : }
8064 : break;
8065 : default:;
8066 : }
8067 : break;
8068 : default:;
8069 : }
8070 : break;
8071 : }
8072 0 : case VEC_PERM_EXPR:
8073 0 : {
8074 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8075 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8076 0 : tree _q22 = TREE_OPERAND (_p0, 2);
8077 0 : switch (TREE_CODE (_q20))
8078 : {
8079 0 : case MULT_EXPR:
8080 0 : {
8081 0 : tree _q30 = TREE_OPERAND (_q20, 0);
8082 0 : tree _q31 = TREE_OPERAND (_q20, 1);
8083 0 : if (tree_vec_same_elem_p (_q31))
8084 : {
8085 0 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
8086 : {
8087 0 : {
8088 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q22, _p1 };
8089 0 : tree res = generic_simplify_110 (loc, type, _p0, _p1, captures);
8090 0 : if (res) return res;
8091 : }
8092 : }
8093 : }
8094 0 : if (tree_vec_same_elem_p (_q30))
8095 : {
8096 0 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
8097 : {
8098 0 : {
8099 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q30, _q22, _p1 };
8100 0 : tree res = generic_simplify_110 (loc, type, _p0, _p1, captures);
8101 0 : if (res) return res;
8102 : }
8103 : }
8104 : }
8105 : break;
8106 : }
8107 : default:;
8108 : }
8109 : break;
8110 : }
8111 714510 : case CALL_EXPR:
8112 714510 : switch (get_call_combined_fn (_p0))
8113 : {
8114 18 : case CFN_BUILT_IN_LOG:
8115 18 : if (call_expr_nargs (_p0) == 1)
8116 : {
8117 18 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8118 18 : switch (TREE_CODE (_p1))
8119 : {
8120 0 : case CALL_EXPR:
8121 0 : switch (get_call_combined_fn (_p1))
8122 : {
8123 0 : case CFN_BUILT_IN_LOG:
8124 0 : if (call_expr_nargs (_p1) == 1)
8125 : {
8126 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8127 0 : {
8128 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8129 0 : tree res = generic_simplify_108 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG);
8130 0 : if (res) return res;
8131 : }
8132 : }
8133 : break;
8134 : default:;
8135 : }
8136 : break;
8137 : default:;
8138 : }
8139 : }
8140 : break;
8141 2 : case CFN_BUILT_IN_LOG2:
8142 2 : if (call_expr_nargs (_p0) == 1)
8143 : {
8144 2 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8145 2 : switch (TREE_CODE (_p1))
8146 : {
8147 0 : case CALL_EXPR:
8148 0 : switch (get_call_combined_fn (_p1))
8149 : {
8150 0 : case CFN_BUILT_IN_LOG2:
8151 0 : if (call_expr_nargs (_p1) == 1)
8152 : {
8153 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8154 0 : {
8155 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8156 0 : tree res = generic_simplify_108 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2);
8157 0 : if (res) return res;
8158 : }
8159 : }
8160 : break;
8161 : default:;
8162 : }
8163 : break;
8164 : default:;
8165 : }
8166 : }
8167 : break;
8168 0 : case CFN_BUILT_IN_LOGF:
8169 0 : if (call_expr_nargs (_p0) == 1)
8170 : {
8171 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8172 0 : switch (TREE_CODE (_p1))
8173 : {
8174 0 : case CALL_EXPR:
8175 0 : switch (get_call_combined_fn (_p1))
8176 : {
8177 0 : case CFN_BUILT_IN_LOGF:
8178 0 : if (call_expr_nargs (_p1) == 1)
8179 : {
8180 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8181 0 : {
8182 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8183 0 : tree res = generic_simplify_108 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGF);
8184 0 : if (res) return res;
8185 : }
8186 : }
8187 : break;
8188 : default:;
8189 : }
8190 : break;
8191 : default:;
8192 : }
8193 : }
8194 : break;
8195 0 : case CFN_BUILT_IN_LOGL:
8196 0 : if (call_expr_nargs (_p0) == 1)
8197 : {
8198 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8199 0 : switch (TREE_CODE (_p1))
8200 : {
8201 0 : case CALL_EXPR:
8202 0 : switch (get_call_combined_fn (_p1))
8203 : {
8204 0 : case CFN_BUILT_IN_LOGL:
8205 0 : if (call_expr_nargs (_p1) == 1)
8206 : {
8207 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8208 0 : {
8209 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8210 0 : tree res = generic_simplify_108 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOGL);
8211 0 : if (res) return res;
8212 : }
8213 : }
8214 : break;
8215 : default:;
8216 : }
8217 : break;
8218 : default:;
8219 : }
8220 : }
8221 : break;
8222 0 : case CFN_BUILT_IN_LOG10F:
8223 0 : if (call_expr_nargs (_p0) == 1)
8224 : {
8225 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8226 0 : switch (TREE_CODE (_p1))
8227 : {
8228 0 : case CALL_EXPR:
8229 0 : switch (get_call_combined_fn (_p1))
8230 : {
8231 0 : case CFN_BUILT_IN_LOG10F:
8232 0 : if (call_expr_nargs (_p1) == 1)
8233 : {
8234 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8235 0 : {
8236 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8237 0 : tree res = generic_simplify_108 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10F);
8238 0 : if (res) return res;
8239 : }
8240 : }
8241 : break;
8242 : default:;
8243 : }
8244 : break;
8245 : default:;
8246 : }
8247 : }
8248 : break;
8249 0 : case CFN_BUILT_IN_LOG10L:
8250 0 : if (call_expr_nargs (_p0) == 1)
8251 : {
8252 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8253 0 : switch (TREE_CODE (_p1))
8254 : {
8255 0 : case CALL_EXPR:
8256 0 : switch (get_call_combined_fn (_p1))
8257 : {
8258 0 : case CFN_BUILT_IN_LOG10L:
8259 0 : if (call_expr_nargs (_p1) == 1)
8260 : {
8261 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8262 0 : {
8263 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8264 0 : tree res = generic_simplify_108 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10L);
8265 0 : if (res) return res;
8266 : }
8267 : }
8268 : break;
8269 : default:;
8270 : }
8271 : break;
8272 : default:;
8273 : }
8274 : }
8275 : break;
8276 0 : case CFN_LOG:
8277 0 : if (call_expr_nargs (_p0) == 1)
8278 : {
8279 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8280 0 : switch (TREE_CODE (_p1))
8281 : {
8282 0 : case CALL_EXPR:
8283 0 : switch (get_call_combined_fn (_p1))
8284 : {
8285 0 : case CFN_LOG:
8286 0 : if (call_expr_nargs (_p1) == 1)
8287 : {
8288 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8289 0 : {
8290 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8291 0 : tree res = generic_simplify_108 (loc, type, _p0, _p1, captures, CFN_LOG);
8292 0 : if (res) return res;
8293 : }
8294 : }
8295 : break;
8296 : default:;
8297 : }
8298 : break;
8299 : default:;
8300 : }
8301 : }
8302 : break;
8303 0 : case CFN_LOG2:
8304 0 : if (call_expr_nargs (_p0) == 1)
8305 : {
8306 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8307 0 : switch (TREE_CODE (_p1))
8308 : {
8309 0 : case CALL_EXPR:
8310 0 : switch (get_call_combined_fn (_p1))
8311 : {
8312 0 : case CFN_LOG2:
8313 0 : if (call_expr_nargs (_p1) == 1)
8314 : {
8315 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8316 0 : {
8317 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8318 0 : tree res = generic_simplify_108 (loc, type, _p0, _p1, captures, CFN_LOG2);
8319 0 : if (res) return res;
8320 : }
8321 : }
8322 : break;
8323 : default:;
8324 : }
8325 : break;
8326 : default:;
8327 : }
8328 : }
8329 : break;
8330 0 : case CFN_LOG10:
8331 0 : if (call_expr_nargs (_p0) == 1)
8332 : {
8333 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8334 0 : switch (TREE_CODE (_p1))
8335 : {
8336 0 : case CALL_EXPR:
8337 0 : switch (get_call_combined_fn (_p1))
8338 : {
8339 0 : case CFN_LOG10:
8340 0 : if (call_expr_nargs (_p1) == 1)
8341 : {
8342 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8343 0 : {
8344 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8345 0 : tree res = generic_simplify_108 (loc, type, _p0, _p1, captures, CFN_LOG10);
8346 0 : if (res) return res;
8347 : }
8348 : }
8349 : break;
8350 : default:;
8351 : }
8352 : break;
8353 : default:;
8354 : }
8355 : }
8356 : break;
8357 6 : case CFN_BUILT_IN_LOG10:
8358 6 : if (call_expr_nargs (_p0) == 1)
8359 : {
8360 6 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8361 6 : switch (TREE_CODE (_p1))
8362 : {
8363 2 : case CALL_EXPR:
8364 2 : switch (get_call_combined_fn (_p1))
8365 : {
8366 2 : case CFN_BUILT_IN_LOG10:
8367 2 : if (call_expr_nargs (_p1) == 1)
8368 : {
8369 2 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8370 2 : {
8371 2 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8372 2 : tree res = generic_simplify_108 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG10);
8373 2 : if (res) return res;
8374 : }
8375 : }
8376 : break;
8377 : default:;
8378 : }
8379 : break;
8380 : default:;
8381 : }
8382 : }
8383 : break;
8384 0 : case CFN_BUILT_IN_LOG2F:
8385 0 : if (call_expr_nargs (_p0) == 1)
8386 : {
8387 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8388 0 : switch (TREE_CODE (_p1))
8389 : {
8390 0 : case CALL_EXPR:
8391 0 : switch (get_call_combined_fn (_p1))
8392 : {
8393 0 : case CFN_BUILT_IN_LOG2F:
8394 0 : if (call_expr_nargs (_p1) == 1)
8395 : {
8396 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8397 0 : {
8398 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8399 0 : tree res = generic_simplify_108 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2F);
8400 0 : if (res) return res;
8401 : }
8402 : }
8403 : break;
8404 : default:;
8405 : }
8406 : break;
8407 : default:;
8408 : }
8409 : }
8410 : break;
8411 0 : case CFN_BUILT_IN_LOG2L:
8412 0 : if (call_expr_nargs (_p0) == 1)
8413 : {
8414 0 : tree _q20 = CALL_EXPR_ARG (_p0, 0);
8415 0 : switch (TREE_CODE (_p1))
8416 : {
8417 0 : case CALL_EXPR:
8418 0 : switch (get_call_combined_fn (_p1))
8419 : {
8420 0 : case CFN_BUILT_IN_LOG2L:
8421 0 : if (call_expr_nargs (_p1) == 1)
8422 : {
8423 0 : tree _q40 = CALL_EXPR_ARG (_p1, 0);
8424 0 : {
8425 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
8426 0 : tree res = generic_simplify_108 (loc, type, _p0, _p1, captures, CFN_BUILT_IN_LOG2L);
8427 0 : if (res) return res;
8428 : }
8429 : }
8430 : break;
8431 : default:;
8432 : }
8433 : break;
8434 : default:;
8435 : }
8436 : }
8437 : break;
8438 : default:;
8439 : }
8440 : break;
8441 20898582 : default:;
8442 : }
8443 20898582 : switch (TREE_CODE (_p1))
8444 : {
8445 7218 : case BIT_AND_EXPR:
8446 7218 : {
8447 7218 : tree _q30 = TREE_OPERAND (_p1, 0);
8448 7218 : tree _q31 = TREE_OPERAND (_p1, 1);
8449 7218 : switch (TREE_CODE (_q30))
8450 : {
8451 80 : case MAX_EXPR:
8452 80 : {
8453 80 : tree _q40 = TREE_OPERAND (_q30, 0);
8454 80 : tree _q41 = TREE_OPERAND (_q30, 1);
8455 80 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
8456 : {
8457 80 : switch (TREE_CODE (_q41))
8458 : {
8459 80 : case INTEGER_CST:
8460 80 : {
8461 80 : switch (TREE_CODE (_q31))
8462 : {
8463 72 : case INTEGER_CST:
8464 72 : {
8465 72 : {
8466 72 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q41, _q31 };
8467 72 : {
8468 72 : auto i = wi::neg (wi::to_wide (captures[2]));
8469 72 : if (wi::popcount (i) == 1
8470 200 : && (wi::to_wide (captures[1])) == (i - 1)
8471 : )
8472 : {
8473 40 : if (TYPE_UNSIGNED (TREE_TYPE (captures[0]))
8474 : )
8475 : {
8476 8 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1310;
8477 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1310;
8478 8 : {
8479 8 : tree res_op0;
8480 8 : res_op0 = captures[0];
8481 8 : tree res_op1;
8482 8 : res_op1 = captures[1];
8483 8 : tree _r;
8484 8 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
8485 8 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 944, __FILE__, __LINE__, true);
8486 8 : return _r;
8487 : }
8488 64 : next_after_fail1310:;
8489 : }
8490 : else
8491 : {
8492 32 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1311;
8493 32 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1311;
8494 32 : {
8495 32 : if (! tree_invariant_p (captures[0])) goto next_after_fail1311;
8496 0 : if (! tree_invariant_p (captures[1])) goto next_after_fail1311;
8497 0 : tree res_op0;
8498 0 : {
8499 0 : tree _o1[2], _r1;
8500 0 : _o1[0] = unshare_expr (captures[0]);
8501 0 : _o1[1] = unshare_expr (captures[1]);
8502 0 : _r1 = fold_build2_loc (loc, LE_EXPR, boolean_type_node, _o1[0], _o1[1]);
8503 0 : res_op0 = _r1;
8504 : }
8505 0 : tree res_op1;
8506 0 : res_op1 = unshare_expr (captures[0]);
8507 0 : tree res_op2;
8508 0 : {
8509 0 : tree _o1[2], _r1;
8510 0 : _o1[0] = captures[0];
8511 0 : _o1[1] = captures[1];
8512 0 : _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8513 0 : res_op2 = _r1;
8514 : }
8515 0 : tree _r;
8516 0 : _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
8517 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 945, __FILE__, __LINE__, true);
8518 0 : return _r;
8519 : }
8520 64 : next_after_fail1311:;
8521 : }
8522 : }
8523 8 : }
8524 : }
8525 64 : break;
8526 : }
8527 : default:;
8528 : }
8529 : break;
8530 : }
8531 : default:;
8532 : }
8533 : }
8534 : break;
8535 : }
8536 : default:;
8537 : }
8538 : break;
8539 : }
8540 20898574 : default:;
8541 : }
8542 20898574 : switch (TREE_CODE (_p0))
8543 : {
8544 0 : case VEC_PERM_EXPR:
8545 0 : {
8546 0 : tree _q20 = TREE_OPERAND (_p0, 0);
8547 0 : tree _q21 = TREE_OPERAND (_p0, 1);
8548 0 : tree _q22 = TREE_OPERAND (_p0, 2);
8549 0 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
8550 : {
8551 0 : switch (TREE_CODE (_p1))
8552 : {
8553 0 : case VEC_PERM_EXPR:
8554 0 : {
8555 0 : tree _q60 = TREE_OPERAND (_p1, 0);
8556 0 : tree _q61 = TREE_OPERAND (_p1, 1);
8557 0 : tree _q62 = TREE_OPERAND (_p1, 2);
8558 0 : if ((_q61 == _q60 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q60, 0) && types_match (_q61, _q60)))
8559 : {
8560 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
8561 : {
8562 0 : {
8563 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q22, _q60 };
8564 0 : if (VECTOR_INTEGER_TYPE_P (type)
8565 : )
8566 : {
8567 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1312;
8568 0 : {
8569 0 : tree res_op0;
8570 0 : {
8571 0 : tree _o1[2], _r1;
8572 0 : _o1[0] = captures[0];
8573 0 : _o1[1] = captures[2];
8574 0 : _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8575 0 : captures[3] = _r1;
8576 : }
8577 0 : res_op0 = unshare_expr (captures[3]);
8578 0 : tree res_op1;
8579 0 : res_op1 = captures[3];
8580 0 : tree res_op2;
8581 0 : res_op2 = captures[1];
8582 0 : tree _r;
8583 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
8584 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 902, __FILE__, __LINE__, true);
8585 0 : return _r;
8586 : }
8587 0 : next_after_fail1312:;
8588 : }
8589 : }
8590 : }
8591 : }
8592 : break;
8593 : }
8594 0 : default:;
8595 : }
8596 0 : switch (TREE_CODE (_q22))
8597 : {
8598 0 : case VECTOR_CST:
8599 0 : {
8600 0 : switch (TREE_CODE (_p1))
8601 : {
8602 0 : case VEC_PERM_EXPR:
8603 0 : {
8604 0 : tree _q60 = TREE_OPERAND (_p1, 0);
8605 0 : tree _q61 = TREE_OPERAND (_p1, 1);
8606 0 : tree _q62 = TREE_OPERAND (_p1, 2);
8607 0 : if ((_q61 == _q60 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q60, 0) && types_match (_q61, _q60)))
8608 : {
8609 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
8610 : {
8611 0 : switch (TREE_CODE (_q62))
8612 : {
8613 0 : case VECTOR_CST:
8614 0 : {
8615 0 : {
8616 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q22, _q60 };
8617 0 : tree res = generic_simplify_85 (loc, type, _p0, _p1, captures, MINUS_EXPR);
8618 0 : if (res) return res;
8619 : }
8620 0 : break;
8621 : }
8622 : default:;
8623 : }
8624 : }
8625 : }
8626 : break;
8627 : }
8628 : default:;
8629 : }
8630 : break;
8631 : }
8632 : default:;
8633 : }
8634 : }
8635 : break;
8636 : }
8637 : default:;
8638 : }
8639 : return NULL_TREE;
8640 : }
8641 :
8642 : tree
8643 1280811 : generic_simplify_LSHIFT_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
8644 : {
8645 1280811 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8646 1280811 : switch (TREE_CODE (_p1))
8647 : {
8648 266 : case TRUNC_MOD_EXPR:
8649 266 : {
8650 266 : tree _q30 = TREE_OPERAND (_p1, 0);
8651 266 : tree _q31 = TREE_OPERAND (_p1, 1);
8652 266 : {
8653 266 : tree _q31_pops[1];
8654 266 : if (tree_power_of_two_cand (_q31, _q31_pops))
8655 : {
8656 260 : tree _q50 = _q31_pops[0];
8657 260 : {
8658 260 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q50 };
8659 260 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, LSHIFT_EXPR, TRUNC_MOD_EXPR);
8660 260 : if (res) return res;
8661 : }
8662 : }
8663 : }
8664 75 : break;
8665 : }
8666 0 : case FLOOR_MOD_EXPR:
8667 0 : {
8668 0 : tree _q30 = TREE_OPERAND (_p1, 0);
8669 0 : tree _q31 = TREE_OPERAND (_p1, 1);
8670 0 : {
8671 0 : tree _q31_pops[1];
8672 0 : if (tree_power_of_two_cand (_q31, _q31_pops))
8673 : {
8674 0 : tree _q50 = _q31_pops[0];
8675 0 : {
8676 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q50 };
8677 0 : tree res = generic_simplify_420 (loc, type, _p0, _p1, captures, LSHIFT_EXPR, FLOOR_MOD_EXPR);
8678 0 : if (res) return res;
8679 : }
8680 : }
8681 : }
8682 0 : break;
8683 : }
8684 1280620 : default:;
8685 : }
8686 1280620 : if (uniform_integer_cst_p (_p1))
8687 : {
8688 870839 : {
8689 870839 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8690 870839 : tree res = generic_simplify_421 (loc, type, _p0, _p1, captures, LSHIFT_EXPR);
8691 870839 : if (res) return res;
8692 : }
8693 : }
8694 1280155 : switch (TREE_CODE (_p0))
8695 : {
8696 715665 : CASE_CONVERT:
8697 715665 : {
8698 715665 : tree _q20 = TREE_OPERAND (_p0, 0);
8699 715665 : switch (TREE_CODE (_q20))
8700 : {
8701 4 : case LT_EXPR:
8702 4 : {
8703 4 : tree _q30 = TREE_OPERAND (_q20, 0);
8704 4 : tree _q31 = TREE_OPERAND (_q20, 1);
8705 4 : if (integer_zerop (_q31))
8706 : {
8707 4 : switch (TREE_CODE (_p1))
8708 : {
8709 4 : case INTEGER_CST:
8710 4 : {
8711 4 : {
8712 4 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p1 };
8713 4 : if (TYPE_SIGN (TREE_TYPE (captures[0])) == SIGNED
8714 4 : && wi::eq_p (wi::to_wide (captures[2]), TYPE_PRECISION (TREE_TYPE (captures[0])) - 1)
8715 : )
8716 : {
8717 0 : {
8718 0 : wide_int wone = wi::one (TYPE_PRECISION (type));
8719 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1667;
8720 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1667;
8721 0 : {
8722 0 : tree res_op0;
8723 0 : {
8724 0 : tree _o1[1], _r1;
8725 0 : _o1[0] = captures[0];
8726 0 : if (TREE_TYPE (_o1[0]) != type)
8727 : {
8728 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
8729 : }
8730 : else
8731 : _r1 = _o1[0];
8732 0 : res_op0 = _r1;
8733 : }
8734 0 : tree res_op1;
8735 0 : res_op1 = wide_int_to_tree (type,
8736 0 : wi::lshift (wone, wi::to_wide (captures[2])));
8737 0 : tree _r;
8738 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
8739 0 : if (TREE_SIDE_EFFECTS (captures[1]))
8740 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
8741 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1011, __FILE__, __LINE__, true);
8742 0 : return _r;
8743 : }
8744 0 : next_after_fail1667:;
8745 0 : }
8746 : }
8747 : }
8748 4 : break;
8749 : }
8750 : default:;
8751 : }
8752 : }
8753 : break;
8754 : }
8755 869 : CASE_CONVERT:
8756 869 : {
8757 869 : tree _q30 = TREE_OPERAND (_q20, 0);
8758 869 : switch (TREE_CODE (_q30))
8759 : {
8760 0 : case RSHIFT_EXPR:
8761 0 : {
8762 0 : tree _q40 = TREE_OPERAND (_q30, 0);
8763 0 : tree _q41 = TREE_OPERAND (_q30, 1);
8764 0 : switch (TREE_CODE (_q41))
8765 : {
8766 0 : case INTEGER_CST:
8767 0 : {
8768 0 : if ((_p1 == _q41 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q41, 0) && types_match (_p1, _q41)))
8769 : {
8770 0 : {
8771 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q40, _q41 };
8772 0 : if (wi::ltu_p (wi::to_wide (captures[2]), element_precision (type))
8773 0 : && INTEGRAL_TYPE_P (type)
8774 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8775 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
8776 0 : && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (captures[1]))
8777 0 : && (TYPE_PRECISION (TREE_TYPE (captures[0])) >= TYPE_PRECISION (type)
8778 0 : || wi::geu_p (wi::to_wide (captures[2]),
8779 0 : TYPE_PRECISION (type)
8780 0 : - TYPE_PRECISION (TREE_TYPE (captures[0]))))
8781 : )
8782 : {
8783 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1668;
8784 0 : {
8785 0 : tree res_op0;
8786 0 : {
8787 0 : tree _o1[1], _r1;
8788 0 : _o1[0] = captures[1];
8789 0 : if (TREE_TYPE (_o1[0]) != type)
8790 : {
8791 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
8792 : }
8793 : else
8794 : _r1 = _o1[0];
8795 0 : res_op0 = _r1;
8796 : }
8797 0 : tree res_op1;
8798 0 : {
8799 0 : tree _o1[2], _r1;
8800 0 : _o1[0] = build_minus_one_cst (type);
8801 0 : _o1[1] = captures[2];
8802 0 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8803 0 : res_op1 = _r1;
8804 : }
8805 0 : tree _r;
8806 0 : _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
8807 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1012, __FILE__, __LINE__, true);
8808 0 : return _r;
8809 : }
8810 0 : next_after_fail1668:;
8811 : }
8812 : }
8813 : }
8814 : break;
8815 : }
8816 : default:;
8817 : }
8818 : break;
8819 : }
8820 : default:;
8821 : }
8822 : break;
8823 : }
8824 : default:;
8825 : }
8826 : break;
8827 : }
8828 19916 : case RSHIFT_EXPR:
8829 19916 : {
8830 19916 : tree _q20 = TREE_OPERAND (_p0, 0);
8831 19916 : tree _q21 = TREE_OPERAND (_p0, 1);
8832 19916 : switch (TREE_CODE (_q21))
8833 : {
8834 48 : case INTEGER_CST:
8835 48 : {
8836 48 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8837 : {
8838 3 : {
8839 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8840 3 : tree res = generic_simplify_422 (loc, type, _p0, _p1, captures);
8841 3 : if (res) return res;
8842 : }
8843 : }
8844 : break;
8845 : }
8846 : default:;
8847 : }
8848 : break;
8849 : }
8850 1280152 : default:;
8851 : }
8852 1280152 : {
8853 1280152 : tree _p0_pops[1];
8854 1280152 : if (tree_nop_convert (_p0, _p0_pops))
8855 : {
8856 680362 : tree _q20 = _p0_pops[0];
8857 680362 : switch (TREE_CODE (_q20))
8858 : {
8859 73 : case RSHIFT_EXPR:
8860 73 : {
8861 73 : tree _q30 = TREE_OPERAND (_q20, 0);
8862 73 : tree _q31 = TREE_OPERAND (_q20, 1);
8863 73 : switch (TREE_CODE (_q31))
8864 : {
8865 67 : case INTEGER_CST:
8866 67 : {
8867 67 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
8868 : {
8869 8 : {
8870 8 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
8871 8 : tree res = generic_simplify_422 (loc, type, _p0, _p1, captures);
8872 8 : if (res) return res;
8873 : }
8874 : }
8875 : break;
8876 : }
8877 : default:;
8878 : }
8879 : break;
8880 : }
8881 : default:;
8882 : }
8883 : }
8884 : }
8885 1280144 : if (integer_onep (_p0))
8886 : {
8887 332408 : switch (TREE_CODE (_p1))
8888 : {
8889 52271 : case MINUS_EXPR:
8890 52271 : {
8891 52271 : tree _q30 = TREE_OPERAND (_p1, 0);
8892 52271 : tree _q31 = TREE_OPERAND (_p1, 1);
8893 52271 : switch (TREE_CODE (_q30))
8894 : {
8895 52268 : case INTEGER_CST:
8896 52268 : {
8897 52268 : {
8898 52268 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31 };
8899 52268 : if (INTEGRAL_TYPE_P (type)
8900 52268 : && wi::eq_p (wi::to_wide (captures[2]), TYPE_PRECISION (type) - 1)
8901 52268 : && single_use (captures[1])
8902 : )
8903 : {
8904 29511 : if (TYPE_UNSIGNED (type)
8905 : )
8906 : {
8907 29505 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1669;
8908 29505 : {
8909 29505 : tree res_op0;
8910 29505 : {
8911 29505 : tree _o1[2], _r1;
8912 29505 : _o1[0] = captures[0];
8913 29505 : _o1[1] = captures[2];
8914 29505 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8915 29505 : res_op0 = _r1;
8916 : }
8917 29505 : tree res_op1;
8918 29505 : res_op1 = captures[3];
8919 29505 : tree _r;
8920 29505 : _r = fold_build2_loc (loc, RSHIFT_EXPR, type, res_op0, res_op1);
8921 29505 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1013, __FILE__, __LINE__, true);
8922 29505 : return _r;
8923 : }
8924 0 : next_after_fail1669:;
8925 : }
8926 : else
8927 : {
8928 6 : {
8929 6 : tree utype = unsigned_type_for (type);
8930 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1670;
8931 6 : {
8932 6 : tree res_op0;
8933 6 : {
8934 6 : tree _o1[2], _r1;
8935 6 : {
8936 6 : tree _o2[2], _r2;
8937 6 : {
8938 6 : tree _o3[1], _r3;
8939 6 : _o3[0] = captures[0];
8940 6 : if (TREE_TYPE (_o3[0]) != utype)
8941 : {
8942 6 : _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
8943 : }
8944 : else
8945 : _r3 = _o3[0];
8946 6 : _o2[0] = _r3;
8947 : }
8948 6 : _o2[1] = captures[2];
8949 6 : _r2 = fold_build2_loc (loc, LSHIFT_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
8950 6 : _o1[0] = _r2;
8951 : }
8952 6 : _o1[1] = captures[3];
8953 6 : _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
8954 6 : res_op0 = _r1;
8955 : }
8956 6 : tree _r;
8957 6 : _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
8958 6 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1014, __FILE__, __LINE__, true);
8959 6 : return _r;
8960 : }
8961 0 : next_after_fail1670:;
8962 : }
8963 : }
8964 : }
8965 : }
8966 22757 : break;
8967 : }
8968 : default:;
8969 : }
8970 : break;
8971 : }
8972 : default:;
8973 : }
8974 : }
8975 1250633 : if (integer_zerop (_p1))
8976 : {
8977 1514 : {
8978 1514 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8979 1514 : tree res = generic_simplify_423 (loc, type, _p0, _p1, captures, LSHIFT_EXPR);
8980 1514 : if (res) return res;
8981 : }
8982 : }
8983 1249119 : if (integer_zerop (_p0))
8984 : {
8985 178 : {
8986 178 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8987 178 : tree res = generic_simplify_424 (loc, type, _p0, _p1, captures, LSHIFT_EXPR);
8988 178 : if (res) return res;
8989 : }
8990 : }
8991 1248941 : switch (TREE_CODE (_p1))
8992 : {
8993 0 : case VECTOR_CST:
8994 0 : {
8995 0 : {
8996 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
8997 0 : tree res = generic_simplify_425 (loc, type, _p0, _p1, captures, LSHIFT_EXPR);
8998 0 : if (res) return res;
8999 : }
9000 0 : break;
9001 : }
9002 0 : case CONSTRUCTOR:
9003 0 : {
9004 0 : {
9005 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
9006 0 : tree res = generic_simplify_426 (loc, type, _p0, _p1, captures, LSHIFT_EXPR);
9007 0 : if (res) return res;
9008 : }
9009 0 : break;
9010 : }
9011 1248941 : default:;
9012 : }
9013 1248941 : switch (TREE_CODE (_p0))
9014 : {
9015 280 : case LSHIFT_EXPR:
9016 280 : {
9017 280 : tree _q20 = TREE_OPERAND (_p0, 0);
9018 280 : tree _q21 = TREE_OPERAND (_p0, 1);
9019 280 : switch (TREE_CODE (_q21))
9020 : {
9021 39 : case INTEGER_CST:
9022 39 : {
9023 39 : switch (TREE_CODE (_p1))
9024 : {
9025 39 : case INTEGER_CST:
9026 39 : {
9027 39 : {
9028 39 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
9029 39 : tree res = generic_simplify_427 (loc, type, _p0, _p1, captures, LSHIFT_EXPR);
9030 39 : if (res) return res;
9031 : }
9032 0 : break;
9033 : }
9034 : default:;
9035 : }
9036 : break;
9037 : }
9038 : default:;
9039 : }
9040 : break;
9041 : }
9042 715042 : CASE_CONVERT:
9043 715042 : {
9044 715042 : tree _q20 = TREE_OPERAND (_p0, 0);
9045 715042 : switch (TREE_CODE (_q20))
9046 : {
9047 0 : case BIT_AND_EXPR:
9048 0 : {
9049 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9050 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9051 0 : switch (TREE_CODE (_q31))
9052 : {
9053 0 : case INTEGER_CST:
9054 0 : {
9055 0 : switch (TREE_CODE (_p1))
9056 : {
9057 0 : case INTEGER_CST:
9058 0 : {
9059 0 : {
9060 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
9061 0 : tree res = generic_simplify_428 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, LSHIFT_EXPR);
9062 0 : if (res) return res;
9063 : }
9064 0 : break;
9065 : }
9066 : default:;
9067 : }
9068 : break;
9069 : }
9070 : default:;
9071 : }
9072 : break;
9073 : }
9074 11 : case BIT_XOR_EXPR:
9075 11 : {
9076 11 : tree _q30 = TREE_OPERAND (_q20, 0);
9077 11 : tree _q31 = TREE_OPERAND (_q20, 1);
9078 11 : switch (TREE_CODE (_q31))
9079 : {
9080 0 : case INTEGER_CST:
9081 0 : {
9082 0 : switch (TREE_CODE (_p1))
9083 : {
9084 0 : case INTEGER_CST:
9085 0 : {
9086 0 : {
9087 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
9088 0 : tree res = generic_simplify_428 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LSHIFT_EXPR);
9089 0 : if (res) return res;
9090 : }
9091 0 : break;
9092 : }
9093 : default:;
9094 : }
9095 : break;
9096 : }
9097 : default:;
9098 : }
9099 : break;
9100 : }
9101 18 : case BIT_IOR_EXPR:
9102 18 : {
9103 18 : tree _q30 = TREE_OPERAND (_q20, 0);
9104 18 : tree _q31 = TREE_OPERAND (_q20, 1);
9105 18 : switch (TREE_CODE (_q31))
9106 : {
9107 11 : case INTEGER_CST:
9108 11 : {
9109 11 : switch (TREE_CODE (_p1))
9110 : {
9111 11 : case INTEGER_CST:
9112 11 : {
9113 11 : {
9114 11 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
9115 11 : tree res = generic_simplify_428 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, LSHIFT_EXPR);
9116 11 : if (res) return res;
9117 : }
9118 2 : break;
9119 : }
9120 : default:;
9121 : }
9122 : break;
9123 : }
9124 : default:;
9125 : }
9126 : break;
9127 : }
9128 : default:;
9129 : }
9130 : break;
9131 : }
9132 14326 : case BIT_AND_EXPR:
9133 14326 : {
9134 14326 : tree _q20 = TREE_OPERAND (_p0, 0);
9135 14326 : tree _q21 = TREE_OPERAND (_p0, 1);
9136 14326 : switch (TREE_CODE (_q21))
9137 : {
9138 14231 : case INTEGER_CST:
9139 14231 : {
9140 14231 : switch (TREE_CODE (_p1))
9141 : {
9142 14092 : case INTEGER_CST:
9143 14092 : {
9144 14092 : {
9145 14092 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
9146 14092 : tree res = generic_simplify_429 (loc, type, _p0, _p1, captures, BIT_AND_EXPR, LSHIFT_EXPR);
9147 14092 : if (res) return res;
9148 : }
9149 7 : break;
9150 : }
9151 : default:;
9152 : }
9153 : break;
9154 : }
9155 : default:;
9156 : }
9157 : break;
9158 : }
9159 76 : case BIT_XOR_EXPR:
9160 76 : {
9161 76 : tree _q20 = TREE_OPERAND (_p0, 0);
9162 76 : tree _q21 = TREE_OPERAND (_p0, 1);
9163 76 : switch (TREE_CODE (_q21))
9164 : {
9165 7 : case INTEGER_CST:
9166 7 : {
9167 7 : switch (TREE_CODE (_p1))
9168 : {
9169 7 : case INTEGER_CST:
9170 7 : {
9171 7 : {
9172 7 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
9173 7 : tree res = generic_simplify_429 (loc, type, _p0, _p1, captures, BIT_XOR_EXPR, LSHIFT_EXPR);
9174 7 : if (res) return res;
9175 : }
9176 0 : break;
9177 : }
9178 : default:;
9179 : }
9180 : break;
9181 : }
9182 : default:;
9183 : }
9184 : break;
9185 : }
9186 78 : case BIT_IOR_EXPR:
9187 78 : {
9188 78 : tree _q20 = TREE_OPERAND (_p0, 0);
9189 78 : tree _q21 = TREE_OPERAND (_p0, 1);
9190 78 : switch (TREE_CODE (_q21))
9191 : {
9192 2 : case INTEGER_CST:
9193 2 : {
9194 2 : switch (TREE_CODE (_p1))
9195 : {
9196 2 : case INTEGER_CST:
9197 2 : {
9198 2 : {
9199 2 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
9200 2 : tree res = generic_simplify_429 (loc, type, _p0, _p1, captures, BIT_IOR_EXPR, LSHIFT_EXPR);
9201 2 : if (res) return res;
9202 : }
9203 0 : break;
9204 : }
9205 : default:;
9206 : }
9207 : break;
9208 : }
9209 : default:;
9210 : }
9211 : break;
9212 : }
9213 1 : case VEC_COND_EXPR:
9214 1 : {
9215 1 : tree _q20 = TREE_OPERAND (_p0, 0);
9216 1 : tree _q21 = TREE_OPERAND (_p0, 1);
9217 1 : tree _q22 = TREE_OPERAND (_p0, 2);
9218 1 : switch (TREE_CODE (_p1))
9219 : {
9220 0 : case VEC_COND_EXPR:
9221 0 : {
9222 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9223 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9224 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9225 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9226 : {
9227 0 : {
9228 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
9229 0 : if (VECTOR_TYPE_P (type)
9230 0 : && (TREE_CODE_CLASS (LSHIFT_EXPR) != tcc_comparison
9231 : || types_match (type, TREE_TYPE (captures[2]))
9232 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9233 : || (optimize_vectors_before_lowering_p ()
9234 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9235 : )
9236 : {
9237 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1671;
9238 0 : {
9239 0 : tree res_op0;
9240 0 : res_op0 = captures[1];
9241 0 : tree res_op1;
9242 0 : {
9243 0 : tree _o1[2], _r1;
9244 0 : _o1[0] = captures[2];
9245 0 : _o1[1] = captures[5];
9246 0 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, type, _o1[0], _o1[1]);
9247 0 : if (EXPR_P (_r1))
9248 0 : goto next_after_fail1671;
9249 0 : res_op1 = _r1;
9250 : }
9251 0 : tree res_op2;
9252 0 : {
9253 0 : tree _o1[2], _r1;
9254 0 : _o1[0] = captures[3];
9255 0 : _o1[1] = captures[6];
9256 0 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, type, _o1[0], _o1[1]);
9257 0 : if (EXPR_P (_r1))
9258 0 : goto next_after_fail1671;
9259 0 : res_op2 = _r1;
9260 : }
9261 0 : tree _r;
9262 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9263 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 898, __FILE__, __LINE__, true);
9264 0 : return _r;
9265 : }
9266 0 : next_after_fail1671:;
9267 : }
9268 : }
9269 : }
9270 : break;
9271 : }
9272 1 : default:;
9273 : }
9274 1 : {
9275 1 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
9276 1 : if (VECTOR_TYPE_P (type)
9277 1 : && (TREE_CODE_CLASS (LSHIFT_EXPR) != tcc_comparison
9278 : || types_match (type, TREE_TYPE (captures[2]))
9279 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
9280 : || (optimize_vectors_before_lowering_p ()
9281 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
9282 : )
9283 : {
9284 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1672;
9285 1 : {
9286 1 : if (! tree_invariant_p (captures[4])) goto next_after_fail1672;
9287 0 : tree res_op0;
9288 0 : res_op0 = captures[1];
9289 0 : tree res_op1;
9290 0 : {
9291 0 : tree _o1[2], _r1;
9292 0 : _o1[0] = captures[2];
9293 0 : _o1[1] = unshare_expr (captures[4]);
9294 0 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, type, _o1[0], _o1[1]);
9295 0 : if (EXPR_P (_r1))
9296 0 : goto next_after_fail1672;
9297 0 : res_op1 = _r1;
9298 : }
9299 0 : tree res_op2;
9300 0 : {
9301 0 : tree _o1[2], _r1;
9302 0 : _o1[0] = captures[3];
9303 0 : _o1[1] = captures[4];
9304 0 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, type, _o1[0], _o1[1]);
9305 0 : if (EXPR_P (_r1))
9306 0 : goto next_after_fail1672;
9307 0 : res_op2 = _r1;
9308 : }
9309 0 : tree _r;
9310 0 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9311 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 900, __FILE__, __LINE__, true);
9312 0 : return _r;
9313 : }
9314 1 : next_after_fail1672:;
9315 : }
9316 : }
9317 1 : break;
9318 : }
9319 1234799 : default:;
9320 : }
9321 1234799 : switch (TREE_CODE (_p1))
9322 : {
9323 3 : case VEC_COND_EXPR:
9324 3 : {
9325 3 : tree _q30 = TREE_OPERAND (_p1, 0);
9326 3 : tree _q31 = TREE_OPERAND (_p1, 1);
9327 3 : tree _q32 = TREE_OPERAND (_p1, 2);
9328 3 : {
9329 3 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
9330 3 : if (VECTOR_TYPE_P (type)
9331 3 : && (TREE_CODE_CLASS (LSHIFT_EXPR) != tcc_comparison
9332 : || types_match (type, TREE_TYPE (captures[3]))
9333 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
9334 : || (optimize_vectors_before_lowering_p ()
9335 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
9336 : )
9337 : {
9338 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1673;
9339 3 : {
9340 3 : if (! tree_invariant_p (captures[0])) goto next_after_fail1673;
9341 1 : tree res_op0;
9342 1 : res_op0 = captures[2];
9343 1 : tree res_op1;
9344 1 : {
9345 1 : tree _o1[2], _r1;
9346 1 : _o1[0] = unshare_expr (captures[0]);
9347 1 : _o1[1] = captures[3];
9348 1 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, type, _o1[0], _o1[1]);
9349 1 : if (EXPR_P (_r1))
9350 0 : goto next_after_fail1673;
9351 1 : res_op1 = _r1;
9352 : }
9353 1 : tree res_op2;
9354 1 : {
9355 1 : tree _o1[2], _r1;
9356 1 : _o1[0] = captures[0];
9357 1 : _o1[1] = captures[4];
9358 1 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, type, _o1[0], _o1[1]);
9359 1 : if (EXPR_P (_r1))
9360 0 : goto next_after_fail1673;
9361 1 : res_op2 = _r1;
9362 : }
9363 1 : tree _r;
9364 1 : _r = fold_build3_loc (loc, VEC_COND_EXPR, type, res_op0, res_op1, res_op2);
9365 1 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 901, __FILE__, __LINE__, true);
9366 1 : return _r;
9367 : }
9368 2 : next_after_fail1673:;
9369 : }
9370 : }
9371 2 : break;
9372 : }
9373 1234798 : default:;
9374 : }
9375 1234798 : switch (TREE_CODE (_p0))
9376 : {
9377 0 : case VEC_PERM_EXPR:
9378 0 : {
9379 0 : tree _q20 = TREE_OPERAND (_p0, 0);
9380 0 : tree _q21 = TREE_OPERAND (_p0, 1);
9381 0 : tree _q22 = TREE_OPERAND (_p0, 2);
9382 0 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
9383 : {
9384 0 : switch (TREE_CODE (_p1))
9385 : {
9386 0 : case VEC_PERM_EXPR:
9387 0 : {
9388 0 : tree _q60 = TREE_OPERAND (_p1, 0);
9389 0 : tree _q61 = TREE_OPERAND (_p1, 1);
9390 0 : tree _q62 = TREE_OPERAND (_p1, 2);
9391 0 : if ((_q61 == _q60 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q60, 0) && types_match (_q61, _q60)))
9392 : {
9393 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
9394 : {
9395 0 : {
9396 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q22, _q60 };
9397 0 : if (VECTOR_INTEGER_TYPE_P (type)
9398 : )
9399 : {
9400 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1674;
9401 0 : {
9402 0 : tree res_op0;
9403 0 : {
9404 0 : tree _o1[2], _r1;
9405 0 : _o1[0] = captures[0];
9406 0 : _o1[1] = captures[2];
9407 0 : _r1 = fold_build2_loc (loc, LSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9408 0 : captures[3] = _r1;
9409 : }
9410 0 : res_op0 = unshare_expr (captures[3]);
9411 0 : tree res_op1;
9412 0 : res_op1 = captures[3];
9413 0 : tree res_op2;
9414 0 : res_op2 = captures[1];
9415 0 : tree _r;
9416 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
9417 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 902, __FILE__, __LINE__, true);
9418 0 : return _r;
9419 : }
9420 0 : next_after_fail1674:;
9421 : }
9422 : }
9423 : }
9424 : }
9425 : break;
9426 : }
9427 : default:;
9428 : }
9429 : }
9430 : break;
9431 : }
9432 : default:;
9433 : }
9434 : return NULL_TREE;
9435 : }
9436 :
9437 : tree
9438 10809702 : generic_simplify_TRUTH_AND_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
9439 : {
9440 10809702 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
9441 10809702 : switch (TREE_CODE (_p0))
9442 : {
9443 976588 : case GE_EXPR:
9444 976588 : {
9445 976588 : tree _q20 = TREE_OPERAND (_p0, 0);
9446 976588 : tree _q21 = TREE_OPERAND (_p0, 1);
9447 976588 : {
9448 976588 : tree _q20_pops[1];
9449 976588 : if (tree_nop_convert (_q20, _q20_pops))
9450 : {
9451 13022 : tree _q30 = _q20_pops[0];
9452 13022 : if (integer_zerop (_q21))
9453 : {
9454 5923 : switch (TREE_CODE (_p1))
9455 : {
9456 548 : case NE_EXPR:
9457 548 : {
9458 548 : tree _q60 = TREE_OPERAND (_p1, 0);
9459 548 : tree _q61 = TREE_OPERAND (_p1, 1);
9460 548 : switch (TREE_CODE (_q60))
9461 : {
9462 0 : case BIT_AND_EXPR:
9463 0 : {
9464 0 : tree _q70 = TREE_OPERAND (_q60, 0);
9465 0 : tree _q71 = TREE_OPERAND (_q60, 1);
9466 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
9467 : {
9468 0 : switch (TREE_CODE (_q71))
9469 : {
9470 0 : case INTEGER_CST:
9471 0 : {
9472 0 : if (integer_zerop (_q61))
9473 : {
9474 0 : {
9475 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q71 };
9476 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
9477 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
9478 0 : && wi::eq_p (wi::to_wide (captures[2]),
9479 0 : wi::max_value (TYPE_PRECISION (TREE_TYPE (captures[1])), SIGNED))
9480 : )
9481 : {
9482 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1742;
9483 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1742;
9484 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1742;
9485 0 : {
9486 0 : tree res_op0;
9487 0 : res_op0 = captures[0];
9488 0 : tree res_op1;
9489 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
9490 0 : tree _r;
9491 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
9492 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 946, __FILE__, __LINE__, true);
9493 0 : return _r;
9494 : }
9495 0 : next_after_fail1742:;
9496 : }
9497 : }
9498 : }
9499 : break;
9500 : }
9501 : default:;
9502 : }
9503 : }
9504 : break;
9505 : }
9506 : default:;
9507 : }
9508 : break;
9509 : }
9510 : default:;
9511 : }
9512 : }
9513 : }
9514 : }
9515 976588 : if (integer_zerop (_q21))
9516 : {
9517 352078 : switch (TREE_CODE (_p1))
9518 : {
9519 34689 : case NE_EXPR:
9520 34689 : {
9521 34689 : tree _q50 = TREE_OPERAND (_p1, 0);
9522 34689 : tree _q51 = TREE_OPERAND (_p1, 1);
9523 34689 : switch (TREE_CODE (_q50))
9524 : {
9525 1 : case BIT_AND_EXPR:
9526 1 : {
9527 1 : tree _q60 = TREE_OPERAND (_q50, 0);
9528 1 : tree _q61 = TREE_OPERAND (_q50, 1);
9529 1 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9530 : {
9531 0 : switch (TREE_CODE (_q61))
9532 : {
9533 0 : case INTEGER_CST:
9534 0 : {
9535 0 : if (integer_zerop (_q51))
9536 : {
9537 0 : {
9538 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q20, _q61 };
9539 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
9540 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
9541 0 : && wi::eq_p (wi::to_wide (captures[2]),
9542 0 : wi::max_value (TYPE_PRECISION (TREE_TYPE (captures[1])), SIGNED))
9543 : )
9544 : {
9545 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1743;
9546 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1743;
9547 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1743;
9548 0 : {
9549 0 : tree res_op0;
9550 0 : res_op0 = captures[0];
9551 0 : tree res_op1;
9552 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
9553 0 : tree _r;
9554 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
9555 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 946, __FILE__, __LINE__, true);
9556 0 : return _r;
9557 : }
9558 0 : next_after_fail1743:;
9559 : }
9560 : }
9561 : }
9562 : break;
9563 : }
9564 : default:;
9565 : }
9566 : }
9567 : break;
9568 : }
9569 : default:;
9570 : }
9571 : break;
9572 : }
9573 : default:;
9574 : }
9575 : }
9576 : break;
9577 : }
9578 2466013 : case NE_EXPR:
9579 2466013 : {
9580 2466013 : tree _q20 = TREE_OPERAND (_p0, 0);
9581 2466013 : tree _q21 = TREE_OPERAND (_p0, 1);
9582 2466013 : switch (TREE_CODE (_q20))
9583 : {
9584 0 : case BIT_AND_EXPR:
9585 0 : {
9586 0 : tree _q30 = TREE_OPERAND (_q20, 0);
9587 0 : tree _q31 = TREE_OPERAND (_q20, 1);
9588 0 : switch (TREE_CODE (_q31))
9589 : {
9590 0 : case INTEGER_CST:
9591 0 : {
9592 0 : if (integer_zerop (_q21))
9593 : {
9594 0 : switch (TREE_CODE (_p1))
9595 : {
9596 0 : case GE_EXPR:
9597 0 : {
9598 0 : tree _q70 = TREE_OPERAND (_p1, 0);
9599 0 : tree _q71 = TREE_OPERAND (_p1, 1);
9600 0 : {
9601 0 : tree _q70_pops[1];
9602 0 : if (tree_nop_convert (_q70, _q70_pops))
9603 : {
9604 0 : tree _q80 = _q70_pops[0];
9605 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
9606 : {
9607 0 : if (integer_zerop (_q71))
9608 : {
9609 0 : {
9610 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q70, _q30, _q31 };
9611 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
9612 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
9613 0 : && wi::eq_p (wi::to_wide (captures[2]),
9614 0 : wi::max_value (TYPE_PRECISION (TREE_TYPE (captures[1])), SIGNED))
9615 : )
9616 : {
9617 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1744;
9618 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1744;
9619 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1744;
9620 0 : {
9621 0 : tree res_op0;
9622 0 : res_op0 = captures[0];
9623 0 : tree res_op1;
9624 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
9625 0 : tree _r;
9626 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
9627 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 946, __FILE__, __LINE__, true);
9628 0 : return _r;
9629 : }
9630 0 : next_after_fail1744:;
9631 : }
9632 : }
9633 : }
9634 : }
9635 : }
9636 : }
9637 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
9638 : {
9639 0 : if (integer_zerop (_q71))
9640 : {
9641 0 : {
9642 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q70, _q30, _q31 };
9643 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
9644 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
9645 0 : && wi::eq_p (wi::to_wide (captures[2]),
9646 0 : wi::max_value (TYPE_PRECISION (TREE_TYPE (captures[1])), SIGNED))
9647 : )
9648 : {
9649 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1745;
9650 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1745;
9651 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1745;
9652 0 : {
9653 0 : tree res_op0;
9654 0 : res_op0 = captures[0];
9655 0 : tree res_op1;
9656 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
9657 0 : tree _r;
9658 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
9659 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 946, __FILE__, __LINE__, true);
9660 0 : return _r;
9661 : }
9662 0 : next_after_fail1745:;
9663 : }
9664 : }
9665 : }
9666 : }
9667 : break;
9668 : }
9669 : default:;
9670 : }
9671 : }
9672 : break;
9673 : }
9674 : default:;
9675 : }
9676 : break;
9677 : }
9678 : default:;
9679 : }
9680 : break;
9681 : }
9682 : default:;
9683 : }
9684 : return NULL_TREE;
9685 : }
9686 :
9687 : tree
9688 9475877 : generic_simplify_TRUTH_OR_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1)
9689 : {
9690 9475877 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
9691 9475877 : switch (TREE_CODE (_p0))
9692 : {
9693 1065610 : case LT_EXPR:
9694 1065610 : {
9695 1065610 : tree _q20 = TREE_OPERAND (_p0, 0);
9696 1065610 : tree _q21 = TREE_OPERAND (_p0, 1);
9697 1065610 : {
9698 1065610 : tree _q20_pops[1];
9699 1065610 : if (tree_nop_convert (_q20, _q20_pops))
9700 : {
9701 15037 : tree _q30 = _q20_pops[0];
9702 15037 : if (integer_zerop (_q21))
9703 : {
9704 4865 : switch (TREE_CODE (_p1))
9705 : {
9706 1133 : case EQ_EXPR:
9707 1133 : {
9708 1133 : tree _q60 = TREE_OPERAND (_p1, 0);
9709 1133 : tree _q61 = TREE_OPERAND (_p1, 1);
9710 1133 : switch (TREE_CODE (_q60))
9711 : {
9712 862 : case BIT_AND_EXPR:
9713 862 : {
9714 862 : tree _q70 = TREE_OPERAND (_q60, 0);
9715 862 : tree _q71 = TREE_OPERAND (_q60, 1);
9716 862 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
9717 : {
9718 0 : switch (TREE_CODE (_q71))
9719 : {
9720 0 : case INTEGER_CST:
9721 0 : {
9722 0 : if (integer_zerop (_q61))
9723 : {
9724 0 : {
9725 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q71 };
9726 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
9727 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
9728 0 : && wi::eq_p (wi::to_wide (captures[2]),
9729 0 : wi::max_value (TYPE_PRECISION (TREE_TYPE (captures[1])), SIGNED))
9730 : )
9731 : {
9732 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1746;
9733 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1746;
9734 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1746;
9735 0 : {
9736 0 : tree res_op0;
9737 0 : res_op0 = captures[0];
9738 0 : tree res_op1;
9739 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
9740 0 : tree _r;
9741 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
9742 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 946, __FILE__, __LINE__, true);
9743 0 : return _r;
9744 : }
9745 0 : next_after_fail1746:;
9746 : }
9747 : }
9748 : }
9749 : break;
9750 : }
9751 : default:;
9752 : }
9753 : }
9754 : break;
9755 : }
9756 : default:;
9757 : }
9758 : break;
9759 : }
9760 : default:;
9761 : }
9762 : }
9763 : }
9764 : }
9765 1065610 : if (integer_zerop (_q21))
9766 : {
9767 324878 : switch (TREE_CODE (_p1))
9768 : {
9769 126799 : case EQ_EXPR:
9770 126799 : {
9771 126799 : tree _q50 = TREE_OPERAND (_p1, 0);
9772 126799 : tree _q51 = TREE_OPERAND (_p1, 1);
9773 126799 : switch (TREE_CODE (_q50))
9774 : {
9775 105528 : case BIT_AND_EXPR:
9776 105528 : {
9777 105528 : tree _q60 = TREE_OPERAND (_q50, 0);
9778 105528 : tree _q61 = TREE_OPERAND (_q50, 1);
9779 105528 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9780 : {
9781 0 : switch (TREE_CODE (_q61))
9782 : {
9783 0 : case INTEGER_CST:
9784 0 : {
9785 0 : if (integer_zerop (_q51))
9786 : {
9787 0 : {
9788 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q20, _q61 };
9789 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
9790 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
9791 0 : && wi::eq_p (wi::to_wide (captures[2]),
9792 0 : wi::max_value (TYPE_PRECISION (TREE_TYPE (captures[1])), SIGNED))
9793 : )
9794 : {
9795 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1747;
9796 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1747;
9797 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1747;
9798 0 : {
9799 0 : tree res_op0;
9800 0 : res_op0 = captures[0];
9801 0 : tree res_op1;
9802 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
9803 0 : tree _r;
9804 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
9805 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 946, __FILE__, __LINE__, true);
9806 0 : return _r;
9807 : }
9808 0 : next_after_fail1747:;
9809 : }
9810 : }
9811 : }
9812 : break;
9813 : }
9814 : default:;
9815 : }
9816 : }
9817 : break;
9818 : }
9819 : default:;
9820 : }
9821 : break;
9822 : }
9823 : default:;
9824 : }
9825 : }
9826 1065610 : switch (TREE_CODE (_q20))
9827 : {
9828 2278 : case POINTER_PLUS_EXPR:
9829 2278 : {
9830 2278 : tree _q30 = TREE_OPERAND (_q20, 0);
9831 2278 : tree _q31 = TREE_OPERAND (_q20, 1);
9832 2278 : switch (TREE_CODE (_q31))
9833 : {
9834 2094 : case INTEGER_CST:
9835 2094 : {
9836 2094 : switch (TREE_CODE (_p1))
9837 : {
9838 143 : case LT_EXPR:
9839 143 : {
9840 143 : tree _q70 = TREE_OPERAND (_p1, 0);
9841 143 : tree _q71 = TREE_OPERAND (_p1, 1);
9842 143 : switch (TREE_CODE (_q70))
9843 : {
9844 10 : case POINTER_PLUS_EXPR:
9845 10 : {
9846 10 : tree _q80 = TREE_OPERAND (_q70, 0);
9847 10 : tree _q81 = TREE_OPERAND (_q70, 1);
9848 10 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
9849 : {
9850 1 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
9851 : {
9852 1 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
9853 : {
9854 1 : {
9855 1 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70 };
9856 1 : const enum tree_code cmp = LT_EXPR;
9857 1 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
9858 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
9859 1 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
9860 : )
9861 : {
9862 0 : {
9863 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
9864 0 : offset_int rhs = off * 2;
9865 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
9866 : )
9867 : {
9868 0 : {
9869 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
9870 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
9871 0 : if (cmp == LT_EXPR
9872 : )
9873 : {
9874 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1748;
9875 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1748;
9876 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1748;
9877 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1748;
9878 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1748;
9879 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1748;
9880 0 : {
9881 0 : tree res_op0;
9882 0 : {
9883 0 : tree _o1[1], _r1;
9884 0 : {
9885 0 : tree _o2[2], _r2;
9886 0 : _o2[0] = swap_p ? captures[6] : captures[1];
9887 0 : _o2[1] = swap_p ? captures[2] : captures[4];
9888 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
9889 0 : _o1[0] = _r2;
9890 : }
9891 0 : if (TREE_TYPE (_o1[0]) != sizetype)
9892 : {
9893 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
9894 : }
9895 : else
9896 : _r1 = _o1[0];
9897 0 : res_op0 = _r1;
9898 : }
9899 0 : tree res_op1;
9900 0 : res_op1 = rhs_tree;
9901 0 : tree _r;
9902 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
9903 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 950, __FILE__, __LINE__, true);
9904 0 : return _r;
9905 : }
9906 0 : next_after_fail1748:;
9907 : }
9908 : else
9909 : {
9910 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1749;
9911 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1749;
9912 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1749;
9913 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1749;
9914 : {
9915 : tree res_op0;
9916 : {
9917 : tree _o1[1], _r1;
9918 : {
9919 : tree _o2[2], _r2;
9920 : {
9921 : tree _o3[2], _r3;
9922 : _o3[0] = swap_p ? captures[4] : captures[2];
9923 : _o3[1] = wide_int_to_tree (sizetype, off);
9924 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
9925 : _o2[0] = _r3;
9926 : }
9927 : _o2[1] = swap_p ? captures[2] : captures[4];
9928 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
9929 : _o1[0] = _r2;
9930 : }
9931 : if (TREE_TYPE (_o1[0]) != sizetype)
9932 : {
9933 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
9934 : }
9935 : else
9936 : _r1 = _o1[0];
9937 : res_op0 = _r1;
9938 : }
9939 : tree res_op1;
9940 : res_op1 = rhs_tree;
9941 : tree _r;
9942 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
9943 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 951, __FILE__, __LINE__, true);
9944 : return _r;
9945 : }
9946 : next_after_fail1749:;
9947 : }
9948 : }
9949 : }
9950 : }
9951 : }
9952 : }
9953 : }
9954 : }
9955 : }
9956 : break;
9957 : }
9958 : default:;
9959 : }
9960 : break;
9961 : }
9962 756 : case GT_EXPR:
9963 756 : {
9964 756 : tree _q70 = TREE_OPERAND (_p1, 0);
9965 756 : tree _q71 = TREE_OPERAND (_p1, 1);
9966 756 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
9967 : {
9968 0 : switch (TREE_CODE (_q71))
9969 : {
9970 0 : case POINTER_PLUS_EXPR:
9971 0 : {
9972 0 : tree _q90 = TREE_OPERAND (_q71, 0);
9973 0 : tree _q91 = TREE_OPERAND (_q71, 1);
9974 0 : if ((_q90 == _q21 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q21, 0) && types_match (_q90, _q21)))
9975 : {
9976 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
9977 : {
9978 0 : {
9979 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q71 };
9980 0 : const enum tree_code cmp = LT_EXPR;
9981 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
9982 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
9983 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
9984 : )
9985 : {
9986 0 : {
9987 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
9988 0 : offset_int rhs = off * 2;
9989 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
9990 : )
9991 : {
9992 0 : {
9993 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
9994 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
9995 0 : if (cmp == LT_EXPR
9996 : )
9997 : {
9998 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1750;
9999 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1750;
10000 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1750;
10001 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1750;
10002 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1750;
10003 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1750;
10004 0 : {
10005 0 : tree res_op0;
10006 0 : {
10007 0 : tree _o1[1], _r1;
10008 0 : {
10009 0 : tree _o2[2], _r2;
10010 0 : _o2[0] = swap_p ? captures[6] : captures[1];
10011 0 : _o2[1] = swap_p ? captures[2] : captures[4];
10012 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10013 0 : _o1[0] = _r2;
10014 : }
10015 0 : if (TREE_TYPE (_o1[0]) != sizetype)
10016 : {
10017 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10018 : }
10019 : else
10020 : _r1 = _o1[0];
10021 0 : res_op0 = _r1;
10022 : }
10023 0 : tree res_op1;
10024 0 : res_op1 = rhs_tree;
10025 0 : tree _r;
10026 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10027 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 950, __FILE__, __LINE__, true);
10028 0 : return _r;
10029 : }
10030 0 : next_after_fail1750:;
10031 : }
10032 : else
10033 : {
10034 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1751;
10035 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1751;
10036 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1751;
10037 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1751;
10038 : {
10039 : tree res_op0;
10040 : {
10041 : tree _o1[1], _r1;
10042 : {
10043 : tree _o2[2], _r2;
10044 : {
10045 : tree _o3[2], _r3;
10046 : _o3[0] = swap_p ? captures[4] : captures[2];
10047 : _o3[1] = wide_int_to_tree (sizetype, off);
10048 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
10049 : _o2[0] = _r3;
10050 : }
10051 : _o2[1] = swap_p ? captures[2] : captures[4];
10052 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10053 : _o1[0] = _r2;
10054 : }
10055 : if (TREE_TYPE (_o1[0]) != sizetype)
10056 : {
10057 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10058 : }
10059 : else
10060 : _r1 = _o1[0];
10061 : res_op0 = _r1;
10062 : }
10063 : tree res_op1;
10064 : res_op1 = rhs_tree;
10065 : tree _r;
10066 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10067 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 951, __FILE__, __LINE__, true);
10068 : return _r;
10069 : }
10070 : next_after_fail1751:;
10071 : }
10072 : }
10073 : }
10074 : }
10075 : }
10076 : }
10077 : }
10078 : }
10079 : break;
10080 : }
10081 : default:;
10082 : }
10083 : }
10084 : break;
10085 : }
10086 : default:;
10087 : }
10088 : break;
10089 : }
10090 : default:;
10091 : }
10092 : break;
10093 : }
10094 : default:;
10095 : }
10096 : break;
10097 : }
10098 2066306 : case EQ_EXPR:
10099 2066306 : {
10100 2066306 : tree _q20 = TREE_OPERAND (_p0, 0);
10101 2066306 : tree _q21 = TREE_OPERAND (_p0, 1);
10102 2066306 : switch (TREE_CODE (_q20))
10103 : {
10104 56425 : case BIT_AND_EXPR:
10105 56425 : {
10106 56425 : tree _q30 = TREE_OPERAND (_q20, 0);
10107 56425 : tree _q31 = TREE_OPERAND (_q20, 1);
10108 56425 : switch (TREE_CODE (_q31))
10109 : {
10110 56425 : case INTEGER_CST:
10111 56425 : {
10112 56425 : if (integer_zerop (_q21))
10113 : {
10114 56406 : switch (TREE_CODE (_p1))
10115 : {
10116 0 : case LT_EXPR:
10117 0 : {
10118 0 : tree _q70 = TREE_OPERAND (_p1, 0);
10119 0 : tree _q71 = TREE_OPERAND (_p1, 1);
10120 0 : {
10121 0 : tree _q70_pops[1];
10122 0 : if (tree_nop_convert (_q70, _q70_pops))
10123 : {
10124 0 : tree _q80 = _q70_pops[0];
10125 0 : if ((_q80 == _q30 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q30, 0) && types_match (_q80, _q30)))
10126 : {
10127 0 : if (integer_zerop (_q71))
10128 : {
10129 0 : {
10130 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q70, _q30, _q31 };
10131 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
10132 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
10133 0 : && wi::eq_p (wi::to_wide (captures[2]),
10134 0 : wi::max_value (TYPE_PRECISION (TREE_TYPE (captures[1])), SIGNED))
10135 : )
10136 : {
10137 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1752;
10138 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1752;
10139 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1752;
10140 0 : {
10141 0 : tree res_op0;
10142 0 : res_op0 = captures[0];
10143 0 : tree res_op1;
10144 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
10145 0 : tree _r;
10146 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
10147 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 946, __FILE__, __LINE__, true);
10148 0 : return _r;
10149 : }
10150 0 : next_after_fail1752:;
10151 : }
10152 : }
10153 : }
10154 : }
10155 : }
10156 : }
10157 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
10158 : {
10159 0 : if (integer_zerop (_q71))
10160 : {
10161 0 : {
10162 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q70, _q30, _q31 };
10163 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
10164 0 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
10165 0 : && wi::eq_p (wi::to_wide (captures[2]),
10166 0 : wi::max_value (TYPE_PRECISION (TREE_TYPE (captures[1])), SIGNED))
10167 : )
10168 : {
10169 0 : if (TREE_SIDE_EFFECTS (_p0)) goto next_after_fail1753;
10170 0 : if (TREE_SIDE_EFFECTS (_p1)) goto next_after_fail1753;
10171 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1753;
10172 0 : {
10173 0 : tree res_op0;
10174 0 : res_op0 = captures[0];
10175 0 : tree res_op1;
10176 0 : res_op1 = build_zero_cst (TREE_TYPE (captures[0]));
10177 0 : tree _r;
10178 0 : _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
10179 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 946, __FILE__, __LINE__, true);
10180 0 : return _r;
10181 : }
10182 0 : next_after_fail1753:;
10183 : }
10184 : }
10185 : }
10186 : }
10187 : break;
10188 : }
10189 : default:;
10190 : }
10191 : }
10192 : break;
10193 : }
10194 : default:;
10195 : }
10196 : break;
10197 : }
10198 : default:;
10199 : }
10200 : break;
10201 : }
10202 1338301 : case LE_EXPR:
10203 1338301 : {
10204 1338301 : tree _q20 = TREE_OPERAND (_p0, 0);
10205 1338301 : tree _q21 = TREE_OPERAND (_p0, 1);
10206 1338301 : switch (TREE_CODE (_q20))
10207 : {
10208 3927 : case POINTER_PLUS_EXPR:
10209 3927 : {
10210 3927 : tree _q30 = TREE_OPERAND (_q20, 0);
10211 3927 : tree _q31 = TREE_OPERAND (_q20, 1);
10212 3927 : switch (TREE_CODE (_q31))
10213 : {
10214 3689 : case INTEGER_CST:
10215 3689 : {
10216 3689 : switch (TREE_CODE (_p1))
10217 : {
10218 1090 : case LE_EXPR:
10219 1090 : {
10220 1090 : tree _q70 = TREE_OPERAND (_p1, 0);
10221 1090 : tree _q71 = TREE_OPERAND (_p1, 1);
10222 1090 : switch (TREE_CODE (_q70))
10223 : {
10224 804 : case POINTER_PLUS_EXPR:
10225 804 : {
10226 804 : tree _q80 = TREE_OPERAND (_q70, 0);
10227 804 : tree _q81 = TREE_OPERAND (_q70, 1);
10228 804 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
10229 : {
10230 518 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
10231 : {
10232 399 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
10233 : {
10234 399 : {
10235 399 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70 };
10236 399 : const enum tree_code cmp = LE_EXPR;
10237 399 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
10238 398 : && TYPE_OVERFLOW_WRAPS (sizetype)
10239 797 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
10240 : )
10241 : {
10242 398 : {
10243 398 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
10244 398 : offset_int rhs = off * 2;
10245 398 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
10246 : )
10247 : {
10248 398 : {
10249 398 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
10250 398 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
10251 398 : if (cmp == LT_EXPR
10252 : )
10253 : {
10254 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1754;
10255 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1754;
10256 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1754;
10257 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1754;
10258 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1754;
10259 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1754;
10260 : {
10261 : tree res_op0;
10262 : {
10263 : tree _o1[1], _r1;
10264 : {
10265 : tree _o2[2], _r2;
10266 : _o2[0] = swap_p ? captures[6] : captures[1];
10267 : _o2[1] = swap_p ? captures[2] : captures[4];
10268 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10269 : _o1[0] = _r2;
10270 : }
10271 : if (TREE_TYPE (_o1[0]) != sizetype)
10272 : {
10273 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10274 : }
10275 : else
10276 : _r1 = _o1[0];
10277 : res_op0 = _r1;
10278 : }
10279 : tree res_op1;
10280 : res_op1 = rhs_tree;
10281 : tree _r;
10282 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10283 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 950, __FILE__, __LINE__, true);
10284 398 : return _r;
10285 : }
10286 : next_after_fail1754:;
10287 : }
10288 : else
10289 : {
10290 398 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1755;
10291 398 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1755;
10292 398 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1755;
10293 398 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1755;
10294 398 : {
10295 398 : tree res_op0;
10296 398 : {
10297 398 : tree _o1[1], _r1;
10298 398 : {
10299 398 : tree _o2[2], _r2;
10300 398 : {
10301 398 : tree _o3[2], _r3;
10302 398 : _o3[0] = swap_p ? captures[4] : captures[2];
10303 398 : _o3[1] = wide_int_to_tree (sizetype, off);
10304 398 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
10305 398 : _o2[0] = _r3;
10306 : }
10307 398 : _o2[1] = swap_p ? captures[2] : captures[4];
10308 398 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10309 398 : _o1[0] = _r2;
10310 : }
10311 398 : if (TREE_TYPE (_o1[0]) != sizetype)
10312 : {
10313 398 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10314 : }
10315 : else
10316 : _r1 = _o1[0];
10317 398 : res_op0 = _r1;
10318 : }
10319 398 : tree res_op1;
10320 398 : res_op1 = rhs_tree;
10321 398 : tree _r;
10322 398 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10323 398 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 951, __FILE__, __LINE__, true);
10324 398 : return _r;
10325 : }
10326 0 : next_after_fail1755:;
10327 : }
10328 : }
10329 : }
10330 : }
10331 : }
10332 : }
10333 : }
10334 : }
10335 : }
10336 : break;
10337 : }
10338 : default:;
10339 : }
10340 : break;
10341 : }
10342 117 : case GE_EXPR:
10343 117 : {
10344 117 : tree _q70 = TREE_OPERAND (_p1, 0);
10345 117 : tree _q71 = TREE_OPERAND (_p1, 1);
10346 117 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
10347 : {
10348 18 : switch (TREE_CODE (_q71))
10349 : {
10350 18 : case POINTER_PLUS_EXPR:
10351 18 : {
10352 18 : tree _q90 = TREE_OPERAND (_q71, 0);
10353 18 : tree _q91 = TREE_OPERAND (_q71, 1);
10354 18 : if ((_q90 == _q21 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q21, 0) && types_match (_q90, _q21)))
10355 : {
10356 16 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
10357 : {
10358 11 : {
10359 11 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q71 };
10360 11 : const enum tree_code cmp = LE_EXPR;
10361 11 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
10362 11 : && TYPE_OVERFLOW_WRAPS (sizetype)
10363 22 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
10364 : )
10365 : {
10366 11 : {
10367 11 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
10368 11 : offset_int rhs = off * 2;
10369 11 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
10370 : )
10371 : {
10372 11 : {
10373 11 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
10374 11 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
10375 11 : if (cmp == LT_EXPR
10376 : )
10377 : {
10378 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1756;
10379 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1756;
10380 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1756;
10381 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1756;
10382 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1756;
10383 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1756;
10384 : {
10385 : tree res_op0;
10386 : {
10387 : tree _o1[1], _r1;
10388 : {
10389 : tree _o2[2], _r2;
10390 : _o2[0] = swap_p ? captures[6] : captures[1];
10391 : _o2[1] = swap_p ? captures[2] : captures[4];
10392 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10393 : _o1[0] = _r2;
10394 : }
10395 : if (TREE_TYPE (_o1[0]) != sizetype)
10396 : {
10397 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10398 : }
10399 : else
10400 : _r1 = _o1[0];
10401 : res_op0 = _r1;
10402 : }
10403 : tree res_op1;
10404 : res_op1 = rhs_tree;
10405 : tree _r;
10406 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10407 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 950, __FILE__, __LINE__, true);
10408 11 : return _r;
10409 : }
10410 : next_after_fail1756:;
10411 : }
10412 : else
10413 : {
10414 11 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1757;
10415 11 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1757;
10416 11 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1757;
10417 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1757;
10418 11 : {
10419 11 : tree res_op0;
10420 11 : {
10421 11 : tree _o1[1], _r1;
10422 11 : {
10423 11 : tree _o2[2], _r2;
10424 11 : {
10425 11 : tree _o3[2], _r3;
10426 11 : _o3[0] = swap_p ? captures[4] : captures[2];
10427 11 : _o3[1] = wide_int_to_tree (sizetype, off);
10428 11 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
10429 11 : _o2[0] = _r3;
10430 : }
10431 11 : _o2[1] = swap_p ? captures[2] : captures[4];
10432 11 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10433 11 : _o1[0] = _r2;
10434 : }
10435 11 : if (TREE_TYPE (_o1[0]) != sizetype)
10436 : {
10437 11 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10438 : }
10439 : else
10440 : _r1 = _o1[0];
10441 11 : res_op0 = _r1;
10442 : }
10443 11 : tree res_op1;
10444 11 : res_op1 = rhs_tree;
10445 11 : tree _r;
10446 11 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10447 11 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 951, __FILE__, __LINE__, true);
10448 11 : return _r;
10449 : }
10450 0 : next_after_fail1757:;
10451 : }
10452 : }
10453 : }
10454 : }
10455 : }
10456 : }
10457 : }
10458 : }
10459 : break;
10460 : }
10461 : default:;
10462 : }
10463 : }
10464 : break;
10465 : }
10466 : default:;
10467 : }
10468 : break;
10469 : }
10470 : default:;
10471 : }
10472 : break;
10473 : }
10474 : default:;
10475 : }
10476 : break;
10477 : }
10478 794286 : case GE_EXPR:
10479 794286 : {
10480 794286 : tree _q20 = TREE_OPERAND (_p0, 0);
10481 794286 : tree _q21 = TREE_OPERAND (_p0, 1);
10482 794286 : switch (TREE_CODE (_q21))
10483 : {
10484 56 : case POINTER_PLUS_EXPR:
10485 56 : {
10486 56 : tree _q40 = TREE_OPERAND (_q21, 0);
10487 56 : tree _q41 = TREE_OPERAND (_q21, 1);
10488 56 : switch (TREE_CODE (_q41))
10489 : {
10490 56 : case INTEGER_CST:
10491 56 : {
10492 56 : switch (TREE_CODE (_p1))
10493 : {
10494 54 : case LE_EXPR:
10495 54 : {
10496 54 : tree _q70 = TREE_OPERAND (_p1, 0);
10497 54 : tree _q71 = TREE_OPERAND (_p1, 1);
10498 54 : switch (TREE_CODE (_q70))
10499 : {
10500 44 : case POINTER_PLUS_EXPR:
10501 44 : {
10502 44 : tree _q80 = TREE_OPERAND (_q70, 0);
10503 44 : tree _q81 = TREE_OPERAND (_q70, 1);
10504 44 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
10505 : {
10506 29 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
10507 : {
10508 3 : if ((_q71 == _q40 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q40, 0) && types_match (_q71, _q40)))
10509 : {
10510 3 : {
10511 3 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q70 };
10512 3 : const enum tree_code cmp = LE_EXPR;
10513 3 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
10514 3 : && TYPE_OVERFLOW_WRAPS (sizetype)
10515 6 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
10516 : )
10517 : {
10518 3 : {
10519 3 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
10520 3 : offset_int rhs = off * 2;
10521 3 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
10522 : )
10523 : {
10524 3 : {
10525 3 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
10526 3 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
10527 3 : if (cmp == LT_EXPR
10528 : )
10529 : {
10530 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1758;
10531 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1758;
10532 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1758;
10533 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1758;
10534 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1758;
10535 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1758;
10536 : {
10537 : tree res_op0;
10538 : {
10539 : tree _o1[1], _r1;
10540 : {
10541 : tree _o2[2], _r2;
10542 : _o2[0] = swap_p ? captures[6] : captures[1];
10543 : _o2[1] = swap_p ? captures[2] : captures[4];
10544 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10545 : _o1[0] = _r2;
10546 : }
10547 : if (TREE_TYPE (_o1[0]) != sizetype)
10548 : {
10549 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10550 : }
10551 : else
10552 : _r1 = _o1[0];
10553 : res_op0 = _r1;
10554 : }
10555 : tree res_op1;
10556 : res_op1 = rhs_tree;
10557 : tree _r;
10558 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10559 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 950, __FILE__, __LINE__, true);
10560 3 : return _r;
10561 : }
10562 : next_after_fail1758:;
10563 : }
10564 : else
10565 : {
10566 3 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1759;
10567 3 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1759;
10568 3 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1759;
10569 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1759;
10570 3 : {
10571 3 : tree res_op0;
10572 3 : {
10573 3 : tree _o1[1], _r1;
10574 3 : {
10575 3 : tree _o2[2], _r2;
10576 3 : {
10577 3 : tree _o3[2], _r3;
10578 3 : _o3[0] = swap_p ? captures[4] : captures[2];
10579 3 : _o3[1] = wide_int_to_tree (sizetype, off);
10580 3 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
10581 3 : _o2[0] = _r3;
10582 : }
10583 3 : _o2[1] = swap_p ? captures[2] : captures[4];
10584 3 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10585 3 : _o1[0] = _r2;
10586 : }
10587 3 : if (TREE_TYPE (_o1[0]) != sizetype)
10588 : {
10589 3 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10590 : }
10591 : else
10592 : _r1 = _o1[0];
10593 3 : res_op0 = _r1;
10594 : }
10595 3 : tree res_op1;
10596 3 : res_op1 = rhs_tree;
10597 3 : tree _r;
10598 3 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10599 3 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 951, __FILE__, __LINE__, true);
10600 3 : return _r;
10601 : }
10602 0 : next_after_fail1759:;
10603 : }
10604 : }
10605 : }
10606 : }
10607 : }
10608 : }
10609 : }
10610 : }
10611 : }
10612 : break;
10613 : }
10614 : default:;
10615 : }
10616 : break;
10617 : }
10618 0 : case GE_EXPR:
10619 0 : {
10620 0 : tree _q70 = TREE_OPERAND (_p1, 0);
10621 0 : tree _q71 = TREE_OPERAND (_p1, 1);
10622 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
10623 : {
10624 0 : switch (TREE_CODE (_q71))
10625 : {
10626 0 : case POINTER_PLUS_EXPR:
10627 0 : {
10628 0 : tree _q90 = TREE_OPERAND (_q71, 0);
10629 0 : tree _q91 = TREE_OPERAND (_q71, 1);
10630 0 : if ((_q90 == _q20 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q20, 0) && types_match (_q90, _q20)))
10631 : {
10632 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
10633 : {
10634 0 : {
10635 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q71 };
10636 0 : const enum tree_code cmp = LE_EXPR;
10637 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
10638 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
10639 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
10640 : )
10641 : {
10642 0 : {
10643 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
10644 0 : offset_int rhs = off * 2;
10645 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
10646 : )
10647 : {
10648 0 : {
10649 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
10650 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
10651 0 : if (cmp == LT_EXPR
10652 : )
10653 : {
10654 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1760;
10655 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1760;
10656 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1760;
10657 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1760;
10658 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1760;
10659 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1760;
10660 : {
10661 : tree res_op0;
10662 : {
10663 : tree _o1[1], _r1;
10664 : {
10665 : tree _o2[2], _r2;
10666 : _o2[0] = swap_p ? captures[6] : captures[1];
10667 : _o2[1] = swap_p ? captures[2] : captures[4];
10668 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10669 : _o1[0] = _r2;
10670 : }
10671 : if (TREE_TYPE (_o1[0]) != sizetype)
10672 : {
10673 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10674 : }
10675 : else
10676 : _r1 = _o1[0];
10677 : res_op0 = _r1;
10678 : }
10679 : tree res_op1;
10680 : res_op1 = rhs_tree;
10681 : tree _r;
10682 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10683 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 950, __FILE__, __LINE__, true);
10684 0 : return _r;
10685 : }
10686 : next_after_fail1760:;
10687 : }
10688 : else
10689 : {
10690 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1761;
10691 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1761;
10692 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1761;
10693 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1761;
10694 0 : {
10695 0 : tree res_op0;
10696 0 : {
10697 0 : tree _o1[1], _r1;
10698 0 : {
10699 0 : tree _o2[2], _r2;
10700 0 : {
10701 0 : tree _o3[2], _r3;
10702 0 : _o3[0] = swap_p ? captures[4] : captures[2];
10703 0 : _o3[1] = wide_int_to_tree (sizetype, off);
10704 0 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
10705 0 : _o2[0] = _r3;
10706 : }
10707 0 : _o2[1] = swap_p ? captures[2] : captures[4];
10708 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10709 0 : _o1[0] = _r2;
10710 : }
10711 0 : if (TREE_TYPE (_o1[0]) != sizetype)
10712 : {
10713 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10714 : }
10715 : else
10716 : _r1 = _o1[0];
10717 0 : res_op0 = _r1;
10718 : }
10719 0 : tree res_op1;
10720 0 : res_op1 = rhs_tree;
10721 0 : tree _r;
10722 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10723 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 951, __FILE__, __LINE__, true);
10724 0 : return _r;
10725 : }
10726 0 : next_after_fail1761:;
10727 : }
10728 : }
10729 : }
10730 : }
10731 : }
10732 : }
10733 : }
10734 : }
10735 : break;
10736 : }
10737 : default:;
10738 : }
10739 : }
10740 : break;
10741 : }
10742 : default:;
10743 : }
10744 : break;
10745 : }
10746 : default:;
10747 : }
10748 : break;
10749 : }
10750 : default:;
10751 : }
10752 : break;
10753 : }
10754 1187283 : case GT_EXPR:
10755 1187283 : {
10756 1187283 : tree _q20 = TREE_OPERAND (_p0, 0);
10757 1187283 : tree _q21 = TREE_OPERAND (_p0, 1);
10758 1187283 : switch (TREE_CODE (_q21))
10759 : {
10760 46 : case POINTER_PLUS_EXPR:
10761 46 : {
10762 46 : tree _q40 = TREE_OPERAND (_q21, 0);
10763 46 : tree _q41 = TREE_OPERAND (_q21, 1);
10764 46 : switch (TREE_CODE (_q41))
10765 : {
10766 46 : case INTEGER_CST:
10767 46 : {
10768 46 : switch (TREE_CODE (_p1))
10769 : {
10770 0 : case LT_EXPR:
10771 0 : {
10772 0 : tree _q70 = TREE_OPERAND (_p1, 0);
10773 0 : tree _q71 = TREE_OPERAND (_p1, 1);
10774 0 : switch (TREE_CODE (_q70))
10775 : {
10776 0 : case POINTER_PLUS_EXPR:
10777 0 : {
10778 0 : tree _q80 = TREE_OPERAND (_q70, 0);
10779 0 : tree _q81 = TREE_OPERAND (_q70, 1);
10780 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
10781 : {
10782 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
10783 : {
10784 0 : if ((_q71 == _q40 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q40, 0) && types_match (_q71, _q40)))
10785 : {
10786 0 : {
10787 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q70 };
10788 0 : const enum tree_code cmp = LT_EXPR;
10789 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
10790 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
10791 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
10792 : )
10793 : {
10794 0 : {
10795 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
10796 0 : offset_int rhs = off * 2;
10797 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
10798 : )
10799 : {
10800 0 : {
10801 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
10802 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
10803 0 : if (cmp == LT_EXPR
10804 : )
10805 : {
10806 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1762;
10807 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1762;
10808 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1762;
10809 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1762;
10810 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1762;
10811 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1762;
10812 0 : {
10813 0 : tree res_op0;
10814 0 : {
10815 0 : tree _o1[1], _r1;
10816 0 : {
10817 0 : tree _o2[2], _r2;
10818 0 : _o2[0] = swap_p ? captures[6] : captures[1];
10819 0 : _o2[1] = swap_p ? captures[2] : captures[4];
10820 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10821 0 : _o1[0] = _r2;
10822 : }
10823 0 : if (TREE_TYPE (_o1[0]) != sizetype)
10824 : {
10825 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10826 : }
10827 : else
10828 : _r1 = _o1[0];
10829 0 : res_op0 = _r1;
10830 : }
10831 0 : tree res_op1;
10832 0 : res_op1 = rhs_tree;
10833 0 : tree _r;
10834 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10835 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 950, __FILE__, __LINE__, true);
10836 0 : return _r;
10837 : }
10838 0 : next_after_fail1762:;
10839 : }
10840 : else
10841 : {
10842 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1763;
10843 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1763;
10844 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1763;
10845 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1763;
10846 : {
10847 : tree res_op0;
10848 : {
10849 : tree _o1[1], _r1;
10850 : {
10851 : tree _o2[2], _r2;
10852 : {
10853 : tree _o3[2], _r3;
10854 : _o3[0] = swap_p ? captures[4] : captures[2];
10855 : _o3[1] = wide_int_to_tree (sizetype, off);
10856 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
10857 : _o2[0] = _r3;
10858 : }
10859 : _o2[1] = swap_p ? captures[2] : captures[4];
10860 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10861 : _o1[0] = _r2;
10862 : }
10863 : if (TREE_TYPE (_o1[0]) != sizetype)
10864 : {
10865 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10866 : }
10867 : else
10868 : _r1 = _o1[0];
10869 : res_op0 = _r1;
10870 : }
10871 : tree res_op1;
10872 : res_op1 = rhs_tree;
10873 : tree _r;
10874 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10875 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 951, __FILE__, __LINE__, true);
10876 : return _r;
10877 : }
10878 : next_after_fail1763:;
10879 : }
10880 : }
10881 : }
10882 : }
10883 : }
10884 : }
10885 : }
10886 : }
10887 : }
10888 : break;
10889 : }
10890 : default:;
10891 : }
10892 : break;
10893 : }
10894 18 : case GT_EXPR:
10895 18 : {
10896 18 : tree _q70 = TREE_OPERAND (_p1, 0);
10897 18 : tree _q71 = TREE_OPERAND (_p1, 1);
10898 18 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
10899 : {
10900 0 : switch (TREE_CODE (_q71))
10901 : {
10902 0 : case POINTER_PLUS_EXPR:
10903 0 : {
10904 0 : tree _q90 = TREE_OPERAND (_q71, 0);
10905 0 : tree _q91 = TREE_OPERAND (_q71, 1);
10906 0 : if ((_q90 == _q20 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q20, 0) && types_match (_q90, _q20)))
10907 : {
10908 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
10909 : {
10910 0 : {
10911 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q71 };
10912 0 : const enum tree_code cmp = LT_EXPR;
10913 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
10914 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
10915 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
10916 : )
10917 : {
10918 0 : {
10919 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
10920 0 : offset_int rhs = off * 2;
10921 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
10922 : )
10923 : {
10924 0 : {
10925 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
10926 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
10927 0 : if (cmp == LT_EXPR
10928 : )
10929 : {
10930 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1764;
10931 0 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1764;
10932 0 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1764;
10933 0 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1764;
10934 0 : if (TREE_SIDE_EFFECTS (captures[6])) goto next_after_fail1764;
10935 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1764;
10936 0 : {
10937 0 : tree res_op0;
10938 0 : {
10939 0 : tree _o1[1], _r1;
10940 0 : {
10941 0 : tree _o2[2], _r2;
10942 0 : _o2[0] = swap_p ? captures[6] : captures[1];
10943 0 : _o2[1] = swap_p ? captures[2] : captures[4];
10944 0 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10945 0 : _o1[0] = _r2;
10946 : }
10947 0 : if (TREE_TYPE (_o1[0]) != sizetype)
10948 : {
10949 0 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10950 : }
10951 : else
10952 : _r1 = _o1[0];
10953 0 : res_op0 = _r1;
10954 : }
10955 0 : tree res_op1;
10956 0 : res_op1 = rhs_tree;
10957 0 : tree _r;
10958 0 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10959 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 950, __FILE__, __LINE__, true);
10960 0 : return _r;
10961 : }
10962 0 : next_after_fail1764:;
10963 : }
10964 : else
10965 : {
10966 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1765;
10967 : if (TREE_SIDE_EFFECTS (captures[3])) goto next_after_fail1765;
10968 : if (TREE_SIDE_EFFECTS (captures[4])) goto next_after_fail1765;
10969 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1765;
10970 : {
10971 : tree res_op0;
10972 : {
10973 : tree _o1[1], _r1;
10974 : {
10975 : tree _o2[2], _r2;
10976 : {
10977 : tree _o3[2], _r3;
10978 : _o3[0] = swap_p ? captures[4] : captures[2];
10979 : _o3[1] = wide_int_to_tree (sizetype, off);
10980 : _r3 = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
10981 : _o2[0] = _r3;
10982 : }
10983 : _o2[1] = swap_p ? captures[2] : captures[4];
10984 : _r2 = fold_build2_loc (loc, POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
10985 : _o1[0] = _r2;
10986 : }
10987 : if (TREE_TYPE (_o1[0]) != sizetype)
10988 : {
10989 : _r1 = fold_build1_loc (loc, NOP_EXPR, sizetype, _o1[0]);
10990 : }
10991 : else
10992 : _r1 = _o1[0];
10993 : res_op0 = _r1;
10994 : }
10995 : tree res_op1;
10996 : res_op1 = rhs_tree;
10997 : tree _r;
10998 : _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
10999 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 951, __FILE__, __LINE__, true);
11000 : return _r;
11001 : }
11002 : next_after_fail1765:;
11003 : }
11004 : }
11005 : }
11006 : }
11007 : }
11008 : }
11009 : }
11010 : }
11011 : break;
11012 : }
11013 : default:;
11014 : }
11015 : }
11016 : break;
11017 : }
11018 : default:;
11019 : }
11020 : break;
11021 : }
11022 : default:;
11023 : }
11024 : break;
11025 : }
11026 : default:;
11027 : }
11028 : break;
11029 : }
11030 : default:;
11031 : }
11032 : return NULL_TREE;
11033 : }
11034 :
11035 : tree
11036 833421 : generic_simplify_VEC_PERM_EXPR (location_t ARG_UNUSED (loc), enum tree_code ARG_UNUSED (code), const tree ARG_UNUSED (type), tree _p0, tree _p1, tree _p2)
11037 : {
11038 833421 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
11039 833421 : switch (TREE_CODE (_p0))
11040 : {
11041 0 : case PLUS_EXPR:
11042 0 : {
11043 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11044 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11045 0 : switch (TREE_CODE (_p1))
11046 : {
11047 0 : case MINUS_EXPR:
11048 0 : {
11049 0 : tree _q50 = TREE_OPERAND (_p1, 0);
11050 0 : tree _q51 = TREE_OPERAND (_p1, 1);
11051 0 : switch (TREE_CODE (_p2))
11052 : {
11053 0 : case VECTOR_CST:
11054 0 : {
11055 0 : {
11056 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51, _p2 };
11057 0 : tree res = generic_simplify_629 (loc, type, _p0, _p1, _p2, captures, PLUS_EXPR, MINUS_EXPR);
11058 0 : if (res) return res;
11059 : }
11060 0 : break;
11061 : }
11062 : default:;
11063 : }
11064 : break;
11065 : }
11066 : default:;
11067 : }
11068 : break;
11069 : }
11070 0 : case MINUS_EXPR:
11071 0 : {
11072 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11073 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11074 0 : switch (TREE_CODE (_p1))
11075 : {
11076 0 : case PLUS_EXPR:
11077 0 : {
11078 0 : tree _q50 = TREE_OPERAND (_p1, 0);
11079 0 : tree _q51 = TREE_OPERAND (_p1, 1);
11080 0 : switch (TREE_CODE (_p2))
11081 : {
11082 0 : case VECTOR_CST:
11083 0 : {
11084 0 : {
11085 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51, _p2 };
11086 0 : tree res = generic_simplify_629 (loc, type, _p0, _p1, _p2, captures, MINUS_EXPR, PLUS_EXPR);
11087 0 : if (res) return res;
11088 : }
11089 0 : break;
11090 : }
11091 : default:;
11092 : }
11093 : break;
11094 : }
11095 : default:;
11096 : }
11097 : break;
11098 : }
11099 833421 : default:;
11100 : }
11101 833421 : switch (TREE_CODE (_p2))
11102 : {
11103 821947 : case VECTOR_CST:
11104 821947 : {
11105 821947 : {
11106 821947 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _p2 };
11107 821947 : {
11108 821947 : tree op0 = captures[0], op1 = captures[1], op2 = captures[2];
11109 821947 : machine_mode result_mode = TYPE_MODE (type);
11110 821947 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (op0));
11111 821947 : vec_perm_builder builder;
11112 821947 : if (tree_to_vec_perm_builder (&builder, op2)
11113 : )
11114 : {
11115 821935 : {
11116 821935 : poly_uint64 nelts = TYPE_VECTOR_SUBPARTS (type);
11117 821935 : poly_uint64 nelts_in = TYPE_VECTOR_SUBPARTS (TREE_TYPE (op0));
11118 821935 : bool single_arg = (op0 == op1);
11119 1435374 : vec_perm_indices sel (builder, single_arg ? 1 : 2, nelts_in);
11120 821935 : if (known_eq (nelts, nelts_in) && sel.series_p (0, 1, 0, 1)
11121 : )
11122 : {
11123 21766 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1996;
11124 21766 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1996;
11125 21766 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1996;
11126 21766 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1996;
11127 21766 : {
11128 21766 : tree res_op0;
11129 21766 : res_op0 = captures[0];
11130 21766 : tree _r;
11131 21766 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11132 21766 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1108, __FILE__, __LINE__, true);
11133 21766 : return _r;
11134 : }
11135 768694 : next_after_fail1996:;
11136 : }
11137 : else
11138 : {
11139 800169 : if (known_eq (nelts, nelts_in) && sel.series_p (0, 1, nelts_in, 1)
11140 : )
11141 : {
11142 13 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1997;
11143 13 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1997;
11144 13 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1997;
11145 13 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1997;
11146 13 : {
11147 13 : tree res_op0;
11148 13 : res_op0 = captures[1];
11149 13 : tree _r;
11150 13 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11151 13 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1109, __FILE__, __LINE__, true);
11152 13 : return _r;
11153 : }
11154 768694 : next_after_fail1997:;
11155 : }
11156 : else
11157 : {
11158 800156 : {
11159 800156 : if (!single_arg)
11160 : {
11161 592336 : if (sel.all_from_input_p (0))
11162 : op1 = op0;
11163 572128 : else if (sel.all_from_input_p (1))
11164 : {
11165 33 : op0 = op1;
11166 33 : sel.rotate_inputs (1);
11167 : }
11168 572095 : else if (known_ge (poly_uint64 (sel[0]), nelts_in))
11169 : {
11170 169 : std::swap (op0, op1);
11171 169 : sel.rotate_inputs (1);
11172 : }
11173 : }
11174 800156 : gassign *def;
11175 800156 : tree cop0 = op0, cop1 = op1;
11176 800156 : if (TREE_CODE (op0) == SSA_NAME
11177 752095 : && (def = dyn_cast <gassign *> (SSA_NAME_DEF_STMT (op0)))
11178 1516332 : && gimple_assign_rhs_code (def) == CONSTRUCTOR)
11179 14235 : cop0 = gimple_assign_rhs1 (def);
11180 800156 : if (TREE_CODE (op1) == SSA_NAME
11181 731189 : && (def = dyn_cast <gassign *> (SSA_NAME_DEF_STMT (op1)))
11182 1497345 : && gimple_assign_rhs_code (def) == CONSTRUCTOR)
11183 21146 : cop1 = gimple_assign_rhs1 (def);
11184 800156 : tree t;
11185 800156 : if ((TREE_CODE (cop0) == VECTOR_CST
11186 756639 : || TREE_CODE (cop0) == CONSTRUCTOR)
11187 59584 : && (TREE_CODE (cop1) == VECTOR_CST
11188 25892 : || TREE_CODE (cop1) == CONSTRUCTOR)
11189 846921 : && (t = fold_vec_perm (type, cop0, cop1, sel))
11190 : )
11191 : {
11192 28997 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1998;
11193 28997 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1998;
11194 28997 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1998;
11195 28997 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1998;
11196 28997 : {
11197 28997 : tree _r;
11198 28997 : _r = t;
11199 28997 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1110, __FILE__, __LINE__, true);
11200 28997 : return _r;
11201 : }
11202 768694 : next_after_fail1998:;
11203 : }
11204 : else
11205 : {
11206 771159 : {
11207 771159 : bool changed = (op0 == op1 && !single_arg);
11208 771159 : tree ins = NULL_TREE;
11209 771159 : unsigned at = 0;
11210 771159 : if (op_mode != BLKmode
11211 758918 : && known_eq (nelts, nelts_in)
11212 1529924 : && (TREE_CODE (cop0) == VECTOR_CST
11213 743276 : || TREE_CODE (cop0) == CONSTRUCTOR
11214 733590 : || TREE_CODE (cop1) == VECTOR_CST
11215 702649 : || TREE_CODE (cop1) == CONSTRUCTOR))
11216 : {
11217 65219 : bool insert_first_p = sel.series_p (1, 1, nelts + 1, 1);
11218 65219 : if (insert_first_p)
11219 : {
11220 777 : at = 0;
11221 777 : if ((ins = fold_read_from_vector (cop0, sel[0])))
11222 115 : op0 = op1;
11223 : }
11224 777 : if (!insert_first_p || (!ins && maybe_eq (nelts, 2u)))
11225 : {
11226 64904 : unsigned int encoded_nelts = sel.encoding ().encoded_nelts ();
11227 140685 : for (at = 0; at < encoded_nelts; ++at)
11228 140538 : if (maybe_ne (sel[at], at))
11229 : break;
11230 64904 : if (at < encoded_nelts
11231 64904 : && (known_eq (at + 1, nelts)
11232 63407 : || sel.series_p (at + 1, 1, at + 1, 1)))
11233 : {
11234 2078 : if (known_lt (poly_uint64 (sel[at]), nelts))
11235 0 : ins = fold_read_from_vector (cop0, sel[at]);
11236 : else
11237 2078 : ins = fold_read_from_vector (cop1, sel[at] - nelts);
11238 : }
11239 : }
11240 : }
11241 771159 : if (!ins && sel.encoding () != builder)
11242 : {
11243 1048 : tree oldop2 = op2;
11244 1048 : if (sel.ninputs () == 2
11245 1048 : || can_vec_perm_const_p (result_mode, op_mode, sel, false))
11246 713 : op2 = vec_perm_indices_to_tree (TREE_TYPE (op2), sel);
11247 : else
11248 : {
11249 335 : vec_perm_indices sel2 (builder, 2, nelts);
11250 335 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false))
11251 60 : op2 = vec_perm_indices_to_tree (TREE_TYPE (op2), sel2);
11252 : else
11253 275 : op2 = vec_perm_indices_to_tree (TREE_TYPE (op2), sel);
11254 335 : }
11255 1048 : if (!operand_equal_p (op2, oldop2, 0))
11256 988 : changed = true;
11257 : }
11258 771159 : if (ins
11259 : )
11260 : {
11261 1476 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail1999;
11262 1476 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail1999;
11263 1476 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail1999;
11264 1476 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1999;
11265 1476 : {
11266 1476 : tree res_op0;
11267 1476 : res_op0 = op0;
11268 1476 : tree res_op1;
11269 1476 : res_op1 = ins;
11270 1476 : tree res_op2;
11271 1476 : res_op2 = bitsize_int (at * vector_element_bits (type));
11272 1476 : tree _r;
11273 1476 : _r = fold_build3_loc (loc, BIT_INSERT_EXPR, type, res_op0, res_op1, res_op2);
11274 1476 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1111, __FILE__, __LINE__, true);
11275 53241 : return _r;
11276 : }
11277 : next_after_fail1999:;
11278 : }
11279 : else
11280 : {
11281 769683 : if (changed
11282 : )
11283 : {
11284 989 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail2000;
11285 989 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail2000;
11286 989 : if (TREE_SIDE_EFFECTS (captures[2])) goto next_after_fail2000;
11287 989 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2000;
11288 989 : {
11289 989 : tree res_op0;
11290 989 : res_op0 = op0;
11291 989 : tree res_op1;
11292 989 : res_op1 = op1;
11293 989 : tree res_op2;
11294 989 : res_op2 = op2;
11295 989 : tree _r;
11296 989 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
11297 989 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1112, __FILE__, __LINE__, true);
11298 989 : return _r;
11299 : }
11300 : next_after_fail2000:;
11301 : }
11302 : }
11303 : }
11304 : }
11305 : }
11306 : }
11307 : }
11308 821935 : }
11309 : }
11310 53241 : }
11311 : }
11312 768706 : break;
11313 : }
11314 780180 : default:;
11315 : }
11316 780180 : switch (TREE_CODE (_p0))
11317 : {
11318 0 : case VIEW_CONVERT_EXPR:
11319 0 : {
11320 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11321 0 : switch (TREE_CODE (_q20))
11322 : {
11323 0 : case VEC_PERM_EXPR:
11324 0 : {
11325 0 : tree _q30 = TREE_OPERAND (_q20, 0);
11326 0 : tree _q31 = TREE_OPERAND (_q20, 1);
11327 0 : tree _q32 = TREE_OPERAND (_q20, 2);
11328 0 : switch (TREE_CODE (_q32))
11329 : {
11330 0 : case VECTOR_CST:
11331 0 : {
11332 0 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
11333 : {
11334 0 : switch (TREE_CODE (_p2))
11335 : {
11336 0 : case VECTOR_CST:
11337 0 : {
11338 0 : {
11339 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q32, _p2 };
11340 0 : if (TYPE_VECTOR_SUBPARTS (type).is_constant ()
11341 : )
11342 : {
11343 0 : {
11344 0 : machine_mode result_mode = TYPE_MODE (type);
11345 0 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (captures[2]));
11346 0 : int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
11347 0 : vec_perm_indices sel0, sel1;
11348 0 : if (tree_to_vec_perm_indices (&sel0, captures[2], captures[3], captures[4])
11349 0 : && tree_to_vec_perm_indices (&sel1, captures[0], captures[0], captures[5])
11350 0 : && TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0])))
11351 0 : == TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[1])))
11352 : )
11353 : {
11354 0 : {
11355 0 : vec_perm_builder builder2 (nelts, nelts, 1);
11356 0 : for (int i = 0; i < nelts; i++)
11357 0 : builder2.quick_push (sel0[sel1[i].to_constant ()]);
11358 0 : vec_perm_indices sel2 (builder2, 2, nelts);
11359 0 : tree op0 = NULL_TREE;
11360 0 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false)
11361 0 : || (single_use (captures[0])
11362 0 : ? (!can_vec_perm_const_p (result_mode, op_mode, sel0, true)
11363 0 : || !can_vec_perm_const_p (result_mode, op_mode, sel1, true))
11364 : : !can_vec_perm_const_p (result_mode, op_mode, sel1, true)))
11365 0 : op0 = vec_perm_indices_to_tree (TREE_TYPE (captures[5]), sel2);
11366 0 : if (op0
11367 : )
11368 : {
11369 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail2001;
11370 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2001;
11371 0 : {
11372 0 : tree res_op0;
11373 0 : {
11374 0 : tree _o1[3], _r1;
11375 0 : _o1[0] = captures[2];
11376 0 : _o1[1] = captures[3];
11377 0 : _o1[2] = op0;
11378 0 : _r1 = fold_build3_loc (loc, VEC_PERM_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1], _o1[2]);
11379 0 : res_op0 = _r1;
11380 : }
11381 0 : tree _r;
11382 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11383 0 : if (TREE_SIDE_EFFECTS (captures[4]))
11384 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
11385 0 : if (TREE_SIDE_EFFECTS (captures[5]))
11386 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
11387 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1113, __FILE__, __LINE__, true);
11388 0 : return _r;
11389 : }
11390 0 : next_after_fail2001:;
11391 : }
11392 0 : }
11393 : }
11394 0 : }
11395 : }
11396 : }
11397 0 : break;
11398 : }
11399 : default:;
11400 : }
11401 : }
11402 : break;
11403 : }
11404 : default:;
11405 : }
11406 : break;
11407 : }
11408 : default:;
11409 : }
11410 : break;
11411 : }
11412 0 : case VEC_PERM_EXPR:
11413 0 : {
11414 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11415 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11416 0 : tree _q22 = TREE_OPERAND (_p0, 2);
11417 0 : switch (TREE_CODE (_q22))
11418 : {
11419 0 : case VECTOR_CST:
11420 0 : {
11421 0 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
11422 : {
11423 0 : switch (TREE_CODE (_p2))
11424 : {
11425 0 : case VECTOR_CST:
11426 0 : {
11427 0 : {
11428 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _q22, _p2 };
11429 0 : if (TYPE_VECTOR_SUBPARTS (type).is_constant ()
11430 : )
11431 : {
11432 0 : {
11433 0 : machine_mode result_mode = TYPE_MODE (type);
11434 0 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (captures[2]));
11435 0 : int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
11436 0 : vec_perm_indices sel0, sel1;
11437 0 : if (tree_to_vec_perm_indices (&sel0, captures[2], captures[3], captures[4])
11438 0 : && tree_to_vec_perm_indices (&sel1, captures[0], captures[0], captures[5])
11439 0 : && TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0])))
11440 0 : == TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[1])))
11441 : )
11442 : {
11443 0 : {
11444 0 : vec_perm_builder builder2 (nelts, nelts, 1);
11445 0 : for (int i = 0; i < nelts; i++)
11446 0 : builder2.quick_push (sel0[sel1[i].to_constant ()]);
11447 0 : vec_perm_indices sel2 (builder2, 2, nelts);
11448 0 : tree op0 = NULL_TREE;
11449 0 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false)
11450 0 : || (single_use (captures[0])
11451 0 : ? (!can_vec_perm_const_p (result_mode, op_mode, sel0, true)
11452 0 : || !can_vec_perm_const_p (result_mode, op_mode, sel1, true))
11453 : : !can_vec_perm_const_p (result_mode, op_mode, sel1, true)))
11454 0 : op0 = vec_perm_indices_to_tree (TREE_TYPE (captures[5]), sel2);
11455 0 : if (op0
11456 : )
11457 : {
11458 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail2002;
11459 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2002;
11460 0 : {
11461 0 : tree res_op0;
11462 0 : {
11463 0 : tree _o1[3], _r1;
11464 0 : _o1[0] = captures[2];
11465 0 : _o1[1] = captures[3];
11466 0 : _o1[2] = op0;
11467 0 : _r1 = fold_build3_loc (loc, VEC_PERM_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1], _o1[2]);
11468 0 : res_op0 = _r1;
11469 : }
11470 0 : tree _r;
11471 0 : _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
11472 0 : if (TREE_SIDE_EFFECTS (captures[4]))
11473 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
11474 0 : if (TREE_SIDE_EFFECTS (captures[5]))
11475 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
11476 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1113, __FILE__, __LINE__, true);
11477 0 : return _r;
11478 : }
11479 0 : next_after_fail2002:;
11480 : }
11481 0 : }
11482 : }
11483 0 : }
11484 : }
11485 : }
11486 0 : break;
11487 : }
11488 : default:;
11489 : }
11490 : }
11491 : break;
11492 : }
11493 : default:;
11494 : }
11495 : break;
11496 : }
11497 780180 : default:;
11498 : }
11499 780180 : if (tree_vec_same_elem_p (_p0))
11500 : {
11501 13981 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
11502 : {
11503 0 : {
11504 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p2 };
11505 0 : if (types_match (type, TREE_TYPE (captures[0]))
11506 : )
11507 : {
11508 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2003;
11509 0 : {
11510 0 : tree _r;
11511 0 : _r = captures[0];
11512 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11513 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11514 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1114, __FILE__, __LINE__, true);
11515 0 : return _r;
11516 : }
11517 0 : next_after_fail2003:;
11518 : }
11519 : else
11520 : {
11521 0 : {
11522 0 : tree elem = uniform_vector_p (captures[0]);
11523 0 : if (elem
11524 : )
11525 : {
11526 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2004;
11527 0 : {
11528 0 : tree _r;
11529 0 : _r = build_vector_from_val (type, elem);
11530 0 : if (TREE_SIDE_EFFECTS (captures[0]))
11531 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
11532 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11533 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11534 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1115, __FILE__, __LINE__, true);
11535 0 : return _r;
11536 : }
11537 0 : next_after_fail2004:;
11538 : }
11539 : }
11540 : }
11541 : }
11542 : }
11543 : }
11544 780180 : switch (TREE_CODE (_p1))
11545 : {
11546 0 : case VEC_PERM_EXPR:
11547 0 : {
11548 0 : tree _q30 = TREE_OPERAND (_p1, 0);
11549 0 : tree _q31 = TREE_OPERAND (_p1, 1);
11550 0 : tree _q32 = TREE_OPERAND (_p1, 2);
11551 0 : switch (TREE_CODE (_q32))
11552 : {
11553 0 : case VECTOR_CST:
11554 0 : {
11555 0 : switch (TREE_CODE (_p2))
11556 : {
11557 0 : case VECTOR_CST:
11558 0 : {
11559 0 : {
11560 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32, _p2 };
11561 0 : if (TYPE_VECTOR_SUBPARTS (type).is_constant ()
11562 : )
11563 : {
11564 0 : {
11565 0 : machine_mode result_mode = TYPE_MODE (type);
11566 0 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (captures[2]));
11567 0 : int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
11568 0 : vec_perm_indices sel0, sel1;
11569 0 : if (tree_to_vec_perm_indices (&sel0, captures[2], captures[3], captures[4])
11570 0 : && tree_to_vec_perm_indices (&sel1, captures[0], captures[1], captures[5])
11571 : )
11572 : {
11573 0 : {
11574 0 : bool use_1 = false, use_2 = false;
11575 0 : vec_perm_builder builder2 (nelts, nelts, 2);
11576 0 : for (int i = 0; i < nelts; i++)
11577 : {
11578 0 : if (known_lt ((poly_uint64)sel1[i], sel1.nelts_per_input ()))
11579 0 : builder2.quick_push (sel1[i]);
11580 : else
11581 : {
11582 0 : poly_uint64 j = sel0[(sel1[i] - sel1.nelts_per_input ())
11583 0 : .to_constant ()];
11584 0 : if (known_lt (j, sel0.nelts_per_input ()))
11585 : use_1 = true;
11586 : else
11587 : {
11588 0 : use_2 = true;
11589 0 : j -= sel0.nelts_per_input ();
11590 : }
11591 0 : builder2.quick_push (j + sel1.nelts_per_input ());
11592 : }
11593 : }
11594 0 : if (use_1 ^ use_2
11595 : )
11596 : {
11597 0 : {
11598 0 : vec_perm_indices sel2 (builder2, 2, nelts);
11599 0 : tree op0 = NULL_TREE;
11600 0 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false)
11601 0 : || (single_use (captures[1])
11602 0 : ? (!can_vec_perm_const_p (result_mode, op_mode, sel0, true)
11603 0 : || !can_vec_perm_const_p (result_mode, op_mode, sel1, true))
11604 : : !can_vec_perm_const_p (result_mode, op_mode, sel1, true)))
11605 0 : op0 = vec_perm_indices_to_tree (TREE_TYPE (captures[5]), sel2);
11606 0 : if (op0
11607 : )
11608 : {
11609 0 : if (use_1
11610 : )
11611 : {
11612 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail2005;
11613 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2005;
11614 0 : {
11615 0 : tree res_op0;
11616 0 : res_op0 = captures[0];
11617 0 : tree res_op1;
11618 0 : res_op1 = captures[2];
11619 0 : tree res_op2;
11620 0 : res_op2 = op0;
11621 0 : tree _r;
11622 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
11623 0 : if (TREE_SIDE_EFFECTS (captures[3]))
11624 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
11625 0 : if (TREE_SIDE_EFFECTS (captures[4]))
11626 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
11627 0 : if (TREE_SIDE_EFFECTS (captures[5]))
11628 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
11629 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1116, __FILE__, __LINE__, true);
11630 0 : return _r;
11631 : }
11632 0 : next_after_fail2005:;
11633 : }
11634 : else
11635 : {
11636 0 : if (use_2
11637 : )
11638 : {
11639 0 : if (TREE_SIDE_EFFECTS (captures[1])) goto next_after_fail2006;
11640 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2006;
11641 0 : {
11642 0 : tree res_op0;
11643 0 : res_op0 = captures[0];
11644 0 : tree res_op1;
11645 0 : res_op1 = captures[3];
11646 0 : tree res_op2;
11647 0 : res_op2 = op0;
11648 0 : tree _r;
11649 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
11650 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11651 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11652 0 : if (TREE_SIDE_EFFECTS (captures[4]))
11653 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
11654 0 : if (TREE_SIDE_EFFECTS (captures[5]))
11655 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
11656 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1117, __FILE__, __LINE__, true);
11657 0 : return _r;
11658 : }
11659 0 : next_after_fail2006:;
11660 : }
11661 : }
11662 : }
11663 0 : }
11664 : }
11665 0 : }
11666 : }
11667 0 : }
11668 : }
11669 : }
11670 0 : break;
11671 : }
11672 : default:;
11673 : }
11674 : break;
11675 : }
11676 : default:;
11677 : }
11678 : break;
11679 : }
11680 780180 : default:;
11681 : }
11682 780180 : switch (TREE_CODE (_p0))
11683 : {
11684 0 : case VEC_PERM_EXPR:
11685 0 : {
11686 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11687 0 : tree _q21 = TREE_OPERAND (_p0, 1);
11688 0 : tree _q22 = TREE_OPERAND (_p0, 2);
11689 0 : switch (TREE_CODE (_q22))
11690 : {
11691 0 : case VECTOR_CST:
11692 0 : {
11693 0 : switch (TREE_CODE (_p2))
11694 : {
11695 0 : case VECTOR_CST:
11696 0 : {
11697 0 : {
11698 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _p2 };
11699 0 : if (TYPE_VECTOR_SUBPARTS (type).is_constant ()
11700 : )
11701 : {
11702 0 : {
11703 0 : machine_mode result_mode = TYPE_MODE (type);
11704 0 : machine_mode op_mode = TYPE_MODE (TREE_TYPE (captures[1]));
11705 0 : int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
11706 0 : vec_perm_indices sel0, sel1;
11707 0 : if (tree_to_vec_perm_indices (&sel0, captures[1], captures[2], captures[3])
11708 0 : && tree_to_vec_perm_indices (&sel1, captures[0], captures[4], captures[5])
11709 : )
11710 : {
11711 0 : {
11712 0 : bool use_1 = false, use_2 = false;
11713 0 : vec_perm_builder builder2 (nelts, nelts, 2);
11714 0 : for (int i = 0; i < nelts; i++)
11715 : {
11716 0 : if (known_ge ((poly_uint64)sel1[i], sel1.nelts_per_input ()))
11717 0 : builder2.quick_push (sel1[i]);
11718 : else
11719 : {
11720 0 : poly_uint64 j = sel0[sel1[i].to_constant ()];
11721 0 : if (known_lt (j, sel0.nelts_per_input ()))
11722 : use_1 = true;
11723 : else
11724 : {
11725 0 : use_2 = true;
11726 0 : j -= sel0.nelts_per_input ();
11727 : }
11728 0 : builder2.quick_push (j);
11729 : }
11730 : }
11731 0 : if (use_1 ^ use_2
11732 : )
11733 : {
11734 0 : {
11735 0 : vec_perm_indices sel2 (builder2, 2, nelts);
11736 0 : tree op0 = NULL_TREE;
11737 0 : if (can_vec_perm_const_p (result_mode, op_mode, sel2, false)
11738 0 : || (single_use (captures[0])
11739 0 : ? (!can_vec_perm_const_p (result_mode, op_mode, sel0, true)
11740 0 : || !can_vec_perm_const_p (result_mode, op_mode, sel1, true))
11741 : : !can_vec_perm_const_p (result_mode, op_mode, sel1, true)))
11742 0 : op0 = vec_perm_indices_to_tree (TREE_TYPE (captures[5]), sel2);
11743 0 : if (op0
11744 : )
11745 : {
11746 0 : if (use_1
11747 : )
11748 : {
11749 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail2007;
11750 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2007;
11751 0 : {
11752 0 : tree res_op0;
11753 0 : res_op0 = captures[1];
11754 0 : tree res_op1;
11755 0 : res_op1 = captures[4];
11756 0 : tree res_op2;
11757 0 : res_op2 = op0;
11758 0 : tree _r;
11759 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
11760 0 : if (TREE_SIDE_EFFECTS (captures[2]))
11761 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
11762 0 : if (TREE_SIDE_EFFECTS (captures[3]))
11763 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
11764 0 : if (TREE_SIDE_EFFECTS (captures[5]))
11765 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
11766 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1118, __FILE__, __LINE__, true);
11767 0 : return _r;
11768 : }
11769 0 : next_after_fail2007:;
11770 : }
11771 : else
11772 : {
11773 0 : if (use_2
11774 : )
11775 : {
11776 0 : if (TREE_SIDE_EFFECTS (captures[0])) goto next_after_fail2008;
11777 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2008;
11778 0 : {
11779 0 : tree res_op0;
11780 0 : res_op0 = captures[2];
11781 0 : tree res_op1;
11782 0 : res_op1 = captures[4];
11783 0 : tree res_op2;
11784 0 : res_op2 = op0;
11785 0 : tree _r;
11786 0 : _r = fold_build3_loc (loc, VEC_PERM_EXPR, type, res_op0, res_op1, res_op2);
11787 0 : if (TREE_SIDE_EFFECTS (captures[1]))
11788 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
11789 0 : if (TREE_SIDE_EFFECTS (captures[3]))
11790 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
11791 0 : if (TREE_SIDE_EFFECTS (captures[5]))
11792 0 : _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
11793 0 : if (UNLIKELY (debug_dump)) generic_dump_logs ("match.pd", 1119, __FILE__, __LINE__, true);
11794 0 : return _r;
11795 : }
11796 0 : next_after_fail2008:;
11797 : }
11798 : }
11799 : }
11800 0 : }
11801 : }
11802 0 : }
11803 : }
11804 0 : }
11805 : }
11806 : }
11807 0 : break;
11808 : }
11809 0 : default:;
11810 : }
11811 0 : switch (TREE_CODE (_p1))
11812 : {
11813 0 : case VEC_PERM_EXPR:
11814 0 : {
11815 0 : tree _q60 = TREE_OPERAND (_p1, 0);
11816 0 : tree _q61 = TREE_OPERAND (_p1, 1);
11817 0 : tree _q62 = TREE_OPERAND (_p1, 2);
11818 0 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
11819 : {
11820 0 : switch (TREE_CODE (_q62))
11821 : {
11822 0 : case VECTOR_CST:
11823 0 : {
11824 0 : switch (TREE_CODE (_p2))
11825 : {
11826 0 : case VECTOR_CST:
11827 0 : {
11828 0 : {
11829 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60, _q61, _p2 };
11830 0 : tree res = generic_simplify_630 (loc, type, _p0, _p1, _p2, captures);
11831 0 : if (res) return res;
11832 : }
11833 0 : break;
11834 : }
11835 : default:;
11836 : }
11837 : break;
11838 : }
11839 : default:;
11840 : }
11841 : }
11842 : break;
11843 : }
11844 : default:;
11845 : }
11846 : break;
11847 : }
11848 : default:;
11849 : }
11850 : break;
11851 : }
11852 0 : case VIEW_CONVERT_EXPR:
11853 0 : {
11854 0 : tree _q20 = TREE_OPERAND (_p0, 0);
11855 0 : switch (TREE_CODE (_q20))
11856 : {
11857 0 : case VEC_PERM_EXPR:
11858 0 : {
11859 0 : tree _q30 = TREE_OPERAND (_q20, 0);
11860 0 : tree _q31 = TREE_OPERAND (_q20, 1);
11861 0 : tree _q32 = TREE_OPERAND (_q20, 2);
11862 0 : switch (TREE_CODE (_q32))
11863 : {
11864 0 : case VECTOR_CST:
11865 0 : {
11866 0 : switch (TREE_CODE (_p1))
11867 : {
11868 0 : case VIEW_CONVERT_EXPR:
11869 0 : {
11870 0 : tree _q70 = TREE_OPERAND (_p1, 0);
11871 0 : switch (TREE_CODE (_q70))
11872 : {
11873 0 : case VEC_PERM_EXPR:
11874 0 : {
11875 0 : tree _q80 = TREE_OPERAND (_q70, 0);
11876 0 : tree _q81 = TREE_OPERAND (_q70, 1);
11877 0 : tree _q82 = TREE_OPERAND (_q70, 2);
11878 0 : if ((_q82 == _q32 && ! TREE_SIDE_EFFECTS (_q82)) || (operand_equal_p (_q82, _q32, 0) && types_match (_q82, _q32)))
11879 : {
11880 0 : switch (TREE_CODE (_q82))
11881 : {
11882 0 : case VECTOR_CST:
11883 0 : {
11884 0 : switch (TREE_CODE (_p2))
11885 : {
11886 0 : case VECTOR_CST:
11887 0 : {
11888 0 : {
11889 0 : tree captures[6] ATTRIBUTE_UNUSED = { _q30, _q31, _q32, _q80, _q81, _p2 };
11890 0 : tree res = generic_simplify_630 (loc, type, _p0, _p1, _p2, captures);
11891 0 : if (res) return res;
11892 : }
11893 0 : break;
11894 : }
11895 : default:;
11896 : }
11897 : break;
11898 : }
11899 : default:;
11900 : }
11901 : }
11902 : break;
11903 : }
11904 : default:;
11905 : }
11906 : break;
11907 : }
11908 : default:;
11909 : }
11910 : break;
11911 : }
11912 : default:;
11913 : }
11914 : break;
11915 : }
11916 : default:;
11917 : }
11918 : break;
11919 : }
11920 : default:;
11921 : }
11922 : return NULL_TREE;
11923 : }
11924 : #pragma GCC diagnostic pop
|
