Branch data 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 "gimple-match-auto.h"
8 : :
9 : : bool
10 : 52541208 : gimple_negate_expr_p (tree t, tree (*valueize)(tree) ATTRIBUTE_UNUSED)
11 : : {
12 : 52541208 : const tree type = TREE_TYPE (t);
13 : 52541208 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 : 52541208 : switch (TREE_CODE (t))
15 : : {
16 : 50154712 : case SSA_NAME:
17 : 50154712 : if (gimple *_d1 = get_def (valueize, t))
18 : : {
19 : 27549738 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
20 : 26215727 : switch (gimple_assign_rhs_code (_a1))
21 : : {
22 : 54856 : case NEGATE_EXPR:
23 : 54856 : {
24 : 54856 : tree _p0 = gimple_assign_rhs1 (_a1);
25 : 54856 : _p0 = do_valueize (valueize, _p0);
26 : 54856 : {
27 : 54856 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
28 : 54856 : if (!TYPE_OVERFLOW_SANITIZED (type)
29 : : )
30 : : {
31 : 54856 : {
32 : 54856 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 9, __FILE__, __LINE__, false);
33 : 54856 : return true;
34 : : }
35 : : }
36 : : }
37 : : break;
38 : : }
39 : 567079 : case MINUS_EXPR:
40 : 567079 : {
41 : 567079 : tree _p0 = gimple_assign_rhs1 (_a1);
42 : 567079 : _p0 = do_valueize (valueize, _p0);
43 : 567079 : tree _p1 = gimple_assign_rhs2 (_a1);
44 : 567079 : _p1 = do_valueize (valueize, _p1);
45 : 567079 : {
46 : 567079 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
47 : 567079 : if ((ANY_INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_WRAPS (type))
48 : 981050 : || (FLOAT_TYPE_P (type)
49 : 123054 : && !HONOR_SIGN_DEPENDENT_ROUNDING (type)
50 : 123029 : && !HONOR_SIGNED_ZEROS (type))
51 : : )
52 : : {
53 : 156986 : {
54 : 156986 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 10, __FILE__, __LINE__, false);
55 : 156986 : return true;
56 : : }
57 : : }
58 : : }
59 : 410093 : break;
60 : : }
61 : : default:;
62 : : }
63 : : }
64 : : break;
65 : 1249173 : case INTEGER_CST:
66 : 1249173 : {
67 : 1249173 : {
68 : 1249173 : if ((INTEGRAL_TYPE_P (type)
69 : 1249173 : && TYPE_UNSIGNED (type))
70 : 1728576 : || (!TYPE_OVERFLOW_SANITIZED (type)
71 : 478251 : && may_negate_without_overflow_p (t))
72 : : )
73 : : {
74 : 1246303 : {
75 : 1246303 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 11, __FILE__, __LINE__, false);
76 : 1246303 : return true;
77 : : }
78 : : }
79 : : }
80 : : break;
81 : : }
82 : 0 : case FIXED_CST:
83 : 0 : {
84 : 0 : {
85 : 0 : {
86 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 12, __FILE__, __LINE__, false);
87 : : return true;
88 : : }
89 : : }
90 : 477562 : break;
91 : : }
92 : 477562 : case REAL_CST:
93 : 477562 : {
94 : 477562 : {
95 : 477562 : if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (t))
96 : : )
97 : : {
98 : 4008 : {
99 : 4008 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 13, __FILE__, __LINE__, false);
100 : 4008 : return true;
101 : : }
102 : : }
103 : : }
104 : : break;
105 : : }
106 : 17806 : case VECTOR_CST:
107 : 17806 : {
108 : 17806 : {
109 : 17806 : if (FLOAT_TYPE_P (TREE_TYPE (type)) || TYPE_OVERFLOW_WRAPS (type)
110 : : )
111 : : {
112 : 8143 : {
113 : 8143 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 14, __FILE__, __LINE__, false);
114 : 8143 : return true;
115 : : }
116 : : }
117 : : }
118 : : break;
119 : : }
120 : : default:;
121 : : }
122 : : return false;
123 : : }
124 : :
125 : : bool
126 : 1799522 : gimple_ctz_table_index (tree t, tree *res_ops, tree (*valueize)(tree) ATTRIBUTE_UNUSED)
127 : : {
128 : 1799522 : const tree type = TREE_TYPE (t);
129 : 1799522 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
130 : 1799522 : switch (TREE_CODE (t))
131 : : {
132 : 846995 : case SSA_NAME:
133 : 846995 : if (gimple *_d1 = get_def (valueize, t))
134 : : {
135 : 846995 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
136 : 426380 : switch (gimple_assign_rhs_code (_a1))
137 : : {
138 : 11811 : case RSHIFT_EXPR:
139 : 11811 : {
140 : 11811 : tree _p0 = gimple_assign_rhs1 (_a1);
141 : 11811 : _p0 = do_valueize (valueize, _p0);
142 : 11811 : tree _p1 = gimple_assign_rhs2 (_a1);
143 : 11811 : _p1 = do_valueize (valueize, _p1);
144 : 11811 : switch (TREE_CODE (_p0))
145 : : {
146 : 11811 : case SSA_NAME:
147 : 11811 : if (gimple *_d2 = get_def (valueize, _p0))
148 : : {
149 : 11811 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
150 : 7534 : switch (gimple_assign_rhs_code (_a2))
151 : : {
152 : 48 : case MULT_EXPR:
153 : 48 : {
154 : 48 : tree _q20 = gimple_assign_rhs1 (_a2);
155 : 48 : _q20 = do_valueize (valueize, _q20);
156 : 48 : tree _q21 = gimple_assign_rhs2 (_a2);
157 : 48 : _q21 = do_valueize (valueize, _q21);
158 : 48 : if (tree_swap_operands_p (_q20, _q21))
159 : 0 : std::swap (_q20, _q21);
160 : 48 : switch (TREE_CODE (_q20))
161 : : {
162 : 48 : case SSA_NAME:
163 : 48 : if (gimple *_d3 = get_def (valueize, _q20))
164 : : {
165 : 48 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
166 : 20 : switch (gimple_assign_rhs_code (_a3))
167 : : {
168 : 20 : case BIT_AND_EXPR:
169 : 20 : {
170 : 20 : tree _q30 = gimple_assign_rhs1 (_a3);
171 : 20 : _q30 = do_valueize (valueize, _q30);
172 : 20 : tree _q31 = gimple_assign_rhs2 (_a3);
173 : 20 : _q31 = do_valueize (valueize, _q31);
174 : 20 : if (tree_swap_operands_p (_q30, _q31))
175 : 0 : std::swap (_q30, _q31);
176 : 20 : switch (TREE_CODE (_q30))
177 : : {
178 : 20 : case SSA_NAME:
179 : 20 : if (gimple *_d4 = get_def (valueize, _q30))
180 : : {
181 : 20 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
182 : 20 : switch (gimple_assign_rhs_code (_a4))
183 : : {
184 : 20 : case NEGATE_EXPR:
185 : 20 : {
186 : 20 : tree _q40 = gimple_assign_rhs1 (_a4);
187 : 20 : _q40 = do_valueize (valueize, _q40);
188 : 20 : if ((_q31 == _q40 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _q40, 0) && types_match (_q31, _q40)))
189 : : {
190 : 20 : switch (TREE_CODE (_q21))
191 : : {
192 : 20 : case INTEGER_CST:
193 : 20 : {
194 : 20 : switch (TREE_CODE (_p1))
195 : : {
196 : 20 : case INTEGER_CST:
197 : 20 : {
198 : 20 : {
199 : 20 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q21, _p1 };
200 : 20 : {
201 : 20 : res_ops[0] = captures[0];
202 : 20 : res_ops[1] = captures[1];
203 : 20 : res_ops[2] = captures[2];
204 : 20 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 50, __FILE__, __LINE__, false);
205 : 20 : return true;
206 : : }
207 : : }
208 : : break;
209 : : }
210 : : default:;
211 : : }
212 : : break;
213 : : }
214 : : default:;
215 : : }
216 : : }
217 : : break;
218 : : }
219 : : default:;
220 : : }
221 : : }
222 : : break;
223 : 0 : default:;
224 : : }
225 : 0 : switch (TREE_CODE (_q31))
226 : : {
227 : 0 : case SSA_NAME:
228 : 0 : if (gimple *_d4 = get_def (valueize, _q31))
229 : : {
230 : 0 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
231 : 0 : switch (gimple_assign_rhs_code (_a4))
232 : : {
233 : 0 : case NEGATE_EXPR:
234 : 0 : {
235 : 0 : tree _q50 = gimple_assign_rhs1 (_a4);
236 : 0 : _q50 = do_valueize (valueize, _q50);
237 : 0 : if ((_q50 == _q30 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q30, 0) && types_match (_q50, _q30)))
238 : : {
239 : 0 : switch (TREE_CODE (_q21))
240 : : {
241 : 0 : case INTEGER_CST:
242 : 0 : {
243 : 0 : switch (TREE_CODE (_p1))
244 : : {
245 : 0 : case INTEGER_CST:
246 : 0 : {
247 : 0 : {
248 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q21, _p1 };
249 : 0 : {
250 : 0 : res_ops[0] = captures[0];
251 : 0 : res_ops[1] = captures[1];
252 : 0 : res_ops[2] = captures[2];
253 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 50, __FILE__, __LINE__, false);
254 : 0 : return true;
255 : : }
256 : : }
257 : : break;
258 : : }
259 : : default:;
260 : : }
261 : : break;
262 : : }
263 : : default:;
264 : : }
265 : : }
266 : : break;
267 : : }
268 : : default:;
269 : : }
270 : : }
271 : : break;
272 : : default:;
273 : : }
274 : 1799522 : break;
275 : : }
276 : : default:;
277 : : }
278 : : }
279 : : break;
280 : : default:;
281 : : }
282 : 1799522 : break;
283 : : }
284 : : default:;
285 : : }
286 : : }
287 : : break;
288 : : default:;
289 : : }
290 : : break;
291 : : }
292 : : default:;
293 : : }
294 : : }
295 : : break;
296 : : default:;
297 : : }
298 : : return false;
299 : : }
300 : :
301 : : bool
302 : 2725 : gimple_simplify_25 (gimple_match_op *res_op, gimple_seq *seq,
303 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
304 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
305 : : const enum tree_code ARG_UNUSED (op),
306 : : const enum tree_code ARG_UNUSED (rop))
307 : : {
308 : 2725 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
309 : 2725 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[1]))
310 : 2725 : && tree_nop_conversion_p (type, TREE_TYPE (captures[2]))
311 : : )
312 : : {
313 : 2715 : gimple_seq *lseq = seq;
314 : 2715 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail184;
315 : 2715 : {
316 : 2715 : res_op->set_op (rop, type, 2);
317 : 2715 : {
318 : 2715 : tree _o1[1], _r1;
319 : 2715 : _o1[0] = captures[0];
320 : 2715 : if (type != TREE_TYPE (_o1[0])
321 : 2715 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
322 : : {
323 : 1 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
324 : 1 : tem_op.resimplify (lseq, valueize);
325 : 1 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
326 : 1 : if (!_r1) goto next_after_fail184;
327 : : }
328 : : else
329 : : _r1 = _o1[0];
330 : 2715 : res_op->ops[0] = _r1;
331 : : }
332 : 2715 : {
333 : 2715 : tree _o1[2], _r1;
334 : 2715 : {
335 : 2715 : tree _o2[1], _r2;
336 : 2715 : _o2[0] = captures[1];
337 : 2715 : if (type != TREE_TYPE (_o2[0])
338 : 2715 : && !useless_type_conversion_p (type, TREE_TYPE (_o2[0])))
339 : : {
340 : 1 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o2[0]);
341 : 1 : tem_op.resimplify (lseq, valueize);
342 : 1 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
343 : 1 : if (!_r2) goto next_after_fail184;
344 : : }
345 : : else
346 : : _r2 = _o2[0];
347 : 2715 : _o1[0] = _r2;
348 : : }
349 : 2715 : {
350 : 2715 : tree _o2[1], _r2;
351 : 2715 : _o2[0] = captures[2];
352 : 2715 : if (type != TREE_TYPE (_o2[0])
353 : 2715 : && !useless_type_conversion_p (type, TREE_TYPE (_o2[0])))
354 : : {
355 : 1 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o2[0]);
356 : 1 : tem_op.resimplify (lseq, valueize);
357 : 1 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
358 : 1 : if (!_r2) goto next_after_fail184;
359 : : }
360 : : else
361 : : _r2 = _o2[0];
362 : 2715 : _o1[1] = _r2;
363 : : }
364 : 2715 : gimple_match_op tem_op (res_op->cond.any_else (), op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
365 : 2715 : tem_op.resimplify (lseq, valueize);
366 : 2715 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
367 : 2715 : if (!_r1) goto next_after_fail184;
368 : 2043 : res_op->ops[1] = _r1;
369 : : }
370 : 2043 : res_op->resimplify (lseq, valueize);
371 : 2043 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 78, __FILE__, __LINE__, true);
372 : 2043 : return true;
373 : : }
374 : : next_after_fail184:;
375 : : }
376 : : return false;
377 : : }
378 : :
379 : : bool
380 : 335 : gimple_simplify_35 (gimple_match_op *res_op, gimple_seq *seq,
381 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
382 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
383 : : const enum tree_code ARG_UNUSED (op))
384 : : {
385 : 335 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
386 : 335 : if (INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_WRAPS (type)
387 : 766 : && (tree_nonzero_bits (captures[0]) & tree_nonzero_bits (captures[1])) == 0
388 : : )
389 : : {
390 : 0 : gimple_seq *lseq = seq;
391 : 0 : if (lseq
392 : 0 : && (!single_use (captures[0])))
393 : 0 : lseq = NULL;
394 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail197;
395 : 0 : {
396 : 0 : res_op->set_op (MULT_EXPR, type, 2);
397 : 0 : res_op->ops[0] = captures[1];
398 : 0 : res_op->ops[1] = wide_int_to_tree (type,
399 : 0 : wi::add (wi::to_wide (captures[2]), 1));
400 : 0 : res_op->resimplify (lseq, valueize);
401 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 89, __FILE__, __LINE__, true);
402 : 0 : return true;
403 : : }
404 : 0 : next_after_fail197:;
405 : : }
406 : : return false;
407 : : }
408 : :
409 : : bool
410 : 76 : gimple_simplify_40 (gimple_match_op *res_op, gimple_seq *seq,
411 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
412 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
413 : : const enum tree_code ARG_UNUSED (cmp))
414 : : {
415 : 76 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
416 : 152 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
417 : 76 : && !TYPE_UNSIGNED (TREE_TYPE (captures[1]))
418 : 152 : && types_match (TREE_TYPE (captures[1]), TREE_TYPE (captures[3]))
419 : : )
420 : : {
421 : 76 : gimple_seq *lseq = seq;
422 : 76 : if (lseq
423 : 32 : && (!single_use (captures[0])
424 : 2 : || !single_use (captures[2])))
425 : 75 : lseq = NULL;
426 : 76 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail203;
427 : 76 : {
428 : 76 : res_op->set_op (LT_EXPR, type, 2);
429 : 76 : {
430 : 76 : tree _o1[2], _r1;
431 : 76 : _o1[0] = captures[1];
432 : 76 : _o1[1] = captures[3];
433 : 76 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_XOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
434 : 76 : tem_op.resimplify (lseq, valueize);
435 : 76 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
436 : 76 : if (!_r1) goto next_after_fail203;
437 : 6 : res_op->ops[0] = _r1;
438 : : }
439 : 6 : res_op->ops[1] = build_zero_cst (TREE_TYPE (captures[1]));
440 : 6 : res_op->resimplify (lseq, valueize);
441 : 6 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 95, __FILE__, __LINE__, true);
442 : 6 : return true;
443 : : }
444 : : next_after_fail203:;
445 : : }
446 : : return false;
447 : : }
448 : :
449 : : bool
450 : 2779 : gimple_simplify_47 (gimple_match_op *res_op, gimple_seq *seq,
451 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
452 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
453 : : const enum tree_code ARG_UNUSED (op))
454 : : {
455 : 2779 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
456 : 2779 : if (INTEGRAL_TYPE_P (type)
457 : 2779 : && TYPE_OVERFLOW_WRAPS (type)
458 : 5364 : && !TYPE_SATURATING (type)
459 : : )
460 : : {
461 : 2585 : gimple_seq *lseq = seq;
462 : 2585 : if (lseq
463 : 640 : && (!single_use (captures[0])
464 : 22 : || !single_use (captures[3])))
465 : 2577 : lseq = NULL;
466 : 2585 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail213;
467 : 2585 : {
468 : 2585 : res_op->set_op (LSHIFT_EXPR, type, 2);
469 : 2585 : {
470 : 2585 : tree _o1[2], _r1;
471 : 2585 : _o1[0] = captures[1];
472 : 2585 : _o1[1] = captures[4];
473 : 2585 : gimple_match_op tem_op (res_op->cond.any_else (), op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
474 : 2585 : tem_op.resimplify (lseq, valueize);
475 : 2585 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
476 : 2585 : if (!_r1) goto next_after_fail213;
477 : 63 : res_op->ops[0] = _r1;
478 : : }
479 : 63 : res_op->ops[1] = captures[2];
480 : 63 : res_op->resimplify (lseq, valueize);
481 : 63 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 105, __FILE__, __LINE__, true);
482 : 63 : return true;
483 : : }
484 : : next_after_fail213:;
485 : : }
486 : : return false;
487 : : }
488 : :
489 : : bool
490 : 92564 : gimple_simplify_53 (gimple_match_op *res_op, gimple_seq *seq,
491 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
492 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
493 : : {
494 : 92564 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
495 : 92564 : if (!TYPE_SATURATING (type)
496 : : )
497 : : {
498 : 92564 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
499 : 184377 : && !FIXED_POINT_TYPE_P (type)
500 : : )
501 : : {
502 : 91813 : gimple_seq *lseq = seq;
503 : 91813 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail220;
504 : 91813 : {
505 : 91813 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
506 : 91813 : res_op->ops[0] = captures[0];
507 : 91813 : res_op->resimplify (lseq, valueize);
508 : 91813 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 112, __FILE__, __LINE__, true);
509 : 91813 : return true;
510 : : }
511 : 0 : next_after_fail220:;
512 : : }
513 : : }
514 : : return false;
515 : : }
516 : :
517 : : bool
518 : 68 : gimple_simplify_58 (gimple_match_op *res_op, gimple_seq *seq,
519 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
520 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
521 : : {
522 : 68 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
523 : 68 : if (!TYPE_SATURATING (type)
524 : : )
525 : : {
526 : 68 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
527 : 126 : && !FIXED_POINT_TYPE_P (type)
528 : : )
529 : : {
530 : 58 : gimple_seq *lseq = seq;
531 : 58 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail233;
532 : 58 : {
533 : 58 : res_op->set_op (MINUS_EXPR, type, 2);
534 : 58 : res_op->ops[0] = captures[2];
535 : 58 : res_op->ops[1] = captures[1];
536 : 58 : res_op->resimplify (lseq, valueize);
537 : 58 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 125, __FILE__, __LINE__, true);
538 : 58 : return true;
539 : : }
540 : 0 : next_after_fail233:;
541 : : }
542 : : }
543 : : return false;
544 : : }
545 : :
546 : : bool
547 : 319 : gimple_simplify_63 (gimple_match_op *res_op, gimple_seq *seq,
548 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
549 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
550 : : {
551 : 319 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
552 : 319 : if (!TYPE_SATURATING (type)
553 : : )
554 : : {
555 : 319 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
556 : 638 : && !FIXED_POINT_TYPE_P (type)
557 : : )
558 : : {
559 : 319 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
560 : : )
561 : : {
562 : 182 : gimple_seq *lseq = seq;
563 : 182 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail238;
564 : 182 : {
565 : 182 : res_op->set_op (NEGATE_EXPR, type, 1);
566 : 182 : {
567 : 182 : tree _o1[1], _r1;
568 : 182 : _o1[0] = captures[0];
569 : 182 : if (type != TREE_TYPE (_o1[0])
570 : 182 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
571 : : {
572 : 105 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
573 : 105 : tem_op.resimplify (lseq, valueize);
574 : 105 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
575 : 105 : if (!_r1) goto next_after_fail238;
576 : : }
577 : : else
578 : : _r1 = _o1[0];
579 : 127 : res_op->ops[0] = _r1;
580 : : }
581 : 127 : res_op->resimplify (lseq, valueize);
582 : 127 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 130, __FILE__, __LINE__, true);
583 : 127 : return true;
584 : : }
585 : : next_after_fail238:;
586 : : }
587 : : }
588 : : }
589 : : return false;
590 : : }
591 : :
592 : : bool
593 : 56 : gimple_simplify_68 (gimple_match_op *res_op, gimple_seq *seq,
594 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
595 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
596 : : const enum tree_code ARG_UNUSED (div),
597 : : const enum tree_code ARG_UNUSED (mod))
598 : : {
599 : 56 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
600 : 56 : gimple_seq *lseq = seq;
601 : 56 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail244;
602 : 56 : {
603 : 56 : tree tem;
604 : 56 : tem = captures[0];
605 : 56 : res_op->set_value (tem);
606 : 56 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 136, __FILE__, __LINE__, true);
607 : : return true;
608 : : }
609 : 0 : next_after_fail244:;
610 : 0 : return false;
611 : : }
612 : :
613 : : bool
614 : 1245 : gimple_simplify_70 (gimple_match_op *res_op, gimple_seq *seq,
615 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
616 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
617 : : const enum tree_code ARG_UNUSED (op))
618 : : {
619 : 1245 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
620 : 1245 : if (flag_unsafe_math_optimizations
621 : : )
622 : : {
623 : 6 : gimple_seq *lseq = seq;
624 : 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail246;
625 : 6 : {
626 : 6 : res_op->set_op (RDIV_EXPR, type, 2);
627 : 6 : {
628 : 6 : tree _o1[2], _r1;
629 : 6 : _o1[0] = captures[0];
630 : 6 : _o1[1] = captures[2];
631 : 6 : gimple_match_op tem_op (res_op->cond.any_else (), op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
632 : 6 : tem_op.resimplify (lseq, valueize);
633 : 6 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
634 : 6 : if (!_r1) goto next_after_fail246;
635 : 4 : res_op->ops[0] = _r1;
636 : : }
637 : 4 : res_op->ops[1] = captures[1];
638 : 4 : res_op->resimplify (lseq, valueize);
639 : 4 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 138, __FILE__, __LINE__, true);
640 : 4 : return true;
641 : : }
642 : : next_after_fail246:;
643 : : }
644 : : return false;
645 : : }
646 : :
647 : : bool
648 : 303 : gimple_simplify_75 (gimple_match_op *res_op, gimple_seq *seq,
649 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
650 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
651 : : const enum tree_code ARG_UNUSED (op))
652 : : {
653 : 303 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
654 : 303 : if (VECTOR_FLOAT_TYPE_P (type)
655 : 504 : && TYPE_VECTOR_SUBPARTS (type).is_constant ()
656 : : )
657 : : {
658 : 201 : {
659 : 201 : tree perm_cst = captures[1];
660 : 201 : vec_perm_builder builder;
661 : 201 : bool full_perm_p = false;
662 : 201 : if (tree_to_vec_perm_builder (&builder, perm_cst))
663 : : {
664 : 201 : unsigned HOST_WIDE_INT nelts;
665 : 201 : nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
666 : 201 : vec_perm_indices sel (builder, 1, nelts);
667 : 201 : if (sel.encoding ().encoded_full_vector_p ())
668 : : {
669 : 53 : auto_sbitmap seen (nelts);
670 : 53 : bitmap_clear (seen);
671 : 53 : unsigned HOST_WIDE_INT count = 0, i;
672 : 200 : for (i = 0; i < nelts; i++)
673 : : {
674 : 118 : if (!bitmap_set_bit (seen, sel[i].to_constant ()))
675 : : break;
676 : 94 : count++;
677 : : }
678 : 53 : full_perm_p = count == nelts;
679 : 53 : }
680 : 201 : }
681 : 201 : if (full_perm_p
682 : : )
683 : : {
684 : 29 : gimple_seq *lseq = seq;
685 : 29 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail251;
686 : 29 : {
687 : 29 : res_op->set_op (VEC_PERM_EXPR, type, 3);
688 : 29 : {
689 : 29 : tree _o1[2], _r1;
690 : 29 : _o1[0] = captures[0];
691 : 29 : _o1[1] = captures[2];
692 : 29 : gimple_match_op tem_op (res_op->cond.any_else (), op, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
693 : 29 : tem_op.resimplify (lseq, valueize);
694 : 29 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
695 : 29 : if (!_r1) goto next_after_fail251;
696 : 11 : captures[3] = _r1;
697 : : }
698 : 11 : res_op->ops[0] = captures[3];
699 : 11 : res_op->ops[1] = captures[3];
700 : 11 : res_op->ops[2] = captures[1];
701 : 11 : res_op->resimplify (lseq, valueize);
702 : 11 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 143, __FILE__, __LINE__, true);
703 : 11 : return true;
704 : : }
705 : 190 : next_after_fail251:;
706 : : }
707 : 201 : }
708 : : }
709 : : return false;
710 : : }
711 : :
712 : : bool
713 : 1592 : gimple_simplify_83 (gimple_match_op *res_op, gimple_seq *seq,
714 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
715 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
716 : : {
717 : 1592 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
718 : 1592 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
719 : 1592 : && tree_nop_conversion_p (type, TREE_TYPE (captures[3]))
720 : : )
721 : : {
722 : 1233 : gimple_seq *lseq = seq;
723 : 1233 : if (lseq
724 : 1233 : && (!single_use (captures[1])
725 : 6 : || !single_use (captures[2])))
726 : 1227 : lseq = NULL;
727 : 1233 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail259;
728 : 1233 : {
729 : 1233 : res_op->set_op (NOP_EXPR, type, 1);
730 : 1233 : {
731 : 1233 : tree _o1[2], _r1;
732 : 1233 : {
733 : 1233 : tree _o2[1], _r2;
734 : 1233 : _o2[0] = captures[3];
735 : 1233 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_NOT_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
736 : 1233 : tem_op.resimplify (lseq, valueize);
737 : 1233 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
738 : 1233 : if (!_r2) goto next_after_fail259;
739 : 1233 : _o1[0] = _r2;
740 : : }
741 : 1233 : _o1[1] = captures[0];
742 : 1233 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
743 : 1233 : tem_op.resimplify (lseq, valueize);
744 : 1233 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
745 : 1233 : if (!_r1) goto next_after_fail259;
746 : 6 : res_op->ops[0] = _r1;
747 : : }
748 : 6 : res_op->resimplify (lseq, valueize);
749 : 6 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 151, __FILE__, __LINE__, true);
750 : 6 : return true;
751 : : }
752 : : next_after_fail259:;
753 : : }
754 : : return false;
755 : : }
756 : :
757 : : bool
758 : 1655 : gimple_simplify_91 (gimple_match_op *res_op, gimple_seq *seq,
759 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
760 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
761 : : {
762 : 1655 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
763 : 1655 : if (!TYPE_SATURATING (type)
764 : : )
765 : : {
766 : 1655 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
767 : 2826 : && !FIXED_POINT_TYPE_P (type)
768 : : )
769 : : {
770 : 1171 : if (!ANY_INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_WRAPS (type)
771 : : )
772 : : {
773 : 288 : if (!CONSTANT_CLASS_P (captures[2])
774 : : )
775 : : {
776 : 288 : gimple_seq *lseq = seq;
777 : 288 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail269;
778 : 288 : {
779 : 288 : res_op->set_op (PLUS_EXPR, type, 2);
780 : 288 : {
781 : 288 : tree _o1[1], _r1;
782 : 288 : _o1[0] = captures[2];
783 : 288 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, type, _o1[0]);
784 : 288 : tem_op.resimplify (lseq, valueize);
785 : 288 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
786 : 288 : if (!_r1) goto next_after_fail269;
787 : 237 : res_op->ops[0] = _r1;
788 : : }
789 : 237 : {
790 : 237 : tree _o1[2], _r1;
791 : 237 : _o1[0] = captures[0];
792 : 237 : {
793 : 237 : tree _o2[1], _r2;
794 : 237 : _o2[0] = captures[1];
795 : 237 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, type, _o2[0]);
796 : 237 : tem_op.resimplify (lseq, valueize);
797 : 237 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
798 : 237 : if (!_r2) goto next_after_fail269;
799 : 237 : _o1[1] = _r2;
800 : : }
801 : 237 : gimple_match_op tem_op (res_op->cond.any_else (), MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
802 : 237 : tem_op.resimplify (NULL, valueize);
803 : 237 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
804 : 237 : if (!_r1) goto next_after_fail269;
805 : 237 : res_op->ops[1] = _r1;
806 : : }
807 : 237 : res_op->resimplify (lseq, valueize);
808 : 237 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 160, __FILE__, __LINE__, true);
809 : 237 : return true;
810 : : }
811 : : next_after_fail269:;
812 : : }
813 : : }
814 : : else
815 : : {
816 : 1766 : if (!ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
817 : 1766 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))
818 : : )
819 : : {
820 : 138 : gimple_seq *lseq = seq;
821 : 138 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail270;
822 : 138 : {
823 : 138 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
824 : 138 : {
825 : 138 : tree _o1[2], _r1;
826 : 138 : _o1[0] = captures[2];
827 : 138 : {
828 : 138 : tree _o2[2], _r2;
829 : 138 : {
830 : 138 : tree _o3[1], _r3;
831 : 138 : _o3[0] = captures[0];
832 : 138 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, TREE_TYPE (_o1[0]), _o3[0]);
833 : 138 : tem_op.resimplify (lseq, valueize);
834 : 138 : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
835 : 138 : if (!_r3) goto next_after_fail270;
836 : 138 : _o2[0] = _r3;
837 : : }
838 : 138 : _o2[1] = captures[1];
839 : 138 : gimple_match_op tem_op (res_op->cond.any_else (), MINUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
840 : 138 : tem_op.resimplify (NULL, valueize);
841 : 138 : _r2 = maybe_push_res_to_seq (&tem_op, NULL);
842 : 138 : if (!_r2) goto next_after_fail270;
843 : 138 : _o1[1] = _r2;
844 : : }
845 : 138 : gimple_match_op tem_op (res_op->cond.any_else (), PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
846 : 138 : tem_op.resimplify (lseq, valueize);
847 : 138 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
848 : 138 : if (!_r1) goto next_after_fail270;
849 : 72 : res_op->ops[0] = _r1;
850 : : }
851 : 72 : res_op->resimplify (lseq, valueize);
852 : 72 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 161, __FILE__, __LINE__, true);
853 : 72 : return true;
854 : : }
855 : : next_after_fail270:;
856 : : }
857 : : else
858 : : {
859 : 745 : if (types_match (type, captures[2]) && !TYPE_OVERFLOW_SANITIZED (type)
860 : : )
861 : : {
862 : 745 : {
863 : 745 : tree cst = const_binop (MINUS_EXPR, type, captures[0], captures[1]);
864 : 745 : if (cst && !TREE_OVERFLOW (cst)
865 : : )
866 : : {
867 : 745 : gimple_seq *lseq = seq;
868 : 745 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail271;
869 : 745 : {
870 : 745 : res_op->set_op (PLUS_EXPR, type, 2);
871 : 745 : res_op->ops[0] = cst;
872 : 745 : res_op->ops[1] = captures[2];
873 : 745 : res_op->resimplify (lseq, valueize);
874 : 745 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 162, __FILE__, __LINE__, true);
875 : 745 : return true;
876 : : }
877 : 0 : next_after_fail271:;
878 : : }
879 : : }
880 : : }
881 : : }
882 : : }
883 : : }
884 : : }
885 : : return false;
886 : : }
887 : :
888 : : bool
889 : 300 : gimple_simplify_110 (gimple_match_op *res_op, gimple_seq *seq,
890 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
891 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
892 : : const enum tree_code ARG_UNUSED (op))
893 : : {
894 : 300 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
895 : 300 : gimple_seq *lseq = seq;
896 : 300 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail292;
897 : 300 : {
898 : 300 : tree tem;
899 : 300 : tem = captures[0];
900 : 300 : res_op->set_value (tem);
901 : 300 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 180, __FILE__, __LINE__, true);
902 : : return true;
903 : : }
904 : 0 : next_after_fail292:;
905 : 0 : return false;
906 : : }
907 : :
908 : : bool
909 : 1 : gimple_simplify_117 (gimple_match_op *res_op, gimple_seq *seq,
910 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
911 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
912 : : {
913 : 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
914 : 2 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
915 : 2 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
916 : : )
917 : : {
918 : 1 : gimple_seq *lseq = seq;
919 : 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail299;
920 : 1 : {
921 : 1 : tree tem;
922 : 1 : tem = captures[2];
923 : 1 : res_op->set_value (tem);
924 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 183, __FILE__, __LINE__, true);
925 : 1 : return true;
926 : : }
927 : 0 : next_after_fail299:;
928 : : }
929 : : return false;
930 : : }
931 : :
932 : : bool
933 : 369 : gimple_simplify_124 (gimple_match_op *res_op, gimple_seq *seq,
934 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
935 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
936 : : const enum tree_code ARG_UNUSED (op))
937 : : {
938 : 369 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
939 : 369 : gimple_seq *lseq = seq;
940 : 369 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail306;
941 : 369 : {
942 : 369 : tree tem;
943 : 369 : tem = captures[0];
944 : 369 : res_op->set_value (tem);
945 : 369 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 181, __FILE__, __LINE__, true);
946 : : return true;
947 : : }
948 : 0 : next_after_fail306:;
949 : 0 : return false;
950 : : }
951 : :
952 : : bool
953 : 0 : gimple_simplify_129 (gimple_match_op *res_op, gimple_seq *seq,
954 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
955 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
956 : : const enum tree_code ARG_UNUSED (op))
957 : : {
958 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
959 : 0 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[3]))
960 : 0 : && tree_nop_conversion_p (type, TREE_TYPE (captures[6]))
961 : : )
962 : : {
963 : 0 : if (single_use (captures[4]) && single_use (captures[5])
964 : : )
965 : : {
966 : 0 : gimple_seq *lseq = seq;
967 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail314;
968 : 0 : {
969 : 0 : res_op->set_op (op, type, 2);
970 : 0 : res_op->ops[0] = captures[0];
971 : 0 : {
972 : 0 : tree _o1[1], _r1;
973 : 0 : _o1[0] = captures[6];
974 : 0 : if (type != TREE_TYPE (_o1[0])
975 : 0 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
976 : : {
977 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
978 : 0 : tem_op.resimplify (lseq, valueize);
979 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
980 : 0 : if (!_r1) goto next_after_fail314;
981 : : }
982 : : else
983 : : _r1 = _o1[0];
984 : 0 : res_op->ops[1] = _r1;
985 : : }
986 : 0 : res_op->resimplify (lseq, valueize);
987 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 192, __FILE__, __LINE__, true);
988 : 0 : return true;
989 : : }
990 : : next_after_fail314:;
991 : : }
992 : : else
993 : : {
994 : 0 : if (single_use (captures[0]) && single_use (captures[1])
995 : : )
996 : : {
997 : 0 : gimple_seq *lseq = seq;
998 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail315;
999 : 0 : {
1000 : 0 : res_op->set_op (op, type, 2);
1001 : 0 : {
1002 : 0 : tree _o1[1], _r1;
1003 : 0 : _o1[0] = captures[3];
1004 : 0 : if (type != TREE_TYPE (_o1[0])
1005 : 0 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
1006 : : {
1007 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
1008 : 0 : tem_op.resimplify (lseq, valueize);
1009 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
1010 : 0 : if (!_r1) goto next_after_fail315;
1011 : : }
1012 : : else
1013 : : _r1 = _o1[0];
1014 : 0 : res_op->ops[0] = _r1;
1015 : : }
1016 : 0 : res_op->ops[1] = captures[4];
1017 : 0 : res_op->resimplify (lseq, valueize);
1018 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 193, __FILE__, __LINE__, true);
1019 : 0 : return true;
1020 : : }
1021 : : next_after_fail315:;
1022 : : }
1023 : : }
1024 : : }
1025 : : return false;
1026 : : }
1027 : :
1028 : : bool
1029 : 36 : gimple_simplify_144 (gimple_match_op *res_op, gimple_seq *seq,
1030 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
1031 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
1032 : : const enum tree_code ARG_UNUSED (cmp),
1033 : : const enum tree_code ARG_UNUSED (icmp))
1034 : : {
1035 : 36 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1036 : 36 : if (INTEGRAL_TYPE_P (type)
1037 : 36 : && invert_tree_comparison (cmp, HONOR_NANS (captures[1])) == icmp
1038 : 36 : && canonicalize_math_after_vectorization_p ()
1039 : : )
1040 : : {
1041 : 1 : gimple_seq *lseq = seq;
1042 : 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail334;
1043 : 1 : {
1044 : 1 : res_op->set_op (COND_EXPR, type, 3);
1045 : 1 : res_op->ops[0] = captures[0];
1046 : 1 : res_op->ops[0] = unshare_expr (res_op->ops[0]);
1047 : 1 : res_op->ops[1] = captures[3];
1048 : 1 : res_op->ops[2] = captures[5];
1049 : 1 : res_op->resimplify (lseq, valueize);
1050 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 207, __FILE__, __LINE__, true);
1051 : 1 : return true;
1052 : : }
1053 : 0 : next_after_fail334:;
1054 : : }
1055 : : return false;
1056 : : }
1057 : :
1058 : : bool
1059 : 14 : gimple_simplify_147 (gimple_match_op *res_op, gimple_seq *seq,
1060 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
1061 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
1062 : : {
1063 : 14 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1064 : 14 : gimple_seq *lseq = seq;
1065 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail337;
1066 : 14 : {
1067 : 14 : tree tem;
1068 : 14 : tem = captures[2];
1069 : 14 : res_op->set_value (tem);
1070 : 14 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 210, __FILE__, __LINE__, true);
1071 : : return true;
1072 : : }
1073 : 0 : next_after_fail337:;
1074 : 0 : return false;
1075 : : }
1076 : :
1077 : : bool
1078 : 0 : gimple_simplify_153 (gimple_match_op *res_op, gimple_seq *seq,
1079 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
1080 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
1081 : : {
1082 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1083 : 0 : gimple_seq *lseq = seq;
1084 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail361;
1085 : 0 : {
1086 : 0 : tree tem;
1087 : 0 : tem = constant_boolean_node (true, type);
1088 : 0 : res_op->set_value (tem);
1089 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 226, __FILE__, __LINE__, true);
1090 : : return true;
1091 : : }
1092 : 0 : next_after_fail361:;
1093 : 0 : return false;
1094 : : }
1095 : :
1096 : : bool
1097 : 350939 : gimple_simplify_157 (gimple_match_op *res_op, gimple_seq *seq,
1098 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
1099 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
1100 : : const enum tree_code ARG_UNUSED (code2),
1101 : : const enum tree_code ARG_UNUSED (code1))
1102 : : {
1103 : 350939 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1104 : 350939 : if ((TREE_CODE (captures[2]) == INTEGER_CST
1105 : 125317 : && TREE_CODE (captures[5]) == INTEGER_CST)
1106 : 403912 : || ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
1107 : 231321 : || POINTER_TYPE_P (TREE_TYPE (captures[2])))
1108 : 117812 : && bitwise_equal_p (captures[2], captures[5]))
1109 : : )
1110 : : {
1111 : 72356 : {
1112 : 72356 : bool one_before = false;
1113 : 72356 : bool one_after = false;
1114 : 72356 : int cmp = 0;
1115 : 72356 : bool allbits = true;
1116 : 72356 : if (TREE_CODE (captures[2]) == INTEGER_CST
1117 : 72344 : && TREE_CODE (captures[5]) == INTEGER_CST)
1118 : : {
1119 : 72344 : allbits = TYPE_PRECISION (TREE_TYPE (captures[2])) <= TYPE_PRECISION (TREE_TYPE (captures[5]));
1120 : 72344 : auto t1 = wi::to_wide (fold_convert (TREE_TYPE (captures[5]), captures[2]));
1121 : 72344 : auto t2 = wi::to_wide (captures[5]);
1122 : 72344 : cmp = wi::cmp (t1, t2, TYPE_SIGN (TREE_TYPE (captures[5])));
1123 : 72344 : if (cmp < 0
1124 : 72344 : && t1 == t2 - 1)
1125 : : one_before = true;
1126 : 72344 : if (cmp > 0
1127 : 72344 : && t1 == t2 + 1)
1128 : : one_after = true;
1129 : : }
1130 : 72356 : bool val;
1131 : 72356 : switch (code2)
1132 : : {
1133 : 67990 : case EQ_EXPR: val = (cmp == 0); break;
1134 : 71 : case NE_EXPR: val = (cmp != 0); break;
1135 : 185 : case LT_EXPR: val = (cmp < 0); break;
1136 : 3042 : case GT_EXPR: val = (cmp > 0); break;
1137 : 930 : case LE_EXPR: val = (cmp <= 0); break;
1138 : 138 : case GE_EXPR: val = (cmp >= 0); break;
1139 : 0 : default: gcc_unreachable ();
1140 : : }
1141 : 72356 : if (code1 == EQ_EXPR && val
1142 : : )
1143 : : {
1144 : 1521 : gimple_seq *lseq = seq;
1145 : 1521 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail372;
1146 : 1521 : {
1147 : 1521 : tree tem;
1148 : 1521 : tem = captures[3];
1149 : 1521 : res_op->set_value (tem);
1150 : 1521 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 212, __FILE__, __LINE__, true);
1151 : 1521 : return true;
1152 : : }
1153 : 0 : next_after_fail372:;
1154 : : }
1155 : : else
1156 : : {
1157 : 70835 : if (code1 == NE_EXPR && val && allbits
1158 : : )
1159 : : {
1160 : 23 : gimple_seq *lseq = seq;
1161 : 23 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail373;
1162 : 23 : {
1163 : 23 : tree tem;
1164 : 23 : tem = constant_boolean_node (true, type);
1165 : 23 : res_op->set_value (tem);
1166 : 23 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 213, __FILE__, __LINE__, true);
1167 : 23 : return true;
1168 : : }
1169 : 0 : next_after_fail373:;
1170 : 0 : }
1171 : : else
1172 : : {
1173 : 70812 : if (code1 == NE_EXPR && !val && allbits
1174 : : )
1175 : : {
1176 : 21 : gimple_seq *lseq = seq;
1177 : 21 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail374;
1178 : 21 : {
1179 : 21 : tree tem;
1180 : 21 : tem = captures[0];
1181 : 21 : res_op->set_value (tem);
1182 : 21 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 214, __FILE__, __LINE__, true);
1183 : 21 : return true;
1184 : : }
1185 : 0 : next_after_fail374:;
1186 : 0 : }
1187 : : else
1188 : : {
1189 : 70791 : if (code1 == EQ_EXPR
1190 : 70791 : && code2 == GT_EXPR
1191 : 3038 : && cmp == 0
1192 : 3038 : && allbits
1193 : : )
1194 : : {
1195 : 38 : gimple_seq *lseq = seq;
1196 : 38 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail375;
1197 : 38 : {
1198 : 38 : res_op->set_op (GE_EXPR, type, 2);
1199 : 38 : res_op->ops[0] = captures[4];
1200 : 38 : res_op->ops[1] = captures[5];
1201 : 38 : res_op->resimplify (lseq, valueize);
1202 : 38 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 215, __FILE__, __LINE__, true);
1203 : 38 : return true;
1204 : : }
1205 : 0 : next_after_fail375:;
1206 : 0 : }
1207 : : else
1208 : : {
1209 : 70753 : if (code1 == EQ_EXPR
1210 : 70753 : && code2 == LT_EXPR
1211 : 185 : && cmp == 0
1212 : 185 : && allbits
1213 : : )
1214 : : {
1215 : 2 : gimple_seq *lseq = seq;
1216 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail376;
1217 : 2 : {
1218 : 2 : res_op->set_op (LE_EXPR, type, 2);
1219 : 2 : res_op->ops[0] = captures[4];
1220 : 2 : res_op->ops[1] = captures[5];
1221 : 2 : res_op->resimplify (lseq, valueize);
1222 : 2 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 216, __FILE__, __LINE__, true);
1223 : 2 : return true;
1224 : : }
1225 : 0 : next_after_fail376:;
1226 : 0 : }
1227 : : else
1228 : : {
1229 : 70751 : if (code1 == EQ_EXPR
1230 : 70751 : && code2 == GE_EXPR
1231 : : && one_before
1232 : 138 : && allbits
1233 : : )
1234 : : {
1235 : 4 : gimple_seq *lseq = seq;
1236 : 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail377;
1237 : 4 : {
1238 : 4 : res_op->set_op (GE_EXPR, type, 2);
1239 : 4 : res_op->ops[0] = captures[4];
1240 : 4 : {
1241 : 4 : tree _o1[1], _r1;
1242 : 4 : _o1[0] = captures[2];
1243 : 4 : if (TREE_TYPE (res_op->ops[0]) != TREE_TYPE (_o1[0])
1244 : 4 : && !useless_type_conversion_p (TREE_TYPE (res_op->ops[0]), TREE_TYPE (_o1[0])))
1245 : : {
1246 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, TREE_TYPE (res_op->ops[0]), _o1[0]);
1247 : 0 : tem_op.resimplify (lseq, valueize);
1248 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
1249 : 0 : if (!_r1) goto next_after_fail377;
1250 : : }
1251 : : else
1252 : : _r1 = _o1[0];
1253 : 4 : res_op->ops[1] = _r1;
1254 : : }
1255 : 4 : res_op->resimplify (lseq, valueize);
1256 : 4 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 217, __FILE__, __LINE__, true);
1257 : 4 : return true;
1258 : : }
1259 : : next_after_fail377:;
1260 : : }
1261 : : else
1262 : : {
1263 : 70747 : if (code1 == EQ_EXPR
1264 : 70747 : && code2 == LE_EXPR
1265 : : && one_after
1266 : 920 : && allbits
1267 : : )
1268 : : {
1269 : 15 : gimple_seq *lseq = seq;
1270 : 15 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail378;
1271 : 15 : {
1272 : 15 : res_op->set_op (LE_EXPR, type, 2);
1273 : 15 : res_op->ops[0] = captures[4];
1274 : 15 : {
1275 : 15 : tree _o1[1], _r1;
1276 : 15 : _o1[0] = captures[2];
1277 : 15 : if (TREE_TYPE (res_op->ops[0]) != TREE_TYPE (_o1[0])
1278 : 15 : && !useless_type_conversion_p (TREE_TYPE (res_op->ops[0]), TREE_TYPE (_o1[0])))
1279 : : {
1280 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, TREE_TYPE (res_op->ops[0]), _o1[0]);
1281 : 0 : tem_op.resimplify (lseq, valueize);
1282 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
1283 : 0 : if (!_r1) goto next_after_fail378;
1284 : : }
1285 : : else
1286 : : _r1 = _o1[0];
1287 : 15 : res_op->ops[1] = _r1;
1288 : : }
1289 : 15 : res_op->resimplify (lseq, valueize);
1290 : 15 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 218, __FILE__, __LINE__, true);
1291 : 15 : return true;
1292 : : }
1293 : : next_after_fail378:;
1294 : : }
1295 : : }
1296 : : }
1297 : : }
1298 : : }
1299 : : }
1300 : : }
1301 : : }
1302 : : }
1303 : : return false;
1304 : : }
1305 : :
1306 : : bool
1307 : 2 : gimple_simplify_190 (gimple_match_op *res_op, gimple_seq *seq,
1308 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
1309 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
1310 : : {
1311 : 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1312 : 2 : if (INTEGRAL_TYPE_P (type)
1313 : 2 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1314 : 4 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1315 : : )
1316 : : {
1317 : 2 : if (TYPE_UNSIGNED (type)
1318 : : )
1319 : : {
1320 : 2 : gimple_seq *lseq = seq;
1321 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail412;
1322 : 2 : {
1323 : 2 : res_op->set_op (ABSU_EXPR, type, 1);
1324 : 2 : res_op->ops[0] = captures[0];
1325 : 2 : res_op->resimplify (lseq, valueize);
1326 : 2 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 240, __FILE__, __LINE__, true);
1327 : 2 : return true;
1328 : : }
1329 : 0 : next_after_fail412:;
1330 : : }
1331 : : else
1332 : : {
1333 : 0 : gimple_seq *lseq = seq;
1334 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail413;
1335 : 0 : {
1336 : 0 : res_op->set_op (ABS_EXPR, type, 1);
1337 : 0 : res_op->ops[0] = captures[0];
1338 : 0 : res_op->resimplify (lseq, valueize);
1339 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 241, __FILE__, __LINE__, true);
1340 : 0 : return true;
1341 : : }
1342 : 0 : next_after_fail413:;
1343 : : }
1344 : : }
1345 : : return false;
1346 : : }
1347 : :
1348 : : bool
1349 : 0 : gimple_simplify_199 (gimple_match_op *res_op, gimple_seq *seq,
1350 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
1351 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
1352 : : const combined_fn ARG_UNUSED (POW))
1353 : : {
1354 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1355 : 0 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
1356 : : )
1357 : : {
1358 : 0 : if (!TREE_OVERFLOW (captures[2])
1359 : : )
1360 : : {
1361 : 0 : gimple_seq *lseq = seq;
1362 : 0 : if (lseq
1363 : 0 : && (!single_use (captures[1])))
1364 : 0 : lseq = NULL;
1365 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail424;
1366 : 0 : {
1367 : 0 : res_op->set_op (POW, type, 2);
1368 : 0 : res_op->ops[0] = captures[0];
1369 : 0 : {
1370 : 0 : tree _o1[2], _r1;
1371 : 0 : _o1[0] = captures[2];
1372 : 0 : _o1[1] = build_one_cst (type);
1373 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1374 : 0 : tem_op.resimplify (lseq, valueize);
1375 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
1376 : 0 : if (!_r1) goto next_after_fail424;
1377 : 0 : res_op->ops[1] = _r1;
1378 : : }
1379 : 0 : res_op->resimplify (lseq, valueize);
1380 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 249, __FILE__, __LINE__, true);
1381 : 0 : return true;
1382 : : }
1383 : : next_after_fail424:;
1384 : : }
1385 : : }
1386 : : return false;
1387 : : }
1388 : :
1389 : : bool
1390 : 3997 : gimple_simplify_209 (gimple_match_op *res_op, gimple_seq *seq,
1391 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
1392 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
1393 : : const enum tree_code ARG_UNUSED (cmp))
1394 : : {
1395 : 3997 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1396 : 3997 : if (element_precision (captures[0]) >= element_precision (captures[1])
1397 : 3997 : && types_match (captures[1], captures[3])
1398 : : )
1399 : : {
1400 : 3997 : if (wi::lt_p (wi::to_wide (captures[2]), 0, TYPE_SIGN (TREE_TYPE (captures[2])))
1401 : : )
1402 : : {
1403 : 2 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1404 : : )
1405 : : {
1406 : 2 : gimple_seq *lseq = seq;
1407 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail434;
1408 : 2 : {
1409 : 2 : res_op->set_op (cmp, type, 2);
1410 : 2 : res_op->ops[0] = captures[3];
1411 : 2 : res_op->ops[1] = captures[1];
1412 : 2 : res_op->resimplify (lseq, valueize);
1413 : 2 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 259, __FILE__, __LINE__, true);
1414 : 2 : return true;
1415 : : }
1416 : 0 : next_after_fail434:;
1417 : : }
1418 : : else
1419 : : {
1420 : 0 : if (tree_expr_nonzero_p (captures[1]) && tree_expr_nonzero_p (captures[3])
1421 : : )
1422 : : {
1423 : 0 : {
1424 : 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[1]));
1425 : 0 : gimple_seq *lseq = seq;
1426 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail435;
1427 : 0 : {
1428 : 0 : res_op->set_op (cmp, type, 2);
1429 : 0 : {
1430 : 0 : tree _o1[1], _r1;
1431 : 0 : _o1[0] = captures[3];
1432 : 0 : if (utype != TREE_TYPE (_o1[0])
1433 : 0 : && !useless_type_conversion_p (utype, TREE_TYPE (_o1[0])))
1434 : : {
1435 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, utype, _o1[0]);
1436 : 0 : tem_op.resimplify (lseq, valueize);
1437 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
1438 : 0 : if (!_r1) goto next_after_fail435;
1439 : : }
1440 : : else
1441 : : _r1 = _o1[0];
1442 : 0 : res_op->ops[0] = _r1;
1443 : : }
1444 : 0 : {
1445 : 0 : tree _o1[1], _r1;
1446 : 0 : _o1[0] = captures[1];
1447 : 0 : if (utype != TREE_TYPE (_o1[0])
1448 : 0 : && !useless_type_conversion_p (utype, TREE_TYPE (_o1[0])))
1449 : : {
1450 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, utype, _o1[0]);
1451 : 0 : tem_op.resimplify (lseq, valueize);
1452 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
1453 : 0 : if (!_r1) goto next_after_fail435;
1454 : : }
1455 : : else
1456 : : _r1 = _o1[0];
1457 : 0 : res_op->ops[1] = _r1;
1458 : : }
1459 : 0 : res_op->resimplify (lseq, valueize);
1460 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 260, __FILE__, __LINE__, true);
1461 : 0 : return true;
1462 : : }
1463 : : next_after_fail435:;
1464 : : }
1465 : : }
1466 : : }
1467 : : }
1468 : : else
1469 : : {
1470 : 3995 : if (wi::gt_p (wi::to_wide (captures[2]), 1, TYPE_SIGN (TREE_TYPE (captures[2])))
1471 : : )
1472 : : {
1473 : 3995 : if (TYPE_UNSIGNED (TREE_TYPE (captures[1])) || !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1474 : : )
1475 : : {
1476 : 1676 : gimple_seq *lseq = seq;
1477 : 1676 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail436;
1478 : 1676 : {
1479 : 1676 : res_op->set_op (cmp, type, 2);
1480 : 1676 : res_op->ops[0] = captures[1];
1481 : 1676 : res_op->ops[1] = captures[3];
1482 : 1676 : res_op->resimplify (lseq, valueize);
1483 : 1676 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 261, __FILE__, __LINE__, true);
1484 : 1676 : return true;
1485 : : }
1486 : 0 : next_after_fail436:;
1487 : : }
1488 : : else
1489 : : {
1490 : 2319 : {
1491 : 2319 : tree utype = unsigned_type_for (TREE_TYPE (captures[1]));
1492 : 2319 : gimple_seq *lseq = seq;
1493 : 2319 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail437;
1494 : 2319 : {
1495 : 2319 : res_op->set_op (cmp, type, 2);
1496 : 2319 : {
1497 : 2319 : tree _o1[1], _r1;
1498 : 2319 : _o1[0] = captures[1];
1499 : 2319 : if (utype != TREE_TYPE (_o1[0])
1500 : 2319 : && !useless_type_conversion_p (utype, TREE_TYPE (_o1[0])))
1501 : : {
1502 : 2319 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, utype, _o1[0]);
1503 : 2319 : tem_op.resimplify (lseq, valueize);
1504 : 2319 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
1505 : 2319 : if (!_r1) goto next_after_fail437;
1506 : : }
1507 : : else
1508 : : _r1 = _o1[0];
1509 : 676 : res_op->ops[0] = _r1;
1510 : : }
1511 : 676 : {
1512 : 676 : tree _o1[1], _r1;
1513 : 676 : _o1[0] = captures[3];
1514 : 676 : if (utype != TREE_TYPE (_o1[0])
1515 : 676 : && !useless_type_conversion_p (utype, TREE_TYPE (_o1[0])))
1516 : : {
1517 : 676 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, utype, _o1[0]);
1518 : 676 : tem_op.resimplify (lseq, valueize);
1519 : 676 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
1520 : 676 : if (!_r1) goto next_after_fail437;
1521 : : }
1522 : : else
1523 : : _r1 = _o1[0];
1524 : 676 : res_op->ops[1] = _r1;
1525 : : }
1526 : 676 : res_op->resimplify (lseq, valueize);
1527 : 676 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 262, __FILE__, __LINE__, true);
1528 : 676 : return true;
1529 : : }
1530 : : next_after_fail437:;
1531 : : }
1532 : : }
1533 : : }
1534 : : }
1535 : : }
1536 : : return false;
1537 : : }
1538 : :
1539 : : bool
1540 : 89 : gimple_simplify_238 (gimple_match_op *res_op, gimple_seq *seq,
1541 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
1542 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
1543 : : {
1544 : 89 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1545 : 89 : if (TREE_CODE (TREE_TYPE (captures[1])) != COMPLEX_TYPE
1546 : : )
1547 : : {
1548 : 49 : gimple_seq *lseq = seq;
1549 : 49 : if (lseq
1550 : 16 : && (!single_use (captures[0])))
1551 : 42 : lseq = NULL;
1552 : 49 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail491;
1553 : 49 : {
1554 : 49 : res_op->set_op (EQ_EXPR, type, 2);
1555 : 49 : {
1556 : 49 : tree _o1[2], _r1;
1557 : 49 : _o1[0] = captures[1];
1558 : 49 : _o1[1] = captures[2];
1559 : 49 : gimple_match_op tem_op (res_op->cond.any_else (), TRUNC_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
1560 : 49 : tem_op.resimplify (lseq, valueize);
1561 : 49 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
1562 : 49 : if (!_r1) goto next_after_fail491;
1563 : 7 : res_op->ops[0] = _r1;
1564 : : }
1565 : 7 : res_op->ops[1] = build_zero_cst (TREE_TYPE (captures[1]));
1566 : 7 : res_op->resimplify (lseq, valueize);
1567 : 7 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 314, __FILE__, __LINE__, true);
1568 : 7 : return true;
1569 : : }
1570 : : next_after_fail491:;
1571 : : }
1572 : : return false;
1573 : : }
1574 : :
1575 : : bool
1576 : 35823 : gimple_simplify_245 (gimple_match_op *res_op, gimple_seq *seq,
1577 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
1578 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
1579 : : const enum tree_code ARG_UNUSED (cmp),
1580 : : const enum tree_code ARG_UNUSED (scmp))
1581 : : {
1582 : 35823 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1583 : 35823 : if (integer_zerop (captures[2])
1584 : : )
1585 : : {
1586 : 0 : gimple_seq *lseq = seq;
1587 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail499;
1588 : 0 : {
1589 : 0 : res_op->set_op (cmp, type, 2);
1590 : 0 : res_op->ops[0] = captures[2];
1591 : 0 : res_op->ops[1] = captures[3];
1592 : 0 : res_op->resimplify (lseq, valueize);
1593 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 321, __FILE__, __LINE__, true);
1594 : 0 : return true;
1595 : : }
1596 : 0 : next_after_fail499:;
1597 : : }
1598 : : else
1599 : : {
1600 : 71646 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1601 : 71646 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
1602 : 75444 : && single_use (captures[0])
1603 : : )
1604 : : {
1605 : 664 : if (tree_int_cst_sgn (captures[2]) < 0
1606 : : )
1607 : : {
1608 : 0 : gimple_seq *lseq = seq;
1609 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail500;
1610 : 0 : {
1611 : 0 : res_op->set_op (scmp, type, 2);
1612 : 0 : res_op->ops[0] = captures[1];
1613 : 0 : res_op->ops[1] = captures[3];
1614 : 0 : res_op->resimplify (lseq, valueize);
1615 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 322, __FILE__, __LINE__, true);
1616 : 0 : return true;
1617 : : }
1618 : 0 : next_after_fail500:;
1619 : : }
1620 : : else
1621 : : {
1622 : 664 : gimple_seq *lseq = seq;
1623 : 664 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail501;
1624 : 664 : {
1625 : 664 : res_op->set_op (cmp, type, 2);
1626 : 664 : res_op->ops[0] = captures[1];
1627 : 664 : res_op->ops[1] = captures[3];
1628 : 664 : res_op->resimplify (lseq, valueize);
1629 : 664 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 323, __FILE__, __LINE__, true);
1630 : 664 : return true;
1631 : : }
1632 : 0 : next_after_fail501:;
1633 : : }
1634 : : }
1635 : : }
1636 : : return false;
1637 : : }
1638 : :
1639 : : bool
1640 : 2216 : gimple_simplify_254 (gimple_match_op *res_op, gimple_seq *seq,
1641 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
1642 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
1643 : : const enum tree_code ARG_UNUSED (cmp))
1644 : : {
1645 : 2216 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1646 : 2216 : if (flag_associative_math
1647 : : )
1648 : : {
1649 : 9 : {
1650 : 9 : tree tem = const_binop (MINUS_EXPR, TREE_TYPE (captures[1]), captures[0], captures[2]);
1651 : 9 : if (tem && !TREE_OVERFLOW (tem)
1652 : : )
1653 : : {
1654 : 9 : gimple_seq *lseq = seq;
1655 : 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail527;
1656 : 9 : {
1657 : 9 : res_op->set_op (cmp, type, 2);
1658 : 9 : res_op->ops[0] = tem;
1659 : 9 : res_op->ops[1] = captures[1];
1660 : 9 : res_op->resimplify (lseq, valueize);
1661 : 9 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 348, __FILE__, __LINE__, true);
1662 : 9 : return true;
1663 : : }
1664 : 0 : next_after_fail527:;
1665 : : }
1666 : : }
1667 : : }
1668 : : return false;
1669 : : }
1670 : :
1671 : : bool
1672 : 1544 : gimple_simplify_260 (gimple_match_op *res_op, gimple_seq *seq,
1673 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
1674 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
1675 : : const enum tree_code ARG_UNUSED (cmp),
1676 : : const enum tree_code ARG_UNUSED (scmp))
1677 : : {
1678 : 1544 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1679 : 2135 : if (FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1680 : 2135 : || (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1681 : 591 : && (cmp == EQ_EXPR
1682 : 591 : || cmp == NE_EXPR
1683 : 551 : || TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))))
1684 : : )
1685 : : {
1686 : 1439 : gimple_seq *lseq = seq;
1687 : 1439 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail560;
1688 : 1439 : {
1689 : 1439 : res_op->set_op (scmp, type, 2);
1690 : 1439 : res_op->ops[0] = captures[0];
1691 : 1439 : res_op->ops[1] = captures[1];
1692 : 1439 : res_op->resimplify (lseq, valueize);
1693 : 1439 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 381, __FILE__, __LINE__, true);
1694 : 1439 : return true;
1695 : : }
1696 : 0 : next_after_fail560:;
1697 : : }
1698 : : return false;
1699 : : }
1700 : :
1701 : : bool
1702 : 651616 : gimple_simplify_262 (gimple_match_op *res_op, gimple_seq *seq,
1703 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
1704 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
1705 : : const enum tree_code ARG_UNUSED (cmp))
1706 : : {
1707 : 651616 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1708 : 1303226 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
1709 : 638102 : && !(targetm.have_canonicalize_funcptr_for_compare ()
1710 : 0 : && ((POINTER_TYPE_P (TREE_TYPE (captures[1]))
1711 : 0 : && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (captures[1]))))
1712 : 0 : || (POINTER_TYPE_P (TREE_TYPE (captures[3]))
1713 : 0 : && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (captures[3]))))))
1714 : 1289718 : && single_use (captures[0])
1715 : : )
1716 : : {
1717 : 451095 : if (TYPE_PRECISION (TREE_TYPE (captures[1])) == TYPE_PRECISION (TREE_TYPE (captures[0]))
1718 : 366627 : && (TREE_CODE (captures[3]) == INTEGER_CST
1719 : 366627 : || captures[2] != captures[3])
1720 : 366627 : && (TYPE_UNSIGNED (TREE_TYPE (captures[1])) == TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1721 : : || cmp == NE_EXPR
1722 : 318153 : || cmp == EQ_EXPR)
1723 : 67669 : && !POINTER_TYPE_P (TREE_TYPE (captures[1]))
1724 : 458501 : && (TREE_CODE (TREE_TYPE (captures[1])) != BOOLEAN_TYPE
1725 : 5 : || TREE_CODE (TREE_TYPE (captures[3])) == BOOLEAN_TYPE)
1726 : : )
1727 : : {
1728 : 7406 : if (TREE_CODE (captures[2]) == INTEGER_CST
1729 : : )
1730 : : {
1731 : 0 : gimple_seq *lseq = seq;
1732 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail562;
1733 : 0 : {
1734 : 0 : res_op->set_op (cmp, type, 2);
1735 : 0 : res_op->ops[0] = captures[1];
1736 : 0 : res_op->ops[1] = force_fit_type (TREE_TYPE (captures[1]),
1737 : 0 : wide_int::from (wi::to_wide (captures[2]),
1738 : 0 : MAX (TYPE_PRECISION (TREE_TYPE (captures[2])),
1739 : : TYPE_PRECISION (TREE_TYPE (captures[1]))),
1740 : 0 : TYPE_SIGN (TREE_TYPE (captures[2]))),
1741 : 0 : 0, TREE_OVERFLOW (captures[2]));
1742 : 0 : res_op->resimplify (lseq, valueize);
1743 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 383, __FILE__, __LINE__, true);
1744 : 0 : return true;
1745 : : }
1746 : 0 : next_after_fail562:;
1747 : : }
1748 : : else
1749 : : {
1750 : 7406 : gimple_seq *lseq = seq;
1751 : 7406 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail563;
1752 : 7406 : {
1753 : 7406 : res_op->set_op (cmp, type, 2);
1754 : 7406 : res_op->ops[0] = captures[1];
1755 : 7406 : {
1756 : 7406 : tree _o1[1], _r1;
1757 : 7406 : _o1[0] = captures[2];
1758 : 7406 : if (TREE_TYPE (res_op->ops[0]) != TREE_TYPE (_o1[0])
1759 : 7406 : && !useless_type_conversion_p (TREE_TYPE (res_op->ops[0]), TREE_TYPE (_o1[0])))
1760 : : {
1761 : 7406 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, TREE_TYPE (res_op->ops[0]), _o1[0]);
1762 : 7406 : tem_op.resimplify (lseq, valueize);
1763 : 7406 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
1764 : 7406 : if (!_r1) goto next_after_fail563;
1765 : : }
1766 : : else
1767 : : _r1 = _o1[0];
1768 : 7192 : res_op->ops[1] = _r1;
1769 : : }
1770 : 7192 : res_op->resimplify (lseq, valueize);
1771 : 7192 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 384, __FILE__, __LINE__, true);
1772 : 7192 : return true;
1773 : : }
1774 : : next_after_fail563:;
1775 : : }
1776 : : }
1777 : : else
1778 : : {
1779 : 443689 : if (TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (TREE_TYPE (captures[1]))
1780 : : )
1781 : : {
1782 : 65704 : if ((cmp == EQ_EXPR || cmp == NE_EXPR
1783 : 43122 : || TYPE_UNSIGNED (TREE_TYPE (captures[0])) == TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1784 : 38975 : || (!TYPE_UNSIGNED (TREE_TYPE (captures[0]))
1785 : 38475 : && TYPE_UNSIGNED (TREE_TYPE (captures[1]))))
1786 : 108326 : && (types_match (TREE_TYPE (captures[3]), TREE_TYPE (captures[1]))
1787 : 57381 : || ((TYPE_PRECISION (TREE_TYPE (captures[1]))
1788 : 57381 : >= TYPE_PRECISION (TREE_TYPE (captures[3])))
1789 : 39571 : && (TYPE_UNSIGNED (TREE_TYPE (captures[1]))
1790 : 39571 : == TYPE_UNSIGNED (TREE_TYPE (captures[3]))))
1791 : 57085 : || (TREE_CODE (captures[2]) == INTEGER_CST
1792 : 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1793 : 0 : && int_fits_type_p (captures[2], TREE_TYPE (captures[1]))))
1794 : : )
1795 : : {
1796 : 8119 : gimple_seq *lseq = seq;
1797 : 8119 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail564;
1798 : 8119 : {
1799 : 8119 : res_op->set_op (cmp, type, 2);
1800 : 8119 : res_op->ops[0] = captures[1];
1801 : 8119 : {
1802 : 8119 : tree _o1[1], _r1;
1803 : 8119 : _o1[0] = captures[3];
1804 : 8119 : if (TREE_TYPE (res_op->ops[0]) != TREE_TYPE (_o1[0])
1805 : 8119 : && !useless_type_conversion_p (TREE_TYPE (res_op->ops[0]), TREE_TYPE (_o1[0])))
1806 : : {
1807 : 296 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, TREE_TYPE (res_op->ops[0]), _o1[0]);
1808 : 296 : tem_op.resimplify (lseq, valueize);
1809 : 296 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
1810 : 296 : if (!_r1) goto next_after_fail564;
1811 : : }
1812 : : else
1813 : : _r1 = _o1[0];
1814 : 7909 : res_op->ops[1] = _r1;
1815 : : }
1816 : 7909 : res_op->resimplify (lseq, valueize);
1817 : 7909 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 385, __FILE__, __LINE__, true);
1818 : 7909 : return true;
1819 : : }
1820 : : next_after_fail564:;
1821 : : }
1822 : : else
1823 : : {
1824 : 57585 : if (TREE_CODE (captures[2]) == INTEGER_CST
1825 : 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
1826 : 57585 : && !int_fits_type_p (captures[2], TREE_TYPE (captures[1]))
1827 : : )
1828 : : {
1829 : 0 : {
1830 : 0 : tree min = lower_bound_in_type (TREE_TYPE (captures[3]), TREE_TYPE (captures[1]));
1831 : 0 : tree max = upper_bound_in_type (TREE_TYPE (captures[3]), TREE_TYPE (captures[1]));
1832 : 0 : bool above = integer_nonzerop (const_binop (LT_EXPR, type, max, captures[2]));
1833 : 0 : bool below = integer_nonzerop (const_binop (LT_EXPR, type, captures[2], min));
1834 : 0 : if (above || below
1835 : : )
1836 : : {
1837 : 0 : if (cmp == EQ_EXPR || cmp == NE_EXPR
1838 : : )
1839 : : {
1840 : 0 : gimple_seq *lseq = seq;
1841 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail565;
1842 : 0 : {
1843 : 0 : tree tem;
1844 : 0 : tem = constant_boolean_node (cmp == EQ_EXPR ? false : true, type);
1845 : 0 : res_op->set_value (tem);
1846 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 386, __FILE__, __LINE__, true);
1847 : 0 : return true;
1848 : : }
1849 : 0 : next_after_fail565:;
1850 : : }
1851 : : else
1852 : : {
1853 : 0 : if (cmp == LT_EXPR || cmp == LE_EXPR
1854 : : )
1855 : : {
1856 : 0 : gimple_seq *lseq = seq;
1857 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail566;
1858 : 0 : {
1859 : 0 : tree tem;
1860 : 0 : tem = constant_boolean_node (above ? true : false, type);
1861 : 0 : res_op->set_value (tem);
1862 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 387, __FILE__, __LINE__, true);
1863 : 0 : return true;
1864 : : }
1865 : 0 : next_after_fail566:;
1866 : : }
1867 : : else
1868 : : {
1869 : 0 : if (cmp == GT_EXPR || cmp == GE_EXPR
1870 : : )
1871 : : {
1872 : 0 : gimple_seq *lseq = seq;
1873 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail567;
1874 : 0 : {
1875 : 0 : tree tem;
1876 : 0 : tem = constant_boolean_node (above ? false : true, type);
1877 : 0 : res_op->set_value (tem);
1878 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 388, __FILE__, __LINE__, true);
1879 : 0 : return true;
1880 : : }
1881 : 0 : next_after_fail567:;
1882 : : }
1883 : : }
1884 : : }
1885 : : }
1886 : : }
1887 : : }
1888 : : }
1889 : : }
1890 : : }
1891 : : }
1892 : : else
1893 : : {
1894 : 398996 : if (FLOAT_TYPE_P (TREE_TYPE (captures[1]))
1895 : 4102 : && (DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1896 : 2051 : == DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[1])))
1897 : 204623 : && (DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))
1898 : 2051 : == DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[3])))
1899 : : )
1900 : : {
1901 : 2051 : {
1902 : 2051 : tree type1 = TREE_TYPE (captures[3]);
1903 : 2051 : if (TREE_CODE (captures[3]) == REAL_CST && !DECIMAL_FLOAT_TYPE_P (type1))
1904 : : {
1905 : 0 : REAL_VALUE_TYPE orig = TREE_REAL_CST (captures[3]);
1906 : 0 : if (TYPE_PRECISION (type1) > TYPE_PRECISION (float_type_node)
1907 : 0 : && exact_real_truncate (TYPE_MODE (float_type_node), &orig))
1908 : 0 : type1 = float_type_node;
1909 : 0 : if (TYPE_PRECISION (type1) > TYPE_PRECISION (double_type_node)
1910 : 0 : && exact_real_truncate (TYPE_MODE (double_type_node), &orig))
1911 : 0 : type1 = double_type_node;
1912 : : }
1913 : 2051 : tree newtype
1914 : 2051 : = (element_precision (TREE_TYPE (captures[1])) > element_precision (type1)
1915 : 2051 : ? TREE_TYPE (captures[1]) : type1);
1916 : 2051 : if (element_precision (TREE_TYPE (captures[0])) > element_precision (newtype)
1917 : 2051 : && (!VECTOR_TYPE_P (type) || is_truth_type_for (newtype, type))
1918 : : )
1919 : : {
1920 : 562 : gimple_seq *lseq = seq;
1921 : 562 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail568;
1922 : 562 : {
1923 : 562 : res_op->set_op (cmp, type, 2);
1924 : 562 : {
1925 : 562 : tree _o1[1], _r1;
1926 : 562 : _o1[0] = captures[1];
1927 : 562 : if (newtype != TREE_TYPE (_o1[0])
1928 : 562 : && !useless_type_conversion_p (newtype, TREE_TYPE (_o1[0])))
1929 : : {
1930 : 4 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, newtype, _o1[0]);
1931 : 4 : tem_op.resimplify (lseq, valueize);
1932 : 4 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
1933 : 4 : if (!_r1) goto next_after_fail568;
1934 : : }
1935 : : else
1936 : : _r1 = _o1[0];
1937 : 562 : res_op->ops[0] = _r1;
1938 : : }
1939 : 562 : {
1940 : 562 : tree _o1[1], _r1;
1941 : 562 : _o1[0] = captures[3];
1942 : 562 : if (newtype != TREE_TYPE (_o1[0])
1943 : 562 : && !useless_type_conversion_p (newtype, TREE_TYPE (_o1[0])))
1944 : : {
1945 : 7 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, newtype, _o1[0]);
1946 : 7 : tem_op.resimplify (lseq, valueize);
1947 : 7 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
1948 : 7 : if (!_r1) goto next_after_fail568;
1949 : : }
1950 : : else
1951 : : _r1 = _o1[0];
1952 : 558 : res_op->ops[1] = _r1;
1953 : : }
1954 : 558 : res_op->resimplify (lseq, valueize);
1955 : 558 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 389, __FILE__, __LINE__, true);
1956 : 558 : return true;
1957 : : }
1958 : : next_after_fail568:;
1959 : : }
1960 : : }
1961 : : }
1962 : : }
1963 : : return false;
1964 : : }
1965 : :
1966 : : bool
1967 : 0 : gimple_simplify_291 (gimple_match_op *res_op, gimple_seq *seq,
1968 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
1969 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
1970 : : const enum tree_code ARG_UNUSED (op))
1971 : : {
1972 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
1973 : 0 : {
1974 : 0 : HOST_WIDE_INT zero_val = tree_to_shwi (captures[2]);
1975 : 0 : tree type0 = TREE_TYPE (captures[1]);
1976 : 0 : int prec = TYPE_PRECISION (type0);
1977 : 0 : if (prec <= MAX_FIXED_MODE_SIZE
1978 : : )
1979 : : {
1980 : 0 : if (tree_int_cst_sgn (captures[3]) < 0 || wi::to_widest (captures[3]) >= prec
1981 : : )
1982 : : {
1983 : 0 : if (zero_val != wi::to_widest (captures[3])
1984 : : )
1985 : : {
1986 : 0 : gimple_seq *lseq = seq;
1987 : 0 : if (lseq
1988 : : && (!single_use (captures[0])))
1989 : : lseq = NULL;
1990 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail628;
1991 : 0 : {
1992 : 0 : tree tem;
1993 : 0 : tem = constant_boolean_node (op == EQ_EXPR ? false : true, type);
1994 : 0 : res_op->set_value (tem);
1995 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 432, __FILE__, __LINE__, true);
1996 : 0 : return true;
1997 : : }
1998 : 0 : next_after_fail628:;
1999 : : }
2000 : : }
2001 : : else
2002 : : {
2003 : 0 : if (zero_val < 0 || zero_val >= prec
2004 : : )
2005 : : {
2006 : 0 : gimple_seq *lseq = seq;
2007 : 0 : if (lseq
2008 : 0 : && (!single_use (captures[0])))
2009 : 0 : lseq = NULL;
2010 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail629;
2011 : 0 : {
2012 : 0 : res_op->set_op (op, type, 2);
2013 : 0 : {
2014 : 0 : tree _o1[2], _r1;
2015 : 0 : _o1[0] = captures[1];
2016 : 0 : _o1[1] = wide_int_to_tree (type0,
2017 : 0 : wi::mask (tree_to_uhwi (captures[3]) + 1,
2018 : : false, prec));
2019 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2020 : 0 : tem_op.resimplify (lseq, valueize);
2021 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
2022 : 0 : if (!_r1) goto next_after_fail629;
2023 : 0 : res_op->ops[0] = _r1;
2024 : : }
2025 : 0 : res_op->ops[1] = wide_int_to_tree (type0,
2026 : 0 : wi::shifted_mask (tree_to_uhwi (captures[3]), 1,
2027 : : false, prec));
2028 : 0 : res_op->resimplify (lseq, valueize);
2029 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 433, __FILE__, __LINE__, true);
2030 : 0 : return true;
2031 : : }
2032 : 0 : next_after_fail629:;
2033 : : }
2034 : : }
2035 : : }
2036 : : }
2037 : 0 : return false;
2038 : : }
2039 : :
2040 : : bool
2041 : 211 : gimple_simplify_302 (gimple_match_op *res_op, gimple_seq *seq,
2042 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2043 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
2044 : : const combined_fn ARG_UNUSED (COPYSIGN_ALL))
2045 : : {
2046 : 211 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2047 : 211 : gimple_seq *lseq = seq;
2048 : 211 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail644;
2049 : 211 : {
2050 : 211 : res_op->set_op (ABS_EXPR, type, 1);
2051 : 211 : res_op->ops[0] = captures[0];
2052 : 211 : res_op->resimplify (lseq, valueize);
2053 : 211 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 448, __FILE__, __LINE__, true);
2054 : : return true;
2055 : : }
2056 : 0 : next_after_fail644:;
2057 : 0 : return false;
2058 : : }
2059 : :
2060 : : bool
2061 : 1167 : gimple_simplify_308 (gimple_match_op *res_op, gimple_seq *seq,
2062 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2063 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
2064 : : const enum tree_code ARG_UNUSED (div))
2065 : : {
2066 : 1167 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2067 : 2334 : if (!ALL_FRACT_MODE_P (TYPE_MODE (type))
2068 : 1167 : && !integer_zerop (captures[0])
2069 : 1193 : && (!flag_non_call_exceptions || tree_expr_nonzero_p (captures[0]))
2070 : : )
2071 : : {
2072 : 22 : gimple_seq *lseq = seq;
2073 : 22 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail652;
2074 : 22 : {
2075 : 22 : tree tem;
2076 : 22 : tem = build_one_cst (type);
2077 : 22 : res_op->set_value (tem);
2078 : 22 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 454, __FILE__, __LINE__, true);
2079 : 22 : return true;
2080 : : }
2081 : 0 : next_after_fail652:;
2082 : : }
2083 : : return false;
2084 : : }
2085 : :
2086 : : bool
2087 : 11 : gimple_simplify_315 (gimple_match_op *res_op, gimple_seq *seq,
2088 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2089 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
2090 : : const enum tree_code ARG_UNUSED (div))
2091 : : {
2092 : 11 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2093 : 11 : if (INTEGRAL_TYPE_P (type)
2094 : 11 : && wi::multiple_of_p (wi::to_widest (captures[1]), wi::to_widest (captures[2]), SIGNED)
2095 : : )
2096 : : {
2097 : 11 : if (TYPE_OVERFLOW_UNDEFINED (type) && !TYPE_OVERFLOW_SANITIZED (type)
2098 : : )
2099 : : {
2100 : 3 : gimple_seq *lseq = seq;
2101 : 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail662;
2102 : 3 : {
2103 : 3 : res_op->set_op (div, type, 2);
2104 : 3 : res_op->ops[0] = captures[1];
2105 : 3 : res_op->ops[1] = captures[2];
2106 : 3 : res_op->resimplify (lseq, valueize);
2107 : 3 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 464, __FILE__, __LINE__, true);
2108 : 3 : return true;
2109 : : }
2110 : 0 : next_after_fail662:;
2111 : : }
2112 : : else
2113 : : {
2114 : 8 : {
2115 : 8 : value_range vr0, vr1, vr2;
2116 : 16 : if (get_range_query (cfun)->range_of_expr (vr0, captures[0])
2117 : 16 : && get_range_query (cfun)->range_of_expr (vr1, captures[1])
2118 : 16 : && get_range_query (cfun)->range_of_expr (vr2, captures[2])
2119 : 8 : && range_op_handler (MULT_EXPR).overflow_free_p (vr0, vr1)
2120 : 16 : && range_op_handler (MULT_EXPR).overflow_free_p (vr0, vr2)
2121 : : )
2122 : : {
2123 : 2 : gimple_seq *lseq = seq;
2124 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail663;
2125 : 2 : {
2126 : 2 : res_op->set_op (div, type, 2);
2127 : 2 : res_op->ops[0] = captures[1];
2128 : 2 : res_op->ops[1] = captures[2];
2129 : 2 : res_op->resimplify (lseq, valueize);
2130 : 2 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 465, __FILE__, __LINE__, true);
2131 : 2 : return true;
2132 : : }
2133 : 0 : next_after_fail663:;
2134 : : }
2135 : 8 : }
2136 : : }
2137 : : }
2138 : : return false;
2139 : : }
2140 : :
2141 : : bool
2142 : 77 : gimple_simplify_323 (gimple_match_op *res_op, gimple_seq *seq,
2143 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2144 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
2145 : : const enum tree_code ARG_UNUSED (mod))
2146 : : {
2147 : 77 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2148 : 77 : gimple_seq *lseq = seq;
2149 : 77 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail671;
2150 : 77 : {
2151 : 77 : tree tem;
2152 : 77 : tem = captures[0];
2153 : 77 : res_op->set_value (tem);
2154 : 77 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 473, __FILE__, __LINE__, true);
2155 : : return true;
2156 : : }
2157 : 0 : next_after_fail671:;
2158 : 0 : return false;
2159 : : }
2160 : :
2161 : : bool
2162 : 0 : gimple_simplify_331 (gimple_match_op *res_op, gimple_seq *seq,
2163 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2164 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
2165 : : const combined_fn ARG_UNUSED (TANH),
2166 : : const combined_fn ARG_UNUSED (SINH),
2167 : : const combined_fn ARG_UNUSED (COSH))
2168 : : {
2169 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2170 : 0 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
2171 : : )
2172 : : {
2173 : 0 : gimple_seq *lseq = seq;
2174 : 0 : if (lseq
2175 : 0 : && (!single_use (captures[0])
2176 : 0 : || !single_use (captures[2])))
2177 : 0 : lseq = NULL;
2178 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail681;
2179 : 0 : {
2180 : 0 : res_op->set_op (RDIV_EXPR, type, 2);
2181 : 0 : res_op->ops[0] = build_one_cst (type);
2182 : 0 : {
2183 : 0 : tree _o1[1], _r1;
2184 : 0 : _o1[0] = captures[1];
2185 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), COSH, TREE_TYPE (_o1[0]), _o1[0]);
2186 : 0 : tem_op.resimplify (lseq, valueize);
2187 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
2188 : 0 : if (!_r1) goto next_after_fail681;
2189 : 0 : res_op->ops[1] = _r1;
2190 : : }
2191 : 0 : res_op->resimplify (lseq, valueize);
2192 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 483, __FILE__, __LINE__, true);
2193 : 0 : return true;
2194 : : }
2195 : : next_after_fail681:;
2196 : : }
2197 : : return false;
2198 : : }
2199 : :
2200 : : bool
2201 : 4141 : gimple_simplify_338 (gimple_match_op *res_op, gimple_seq *seq,
2202 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2203 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
2204 : : const enum tree_code ARG_UNUSED (cmp))
2205 : : {
2206 : 4141 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2207 : 8282 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
2208 : 8062 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
2209 : : )
2210 : : {
2211 : 2852 : if (tree_expr_nonnegative_p (captures[1]) && tree_expr_nonzero_p (captures[1])
2212 : : )
2213 : : {
2214 : 286 : gimple_seq *lseq = seq;
2215 : 286 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail689;
2216 : 286 : {
2217 : 286 : res_op->set_op (cmp, type, 2);
2218 : 286 : res_op->ops[0] = captures[0];
2219 : 286 : res_op->ops[1] = captures[2];
2220 : 286 : res_op->resimplify (lseq, valueize);
2221 : 286 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 491, __FILE__, __LINE__, true);
2222 : 286 : return true;
2223 : : }
2224 : 0 : next_after_fail689:;
2225 : : }
2226 : : else
2227 : : {
2228 : 2566 : if (TREE_CODE (captures[1]) == INTEGER_CST
2229 : 2566 : && wi::neg_p (wi::to_wide (captures[1]), TYPE_SIGN (TREE_TYPE (captures[1])))
2230 : : )
2231 : : {
2232 : 18 : gimple_seq *lseq = seq;
2233 : 18 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail690;
2234 : 18 : {
2235 : 18 : res_op->set_op (cmp, type, 2);
2236 : 18 : res_op->ops[0] = captures[2];
2237 : 18 : res_op->ops[1] = captures[0];
2238 : 18 : res_op->resimplify (lseq, valueize);
2239 : 18 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 492, __FILE__, __LINE__, true);
2240 : 18 : return true;
2241 : : }
2242 : 0 : next_after_fail690:;
2243 : : }
2244 : : }
2245 : : }
2246 : : return false;
2247 : : }
2248 : :
2249 : : bool
2250 : 1233061 : gimple_simplify_351 (gimple_match_op *res_op, gimple_seq *seq,
2251 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2252 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
2253 : : const enum tree_code ARG_UNUSED (cmp))
2254 : : {
2255 : 1233061 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2256 : 2466122 : if ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
2257 : 12 : || POINTER_TYPE_P (TREE_TYPE (captures[2]))
2258 : 0 : || VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[2])))
2259 : 2466122 : && tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
2260 : : )
2261 : : {
2262 : 880462 : {
2263 : 880462 : tree cst = uniform_integer_cst_p (captures[2]);
2264 : 880462 : tree arg1_type = TREE_TYPE (cst);
2265 : 880462 : unsigned int prec = TYPE_PRECISION (arg1_type);
2266 : 880462 : wide_int max = wi::max_value (arg1_type);
2267 : 880462 : wide_int signed_max = wi::max_value (prec, SIGNED);
2268 : 880462 : wide_int min = wi::min_value (arg1_type);
2269 : 880462 : if (wi::to_wide (cst) == max
2270 : : )
2271 : : {
2272 : 354 : if (cmp == GT_EXPR
2273 : : )
2274 : : {
2275 : 342 : gimple_seq *lseq = seq;
2276 : 342 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail706;
2277 : 342 : {
2278 : 342 : tree tem;
2279 : 342 : tem = constant_boolean_node (false, type);
2280 : 342 : res_op->set_value (tem);
2281 : 342 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 508, __FILE__, __LINE__, true);
2282 : 342 : return true;
2283 : : }
2284 : 0 : next_after_fail706:;
2285 : : }
2286 : : else
2287 : : {
2288 : 12 : if (cmp == GE_EXPR
2289 : : )
2290 : : {
2291 : 0 : gimple_seq *lseq = seq;
2292 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail707;
2293 : 0 : {
2294 : 0 : res_op->set_op (EQ_EXPR, type, 2);
2295 : 0 : res_op->ops[0] = captures[0];
2296 : 0 : res_op->ops[1] = captures[2];
2297 : 0 : res_op->resimplify (lseq, valueize);
2298 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 509, __FILE__, __LINE__, true);
2299 : 0 : return true;
2300 : : }
2301 : 0 : next_after_fail707:;
2302 : : }
2303 : : else
2304 : : {
2305 : 12 : if (cmp == LE_EXPR
2306 : : )
2307 : : {
2308 : 12 : gimple_seq *lseq = seq;
2309 : 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail708;
2310 : 12 : {
2311 : 12 : tree tem;
2312 : 12 : tem = constant_boolean_node (true, type);
2313 : 12 : res_op->set_value (tem);
2314 : 12 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 510, __FILE__, __LINE__, true);
2315 : 12 : return true;
2316 : : }
2317 : 0 : next_after_fail708:;
2318 : : }
2319 : : else
2320 : : {
2321 : 0 : if (cmp == LT_EXPR
2322 : : )
2323 : : {
2324 : 0 : gimple_seq *lseq = seq;
2325 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail709;
2326 : 0 : {
2327 : 0 : res_op->set_op (NE_EXPR, type, 2);
2328 : 0 : res_op->ops[0] = captures[0];
2329 : 0 : res_op->ops[1] = captures[2];
2330 : 0 : res_op->resimplify (lseq, valueize);
2331 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 511, __FILE__, __LINE__, true);
2332 : 0 : return true;
2333 : : }
2334 : 0 : next_after_fail709:;
2335 : : }
2336 : : }
2337 : : }
2338 : : }
2339 : : }
2340 : : else
2341 : : {
2342 : 880108 : if (wi::to_wide (cst) == min
2343 : : )
2344 : : {
2345 : 20844 : if (cmp == LT_EXPR
2346 : : )
2347 : : {
2348 : 1686 : gimple_seq *lseq = seq;
2349 : 1686 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail710;
2350 : 1686 : {
2351 : 1686 : tree tem;
2352 : 1686 : tem = constant_boolean_node (false, type);
2353 : 1686 : res_op->set_value (tem);
2354 : 1686 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 512, __FILE__, __LINE__, true);
2355 : 1686 : return true;
2356 : : }
2357 : 0 : next_after_fail710:;
2358 : : }
2359 : : else
2360 : : {
2361 : 19158 : if (cmp == LE_EXPR
2362 : : )
2363 : : {
2364 : 4997 : gimple_seq *lseq = seq;
2365 : 4997 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail711;
2366 : 4997 : {
2367 : 4997 : res_op->set_op (EQ_EXPR, type, 2);
2368 : 4997 : res_op->ops[0] = captures[0];
2369 : 4997 : res_op->ops[1] = captures[2];
2370 : 4997 : res_op->resimplify (lseq, valueize);
2371 : 4997 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 513, __FILE__, __LINE__, true);
2372 : 4997 : return true;
2373 : : }
2374 : 0 : next_after_fail711:;
2375 : : }
2376 : : else
2377 : : {
2378 : 14161 : if (cmp == GE_EXPR
2379 : : )
2380 : : {
2381 : 344 : gimple_seq *lseq = seq;
2382 : 344 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail712;
2383 : 344 : {
2384 : 344 : tree tem;
2385 : 344 : tem = constant_boolean_node (true, type);
2386 : 344 : res_op->set_value (tem);
2387 : 344 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 514, __FILE__, __LINE__, true);
2388 : 344 : return true;
2389 : : }
2390 : 0 : next_after_fail712:;
2391 : : }
2392 : : else
2393 : : {
2394 : 13817 : if (cmp == GT_EXPR
2395 : : )
2396 : : {
2397 : 13817 : gimple_seq *lseq = seq;
2398 : 13817 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail713;
2399 : 13817 : {
2400 : 13817 : res_op->set_op (NE_EXPR, type, 2);
2401 : 13817 : res_op->ops[0] = captures[0];
2402 : 13817 : res_op->ops[1] = captures[2];
2403 : 13817 : res_op->resimplify (lseq, valueize);
2404 : 13817 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 515, __FILE__, __LINE__, true);
2405 : 13817 : return true;
2406 : : }
2407 : 0 : next_after_fail713:;
2408 : : }
2409 : : }
2410 : : }
2411 : : }
2412 : : }
2413 : : else
2414 : : {
2415 : 859264 : if (wi::to_wide (cst) == max - 1
2416 : : )
2417 : : {
2418 : 159 : if (cmp == GT_EXPR
2419 : : )
2420 : : {
2421 : 109 : gimple_seq *lseq = seq;
2422 : 109 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail714;
2423 : 109 : {
2424 : 109 : res_op->set_op (EQ_EXPR, type, 2);
2425 : 109 : res_op->ops[0] = captures[0];
2426 : 109 : res_op->ops[1] = build_uniform_cst (TREE_TYPE (captures[2]),
2427 : 109 : wide_int_to_tree (TREE_TYPE (cst),
2428 : 109 : wi::to_wide (cst)
2429 : 218 : + 1));
2430 : 109 : res_op->resimplify (lseq, valueize);
2431 : 109 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 516, __FILE__, __LINE__, true);
2432 : 109 : return true;
2433 : : }
2434 : 0 : next_after_fail714:;
2435 : : }
2436 : : else
2437 : : {
2438 : 50 : if (cmp == LE_EXPR
2439 : : )
2440 : : {
2441 : 50 : gimple_seq *lseq = seq;
2442 : 50 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail715;
2443 : 50 : {
2444 : 50 : res_op->set_op (NE_EXPR, type, 2);
2445 : 50 : res_op->ops[0] = captures[0];
2446 : 50 : res_op->ops[1] = build_uniform_cst (TREE_TYPE (captures[2]),
2447 : 50 : wide_int_to_tree (TREE_TYPE (cst),
2448 : 50 : wi::to_wide (cst)
2449 : 100 : + 1));
2450 : 50 : res_op->resimplify (lseq, valueize);
2451 : 50 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 517, __FILE__, __LINE__, true);
2452 : 50 : return true;
2453 : : }
2454 : 0 : next_after_fail715:;
2455 : : }
2456 : : }
2457 : : }
2458 : : else
2459 : : {
2460 : 859105 : if (wi::to_wide (cst) == min + 1
2461 : : )
2462 : : {
2463 : 23738 : if (cmp == GE_EXPR
2464 : : )
2465 : : {
2466 : 0 : gimple_seq *lseq = seq;
2467 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail716;
2468 : 0 : {
2469 : 0 : res_op->set_op (NE_EXPR, type, 2);
2470 : 0 : res_op->ops[0] = captures[0];
2471 : 0 : res_op->ops[1] = build_uniform_cst (TREE_TYPE (captures[2]),
2472 : 0 : wide_int_to_tree (TREE_TYPE (cst),
2473 : 0 : wi::to_wide (cst)
2474 : 0 : - 1));
2475 : 0 : res_op->resimplify (lseq, valueize);
2476 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 518, __FILE__, __LINE__, true);
2477 : 0 : return true;
2478 : : }
2479 : 0 : next_after_fail716:;
2480 : : }
2481 : : else
2482 : : {
2483 : 23738 : if (cmp == LT_EXPR
2484 : : )
2485 : : {
2486 : 5 : gimple_seq *lseq = seq;
2487 : 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail717;
2488 : 5 : {
2489 : 5 : res_op->set_op (EQ_EXPR, type, 2);
2490 : 5 : res_op->ops[0] = captures[0];
2491 : 5 : res_op->ops[1] = build_uniform_cst (TREE_TYPE (captures[2]),
2492 : 5 : wide_int_to_tree (TREE_TYPE (cst),
2493 : 5 : wi::to_wide (cst)
2494 : 10 : - 1));
2495 : 5 : res_op->resimplify (lseq, valueize);
2496 : 5 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 519, __FILE__, __LINE__, true);
2497 : 5 : return true;
2498 : : }
2499 : 0 : next_after_fail717:;
2500 : : }
2501 : : }
2502 : : }
2503 : : else
2504 : : {
2505 : 835367 : if (wi::to_wide (cst) == signed_max
2506 : 644 : && TYPE_UNSIGNED (arg1_type)
2507 : 644 : && TYPE_MODE (arg1_type) != BLKmode
2508 : 835367 : && prec == GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (arg1_type))
2509 : 836011 : && INTEGRAL_TYPE_P (arg1_type)
2510 : : )
2511 : : {
2512 : 644 : if (cmp == LE_EXPR || cmp == GT_EXPR
2513 : : )
2514 : : {
2515 : 644 : {
2516 : 644 : tree st = signed_type_for (TREE_TYPE (captures[2]));
2517 : 644 : if (cst == captures[2] && cmp == LE_EXPR
2518 : : )
2519 : : {
2520 : 392 : gimple_seq *lseq = seq;
2521 : 392 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail718;
2522 : 392 : {
2523 : 392 : res_op->set_op (GE_EXPR, type, 2);
2524 : 392 : {
2525 : 392 : tree _o1[1], _r1;
2526 : 392 : _o1[0] = captures[1];
2527 : 392 : if (st != TREE_TYPE (_o1[0])
2528 : 392 : && !useless_type_conversion_p (st, TREE_TYPE (_o1[0])))
2529 : : {
2530 : 12 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, st, _o1[0]);
2531 : 12 : tem_op.resimplify (lseq, valueize);
2532 : 12 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
2533 : 12 : if (!_r1) goto next_after_fail718;
2534 : : }
2535 : : else
2536 : : _r1 = _o1[0];
2537 : 380 : res_op->ops[0] = _r1;
2538 : : }
2539 : 380 : res_op->ops[1] = build_zero_cst (st);
2540 : 380 : res_op->resimplify (lseq, valueize);
2541 : 380 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 520, __FILE__, __LINE__, true);
2542 : 380 : return true;
2543 : : }
2544 : 858480 : next_after_fail718:;
2545 : : }
2546 : : else
2547 : : {
2548 : 252 : if (cst == captures[2] && cmp == GT_EXPR
2549 : : )
2550 : : {
2551 : 252 : gimple_seq *lseq = seq;
2552 : 252 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail719;
2553 : 252 : {
2554 : 252 : res_op->set_op (LT_EXPR, type, 2);
2555 : 252 : {
2556 : 252 : tree _o1[1], _r1;
2557 : 252 : _o1[0] = captures[1];
2558 : 252 : if (st != TREE_TYPE (_o1[0])
2559 : 252 : && !useless_type_conversion_p (st, TREE_TYPE (_o1[0])))
2560 : : {
2561 : 12 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, st, _o1[0]);
2562 : 12 : tem_op.resimplify (lseq, valueize);
2563 : 12 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
2564 : 12 : if (!_r1) goto next_after_fail719;
2565 : : }
2566 : : else
2567 : : _r1 = _o1[0];
2568 : 240 : res_op->ops[0] = _r1;
2569 : : }
2570 : 240 : res_op->ops[1] = build_zero_cst (st);
2571 : 240 : res_op->resimplify (lseq, valueize);
2572 : 240 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 521, __FILE__, __LINE__, true);
2573 : 240 : return true;
2574 : : }
2575 : 858480 : next_after_fail719:;
2576 : : }
2577 : : else
2578 : : {
2579 : 0 : if (cmp == LE_EXPR
2580 : : )
2581 : : {
2582 : 0 : gimple_seq *lseq = seq;
2583 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail720;
2584 : 0 : {
2585 : 0 : res_op->set_op (GE_EXPR, type, 2);
2586 : 0 : {
2587 : 0 : tree _o1[1], _r1;
2588 : 0 : _o1[0] = captures[1];
2589 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, st, _o1[0]);
2590 : 0 : tem_op.resimplify (lseq, valueize);
2591 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
2592 : 0 : if (!_r1) goto next_after_fail720;
2593 : 0 : res_op->ops[0] = _r1;
2594 : : }
2595 : 0 : res_op->ops[1] = build_zero_cst (st);
2596 : 0 : res_op->resimplify (lseq, valueize);
2597 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 522, __FILE__, __LINE__, true);
2598 : 0 : return true;
2599 : : }
2600 : 858480 : next_after_fail720:;
2601 : : }
2602 : : else
2603 : : {
2604 : 0 : if (cmp == GT_EXPR
2605 : : )
2606 : : {
2607 : 0 : gimple_seq *lseq = seq;
2608 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail721;
2609 : 0 : {
2610 : 0 : res_op->set_op (LT_EXPR, type, 2);
2611 : 0 : {
2612 : 0 : tree _o1[1], _r1;
2613 : 0 : _o1[0] = captures[1];
2614 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, st, _o1[0]);
2615 : 0 : tem_op.resimplify (lseq, valueize);
2616 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
2617 : 0 : if (!_r1) goto next_after_fail721;
2618 : 0 : res_op->ops[0] = _r1;
2619 : : }
2620 : 0 : res_op->ops[1] = build_zero_cst (st);
2621 : 0 : res_op->resimplify (lseq, valueize);
2622 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 523, __FILE__, __LINE__, true);
2623 : 0 : return true;
2624 : : }
2625 : 858480 : next_after_fail721:;
2626 : : }
2627 : : }
2628 : : }
2629 : : }
2630 : : }
2631 : : }
2632 : : }
2633 : : }
2634 : : }
2635 : : }
2636 : : }
2637 : 880462 : }
2638 : : }
2639 : : return false;
2640 : : }
2641 : :
2642 : : bool
2643 : 20 : gimple_simplify_398 (gimple_match_op *res_op, gimple_seq *seq,
2644 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2645 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
2646 : : const combined_fn ARG_UNUSED (copysigns),
2647 : : const combined_fn ARG_UNUSED (coss))
2648 : : {
2649 : 20 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2650 : 20 : gimple_seq *lseq = seq;
2651 : 20 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail814;
2652 : 20 : {
2653 : 20 : res_op->set_op (coss, type, 1);
2654 : 20 : res_op->ops[0] = captures[0];
2655 : 20 : res_op->resimplify (lseq, valueize);
2656 : 20 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 581, __FILE__, __LINE__, true);
2657 : : return true;
2658 : : }
2659 : 0 : next_after_fail814:;
2660 : 0 : return false;
2661 : : }
2662 : :
2663 : : bool
2664 : 2 : gimple_simplify_401 (gimple_match_op *res_op, gimple_seq *seq,
2665 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2666 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
2667 : : const combined_fn ARG_UNUSED (copysigns),
2668 : : const combined_fn ARG_UNUSED (pows))
2669 : : {
2670 : 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2671 : 2 : {
2672 : 2 : HOST_WIDE_INT n;
2673 : 2 : if (real_isinteger (&TREE_REAL_CST (captures[2]), &n) && (n & 1) == 0
2674 : : )
2675 : : {
2676 : 2 : gimple_seq *lseq = seq;
2677 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail817;
2678 : 2 : {
2679 : 2 : res_op->set_op (pows, type, 2);
2680 : 2 : res_op->ops[0] = captures[0];
2681 : 2 : res_op->ops[1] = captures[2];
2682 : 2 : res_op->resimplify (lseq, valueize);
2683 : 2 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 584, __FILE__, __LINE__, true);
2684 : 2 : return true;
2685 : : }
2686 : 0 : next_after_fail817:;
2687 : : }
2688 : : }
2689 : 0 : return false;
2690 : : }
2691 : :
2692 : : bool
2693 : 1 : gimple_simplify_404 (gimple_match_op *res_op, gimple_seq *seq,
2694 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2695 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
2696 : : {
2697 : 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2698 : 1 : gimple_seq *lseq = seq;
2699 : 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail821;
2700 : 1 : {
2701 : 1 : tree tem;
2702 : 1 : tem = captures[0];
2703 : 1 : res_op->set_value (tem);
2704 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 588, __FILE__, __LINE__, true);
2705 : : return true;
2706 : : }
2707 : 0 : next_after_fail821:;
2708 : 0 : return false;
2709 : : }
2710 : :
2711 : : bool
2712 : 2 : gimple_simplify_406 (gimple_match_op *res_op, gimple_seq *seq,
2713 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2714 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
2715 : : const combined_fn ARG_UNUSED (copysigns),
2716 : : const combined_fn ARG_UNUSED (hypots))
2717 : : {
2718 : 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2719 : 2 : gimple_seq *lseq = seq;
2720 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail823;
2721 : 2 : {
2722 : 2 : res_op->set_op (hypots, type, 2);
2723 : 2 : res_op->ops[0] = captures[0];
2724 : 2 : res_op->ops[1] = captures[1];
2725 : 2 : res_op->resimplify (lseq, valueize);
2726 : 2 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 590, __FILE__, __LINE__, true);
2727 : : return true;
2728 : : }
2729 : 0 : next_after_fail823:;
2730 : 0 : return false;
2731 : : }
2732 : :
2733 : : bool
2734 : 368345 : gimple_simplify_409 (gimple_match_op *res_op, gimple_seq *seq,
2735 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2736 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
2737 : : {
2738 : 368345 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2739 : 368345 : if (!HONOR_SIGN_DEPENDENT_ROUNDING (type)
2740 : 368345 : && !HONOR_SIGNED_ZEROS (type)
2741 : : )
2742 : : {
2743 : 368022 : gimple_seq *lseq = seq;
2744 : 368022 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail826;
2745 : 368022 : {
2746 : 368022 : res_op->set_op (MINUS_EXPR, type, 2);
2747 : 368022 : {
2748 : 368022 : tree _o1[1], _r1;
2749 : 368022 : _o1[0] = captures[1];
2750 : 368022 : gimple_match_op tem_op (res_op->cond.any_else (), NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2751 : 368022 : tem_op.resimplify (lseq, valueize);
2752 : 368022 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
2753 : 368022 : if (!_r1) goto next_after_fail826;
2754 : 362327 : res_op->ops[0] = _r1;
2755 : : }
2756 : 362327 : res_op->ops[1] = captures[0];
2757 : 362327 : res_op->resimplify (lseq, valueize);
2758 : 362327 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 593, __FILE__, __LINE__, true);
2759 : 362327 : return true;
2760 : : }
2761 : : next_after_fail826:;
2762 : : }
2763 : : return false;
2764 : : }
2765 : :
2766 : : bool
2767 : 36315 : gimple_simplify_413 (gimple_match_op *res_op, gimple_seq *seq,
2768 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2769 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
2770 : : {
2771 : 36315 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2772 : 36315 : if (!TYPE_SATURATING (type)
2773 : : )
2774 : : {
2775 : 16987 : if (!TYPE_OVERFLOW_SANITIZED (type)
2776 : 53302 : && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[0]))
2777 : : )
2778 : : {
2779 : 36315 : gimple_seq *lseq = seq;
2780 : 36315 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail831;
2781 : 36315 : {
2782 : 36315 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
2783 : 36315 : res_op->ops[0] = captures[0];
2784 : 36315 : res_op->resimplify (lseq, valueize);
2785 : 36315 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 598, __FILE__, __LINE__, true);
2786 : 36315 : return true;
2787 : : }
2788 : 0 : next_after_fail831:;
2789 : : }
2790 : : }
2791 : : return false;
2792 : : }
2793 : :
2794 : : bool
2795 : 1 : gimple_simplify_417 (gimple_match_op *res_op, gimple_seq *seq,
2796 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2797 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
2798 : : {
2799 : 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2800 : 2 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2801 : 2 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
2802 : : )
2803 : : {
2804 : 1 : gimple_seq *lseq = seq;
2805 : 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail835;
2806 : 1 : {
2807 : 1 : res_op->set_op (BIT_AND_EXPR, type, 2);
2808 : 1 : res_op->ops[0] = captures[0];
2809 : 1 : res_op->ops[1] = captures[1];
2810 : 1 : res_op->resimplify (lseq, valueize);
2811 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 602, __FILE__, __LINE__, true);
2812 : 1 : return true;
2813 : : }
2814 : 0 : next_after_fail835:;
2815 : : }
2816 : : return false;
2817 : : }
2818 : :
2819 : : bool
2820 : 0 : gimple_simplify_422 (gimple_match_op *res_op, gimple_seq *seq,
2821 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2822 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
2823 : : {
2824 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2825 : 0 : gimple_seq *lseq = seq;
2826 : 0 : if (lseq
2827 : 0 : && (!single_use (captures[3])
2828 : 0 : || !single_use (captures[4])))
2829 : 0 : lseq = NULL;
2830 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail840;
2831 : 0 : {
2832 : 0 : res_op->set_op (BIT_AND_EXPR, type, 2);
2833 : 0 : res_op->ops[0] = captures[0];
2834 : 0 : {
2835 : 0 : tree _o1[1], _r1;
2836 : 0 : _o1[0] = captures[5];
2837 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
2838 : 0 : tem_op.resimplify (lseq, valueize);
2839 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
2840 : 0 : if (!_r1) goto next_after_fail840;
2841 : 0 : res_op->ops[1] = _r1;
2842 : : }
2843 : 0 : res_op->resimplify (lseq, valueize);
2844 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 606, __FILE__, __LINE__, true);
2845 : : return true;
2846 : : }
2847 : : next_after_fail840:;
2848 : : return false;
2849 : : }
2850 : :
2851 : : bool
2852 : 596 : gimple_simplify_427 (gimple_match_op *res_op, gimple_seq *seq,
2853 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2854 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
2855 : : {
2856 : 596 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2857 : 596 : if (INTEGRAL_TYPE_P (type)
2858 : 596 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2859 : 596 : && TREE_CODE (TREE_TYPE (captures[0])) != BOOLEAN_TYPE
2860 : 1192 : && (!TYPE_UNSIGNED (TREE_TYPE (captures[0]))
2861 : 488 : || TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (captures[0])))
2862 : : )
2863 : : {
2864 : 596 : gimple_seq *lseq = seq;
2865 : 596 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail845;
2866 : 596 : {
2867 : 596 : res_op->set_op (MULT_EXPR, type, 2);
2868 : 596 : {
2869 : 596 : tree _o1[1], _r1;
2870 : 596 : _o1[0] = captures[0];
2871 : 596 : if (type != TREE_TYPE (_o1[0])
2872 : 596 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
2873 : : {
2874 : 10 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
2875 : 10 : tem_op.resimplify (lseq, valueize);
2876 : 10 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
2877 : 10 : if (!_r1) goto next_after_fail845;
2878 : : }
2879 : : else
2880 : : _r1 = _o1[0];
2881 : 588 : res_op->ops[0] = _r1;
2882 : : }
2883 : 588 : res_op->ops[1] = captures[1];
2884 : 588 : res_op->resimplify (lseq, valueize);
2885 : 588 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 611, __FILE__, __LINE__, true);
2886 : 588 : return true;
2887 : : }
2888 : : next_after_fail845:;
2889 : : }
2890 : : return false;
2891 : : }
2892 : :
2893 : : bool
2894 : 0 : gimple_simplify_434 (gimple_match_op *res_op, gimple_seq *seq,
2895 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2896 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
2897 : : const enum tree_code ARG_UNUSED (cmp))
2898 : : {
2899 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2900 : 0 : if (!canonicalize_math_p ()
2901 : : )
2902 : : {
2903 : 0 : if (INTEGRAL_TYPE_P (type)
2904 : 0 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
2905 : : )
2906 : : {
2907 : 0 : gimple_seq *lseq = seq;
2908 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail852;
2909 : 0 : {
2910 : 0 : res_op->set_op (COND_EXPR, type, 3);
2911 : 0 : res_op->ops[0] = captures[0];
2912 : 0 : res_op->ops[1] = captures[3];
2913 : 0 : res_op->ops[2] = build_zero_cst (type);
2914 : 0 : res_op->resimplify (lseq, valueize);
2915 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 618, __FILE__, __LINE__, true);
2916 : 0 : return true;
2917 : : }
2918 : 0 : next_after_fail852:;
2919 : : }
2920 : : }
2921 : : return false;
2922 : : }
2923 : :
2924 : : bool
2925 : 1067 : gimple_simplify_440 (gimple_match_op *res_op, gimple_seq *seq,
2926 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2927 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
2928 : : const combined_fn ARG_UNUSED (bswap))
2929 : : {
2930 : 1067 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2931 : 1067 : if (BITS_PER_UNIT == 8
2932 : 1067 : && tree_fits_uhwi_p (captures[2])
2933 : 1067 : && tree_to_uhwi (captures[2]) < 256
2934 : : )
2935 : : {
2936 : 42 : {
2937 : 42 : unsigned HOST_WIDE_INT prec = TYPE_PRECISION (TREE_TYPE (captures[0]));
2938 : 42 : tree utype = unsigned_type_for (TREE_TYPE (captures[1]));
2939 : 42 : tree nst = build_int_cst (integer_type_node, prec - 8);
2940 : 42 : gimple_seq *lseq = seq;
2941 : 42 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail863;
2942 : 42 : {
2943 : 42 : res_op->set_op (BIT_AND_EXPR, type, 2);
2944 : 42 : {
2945 : 42 : tree _o1[1], _r1;
2946 : 42 : {
2947 : 42 : tree _o2[2], _r2;
2948 : 42 : {
2949 : 42 : tree _o3[1], _r3;
2950 : 42 : _o3[0] = captures[1];
2951 : 42 : if (utype != TREE_TYPE (_o3[0])
2952 : 42 : && !useless_type_conversion_p (utype, TREE_TYPE (_o3[0])))
2953 : : {
2954 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, utype, _o3[0]);
2955 : 0 : tem_op.resimplify (lseq, valueize);
2956 : 0 : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
2957 : 0 : if (!_r3) goto next_after_fail863;
2958 : : }
2959 : : else
2960 : : _r3 = _o3[0];
2961 : 42 : _o2[0] = _r3;
2962 : : }
2963 : 42 : _o2[1] = nst;
2964 : 42 : gimple_match_op tem_op (res_op->cond.any_else (), RSHIFT_EXPR, utype, _o2[0], _o2[1]);
2965 : 42 : tem_op.resimplify (lseq, valueize);
2966 : 42 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
2967 : 42 : if (!_r2) goto next_after_fail863;
2968 : 13 : _o1[0] = _r2;
2969 : : }
2970 : 13 : if (type != TREE_TYPE (_o1[0])
2971 : 13 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
2972 : : {
2973 : 4 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
2974 : 4 : tem_op.resimplify (lseq, valueize);
2975 : 4 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
2976 : 4 : if (!_r1) goto next_after_fail863;
2977 : : }
2978 : : else
2979 : : _r1 = _o1[0];
2980 : 13 : res_op->ops[0] = _r1;
2981 : : }
2982 : 13 : res_op->ops[1] = captures[2];
2983 : 13 : res_op->resimplify (lseq, valueize);
2984 : 13 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 625, __FILE__, __LINE__, true);
2985 : 13 : return true;
2986 : : }
2987 : : next_after_fail863:;
2988 : : }
2989 : : }
2990 : : return false;
2991 : : }
2992 : :
2993 : : bool
2994 : 6 : gimple_simplify_449 (gimple_match_op *res_op, gimple_seq *seq,
2995 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2996 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
2997 : : {
2998 : 6 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2999 : 6 : gimple_seq *lseq = seq;
3000 : 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail894;
3001 : 6 : {
3002 : 6 : tree tem;
3003 : 6 : tem = captures[2];
3004 : 6 : res_op->set_value (tem);
3005 : 6 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 645, __FILE__, __LINE__, true);
3006 : : return true;
3007 : : }
3008 : 0 : next_after_fail894:;
3009 : 0 : return false;
3010 : : }
3011 : :
3012 : : bool
3013 : 167691 : gimple_simplify_451 (gimple_match_op *res_op, gimple_seq *seq,
3014 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3015 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3016 : : const enum tree_code ARG_UNUSED (code2),
3017 : : const enum tree_code ARG_UNUSED (code1))
3018 : : {
3019 : 167691 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3020 : 167691 : if ((TREE_CODE (captures[2]) == INTEGER_CST
3021 : 60778 : && TREE_CODE (captures[5]) == INTEGER_CST)
3022 : 183117 : || ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
3023 : 27259 : || POINTER_TYPE_P (TREE_TYPE (captures[2])))
3024 : 117250 : && bitwise_equal_p (captures[2], captures[5]))
3025 : : )
3026 : : {
3027 : 45361 : {
3028 : 45361 : bool one_before = false;
3029 : 45361 : bool one_after = false;
3030 : 45361 : int cmp = 0;
3031 : 45361 : bool allbits = true;
3032 : 45361 : if (TREE_CODE (captures[2]) == INTEGER_CST
3033 : 45352 : && TREE_CODE (captures[5]) == INTEGER_CST)
3034 : : {
3035 : 45352 : allbits = TYPE_PRECISION (TREE_TYPE (captures[2])) <= TYPE_PRECISION (TREE_TYPE (captures[5]));
3036 : 45352 : auto t1 = wi::to_wide (fold_convert (TREE_TYPE (captures[5]), captures[2]));
3037 : 45352 : auto t2 = wi::to_wide (captures[5]);
3038 : 45352 : cmp = wi::cmp (t1, t2, TYPE_SIGN (TREE_TYPE (captures[5])));
3039 : 45352 : if (cmp < 0
3040 : 45352 : && t1 == t2 - 1)
3041 : : one_before = true;
3042 : 45352 : if (cmp > 0
3043 : 45352 : && t1 == t2 + 1)
3044 : : one_after = true;
3045 : : }
3046 : 45361 : bool val;
3047 : 45361 : switch (code2)
3048 : : {
3049 : 188 : case EQ_EXPR: val = (cmp == 0); break;
3050 : 42545 : case NE_EXPR: val = (cmp != 0); break;
3051 : 20 : case LT_EXPR: val = (cmp < 0); break;
3052 : 1614 : case GT_EXPR: val = (cmp > 0); break;
3053 : 909 : case LE_EXPR: val = (cmp <= 0); break;
3054 : 85 : case GE_EXPR: val = (cmp >= 0); break;
3055 : 0 : default: gcc_unreachable ();
3056 : : }
3057 : 45361 : if (code1 == EQ_EXPR && val
3058 : : )
3059 : : {
3060 : 249 : gimple_seq *lseq = seq;
3061 : 249 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail902;
3062 : 249 : {
3063 : 249 : tree tem;
3064 : 249 : tem = captures[0];
3065 : 249 : res_op->set_value (tem);
3066 : 249 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 630, __FILE__, __LINE__, true);
3067 : 249 : return true;
3068 : : }
3069 : 0 : next_after_fail902:;
3070 : : }
3071 : : else
3072 : : {
3073 : 45112 : if (code1 == EQ_EXPR && !val
3074 : : )
3075 : : {
3076 : 2 : gimple_seq *lseq = seq;
3077 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail903;
3078 : 2 : {
3079 : 2 : tree tem;
3080 : 2 : tem = constant_boolean_node (false, type);
3081 : 2 : res_op->set_value (tem);
3082 : 2 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 631, __FILE__, __LINE__, true);
3083 : 2 : return true;
3084 : : }
3085 : 0 : next_after_fail903:;
3086 : : }
3087 : : else
3088 : : {
3089 : 45110 : if (code1 == NE_EXPR && !val && allbits
3090 : : )
3091 : : {
3092 : 198 : gimple_seq *lseq = seq;
3093 : 198 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail904;
3094 : 198 : {
3095 : 198 : tree tem;
3096 : 198 : tem = captures[3];
3097 : 198 : res_op->set_value (tem);
3098 : 198 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 632, __FILE__, __LINE__, true);
3099 : 198 : return true;
3100 : : }
3101 : 0 : next_after_fail904:;
3102 : 0 : }
3103 : : else
3104 : : {
3105 : 44912 : if (code1 == NE_EXPR
3106 : 44912 : && code2 == GE_EXPR
3107 : 74 : && cmp == 0
3108 : 74 : && allbits
3109 : : )
3110 : : {
3111 : 4 : gimple_seq *lseq = seq;
3112 : 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail905;
3113 : 4 : {
3114 : 4 : res_op->set_op (GT_EXPR, type, 2);
3115 : 4 : res_op->ops[0] = captures[4];
3116 : 4 : {
3117 : 4 : tree _o1[1], _r1;
3118 : 4 : _o1[0] = captures[2];
3119 : 4 : if (TREE_TYPE (res_op->ops[0]) != TREE_TYPE (_o1[0])
3120 : 4 : && !useless_type_conversion_p (TREE_TYPE (res_op->ops[0]), TREE_TYPE (_o1[0])))
3121 : : {
3122 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, TREE_TYPE (res_op->ops[0]), _o1[0]);
3123 : 0 : tem_op.resimplify (lseq, valueize);
3124 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3125 : 0 : if (!_r1) goto next_after_fail905;
3126 : : }
3127 : : else
3128 : : _r1 = _o1[0];
3129 : 4 : res_op->ops[1] = _r1;
3130 : : }
3131 : 4 : res_op->resimplify (lseq, valueize);
3132 : 4 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 633, __FILE__, __LINE__, true);
3133 : 4 : return true;
3134 : : }
3135 : : next_after_fail905:;
3136 : : }
3137 : : else
3138 : : {
3139 : 44908 : if (code1 == NE_EXPR
3140 : 44908 : && code2 == LE_EXPR
3141 : 892 : && cmp == 0
3142 : 892 : && allbits
3143 : : )
3144 : : {
3145 : 6 : gimple_seq *lseq = seq;
3146 : 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail906;
3147 : 6 : {
3148 : 6 : res_op->set_op (LT_EXPR, type, 2);
3149 : 6 : res_op->ops[0] = captures[4];
3150 : 6 : {
3151 : 6 : tree _o1[1], _r1;
3152 : 6 : _o1[0] = captures[2];
3153 : 6 : if (TREE_TYPE (res_op->ops[0]) != TREE_TYPE (_o1[0])
3154 : 6 : && !useless_type_conversion_p (TREE_TYPE (res_op->ops[0]), TREE_TYPE (_o1[0])))
3155 : : {
3156 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, TREE_TYPE (res_op->ops[0]), _o1[0]);
3157 : 0 : tem_op.resimplify (lseq, valueize);
3158 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3159 : 0 : if (!_r1) goto next_after_fail906;
3160 : : }
3161 : : else
3162 : : _r1 = _o1[0];
3163 : 6 : res_op->ops[1] = _r1;
3164 : : }
3165 : 6 : res_op->resimplify (lseq, valueize);
3166 : 6 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 634, __FILE__, __LINE__, true);
3167 : 6 : return true;
3168 : : }
3169 : : next_after_fail906:;
3170 : : }
3171 : : else
3172 : : {
3173 : 44902 : if (code1 == NE_EXPR
3174 : 44902 : && code2 == GT_EXPR
3175 : : && one_after
3176 : 1580 : && allbits
3177 : : )
3178 : : {
3179 : 107 : gimple_seq *lseq = seq;
3180 : 107 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail907;
3181 : 107 : {
3182 : 107 : res_op->set_op (GT_EXPR, type, 2);
3183 : 107 : res_op->ops[0] = captures[4];
3184 : 107 : {
3185 : 107 : tree _o1[1], _r1;
3186 : 107 : _o1[0] = captures[2];
3187 : 107 : if (TREE_TYPE (res_op->ops[0]) != TREE_TYPE (_o1[0])
3188 : 107 : && !useless_type_conversion_p (TREE_TYPE (res_op->ops[0]), TREE_TYPE (_o1[0])))
3189 : : {
3190 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, TREE_TYPE (res_op->ops[0]), _o1[0]);
3191 : 0 : tem_op.resimplify (lseq, valueize);
3192 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3193 : 0 : if (!_r1) goto next_after_fail907;
3194 : : }
3195 : : else
3196 : : _r1 = _o1[0];
3197 : 107 : res_op->ops[1] = _r1;
3198 : : }
3199 : 107 : res_op->resimplify (lseq, valueize);
3200 : 107 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 635, __FILE__, __LINE__, true);
3201 : 107 : return true;
3202 : : }
3203 : : next_after_fail907:;
3204 : : }
3205 : : else
3206 : : {
3207 : 44795 : if (code1 == NE_EXPR
3208 : 44795 : && code2 == LT_EXPR
3209 : : && one_before
3210 : 15 : && allbits
3211 : : )
3212 : : {
3213 : 4 : gimple_seq *lseq = seq;
3214 : 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail908;
3215 : 4 : {
3216 : 4 : res_op->set_op (LT_EXPR, type, 2);
3217 : 4 : res_op->ops[0] = captures[4];
3218 : 4 : {
3219 : 4 : tree _o1[1], _r1;
3220 : 4 : _o1[0] = captures[2];
3221 : 4 : if (TREE_TYPE (res_op->ops[0]) != TREE_TYPE (_o1[0])
3222 : 4 : && !useless_type_conversion_p (TREE_TYPE (res_op->ops[0]), TREE_TYPE (_o1[0])))
3223 : : {
3224 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, TREE_TYPE (res_op->ops[0]), _o1[0]);
3225 : 0 : tem_op.resimplify (lseq, valueize);
3226 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3227 : 0 : if (!_r1) goto next_after_fail908;
3228 : : }
3229 : : else
3230 : : _r1 = _o1[0];
3231 : 4 : res_op->ops[1] = _r1;
3232 : : }
3233 : 4 : res_op->resimplify (lseq, valueize);
3234 : 4 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 636, __FILE__, __LINE__, true);
3235 : 4 : return true;
3236 : : }
3237 : : next_after_fail908:;
3238 : : }
3239 : : }
3240 : : }
3241 : : }
3242 : : }
3243 : : }
3244 : : }
3245 : : }
3246 : : }
3247 : : return false;
3248 : : }
3249 : :
3250 : : bool
3251 : 3 : gimple_simplify_477 (gimple_match_op *res_op, gimple_seq *seq,
3252 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3253 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3254 : : const enum tree_code ARG_UNUSED (rotate))
3255 : : {
3256 : 3 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3257 : 3 : if ((element_precision (TREE_TYPE (captures[2]))
3258 : 3 : <= element_precision (TREE_TYPE (captures[3]))
3259 : 0 : || !TYPE_UNSIGNED (TREE_TYPE (captures[3])))
3260 : 3 : && (element_precision (type) <= element_precision (TREE_TYPE (captures[2]))
3261 : 0 : || !TYPE_UNSIGNED (TREE_TYPE (captures[2])))
3262 : : )
3263 : : {
3264 : 3 : {
3265 : 3 : tree rotate_type = TREE_TYPE (captures[2]);
3266 : 3 : gimple_seq *lseq = seq;
3267 : 3 : if (lseq
3268 : 3 : && (!single_use (captures[0])
3269 : 3 : || !single_use (captures[1])))
3270 : 0 : lseq = NULL;
3271 : 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail941;
3272 : 3 : {
3273 : 3 : res_op->set_op (NOP_EXPR, type, 1);
3274 : 3 : {
3275 : 3 : tree _o1[2], _r1;
3276 : 3 : {
3277 : 3 : tree _o2[1], _r2;
3278 : 3 : _o2[0] = captures[3];
3279 : 3 : if (rotate_type != TREE_TYPE (_o2[0])
3280 : 3 : && !useless_type_conversion_p (rotate_type, TREE_TYPE (_o2[0])))
3281 : : {
3282 : 1 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, rotate_type, _o2[0]);
3283 : 1 : tem_op.resimplify (lseq, valueize);
3284 : 1 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
3285 : 1 : if (!_r2) goto next_after_fail941;
3286 : : }
3287 : : else
3288 : : _r2 = _o2[0];
3289 : 3 : _o1[0] = _r2;
3290 : : }
3291 : 3 : _o1[1] = captures[4];
3292 : 3 : gimple_match_op tem_op (res_op->cond.any_else (), rotate, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3293 : 3 : tem_op.resimplify (lseq, valueize);
3294 : 3 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3295 : 3 : if (!_r1) goto next_after_fail941;
3296 : 3 : res_op->ops[0] = _r1;
3297 : : }
3298 : 3 : res_op->resimplify (lseq, valueize);
3299 : 3 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 663, __FILE__, __LINE__, true);
3300 : 3 : return true;
3301 : : }
3302 : : next_after_fail941:;
3303 : : }
3304 : : }
3305 : : return false;
3306 : : }
3307 : :
3308 : : bool
3309 : 286 : gimple_simplify_492 (gimple_match_op *res_op, gimple_seq *seq,
3310 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3311 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3312 : : const combined_fn ARG_UNUSED (minmax))
3313 : : {
3314 : 286 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3315 : 286 : if (!tree_expr_maybe_signaling_nan_p (captures[0])
3316 : : )
3317 : : {
3318 : 170 : gimple_seq *lseq = seq;
3319 : 170 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail969;
3320 : 170 : {
3321 : 170 : tree tem;
3322 : 170 : tem = captures[0];
3323 : 170 : res_op->set_value (tem);
3324 : 170 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 679, __FILE__, __LINE__, true);
3325 : 170 : return true;
3326 : : }
3327 : 0 : next_after_fail969:;
3328 : : }
3329 : : return false;
3330 : : }
3331 : :
3332 : : bool
3333 : 5583 : gimple_simplify_495 (gimple_match_op *res_op, gimple_seq *seq,
3334 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3335 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3336 : : const combined_fn ARG_UNUSED (FMAX_ALL))
3337 : : {
3338 : 5583 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3339 : 5583 : if (flag_finite_math_only
3340 : : )
3341 : : {
3342 : 93 : gimple_seq *lseq = seq;
3343 : 93 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail972;
3344 : 93 : {
3345 : 93 : res_op->set_op (MAX_EXPR, type, 2);
3346 : 93 : res_op->ops[0] = captures[0];
3347 : 93 : res_op->ops[1] = captures[1];
3348 : 93 : res_op->resimplify (lseq, valueize);
3349 : 93 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 682, __FILE__, __LINE__, true);
3350 : 93 : return true;
3351 : : }
3352 : 0 : next_after_fail972:;
3353 : : }
3354 : : return false;
3355 : : }
3356 : :
3357 : : bool
3358 : 1 : gimple_simplify_501 (gimple_match_op *res_op, gimple_seq *seq,
3359 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3360 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3361 : : const enum tree_code ARG_UNUSED (op))
3362 : : {
3363 : 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3364 : 1 : gimple_seq *lseq = seq;
3365 : 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail978;
3366 : 1 : {
3367 : 1 : tree tem;
3368 : 1 : tem = captures[2];
3369 : 1 : res_op->set_value (tem);
3370 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 688, __FILE__, __LINE__, true);
3371 : : return true;
3372 : : }
3373 : 0 : next_after_fail978:;
3374 : 0 : return false;
3375 : : }
3376 : :
3377 : : bool
3378 : 2325 : gimple_simplify_509 (gimple_match_op *res_op, gimple_seq *seq,
3379 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3380 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3381 : : const enum tree_code ARG_UNUSED (cmp))
3382 : : {
3383 : 2325 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3384 : 2325 : if (!HONOR_SIGNED_ZEROS (type)
3385 : 2325 : && (
3386 : 2325 : (INTEGRAL_TYPE_P (type)
3387 : 2319 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
3388 : 2319 : && types_match (TREE_TYPE (captures[2]), TREE_TYPE (captures[3]))
3389 : 0 : && TYPE_PRECISION (TREE_TYPE (captures[1])) <= TYPE_PRECISION (type)
3390 : 0 : && TYPE_PRECISION (TREE_TYPE (captures[3])) <= TYPE_PRECISION (type))
3391 : 2325 : || (types_match (type, TREE_TYPE (captures[1]))
3392 : 2271 : && types_match (type, TREE_TYPE (captures[3]))))
3393 : : )
3394 : : {
3395 : 0 : if (cmp == EQ_EXPR
3396 : : )
3397 : : {
3398 : 0 : if (VECTOR_TYPE_P (type)
3399 : : )
3400 : : {
3401 : 0 : gimple_seq *lseq = seq;
3402 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1011;
3403 : 0 : {
3404 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
3405 : 0 : res_op->ops[0] = captures[2];
3406 : 0 : res_op->resimplify (lseq, valueize);
3407 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 697, __FILE__, __LINE__, true);
3408 : 0 : return true;
3409 : : }
3410 : 0 : next_after_fail1011:;
3411 : : }
3412 : : else
3413 : : {
3414 : 0 : gimple_seq *lseq = seq;
3415 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1012;
3416 : 0 : {
3417 : 0 : res_op->set_op (NOP_EXPR, type, 1);
3418 : 0 : res_op->ops[0] = captures[2];
3419 : 0 : res_op->resimplify (lseq, valueize);
3420 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 698, __FILE__, __LINE__, true);
3421 : 0 : return true;
3422 : : }
3423 : 0 : next_after_fail1012:;
3424 : : }
3425 : : }
3426 : : else
3427 : : {
3428 : : if (cmp == NE_EXPR
3429 : : )
3430 : : {
3431 : 0 : if (VECTOR_TYPE_P (type)
3432 : : )
3433 : : {
3434 : 0 : gimple_seq *lseq = seq;
3435 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1013;
3436 : 0 : {
3437 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
3438 : 0 : res_op->ops[0] = captures[0];
3439 : 0 : res_op->resimplify (lseq, valueize);
3440 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 699, __FILE__, __LINE__, true);
3441 : 0 : return true;
3442 : : }
3443 : 0 : next_after_fail1013:;
3444 : : }
3445 : : else
3446 : : {
3447 : 0 : gimple_seq *lseq = seq;
3448 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1014;
3449 : 0 : {
3450 : 0 : res_op->set_op (NOP_EXPR, type, 1);
3451 : 0 : res_op->ops[0] = captures[0];
3452 : 0 : res_op->resimplify (lseq, valueize);
3453 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 700, __FILE__, __LINE__, true);
3454 : 0 : return true;
3455 : : }
3456 : 0 : next_after_fail1014:;
3457 : : }
3458 : : }
3459 : : else
3460 : : {
3461 : : if (cmp == LE_EXPR || cmp == UNLE_EXPR || cmp == LT_EXPR || cmp == UNLT_EXPR
3462 : : )
3463 : : {
3464 : 0 : if (!HONOR_NANS (type)
3465 : : )
3466 : : {
3467 : 0 : if (VECTOR_TYPE_P (type)
3468 : : )
3469 : : {
3470 : 0 : gimple_seq *lseq = seq;
3471 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1015;
3472 : 0 : {
3473 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
3474 : 0 : {
3475 : 0 : tree _o1[2], _r1;
3476 : 0 : _o1[0] = captures[0];
3477 : 0 : _o1[1] = captures[2];
3478 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), MIN_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3479 : 0 : tem_op.resimplify (lseq, valueize);
3480 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3481 : 0 : if (!_r1) goto next_after_fail1015;
3482 : 0 : res_op->ops[0] = _r1;
3483 : : }
3484 : 0 : res_op->resimplify (lseq, valueize);
3485 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 701, __FILE__, __LINE__, true);
3486 : 0 : return true;
3487 : : }
3488 : : next_after_fail1015:;
3489 : : }
3490 : : else
3491 : : {
3492 : 0 : gimple_seq *lseq = seq;
3493 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1016;
3494 : 0 : {
3495 : 0 : res_op->set_op (NOP_EXPR, type, 1);
3496 : 0 : {
3497 : 0 : tree _o1[2], _r1;
3498 : 0 : _o1[0] = captures[0];
3499 : 0 : _o1[1] = captures[2];
3500 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), MIN_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3501 : 0 : tem_op.resimplify (lseq, valueize);
3502 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3503 : 0 : if (!_r1) goto next_after_fail1016;
3504 : 0 : res_op->ops[0] = _r1;
3505 : : }
3506 : 0 : res_op->resimplify (lseq, valueize);
3507 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 702, __FILE__, __LINE__, true);
3508 : 0 : return true;
3509 : : }
3510 : : next_after_fail1016:;
3511 : : }
3512 : : }
3513 : : }
3514 : : else
3515 : : {
3516 : : if (cmp == GE_EXPR || cmp == UNGE_EXPR || cmp == GT_EXPR || cmp == UNGT_EXPR
3517 : : )
3518 : : {
3519 : 0 : if (!HONOR_NANS (type)
3520 : : )
3521 : : {
3522 : 0 : if (VECTOR_TYPE_P (type)
3523 : : )
3524 : : {
3525 : 0 : gimple_seq *lseq = seq;
3526 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1017;
3527 : 0 : {
3528 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
3529 : 0 : {
3530 : 0 : tree _o1[2], _r1;
3531 : 0 : _o1[0] = captures[0];
3532 : 0 : _o1[1] = captures[2];
3533 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), MAX_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3534 : 0 : tem_op.resimplify (lseq, valueize);
3535 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3536 : 0 : if (!_r1) goto next_after_fail1017;
3537 : 0 : res_op->ops[0] = _r1;
3538 : : }
3539 : 0 : res_op->resimplify (lseq, valueize);
3540 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 703, __FILE__, __LINE__, true);
3541 : 0 : return true;
3542 : : }
3543 : : next_after_fail1017:;
3544 : : }
3545 : : else
3546 : : {
3547 : 0 : gimple_seq *lseq = seq;
3548 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1018;
3549 : 0 : {
3550 : 0 : res_op->set_op (NOP_EXPR, type, 1);
3551 : 0 : {
3552 : 0 : tree _o1[2], _r1;
3553 : 0 : _o1[0] = captures[0];
3554 : 0 : _o1[1] = captures[2];
3555 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), MAX_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3556 : 0 : tem_op.resimplify (lseq, valueize);
3557 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3558 : 0 : if (!_r1) goto next_after_fail1018;
3559 : 0 : res_op->ops[0] = _r1;
3560 : : }
3561 : 0 : res_op->resimplify (lseq, valueize);
3562 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 704, __FILE__, __LINE__, true);
3563 : 0 : return true;
3564 : : }
3565 : : next_after_fail1018:;
3566 : : }
3567 : : }
3568 : : }
3569 : : else
3570 : : {
3571 : : if (cmp == UNEQ_EXPR
3572 : : )
3573 : : {
3574 : 0 : if (!HONOR_NANS (type)
3575 : : )
3576 : : {
3577 : 0 : if (VECTOR_TYPE_P (type)
3578 : : )
3579 : : {
3580 : 0 : gimple_seq *lseq = seq;
3581 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1019;
3582 : 0 : {
3583 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
3584 : 0 : res_op->ops[0] = captures[2];
3585 : 0 : res_op->resimplify (lseq, valueize);
3586 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 705, __FILE__, __LINE__, true);
3587 : 0 : return true;
3588 : : }
3589 : 0 : next_after_fail1019:;
3590 : : }
3591 : : else
3592 : : {
3593 : 0 : gimple_seq *lseq = seq;
3594 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1020;
3595 : 0 : {
3596 : 0 : res_op->set_op (NOP_EXPR, type, 1);
3597 : 0 : res_op->ops[0] = captures[2];
3598 : 0 : res_op->resimplify (lseq, valueize);
3599 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 706, __FILE__, __LINE__, true);
3600 : 0 : return true;
3601 : : }
3602 : 0 : next_after_fail1020:;
3603 : : }
3604 : : }
3605 : : }
3606 : : else
3607 : : {
3608 : : if (cmp == LTGT_EXPR
3609 : : )
3610 : : {
3611 : 0 : if (!HONOR_NANS (type)
3612 : : )
3613 : : {
3614 : 0 : if (VECTOR_TYPE_P (type)
3615 : : )
3616 : : {
3617 : 0 : gimple_seq *lseq = seq;
3618 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1021;
3619 : 0 : {
3620 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
3621 : 0 : res_op->ops[0] = captures[0];
3622 : 0 : res_op->resimplify (lseq, valueize);
3623 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 707, __FILE__, __LINE__, true);
3624 : 0 : return true;
3625 : : }
3626 : 0 : next_after_fail1021:;
3627 : : }
3628 : : else
3629 : : {
3630 : 0 : gimple_seq *lseq = seq;
3631 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1022;
3632 : 0 : {
3633 : 0 : res_op->set_op (NOP_EXPR, type, 1);
3634 : 0 : res_op->ops[0] = captures[0];
3635 : 0 : res_op->resimplify (lseq, valueize);
3636 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 708, __FILE__, __LINE__, true);
3637 : 0 : return true;
3638 : : }
3639 : 0 : next_after_fail1022:;
3640 : : }
3641 : : }
3642 : : }
3643 : : }
3644 : : }
3645 : : }
3646 : : }
3647 : : }
3648 : : }
3649 : : return false;
3650 : : }
3651 : :
3652 : : bool
3653 : 8 : gimple_simplify_546 (gimple_match_op *res_op, gimple_seq *seq,
3654 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3655 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3656 : : const enum tree_code ARG_UNUSED (cmp))
3657 : : {
3658 : 8 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3659 : 8 : if (!HONOR_SIGNED_ZEROS (type)
3660 : 8 : && !TYPE_UNSIGNED (type)
3661 : : )
3662 : : {
3663 : 8 : gimple_seq *lseq = seq;
3664 : 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1077;
3665 : 8 : {
3666 : 8 : res_op->set_op (ABS_EXPR, type, 1);
3667 : 8 : res_op->ops[0] = captures[0];
3668 : 8 : res_op->resimplify (lseq, valueize);
3669 : 8 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 737, __FILE__, __LINE__, true);
3670 : 8 : return true;
3671 : : }
3672 : 0 : next_after_fail1077:;
3673 : : }
3674 : : return false;
3675 : : }
3676 : :
3677 : : bool
3678 : 8 : gimple_simplify_553 (gimple_match_op *res_op, gimple_seq *seq,
3679 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3680 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3681 : : const enum tree_code ARG_UNUSED (cmp))
3682 : : {
3683 : 8 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3684 : 8 : if (!HONOR_SIGNED_ZEROS (TREE_TYPE(captures[0]))
3685 : 8 : && !TYPE_UNSIGNED (TREE_TYPE(captures[0]))
3686 : 16 : && bitwise_equal_p (captures[0], captures[1])
3687 : : )
3688 : : {
3689 : 16 : if ((ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3690 : 6 : && !TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
3691 : 10 : || TYPE_UNSIGNED (type)
3692 : : )
3693 : : {
3694 : 6 : {
3695 : 6 : tree utype = unsigned_type_for (TREE_TYPE(captures[0]));
3696 : 6 : gimple_seq *lseq = seq;
3697 : 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1089;
3698 : 6 : {
3699 : 6 : res_op->set_op (NOP_EXPR, type, 1);
3700 : 6 : {
3701 : 6 : tree _o1[1], _r1;
3702 : 6 : {
3703 : 6 : tree _o2[1], _r2;
3704 : 6 : _o2[0] = captures[0];
3705 : 6 : gimple_match_op tem_op (res_op->cond.any_else (), ABSU_EXPR, utype, _o2[0]);
3706 : 6 : tem_op.resimplify (lseq, valueize);
3707 : 6 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
3708 : 6 : if (!_r2) goto next_after_fail1089;
3709 : 6 : _o1[0] = _r2;
3710 : : }
3711 : 6 : gimple_match_op tem_op (res_op->cond.any_else (), NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
3712 : 6 : tem_op.resimplify (lseq, valueize);
3713 : 6 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3714 : 6 : if (!_r1) goto next_after_fail1089;
3715 : 6 : res_op->ops[0] = _r1;
3716 : : }
3717 : 6 : res_op->resimplify (lseq, valueize);
3718 : 6 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 742, __FILE__, __LINE__, true);
3719 : 6 : return true;
3720 : : }
3721 : : next_after_fail1089:;
3722 : : }
3723 : : }
3724 : : else
3725 : : {
3726 : 2 : gimple_seq *lseq = seq;
3727 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1090;
3728 : 2 : {
3729 : 2 : res_op->set_op (NEGATE_EXPR, type, 1);
3730 : 2 : {
3731 : 2 : tree _o1[1], _r1;
3732 : 2 : _o1[0] = captures[0];
3733 : 2 : gimple_match_op tem_op (res_op->cond.any_else (), ABS_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
3734 : 2 : tem_op.resimplify (lseq, valueize);
3735 : 2 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3736 : 2 : if (!_r1) goto next_after_fail1090;
3737 : 2 : res_op->ops[0] = _r1;
3738 : : }
3739 : 2 : res_op->resimplify (lseq, valueize);
3740 : 2 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 743, __FILE__, __LINE__, true);
3741 : 2 : return true;
3742 : : }
3743 : : next_after_fail1090:;
3744 : : }
3745 : : }
3746 : : return false;
3747 : : }
3748 : :
3749 : : bool
3750 : 2593 : gimple_simplify_561 (gimple_match_op *res_op, gimple_seq *seq,
3751 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3752 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3753 : : const combined_fn ARG_UNUSED (func))
3754 : : {
3755 : 2593 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3756 : 2593 : {
3757 : 2593 : int val;
3758 : 2593 : internal_fn ifn = IFN_LAST;
3759 : 2593 : if (TREE_CODE (TREE_TYPE (captures[2])) == BITINT_TYPE)
3760 : : {
3761 : 0 : if (tree_fits_shwi_p (captures[3]))
3762 : : {
3763 : 0 : HOST_WIDE_INT valw = tree_to_shwi (captures[3]);
3764 : 0 : if ((int) valw == valw)
3765 : : {
3766 : 0 : val = valw;
3767 : 0 : ifn = IFN_CLZ;
3768 : : }
3769 : : }
3770 : : }
3771 : 2593 : else if (direct_internal_fn_supported_p (IFN_CLZ, TREE_TYPE (captures[2]),
3772 : : OPTIMIZE_FOR_BOTH)
3773 : 5142 : && CLZ_DEFINED_VALUE_AT_ZERO
3774 : : (SCALAR_INT_TYPE_MODE (TREE_TYPE (captures[2])), val) == 2)
3775 : 29 : ifn = IFN_CLZ;
3776 : 2593 : if (ifn == IFN_CLZ && wi::to_widest (captures[3]) == val
3777 : : )
3778 : : {
3779 : 29 : gimple_seq *lseq = seq;
3780 : 29 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1101;
3781 : 29 : {
3782 : 29 : res_op->set_op (CFN_CLZ, type, 2);
3783 : 29 : res_op->ops[0] = captures[2];
3784 : 29 : res_op->ops[1] = captures[3];
3785 : 29 : res_op->resimplify (lseq, valueize);
3786 : 29 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 752, __FILE__, __LINE__, true);
3787 : 29 : return true;
3788 : : }
3789 : 0 : next_after_fail1101:;
3790 : : }
3791 : : }
3792 : 2564 : return false;
3793 : : }
3794 : :
3795 : : bool
3796 : 4 : gimple_simplify_572 (gimple_match_op *res_op, gimple_seq *seq,
3797 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3798 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3799 : : const combined_fn ARG_UNUSED (bswap))
3800 : : {
3801 : 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3802 : 4 : gimple_seq *lseq = seq;
3803 : 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1114;
3804 : 4 : {
3805 : 4 : res_op->set_op (BIT_NOT_EXPR, type, 1);
3806 : 4 : res_op->ops[0] = captures[0];
3807 : 4 : res_op->resimplify (lseq, valueize);
3808 : 4 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 762, __FILE__, __LINE__, true);
3809 : : return true;
3810 : : }
3811 : 0 : next_after_fail1114:;
3812 : 0 : return false;
3813 : : }
3814 : :
3815 : : bool
3816 : 0 : gimple_simplify_580 (gimple_match_op *res_op, gimple_seq *seq,
3817 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3818 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3819 : : const enum tree_code ARG_UNUSED (cmp))
3820 : : {
3821 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3822 : 0 : gimple_seq *lseq = seq;
3823 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1122;
3824 : 0 : {
3825 : 0 : tree tem;
3826 : 0 : tem = captures[3];
3827 : 0 : res_op->set_value (tem);
3828 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 728, __FILE__, __LINE__, true);
3829 : : return true;
3830 : : }
3831 : 0 : next_after_fail1122:;
3832 : 0 : return false;
3833 : : }
3834 : :
3835 : : bool
3836 : 0 : gimple_simplify_587 (gimple_match_op *res_op, gimple_seq *seq,
3837 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3838 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3839 : : const combined_fn ARG_UNUSED (cond_op))
3840 : : {
3841 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3842 : 0 : {
3843 : 0 : tree op_type = TREE_TYPE (captures[6]);
3844 : 0 : if (inverse_conditions_p (captures[0], captures[2])
3845 : 0 : && element_precision (type) == element_precision (op_type)
3846 : : )
3847 : : {
3848 : 0 : gimple_seq *lseq = seq;
3849 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1129;
3850 : 0 : {
3851 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
3852 : 0 : {
3853 : 0 : tree _o1[5], _r1;
3854 : 0 : _o1[0] = captures[2];
3855 : 0 : _o1[1] = captures[3];
3856 : 0 : _o1[2] = captures[4];
3857 : 0 : _o1[3] = captures[5];
3858 : 0 : {
3859 : 0 : tree _o2[1], _r2;
3860 : 0 : _o2[0] = captures[1];
3861 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, op_type, _o2[0]);
3862 : 0 : tem_op.resimplify (lseq, valueize);
3863 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
3864 : 0 : if (!_r2) goto next_after_fail1129;
3865 : 0 : _o1[4] = _r2;
3866 : : }
3867 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), cond_op, TREE_TYPE (_o1[1]), _o1[0], _o1[1], _o1[2], _o1[3], _o1[4]);
3868 : 0 : tem_op.resimplify (lseq, valueize);
3869 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3870 : 0 : if (!_r1) goto next_after_fail1129;
3871 : 0 : res_op->ops[0] = _r1;
3872 : : }
3873 : 0 : res_op->resimplify (lseq, valueize);
3874 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 772, __FILE__, __LINE__, true);
3875 : 0 : return true;
3876 : : }
3877 : : next_after_fail1129:;
3878 : : }
3879 : : }
3880 : : return false;
3881 : : }
3882 : :
3883 : : bool
3884 : 744998 : gimple_simplify_594 (gimple_match_op *res_op, gimple_seq *seq,
3885 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3886 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3887 : : const enum tree_code ARG_UNUSED (cmp))
3888 : : {
3889 : 744998 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3890 : 744998 : if (REAL_VALUE_ISNAN (TREE_REAL_CST (captures[1]))
3891 : 744998 : && (cmp != LTGT_EXPR || ! flag_trapping_math)
3892 : : )
3893 : : {
3894 : 0 : gimple_seq *lseq = seq;
3895 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1136;
3896 : 0 : {
3897 : 0 : tree tem;
3898 : 0 : tem = constant_boolean_node (cmp == ORDERED_EXPR || cmp == LTGT_EXPR
3899 : 0 : ? false : true, type);
3900 : 0 : res_op->set_value (tem);
3901 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 779, __FILE__, __LINE__, true);
3902 : 0 : return true;
3903 : : }
3904 : 0 : next_after_fail1136:;
3905 : : }
3906 : : return false;
3907 : : }
3908 : :
3909 : : bool
3910 : 17119 : gimple_simplify_597 (gimple_match_op *res_op, gimple_seq *seq,
3911 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3912 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3913 : : const combined_fn ARG_UNUSED (ovf))
3914 : : {
3915 : 17119 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3916 : 34238 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
3917 : 17119 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3918 : 17119 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (TREE_TYPE (captures[1]))
3919 : 32556 : && (!TYPE_UNSIGNED (TREE_TYPE (captures[0])) || TYPE_UNSIGNED (TREE_TYPE (captures[1])))
3920 : : )
3921 : : {
3922 : 14522 : gimple_seq *lseq = seq;
3923 : 14522 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1139;
3924 : 14522 : {
3925 : 14522 : res_op->set_op (ovf, type, 2);
3926 : 14522 : res_op->ops[0] = captures[1];
3927 : 14522 : res_op->ops[1] = captures[2];
3928 : 14522 : res_op->resimplify (lseq, valueize);
3929 : 14522 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 782, __FILE__, __LINE__, true);
3930 : 14522 : return true;
3931 : : }
3932 : 0 : next_after_fail1139:;
3933 : : }
3934 : : return false;
3935 : : }
3936 : :
3937 : : bool
3938 : 94 : gimple_simplify_607 (gimple_match_op *res_op, gimple_seq *seq,
3939 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3940 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3941 : : const combined_fn ARG_UNUSED (floors),
3942 : : const combined_fn ARG_UNUSED (truncs))
3943 : : {
3944 : 94 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3945 : 94 : if (canonicalize_math_p ()
3946 : : )
3947 : : {
3948 : 94 : gimple_seq *lseq = seq;
3949 : 94 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1149;
3950 : 94 : {
3951 : 94 : res_op->set_op (truncs, type, 1);
3952 : 94 : res_op->ops[0] = captures[0];
3953 : 94 : res_op->resimplify (lseq, valueize);
3954 : 94 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 792, __FILE__, __LINE__, true);
3955 : 94 : return true;
3956 : : }
3957 : 0 : next_after_fail1149:;
3958 : : }
3959 : : return false;
3960 : : }
3961 : :
3962 : : bool
3963 : 2947 : gimple_simplify_614 (gimple_match_op *res_op, gimple_seq *seq,
3964 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3965 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3966 : : const combined_fn ARG_UNUSED (ifn),
3967 : : const combined_fn ARG_UNUSED (lfn),
3968 : : const combined_fn ARG_UNUSED (llfn))
3969 : : {
3970 : 2947 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3971 : 2947 : if (canonicalize_math_p ()
3972 : : )
3973 : : {
3974 : 2033 : if (TYPE_PRECISION (integer_type_node)
3975 : 2033 : == TYPE_PRECISION (long_integer_type_node)
3976 : : )
3977 : : {
3978 : 12 : gimple_seq *lseq = seq;
3979 : 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1156;
3980 : 12 : {
3981 : 12 : res_op->set_op (lfn, type, 1);
3982 : 12 : res_op->ops[0] = captures[0];
3983 : 12 : res_op->resimplify (lseq, valueize);
3984 : 12 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 799, __FILE__, __LINE__, true);
3985 : 12 : return true;
3986 : : }
3987 : 0 : next_after_fail1156:;
3988 : : }
3989 : : }
3990 : : return false;
3991 : : }
3992 : :
3993 : : bool
3994 : 0 : gimple_simplify_623 (gimple_match_op *res_op, gimple_seq *seq,
3995 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3996 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
3997 : : {
3998 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3999 : 0 : if (canonicalize_math_after_vectorization_p ()
4000 : : )
4001 : : {
4002 : 0 : gimple_seq *lseq = seq;
4003 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1165;
4004 : 0 : {
4005 : 0 : res_op->set_op (CFN_FNMA, type, 3);
4006 : 0 : res_op->ops[0] = captures[0];
4007 : 0 : res_op->ops[1] = captures[1];
4008 : 0 : res_op->ops[2] = captures[2];
4009 : 0 : res_op->resimplify (lseq, valueize);
4010 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 808, __FILE__, __LINE__, true);
4011 : 0 : return true;
4012 : : }
4013 : 0 : next_after_fail1165:;
4014 : : }
4015 : : return false;
4016 : : }
4017 : :
4018 : : bool
4019 : 2323 : gimple_simplify_631 (gimple_match_op *res_op, gimple_seq *seq,
4020 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4021 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
4022 : : const combined_fn ARG_UNUSED (POPCOUNT))
4023 : : {
4024 : 2323 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4025 : 4646 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4026 : 2323 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
4027 : 2323 : && TYPE_UNSIGNED (TREE_TYPE (captures[1]))
4028 : 3544 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (TREE_TYPE (captures[1]))
4029 : : )
4030 : : {
4031 : 978 : {
4032 : 978 : combined_fn cfn = CFN_LAST;
4033 : 978 : tree type0 = TREE_TYPE (captures[1]);
4034 : 978 : if (TREE_CODE (type0) == BITINT_TYPE)
4035 : : {
4036 : 4 : if (TYPE_PRECISION (type0) > MAX_FIXED_MODE_SIZE)
4037 : : cfn = CFN_POPCOUNT;
4038 : : else
4039 : 0 : type0
4040 : 0 : = build_nonstandard_integer_type (TYPE_PRECISION (type0),
4041 : : 1);
4042 : : }
4043 : 0 : if (cfn == CFN_LAST
4044 : 976 : && direct_internal_fn_supported_p (IFN_POPCOUNT, type0,
4045 : : OPTIMIZE_FOR_BOTH))
4046 : : cfn = CFN_POPCOUNT;
4047 : 948 : if (cfn == CFN_LAST
4048 : 1195 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > BITS_PER_WORD
4049 : 948 : && !direct_internal_fn_supported_p (IFN_POPCOUNT,
4050 : 0 : TREE_TYPE (captures[0]),
4051 : : OPTIMIZE_FOR_BOTH))
4052 : : {
4053 : 0 : if (TYPE_PRECISION (type0)
4054 : 0 : == TYPE_PRECISION (unsigned_type_node))
4055 : : cfn = CFN_BUILT_IN_POPCOUNT;
4056 : 0 : else if (TYPE_PRECISION (type0)
4057 : 0 : == TYPE_PRECISION (long_long_unsigned_type_node))
4058 : : cfn = CFN_BUILT_IN_POPCOUNTLL;
4059 : : }
4060 : 978 : if (cfn == CFN_POPCOUNT
4061 : : )
4062 : : {
4063 : 32 : gimple_seq *lseq = seq;
4064 : 32 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1175;
4065 : 32 : {
4066 : 32 : res_op->set_op (CFN_POPCOUNT, type, 1);
4067 : 32 : {
4068 : 32 : tree _o1[1], _r1;
4069 : 32 : _o1[0] = captures[1];
4070 : 32 : if (type0 != TREE_TYPE (_o1[0])
4071 : 32 : && !useless_type_conversion_p (type0, TREE_TYPE (_o1[0])))
4072 : : {
4073 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type0, _o1[0]);
4074 : 0 : tem_op.resimplify (lseq, valueize);
4075 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4076 : 0 : if (!_r1) goto next_after_fail1175;
4077 : : }
4078 : : else
4079 : : _r1 = _o1[0];
4080 : 32 : res_op->ops[0] = _r1;
4081 : : }
4082 : 32 : res_op->resimplify (lseq, valueize);
4083 : 32 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 818, __FILE__, __LINE__, true);
4084 : 32 : return true;
4085 : : }
4086 : : next_after_fail1175:;
4087 : : }
4088 : : else
4089 : : {
4090 : 946 : if (cfn == CFN_BUILT_IN_POPCOUNT
4091 : : )
4092 : : {
4093 : 0 : gimple_seq *lseq = seq;
4094 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1176;
4095 : 0 : {
4096 : 0 : res_op->set_op (CFN_BUILT_IN_POPCOUNT, type, 1);
4097 : 0 : {
4098 : 0 : tree _o1[1], _r1;
4099 : 0 : _o1[0] = captures[1];
4100 : 0 : if (type0 != TREE_TYPE (_o1[0])
4101 : 0 : && !useless_type_conversion_p (type0, TREE_TYPE (_o1[0])))
4102 : : {
4103 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type0, _o1[0]);
4104 : 0 : tem_op.resimplify (lseq, valueize);
4105 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4106 : 0 : if (!_r1) goto next_after_fail1176;
4107 : : }
4108 : : else
4109 : : _r1 = _o1[0];
4110 : 0 : res_op->ops[0] = _r1;
4111 : : }
4112 : 0 : res_op->resimplify (lseq, valueize);
4113 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 819, __FILE__, __LINE__, true);
4114 : 0 : return true;
4115 : : }
4116 : : next_after_fail1176:;
4117 : : }
4118 : : else
4119 : : {
4120 : 946 : if (cfn == CFN_BUILT_IN_POPCOUNTLL
4121 : : )
4122 : : {
4123 : 0 : gimple_seq *lseq = seq;
4124 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1177;
4125 : 0 : {
4126 : 0 : res_op->set_op (CFN_BUILT_IN_POPCOUNTLL, type, 1);
4127 : 0 : {
4128 : 0 : tree _o1[1], _r1;
4129 : 0 : _o1[0] = captures[1];
4130 : 0 : if (type0 != TREE_TYPE (_o1[0])
4131 : 0 : && !useless_type_conversion_p (type0, TREE_TYPE (_o1[0])))
4132 : : {
4133 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type0, _o1[0]);
4134 : 0 : tem_op.resimplify (lseq, valueize);
4135 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4136 : 0 : if (!_r1) goto next_after_fail1177;
4137 : : }
4138 : : else
4139 : : _r1 = _o1[0];
4140 : 0 : res_op->ops[0] = _r1;
4141 : : }
4142 : 0 : res_op->resimplify (lseq, valueize);
4143 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 820, __FILE__, __LINE__, true);
4144 : 0 : return true;
4145 : : }
4146 : : next_after_fail1177:;
4147 : : }
4148 : : }
4149 : : }
4150 : : }
4151 : : }
4152 : : return false;
4153 : : }
4154 : :
4155 : : bool
4156 : 68561254 : gimple_simplify_CONVERT_EXPR (gimple_match_op *res_op, gimple_seq *seq,
4157 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4158 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
4159 : : {
4160 : 68561254 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4161 : 68561254 : switch (TREE_CODE (_p0))
4162 : : {
4163 : 65527111 : case SSA_NAME:
4164 : 65527111 : if (gimple *_d1 = get_def (valueize, _p0))
4165 : : {
4166 : 32278024 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
4167 : 31313515 : switch (gimple_assign_rhs_code (_a1))
4168 : : {
4169 : 48589 : case NEGATE_EXPR:
4170 : 48589 : {
4171 : 48589 : tree _q20 = gimple_assign_rhs1 (_a1);
4172 : 48589 : _q20 = do_valueize (valueize, _q20);
4173 : 48589 : switch (TREE_CODE (_q20))
4174 : : {
4175 : 48589 : case SSA_NAME:
4176 : 48589 : if (gimple *_d2 = get_def (valueize, _q20))
4177 : : {
4178 : 44990 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
4179 : 35962 : switch (gimple_assign_rhs_code (_a2))
4180 : : {
4181 : 21286 : CASE_CONVERT:
4182 : 21286 : {
4183 : 21286 : tree _q30 = gimple_assign_rhs1 (_a2);
4184 : 21286 : _q30 = do_valueize (valueize, _q30);
4185 : 21286 : {
4186 : 21286 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q30 };
4187 : 21286 : if (INTEGRAL_TYPE_P (type)
4188 : 19923 : && tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
4189 : 17012 : && TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (captures[2]))
4190 : 27727 : && TREE_CODE (type) != BOOLEAN_TYPE
4191 : : )
4192 : : {
4193 : 686 : gimple_seq *lseq = seq;
4194 : 686 : if (lseq
4195 : 185 : && (!single_use (captures[0])
4196 : 74 : || !single_use (captures[1])))
4197 : 615 : lseq = NULL;
4198 : 686 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1205;
4199 : 686 : {
4200 : 686 : res_op->set_op (NEGATE_EXPR, type, 1);
4201 : 686 : {
4202 : 686 : tree _o1[1], _r1;
4203 : 686 : _o1[0] = captures[2];
4204 : 686 : if (type != TREE_TYPE (_o1[0])
4205 : 686 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
4206 : : {
4207 : 686 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
4208 : 686 : tem_op.resimplify (lseq, valueize);
4209 : 686 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4210 : 686 : if (!_r1) goto next_after_fail1205;
4211 : : }
4212 : : else
4213 : : _r1 = _o1[0];
4214 : 109 : res_op->ops[0] = _r1;
4215 : : }
4216 : 109 : res_op->resimplify (lseq, valueize);
4217 : 109 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 844, __FILE__, __LINE__, true);
4218 : 109 : return true;
4219 : : }
4220 : 21177 : next_after_fail1205:;
4221 : : }
4222 : : }
4223 : 21177 : break;
4224 : : }
4225 : : default:;
4226 : : }
4227 : : }
4228 : : break;
4229 : : default:;
4230 : : }
4231 : : break;
4232 : : }
4233 : 557148 : case BIT_AND_EXPR:
4234 : 557148 : {
4235 : 557148 : tree _q20 = gimple_assign_rhs1 (_a1);
4236 : 557148 : _q20 = do_valueize (valueize, _q20);
4237 : 557148 : tree _q21 = gimple_assign_rhs2 (_a1);
4238 : 557148 : _q21 = do_valueize (valueize, _q21);
4239 : 557148 : if (tree_swap_operands_p (_q20, _q21))
4240 : 2121 : std::swap (_q20, _q21);
4241 : 557148 : {
4242 : 557148 : tree _q20_pops[1];
4243 : 557148 : if (gimple_nop_convert (_q20, _q20_pops, valueize))
4244 : : {
4245 : 7899 : tree _q30 = _q20_pops[0];
4246 : 7899 : {
4247 : 7899 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
4248 : 7899 : if (gimple_simplify_386 (res_op, seq, valueize, type, captures, BIT_AND_EXPR))
4249 : 227 : return true;
4250 : : }
4251 : : }
4252 : : }
4253 : 556921 : {
4254 : 556921 : tree _q21_pops[1];
4255 : 556921 : if (gimple_nop_convert (_q21, _q21_pops, valueize))
4256 : : {
4257 : 1250 : tree _q40 = _q21_pops[0];
4258 : 1250 : {
4259 : 1250 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
4260 : 1250 : if (gimple_simplify_386 (res_op, seq, valueize, type, captures, BIT_AND_EXPR))
4261 : 197 : return true;
4262 : : }
4263 : : }
4264 : : }
4265 : 556724 : break;
4266 : : }
4267 : 123937 : case BIT_IOR_EXPR:
4268 : 123937 : {
4269 : 123937 : tree _q20 = gimple_assign_rhs1 (_a1);
4270 : 123937 : _q20 = do_valueize (valueize, _q20);
4271 : 123937 : tree _q21 = gimple_assign_rhs2 (_a1);
4272 : 123937 : _q21 = do_valueize (valueize, _q21);
4273 : 123937 : if (tree_swap_operands_p (_q20, _q21))
4274 : 3921 : std::swap (_q20, _q21);
4275 : 123937 : {
4276 : 123937 : tree _q20_pops[1];
4277 : 123937 : if (gimple_nop_convert (_q20, _q20_pops, valueize))
4278 : : {
4279 : 3084 : tree _q30 = _q20_pops[0];
4280 : 3084 : {
4281 : 3084 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
4282 : 3084 : if (gimple_simplify_386 (res_op, seq, valueize, type, captures, BIT_IOR_EXPR))
4283 : 694 : return true;
4284 : : }
4285 : : }
4286 : : }
4287 : 123243 : {
4288 : 123243 : tree _q21_pops[1];
4289 : 123243 : if (gimple_nop_convert (_q21, _q21_pops, valueize))
4290 : : {
4291 : 2438 : tree _q40 = _q21_pops[0];
4292 : 2438 : {
4293 : 2438 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
4294 : 2438 : if (gimple_simplify_386 (res_op, seq, valueize, type, captures, BIT_IOR_EXPR))
4295 : 715 : return true;
4296 : : }
4297 : : }
4298 : : }
4299 : 122528 : break;
4300 : : }
4301 : 56708 : case BIT_XOR_EXPR:
4302 : 56708 : {
4303 : 56708 : tree _q20 = gimple_assign_rhs1 (_a1);
4304 : 56708 : _q20 = do_valueize (valueize, _q20);
4305 : 56708 : tree _q21 = gimple_assign_rhs2 (_a1);
4306 : 56708 : _q21 = do_valueize (valueize, _q21);
4307 : 56708 : if (tree_swap_operands_p (_q20, _q21))
4308 : 1709 : std::swap (_q20, _q21);
4309 : 56708 : {
4310 : 56708 : tree _q20_pops[1];
4311 : 56708 : if (gimple_nop_convert (_q20, _q20_pops, valueize))
4312 : : {
4313 : 1165 : tree _q30 = _q20_pops[0];
4314 : 1165 : {
4315 : 1165 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21 };
4316 : 1165 : if (gimple_simplify_386 (res_op, seq, valueize, type, captures, BIT_XOR_EXPR))
4317 : 168 : return true;
4318 : : }
4319 : : }
4320 : : }
4321 : 56540 : {
4322 : 56540 : tree _q21_pops[1];
4323 : 56540 : if (gimple_nop_convert (_q21, _q21_pops, valueize))
4324 : : {
4325 : 695 : tree _q40 = _q21_pops[0];
4326 : 695 : {
4327 : 695 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q20 };
4328 : 695 : if (gimple_simplify_386 (res_op, seq, valueize, type, captures, BIT_XOR_EXPR))
4329 : 79 : return true;
4330 : : }
4331 : : }
4332 : : }
4333 : 56461 : break;
4334 : : }
4335 : 1624558 : case MULT_EXPR:
4336 : 1624558 : {
4337 : 1624558 : tree _q20 = gimple_assign_rhs1 (_a1);
4338 : 1624558 : _q20 = do_valueize (valueize, _q20);
4339 : 1624558 : tree _q21 = gimple_assign_rhs2 (_a1);
4340 : 1624558 : _q21 = do_valueize (valueize, _q21);
4341 : 1624558 : if (tree_swap_operands_p (_q20, _q21))
4342 : 57093 : std::swap (_q20, _q21);
4343 : 1624558 : if (gimple_zero_one_valued_p (_q20, valueize))
4344 : : {
4345 : 4369 : switch (TREE_CODE (_q21))
4346 : : {
4347 : 3138 : case INTEGER_CST:
4348 : 3138 : {
4349 : 3138 : {
4350 : 3138 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
4351 : 3138 : if (INTEGRAL_TYPE_P (type)
4352 : 3119 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4353 : 6257 : && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (captures[0]))
4354 : : )
4355 : : {
4356 : 5 : gimple_seq *lseq = seq;
4357 : 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1206;
4358 : 5 : {
4359 : 5 : res_op->set_op (MULT_EXPR, type, 2);
4360 : 5 : {
4361 : 5 : tree _o1[1], _r1;
4362 : 5 : _o1[0] = captures[1];
4363 : 5 : if (type != TREE_TYPE (_o1[0])
4364 : 5 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
4365 : : {
4366 : 5 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
4367 : 5 : tem_op.resimplify (lseq, valueize);
4368 : 5 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4369 : 5 : if (!_r1) goto next_after_fail1206;
4370 : : }
4371 : : else
4372 : : _r1 = _o1[0];
4373 : 3 : res_op->ops[0] = _r1;
4374 : : }
4375 : 3 : {
4376 : 3 : tree _o1[1], _r1;
4377 : 3 : _o1[0] = captures[2];
4378 : 3 : if (type != TREE_TYPE (_o1[0])
4379 : 3 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
4380 : : {
4381 : 3 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
4382 : 3 : tem_op.resimplify (lseq, valueize);
4383 : 3 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4384 : 3 : if (!_r1) goto next_after_fail1206;
4385 : : }
4386 : : else
4387 : : _r1 = _o1[0];
4388 : 3 : res_op->ops[1] = _r1;
4389 : : }
4390 : 3 : res_op->resimplify (lseq, valueize);
4391 : 3 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 845, __FILE__, __LINE__, true);
4392 : 3 : return true;
4393 : : }
4394 : 3135 : next_after_fail1206:;
4395 : : }
4396 : : }
4397 : 3135 : break;
4398 : : }
4399 : : default:;
4400 : : }
4401 : : }
4402 : 68546797 : break;
4403 : : }
4404 : 796486 : case POINTER_DIFF_EXPR:
4405 : 796486 : {
4406 : 796486 : tree _q20 = gimple_assign_rhs1 (_a1);
4407 : 796486 : _q20 = do_valueize (valueize, _q20);
4408 : 796486 : tree _q21 = gimple_assign_rhs2 (_a1);
4409 : 796486 : _q21 = do_valueize (valueize, _q21);
4410 : 796486 : switch (TREE_CODE (_q21))
4411 : : {
4412 : 2 : case INTEGER_CST:
4413 : 2 : {
4414 : 2 : {
4415 : 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4416 : 2 : if (POINTER_TYPE_P (type)
4417 : : )
4418 : : {
4419 : 0 : gimple_seq *lseq = seq;
4420 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1207;
4421 : 0 : {
4422 : 0 : tree tem;
4423 : 0 : tem = build_fold_addr_expr_with_type
4424 : : (build2 (MEM_REF, char_type_node, captures[0],
4425 : : wide_int_to_tree (ptr_type_node, wi::neg (wi::to_wide (captures[1])))),
4426 : : type);
4427 : 0 : res_op->set_value (tem);
4428 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 846, __FILE__, __LINE__, true);
4429 : 0 : return true;
4430 : : }
4431 : 0 : next_after_fail1207:;
4432 : : }
4433 : : }
4434 : 2 : break;
4435 : : }
4436 : : default:;
4437 : : }
4438 : : break;
4439 : : }
4440 : 504883 : case EQ_EXPR:
4441 : 504883 : {
4442 : 504883 : tree _q20 = gimple_assign_rhs1 (_a1);
4443 : 504883 : _q20 = do_valueize (valueize, _q20);
4444 : 504883 : tree _q21 = gimple_assign_rhs2 (_a1);
4445 : 504883 : _q21 = do_valueize (valueize, _q21);
4446 : 504883 : if (tree_swap_operands_p (_q20, _q21))
4447 : 6382 : std::swap (_q20, _q21);
4448 : 504883 : if (gimple_zero_one_valued_p (_q20, valueize))
4449 : : {
4450 : 12847 : switch (TREE_CODE (_q21))
4451 : : {
4452 : 8579 : case INTEGER_CST:
4453 : 8579 : {
4454 : 8579 : {
4455 : 8579 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4456 : 8579 : if (gimple_simplify_387 (res_op, seq, valueize, type, captures, EQ_EXPR))
4457 : 1476 : return true;
4458 : : }
4459 : 7103 : break;
4460 : : }
4461 : : default:;
4462 : : }
4463 : : }
4464 : 68546797 : break;
4465 : : }
4466 : 447865 : case NE_EXPR:
4467 : 447865 : {
4468 : 447865 : tree _q20 = gimple_assign_rhs1 (_a1);
4469 : 447865 : _q20 = do_valueize (valueize, _q20);
4470 : 447865 : tree _q21 = gimple_assign_rhs2 (_a1);
4471 : 447865 : _q21 = do_valueize (valueize, _q21);
4472 : 447865 : if (tree_swap_operands_p (_q20, _q21))
4473 : 3460 : std::swap (_q20, _q21);
4474 : 447865 : if (gimple_zero_one_valued_p (_q20, valueize))
4475 : : {
4476 : 8209 : switch (TREE_CODE (_q21))
4477 : : {
4478 : 7053 : case INTEGER_CST:
4479 : 7053 : {
4480 : 7053 : {
4481 : 7053 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
4482 : 7053 : if (gimple_simplify_387 (res_op, seq, valueize, type, captures, NE_EXPR))
4483 : 6979 : return true;
4484 : : }
4485 : 74 : break;
4486 : : }
4487 : : default:;
4488 : : }
4489 : : }
4490 : 68546797 : break;
4491 : : }
4492 : 114941 : case MIN_EXPR:
4493 : 114941 : {
4494 : 114941 : tree _q20 = gimple_assign_rhs1 (_a1);
4495 : 114941 : _q20 = do_valueize (valueize, _q20);
4496 : 114941 : tree _q21 = gimple_assign_rhs2 (_a1);
4497 : 114941 : _q21 = do_valueize (valueize, _q21);
4498 : 114941 : if (tree_swap_operands_p (_q20, _q21))
4499 : 10855 : std::swap (_q20, _q21);
4500 : 114941 : switch (TREE_CODE (_q20))
4501 : : {
4502 : 114940 : case SSA_NAME:
4503 : 114940 : if (gimple *_d2 = get_def (valueize, _q20))
4504 : : {
4505 : 110535 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
4506 : 123356 : switch (gimple_assign_rhs_code (_a2))
4507 : : {
4508 : 8932 : CASE_CONVERT:
4509 : 8932 : {
4510 : 8932 : tree _q30 = gimple_assign_rhs1 (_a2);
4511 : 8932 : _q30 = do_valueize (valueize, _q30);
4512 : 8932 : switch (TREE_CODE (_q21))
4513 : : {
4514 : 5561 : case INTEGER_CST:
4515 : 5561 : {
4516 : 5561 : {
4517 : 5561 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q21 };
4518 : 5561 : if (gimple_simplify_388 (res_op, seq, valueize, type, captures, MIN_EXPR))
4519 : 5 : return true;
4520 : : }
4521 : 5556 : break;
4522 : : }
4523 : : default:;
4524 : : }
4525 : : break;
4526 : : }
4527 : : default:;
4528 : : }
4529 : : }
4530 : : break;
4531 : : default:;
4532 : : }
4533 : 68546797 : break;
4534 : : }
4535 : 196272 : case MAX_EXPR:
4536 : 196272 : {
4537 : 196272 : tree _q20 = gimple_assign_rhs1 (_a1);
4538 : 196272 : _q20 = do_valueize (valueize, _q20);
4539 : 196272 : tree _q21 = gimple_assign_rhs2 (_a1);
4540 : 196272 : _q21 = do_valueize (valueize, _q21);
4541 : 196272 : if (tree_swap_operands_p (_q20, _q21))
4542 : 212 : std::swap (_q20, _q21);
4543 : 196272 : switch (TREE_CODE (_q20))
4544 : : {
4545 : 196272 : case SSA_NAME:
4546 : 196272 : if (gimple *_d2 = get_def (valueize, _q20))
4547 : : {
4548 : 191767 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
4549 : 203135 : switch (gimple_assign_rhs_code (_a2))
4550 : : {
4551 : 59960 : CASE_CONVERT:
4552 : 59960 : {
4553 : 59960 : tree _q30 = gimple_assign_rhs1 (_a2);
4554 : 59960 : _q30 = do_valueize (valueize, _q30);
4555 : 59960 : switch (TREE_CODE (_q21))
4556 : : {
4557 : 59233 : case INTEGER_CST:
4558 : 59233 : {
4559 : 59233 : {
4560 : 59233 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q21 };
4561 : 59233 : if (gimple_simplify_388 (res_op, seq, valueize, type, captures, MAX_EXPR))
4562 : 1504 : return true;
4563 : : }
4564 : 57729 : break;
4565 : : }
4566 : : default:;
4567 : : }
4568 : : break;
4569 : : }
4570 : : default:;
4571 : : }
4572 : : }
4573 : : break;
4574 : : default:;
4575 : : }
4576 : 68546797 : break;
4577 : : }
4578 : 184688 : case LSHIFT_EXPR:
4579 : 184688 : {
4580 : 184688 : tree _q20 = gimple_assign_rhs1 (_a1);
4581 : 184688 : _q20 = do_valueize (valueize, _q20);
4582 : 184688 : tree _q21 = gimple_assign_rhs2 (_a1);
4583 : 184688 : _q21 = do_valueize (valueize, _q21);
4584 : 184688 : switch (TREE_CODE (_q21))
4585 : : {
4586 : 59121 : case INTEGER_CST:
4587 : 59121 : {
4588 : 59121 : {
4589 : 59121 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
4590 : 59121 : if (INTEGRAL_TYPE_P (type)
4591 : 58382 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4592 : 58382 : && !integer_zerop (captures[2])
4593 : 117487 : && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (captures[0]))
4594 : : )
4595 : : {
4596 : 48941 : if (TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (captures[0]))
4597 : 48941 : || wi::ltu_p (wi::to_wide (captures[2]), TYPE_PRECISION (type))
4598 : : )
4599 : : {
4600 : 48879 : gimple_seq *lseq = seq;
4601 : 48879 : if (lseq
4602 : 2341 : && (!single_use (captures[0])))
4603 : 47672 : lseq = NULL;
4604 : 48879 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1208;
4605 : 48879 : {
4606 : 48879 : res_op->set_op (LSHIFT_EXPR, type, 2);
4607 : 48879 : {
4608 : 48879 : tree _o1[1], _r1;
4609 : 48879 : _o1[0] = captures[1];
4610 : 48879 : if (type != TREE_TYPE (_o1[0])
4611 : 48879 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
4612 : : {
4613 : 48848 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
4614 : 48848 : tem_op.resimplify (lseq, valueize);
4615 : 48848 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4616 : 48848 : if (!_r1) goto next_after_fail1208;
4617 : : }
4618 : : else
4619 : : _r1 = _o1[0];
4620 : 2281 : res_op->ops[0] = _r1;
4621 : : }
4622 : 2281 : res_op->ops[1] = captures[2];
4623 : 2281 : res_op->resimplify (lseq, valueize);
4624 : 2281 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 847, __FILE__, __LINE__, true);
4625 : 2281 : return true;
4626 : : }
4627 : 56820 : next_after_fail1208:;
4628 : : }
4629 : : else
4630 : : {
4631 : 62 : if (wi::ltu_p (wi::to_wide (captures[2]), TYPE_PRECISION (TREE_TYPE (captures[0])))
4632 : : )
4633 : : {
4634 : 20 : gimple_seq *lseq = seq;
4635 : 20 : if (lseq
4636 : : && (!single_use (captures[0])))
4637 : : lseq = NULL;
4638 : 20 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1209;
4639 : 20 : {
4640 : 20 : tree tem;
4641 : 20 : tem = build_zero_cst (type);
4642 : 20 : res_op->set_value (tem);
4643 : 20 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 848, __FILE__, __LINE__, true);
4644 : 20 : return true;
4645 : : }
4646 : 0 : next_after_fail1209:;
4647 : : }
4648 : : }
4649 : : }
4650 : : }
4651 : 56820 : break;
4652 : : }
4653 : : default:;
4654 : : }
4655 : : break;
4656 : : }
4657 : : default:;
4658 : : }
4659 : : }
4660 : : break;
4661 : 68546797 : default:;
4662 : : }
4663 : 68546797 : {
4664 : 68546797 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
4665 : 68546797 : if ((
4666 : : 1
4667 : 68546797 : && useless_type_conversion_p (type, TREE_TYPE (captures[0])))
4668 : : || (
4669 : :
4670 : : && type == TREE_TYPE (captures[0]))
4671 : : )
4672 : : {
4673 : 518009 : gimple_seq *lseq = seq;
4674 : 518009 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1210;
4675 : 518009 : {
4676 : 518009 : tree tem;
4677 : 518009 : tem = captures[0];
4678 : 518009 : res_op->set_value (tem);
4679 : 518009 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 849, __FILE__, __LINE__, true);
4680 : 518009 : return true;
4681 : : }
4682 : 0 : next_after_fail1210:;
4683 : : }
4684 : : }
4685 : 68028788 : switch (TREE_CODE (_p0))
4686 : : {
4687 : 65020462 : case SSA_NAME:
4688 : 65020462 : if (gimple *_d1 = get_def (valueize, _p0))
4689 : : {
4690 : 31794148 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
4691 : 30811181 : switch (gimple_assign_rhs_code (_a1))
4692 : : {
4693 : 1478078 : CASE_CONVERT:
4694 : 1478078 : {
4695 : 1478078 : tree _q20 = gimple_assign_rhs1 (_a1);
4696 : 1478078 : _q20 = do_valueize (valueize, _q20);
4697 : 1478078 : {
4698 : 1478078 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
4699 : 1478078 : {
4700 : 1478078 : tree inside_type = TREE_TYPE (captures[1]);
4701 : 1478078 : tree inter_type = TREE_TYPE (captures[0]);
4702 : 1478078 : int inside_int = INTEGRAL_TYPE_P (inside_type);
4703 : 1478078 : int inside_ptr = POINTER_TYPE_P (inside_type);
4704 : 1478078 : int inside_float = FLOAT_TYPE_P (inside_type);
4705 : 1478078 : int inside_vec = VECTOR_TYPE_P (inside_type);
4706 : 1478078 : unsigned int inside_prec = element_precision (inside_type);
4707 : 1478078 : int inside_unsignedp = TYPE_UNSIGNED (inside_type);
4708 : 1478078 : int inter_int = INTEGRAL_TYPE_P (inter_type);
4709 : 1478078 : int inter_ptr = POINTER_TYPE_P (inter_type);
4710 : 1478078 : int inter_float = FLOAT_TYPE_P (inter_type);
4711 : 1478078 : int inter_vec = VECTOR_TYPE_P (inter_type);
4712 : 1478078 : unsigned int inter_prec = element_precision (inter_type);
4713 : 1478078 : int inter_unsignedp = TYPE_UNSIGNED (inter_type);
4714 : 1478078 : int final_int = INTEGRAL_TYPE_P (type);
4715 : 1478078 : int final_ptr = POINTER_TYPE_P (type);
4716 : 1478078 : int final_float = FLOAT_TYPE_P (type);
4717 : 1478078 : int final_vec = VECTOR_TYPE_P (type);
4718 : 1478078 : unsigned int final_prec = element_precision (type);
4719 : 1478078 : int final_unsignedp = TYPE_UNSIGNED (type);
4720 : 1478078 : if (((
4721 : : 1
4722 : 1478078 : && useless_type_conversion_p (type, inside_type))
4723 : : || (
4724 : :
4725 : : && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
4726 : 522103 : && (((inter_int || inter_ptr) && final_int)
4727 : 169551 : || (inter_float && final_float))
4728 : 1919168 : && inter_prec >= final_prec
4729 : : )
4730 : : {
4731 : 224424 : gimple_seq *lseq = seq;
4732 : 224424 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1211;
4733 : 224424 : {
4734 : 224424 : res_op->set_op (NOP_EXPR, type, 1);
4735 : 224424 : res_op->ops[0] = captures[1];
4736 : 224424 : res_op->resimplify (lseq, valueize);
4737 : 224424 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 850, __FILE__, __LINE__, true);
4738 : 224424 : return true;
4739 : : }
4740 : 0 : next_after_fail1211:;
4741 : : }
4742 : : else
4743 : : {
4744 : 1253654 : if (((inter_int && inside_int) || (inter_float && inside_float))
4745 : 1006230 : && (final_int || final_float)
4746 : 892786 : && inter_prec >= inside_prec
4747 : 507221 : && (inter_float || inter_unsignedp == inside_unsignedp)
4748 : : )
4749 : : {
4750 : 31674 : gimple_seq *lseq = seq;
4751 : 31674 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1212;
4752 : 31674 : {
4753 : 31674 : res_op->set_op (NOP_EXPR, type, 1);
4754 : 31674 : res_op->ops[0] = captures[1];
4755 : 31674 : res_op->resimplify (lseq, valueize);
4756 : 31674 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 851, __FILE__, __LINE__, true);
4757 : 31674 : return true;
4758 : : }
4759 : 0 : next_after_fail1212:;
4760 : 0 : }
4761 : : else
4762 : : {
4763 : 1221980 : if (inside_int && inter_int && final_int
4764 : 773551 : && ((inside_prec < inter_prec && inter_prec < final_prec
4765 : 16888 : && inside_unsignedp && !inter_unsignedp)
4766 : 771254 : || final_prec == inter_prec
4767 : 697827 : || (inside_prec < inter_prec && inter_prec > final_prec
4768 : 34548 : && !inside_unsignedp && inter_unsignedp))
4769 : : )
4770 : : {
4771 : 78169 : gimple_seq *lseq = seq;
4772 : 78169 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1213;
4773 : 78169 : {
4774 : 78169 : res_op->set_op (NOP_EXPR, type, 1);
4775 : 78169 : res_op->ops[0] = captures[1];
4776 : 78169 : res_op->resimplify (lseq, valueize);
4777 : 78169 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 852, __FILE__, __LINE__, true);
4778 : 78169 : return true;
4779 : : }
4780 : 0 : next_after_fail1213:;
4781 : 0 : }
4782 : : else
4783 : : {
4784 : 1143811 : if (! inside_float && ! inter_float && ! final_float
4785 : : && ! inside_vec && ! inter_vec && ! final_vec
4786 : 1055952 : && (inter_prec >= inside_prec || inter_prec >= final_prec)
4787 : 816096 : && ! (inside_int && inter_int
4788 : 568970 : && inter_unsignedp != inside_unsignedp
4789 : 568970 : && inter_prec < final_prec)
4790 : 401859 : && ((inter_unsignedp && inter_prec > inside_prec)
4791 : 401859 : == (final_unsignedp && final_prec > inter_prec))
4792 : 305630 : && ! (inside_ptr && inter_prec != final_prec)
4793 : 157656 : && ! (final_ptr && inside_prec != inter_prec)
4794 : : )
4795 : : {
4796 : 138383 : gimple_seq *lseq = seq;
4797 : 138383 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1214;
4798 : 138383 : {
4799 : 138383 : res_op->set_op (NOP_EXPR, type, 1);
4800 : 138383 : res_op->ops[0] = captures[1];
4801 : 138383 : res_op->resimplify (lseq, valueize);
4802 : 138383 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 853, __FILE__, __LINE__, true);
4803 : 138383 : return true;
4804 : : }
4805 : 0 : next_after_fail1214:;
4806 : 0 : }
4807 : : else
4808 : : {
4809 : 1005428 : if (inside_int && inter_int && final_int
4810 : 764163 : && final_prec <= inside_prec
4811 : 200959 : && inter_prec >= inside_prec
4812 : : )
4813 : : {
4814 : 0 : gimple_seq *lseq = seq;
4815 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1215;
4816 : 0 : {
4817 : 0 : res_op->set_op (NOP_EXPR, type, 1);
4818 : 0 : res_op->ops[0] = captures[1];
4819 : 0 : res_op->resimplify (lseq, valueize);
4820 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 854, __FILE__, __LINE__, true);
4821 : 0 : return true;
4822 : : }
4823 : 0 : next_after_fail1215:;
4824 : 0 : }
4825 : : else
4826 : : {
4827 : 1005428 : if (1
4828 : 1005428 : && final_int && inter_int && inside_int
4829 : 807269 : && final_prec == inside_prec
4830 : 166723 : && final_prec > inter_prec
4831 : 166723 : && inter_unsignedp
4832 : : )
4833 : : {
4834 : 38028 : gimple_seq *lseq = seq;
4835 : 38028 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1216;
4836 : 38028 : {
4837 : 38028 : res_op->set_op (NOP_EXPR, type, 1);
4838 : 38028 : {
4839 : 38028 : tree _o1[2], _r1;
4840 : 38028 : _o1[0] = captures[1];
4841 : 38028 : _o1[1] = wide_int_to_tree
4842 : 38028 : (inside_type,
4843 : 38028 : wi::mask (inter_prec, false,
4844 : 38028 : TYPE_PRECISION (inside_type)));
4845 : 38028 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4846 : 38028 : tem_op.resimplify (lseq, valueize);
4847 : 38028 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4848 : 38028 : if (!_r1) goto next_after_fail1216;
4849 : 21818 : res_op->ops[0] = _r1;
4850 : : }
4851 : 21818 : res_op->resimplify (lseq, valueize);
4852 : 21818 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 855, __FILE__, __LINE__, true);
4853 : 21818 : return true;
4854 : : }
4855 : 983610 : next_after_fail1216:;
4856 : : }
4857 : : else
4858 : : {
4859 : 967400 : if (1
4860 : 967400 : && inside_int && inter_float && final_int &&
4861 : 967400 : (unsigned) significand_size (TYPE_MODE (inter_type))
4862 : 0 : >= inside_prec - !inside_unsignedp
4863 : : )
4864 : : {
4865 : 0 : gimple_seq *lseq = seq;
4866 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1217;
4867 : 0 : {
4868 : 0 : res_op->set_op (NOP_EXPR, type, 1);
4869 : 0 : res_op->ops[0] = captures[1];
4870 : 0 : res_op->resimplify (lseq, valueize);
4871 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 856, __FILE__, __LINE__, true);
4872 : 0 : return true;
4873 : : }
4874 : 0 : next_after_fail1217:;
4875 : : }
4876 : : }
4877 : : }
4878 : : }
4879 : : }
4880 : : }
4881 : : }
4882 : : }
4883 : : }
4884 : 983610 : break;
4885 : : }
4886 : 14722 : case FLOAT_EXPR:
4887 : 14722 : {
4888 : 14722 : tree _q20 = gimple_assign_rhs1 (_a1);
4889 : 14722 : _q20 = do_valueize (valueize, _q20);
4890 : 14722 : {
4891 : 14722 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
4892 : 14722 : {
4893 : 14722 : tree inside_type = TREE_TYPE (captures[1]);
4894 : 14722 : tree inter_type = TREE_TYPE (captures[0]);
4895 : 14722 : int inside_int = INTEGRAL_TYPE_P (inside_type);
4896 : 14722 : int inside_ptr = POINTER_TYPE_P (inside_type);
4897 : 14722 : int inside_float = FLOAT_TYPE_P (inside_type);
4898 : 14722 : int inside_vec = VECTOR_TYPE_P (inside_type);
4899 : 14722 : unsigned int inside_prec = element_precision (inside_type);
4900 : 14722 : int inside_unsignedp = TYPE_UNSIGNED (inside_type);
4901 : 14722 : int inter_int = INTEGRAL_TYPE_P (inter_type);
4902 : 14722 : int inter_ptr = POINTER_TYPE_P (inter_type);
4903 : 14722 : int inter_float = FLOAT_TYPE_P (inter_type);
4904 : 14722 : int inter_vec = VECTOR_TYPE_P (inter_type);
4905 : 14722 : unsigned int inter_prec = element_precision (inter_type);
4906 : 14722 : int inter_unsignedp = TYPE_UNSIGNED (inter_type);
4907 : 14722 : int final_int = INTEGRAL_TYPE_P (type);
4908 : 14722 : int final_ptr = POINTER_TYPE_P (type);
4909 : 14722 : int final_float = FLOAT_TYPE_P (type);
4910 : 14722 : int final_vec = VECTOR_TYPE_P (type);
4911 : 14722 : unsigned int final_prec = element_precision (type);
4912 : 14722 : int final_unsignedp = TYPE_UNSIGNED (type);
4913 : 14722 : if (((
4914 : : 1
4915 : 14722 : && useless_type_conversion_p (type, inside_type))
4916 : : || (
4917 : :
4918 : : && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
4919 : 0 : && (((inter_int || inter_ptr) && final_int)
4920 : 0 : || (inter_float && final_float))
4921 : 14722 : && inter_prec >= final_prec
4922 : : )
4923 : : {
4924 : 0 : gimple_seq *lseq = seq;
4925 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1218;
4926 : 0 : {
4927 : 0 : res_op->set_op (NOP_EXPR, type, 1);
4928 : 0 : res_op->ops[0] = captures[1];
4929 : 0 : res_op->resimplify (lseq, valueize);
4930 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 850, __FILE__, __LINE__, true);
4931 : 0 : return true;
4932 : : }
4933 : 0 : next_after_fail1218:;
4934 : : }
4935 : : else
4936 : : {
4937 : 14722 : if (((inter_int && inside_int) || (inter_float && inside_float))
4938 : 0 : && (final_int || final_float)
4939 : 0 : && inter_prec >= inside_prec
4940 : 0 : && (inter_float || inter_unsignedp == inside_unsignedp)
4941 : : )
4942 : : {
4943 : 0 : gimple_seq *lseq = seq;
4944 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1219;
4945 : 0 : {
4946 : 0 : res_op->set_op (NOP_EXPR, type, 1);
4947 : 0 : res_op->ops[0] = captures[1];
4948 : 0 : res_op->resimplify (lseq, valueize);
4949 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 851, __FILE__, __LINE__, true);
4950 : 0 : return true;
4951 : : }
4952 : 0 : next_after_fail1219:;
4953 : 0 : }
4954 : : else
4955 : : {
4956 : 14722 : if (inside_int && inter_int && final_int
4957 : 0 : && ((inside_prec < inter_prec && inter_prec < final_prec
4958 : 0 : && inside_unsignedp && !inter_unsignedp)
4959 : 0 : || final_prec == inter_prec
4960 : 0 : || (inside_prec < inter_prec && inter_prec > final_prec
4961 : 0 : && !inside_unsignedp && inter_unsignedp))
4962 : : )
4963 : : {
4964 : 0 : gimple_seq *lseq = seq;
4965 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1220;
4966 : 0 : {
4967 : 0 : res_op->set_op (NOP_EXPR, type, 1);
4968 : 0 : res_op->ops[0] = captures[1];
4969 : 0 : res_op->resimplify (lseq, valueize);
4970 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 852, __FILE__, __LINE__, true);
4971 : 0 : return true;
4972 : : }
4973 : 0 : next_after_fail1220:;
4974 : 0 : }
4975 : : else
4976 : : {
4977 : 14722 : if (! inside_float && ! inter_float && ! final_float
4978 : : && ! inside_vec && ! inter_vec && ! final_vec
4979 : 0 : && (inter_prec >= inside_prec || inter_prec >= final_prec)
4980 : 0 : && ! (inside_int && inter_int
4981 : 0 : && inter_unsignedp != inside_unsignedp
4982 : 0 : && inter_prec < final_prec)
4983 : 0 : && ((inter_unsignedp && inter_prec > inside_prec)
4984 : 0 : == (final_unsignedp && final_prec > inter_prec))
4985 : 0 : && ! (inside_ptr && inter_prec != final_prec)
4986 : 0 : && ! (final_ptr && inside_prec != inter_prec)
4987 : : )
4988 : : {
4989 : 0 : gimple_seq *lseq = seq;
4990 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1221;
4991 : 0 : {
4992 : 0 : res_op->set_op (NOP_EXPR, type, 1);
4993 : 0 : res_op->ops[0] = captures[1];
4994 : 0 : res_op->resimplify (lseq, valueize);
4995 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 853, __FILE__, __LINE__, true);
4996 : 0 : return true;
4997 : : }
4998 : 0 : next_after_fail1221:;
4999 : 0 : }
5000 : : else
5001 : : {
5002 : 14722 : if (inside_int && inter_int && final_int
5003 : 0 : && final_prec <= inside_prec
5004 : 0 : && inter_prec >= inside_prec
5005 : : )
5006 : : {
5007 : 0 : gimple_seq *lseq = seq;
5008 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1222;
5009 : 0 : {
5010 : 0 : res_op->set_op (NOP_EXPR, type, 1);
5011 : 0 : res_op->ops[0] = captures[1];
5012 : 0 : res_op->resimplify (lseq, valueize);
5013 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 854, __FILE__, __LINE__, true);
5014 : 0 : return true;
5015 : : }
5016 : 0 : next_after_fail1222:;
5017 : 0 : }
5018 : : else
5019 : : {
5020 : 14722 : if (1
5021 : 14722 : && final_int && inter_int && inside_int
5022 : 0 : && final_prec == inside_prec
5023 : 0 : && final_prec > inter_prec
5024 : 0 : && inter_unsignedp
5025 : : )
5026 : : {
5027 : 0 : gimple_seq *lseq = seq;
5028 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1223;
5029 : 0 : {
5030 : 0 : res_op->set_op (NOP_EXPR, type, 1);
5031 : 0 : {
5032 : 0 : tree _o1[2], _r1;
5033 : 0 : _o1[0] = captures[1];
5034 : 0 : _o1[1] = wide_int_to_tree
5035 : 0 : (inside_type,
5036 : 0 : wi::mask (inter_prec, false,
5037 : 0 : TYPE_PRECISION (inside_type)));
5038 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
5039 : 0 : tem_op.resimplify (lseq, valueize);
5040 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
5041 : 0 : if (!_r1) goto next_after_fail1223;
5042 : 0 : res_op->ops[0] = _r1;
5043 : : }
5044 : 0 : res_op->resimplify (lseq, valueize);
5045 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 855, __FILE__, __LINE__, true);
5046 : 0 : return true;
5047 : : }
5048 : 14722 : next_after_fail1223:;
5049 : : }
5050 : : else
5051 : : {
5052 : 14722 : if (1
5053 : 14722 : && inside_int && inter_float && final_int &&
5054 : 14722 : (unsigned) significand_size (TYPE_MODE (inter_type))
5055 : 0 : >= inside_prec - !inside_unsignedp
5056 : : )
5057 : : {
5058 : 0 : gimple_seq *lseq = seq;
5059 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1224;
5060 : 0 : {
5061 : 0 : res_op->set_op (NOP_EXPR, type, 1);
5062 : 0 : res_op->ops[0] = captures[1];
5063 : 0 : res_op->resimplify (lseq, valueize);
5064 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 856, __FILE__, __LINE__, true);
5065 : 0 : return true;
5066 : : }
5067 : 0 : next_after_fail1224:;
5068 : : }
5069 : : }
5070 : : }
5071 : : }
5072 : : }
5073 : : }
5074 : : }
5075 : : }
5076 : : }
5077 : 14722 : break;
5078 : : }
5079 : 530796 : case BIT_AND_EXPR:
5080 : 530796 : {
5081 : 530796 : tree _q20 = gimple_assign_rhs1 (_a1);
5082 : 530796 : _q20 = do_valueize (valueize, _q20);
5083 : 530796 : tree _q21 = gimple_assign_rhs2 (_a1);
5084 : 530796 : _q21 = do_valueize (valueize, _q21);
5085 : 530796 : if (tree_swap_operands_p (_q20, _q21))
5086 : 2084 : std::swap (_q20, _q21);
5087 : 530796 : switch (TREE_CODE (_q21))
5088 : : {
5089 : 492788 : case INTEGER_CST:
5090 : 492788 : {
5091 : 492788 : {
5092 : 492788 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
5093 : 492788 : if (INTEGRAL_TYPE_P (type)
5094 : 398692 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
5095 : 398692 : && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (captures[0]))
5096 : 715666 : && operand_equal_p (captures[1], build_low_bits_mask (TREE_TYPE (captures[1]),
5097 : 222878 : TYPE_PRECISION (type)), 0)
5098 : : )
5099 : : {
5100 : 5672 : gimple_seq *lseq = seq;
5101 : 5672 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1225;
5102 : 5672 : {
5103 : 5672 : res_op->set_op (NOP_EXPR, type, 1);
5104 : 5672 : res_op->ops[0] = captures[0];
5105 : 5672 : res_op->resimplify (lseq, valueize);
5106 : 5672 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 857, __FILE__, __LINE__, true);
5107 : 5672 : return true;
5108 : : }
5109 : 0 : next_after_fail1225:;
5110 : : }
5111 : : }
5112 : 487116 : break;
5113 : : }
5114 : : default:;
5115 : : }
5116 : 68561254 : break;
5117 : : }
5118 : 32 : case VEC_COND_EXPR:
5119 : 32 : {
5120 : 32 : tree _q20 = gimple_assign_rhs1 (_a1);
5121 : 32 : _q20 = do_valueize (valueize, _q20);
5122 : 32 : tree _q21 = gimple_assign_rhs2 (_a1);
5123 : 32 : _q21 = do_valueize (valueize, _q21);
5124 : 32 : tree _q22 = gimple_assign_rhs3 (_a1);
5125 : 32 : _q22 = do_valueize (valueize, _q22);
5126 : 32 : {
5127 : 32 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
5128 : 32 : if (VECTOR_TYPE_P (type)
5129 : 32 : && types_match (TREE_TYPE (captures[1]), truth_type_for (type))
5130 : : )
5131 : : {
5132 : 0 : gimple_seq *lseq = seq;
5133 : 0 : if (lseq
5134 : 0 : && (!single_use (captures[0])))
5135 : 0 : lseq = NULL;
5136 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1226;
5137 : 0 : {
5138 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
5139 : 0 : res_op->ops[0] = captures[1];
5140 : 0 : {
5141 : 0 : tree _o1[1], _r1;
5142 : 0 : _o1[0] = captures[2];
5143 : 0 : if (type != TREE_TYPE (_o1[0])
5144 : 0 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
5145 : : {
5146 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
5147 : 0 : tem_op.resimplify (NULL, valueize);
5148 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
5149 : 0 : if (!_r1) goto next_after_fail1226;
5150 : : }
5151 : : else
5152 : : _r1 = _o1[0];
5153 : 0 : res_op->ops[1] = _r1;
5154 : : }
5155 : 0 : {
5156 : 0 : tree _o1[1], _r1;
5157 : 0 : _o1[0] = captures[3];
5158 : 0 : if (type != TREE_TYPE (_o1[0])
5159 : 0 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
5160 : : {
5161 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
5162 : 0 : tem_op.resimplify (NULL, valueize);
5163 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
5164 : 0 : if (!_r1) goto next_after_fail1226;
5165 : : }
5166 : : else
5167 : : _r1 = _o1[0];
5168 : 0 : res_op->ops[2] = _r1;
5169 : : }
5170 : 0 : res_op->resimplify (lseq, valueize);
5171 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 858, __FILE__, __LINE__, true);
5172 : 0 : return true;
5173 : : }
5174 : 32 : next_after_fail1226:;
5175 : : }
5176 : : }
5177 : 32 : break;
5178 : : }
5179 : 3561 : case COND_EXPR:
5180 : 3561 : {
5181 : 3561 : tree _q20 = gimple_assign_rhs1 (_a1);
5182 : 3561 : _q20 = do_valueize (valueize, _q20);
5183 : 3561 : tree _q21 = gimple_assign_rhs2 (_a1);
5184 : 3561 : _q21 = do_valueize (valueize, _q21);
5185 : 3561 : tree _q22 = gimple_assign_rhs3 (_a1);
5186 : 3561 : _q22 = do_valueize (valueize, _q22);
5187 : 3561 : switch (TREE_CODE (_q21))
5188 : : {
5189 : 485 : case INTEGER_CST:
5190 : 485 : {
5191 : 485 : switch (TREE_CODE (_q22))
5192 : : {
5193 : 374 : case INTEGER_CST:
5194 : 374 : {
5195 : 374 : {
5196 : 374 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
5197 : 374 : if (INTEGRAL_TYPE_P (type)
5198 : 374 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
5199 : : )
5200 : : {
5201 : 354 : gimple_seq *lseq = seq;
5202 : 354 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1227;
5203 : 354 : {
5204 : 354 : res_op->set_op (COND_EXPR, type, 3);
5205 : 354 : res_op->ops[0] = captures[1];
5206 : 354 : res_op->ops[0] = unshare_expr (res_op->ops[0]);
5207 : 354 : {
5208 : 354 : tree _o1[1], _r1;
5209 : 354 : _o1[0] = captures[2];
5210 : 354 : if (type != TREE_TYPE (_o1[0])
5211 : 354 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
5212 : : {
5213 : 354 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
5214 : 354 : tem_op.resimplify (lseq, valueize);
5215 : 354 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
5216 : 354 : if (!_r1) goto next_after_fail1227;
5217 : : }
5218 : : else
5219 : : _r1 = _o1[0];
5220 : 354 : res_op->ops[1] = _r1;
5221 : : }
5222 : 354 : {
5223 : 354 : tree _o1[1], _r1;
5224 : 354 : _o1[0] = captures[3];
5225 : 354 : if (type != TREE_TYPE (_o1[0])
5226 : 354 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
5227 : : {
5228 : 354 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
5229 : 354 : tem_op.resimplify (lseq, valueize);
5230 : 354 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
5231 : 354 : if (!_r1) goto next_after_fail1227;
5232 : : }
5233 : : else
5234 : : _r1 = _o1[0];
5235 : 354 : res_op->ops[2] = _r1;
5236 : : }
5237 : 354 : res_op->resimplify (lseq, valueize);
5238 : 354 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 859, __FILE__, __LINE__, true);
5239 : 354 : return true;
5240 : : }
5241 : 20 : next_after_fail1227:;
5242 : : }
5243 : : }
5244 : 20 : break;
5245 : : }
5246 : : default:;
5247 : : }
5248 : : break;
5249 : : }
5250 : : default:;
5251 : : }
5252 : : break;
5253 : : }
5254 : 177878 : case MAX_EXPR:
5255 : 177878 : {
5256 : 177878 : tree _q20 = gimple_assign_rhs1 (_a1);
5257 : 177878 : _q20 = do_valueize (valueize, _q20);
5258 : 177878 : tree _q21 = gimple_assign_rhs2 (_a1);
5259 : 177878 : _q21 = do_valueize (valueize, _q21);
5260 : 177878 : if (tree_swap_operands_p (_q20, _q21))
5261 : 211 : std::swap (_q20, _q21);
5262 : 177878 : switch (TREE_CODE (_q20))
5263 : : {
5264 : 177878 : case SSA_NAME:
5265 : 177878 : if (gimple *_d2 = get_def (valueize, _q20))
5266 : : {
5267 : 173380 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
5268 : 183338 : switch (gimple_assign_rhs_code (_a2))
5269 : : {
5270 : 57614 : CASE_CONVERT:
5271 : 57614 : {
5272 : 57614 : tree _q30 = gimple_assign_rhs1 (_a2);
5273 : 57614 : _q30 = do_valueize (valueize, _q30);
5274 : 57614 : switch (TREE_CODE (_q21))
5275 : : {
5276 : 596 : case SSA_NAME:
5277 : 596 : if (gimple *_d3 = get_def (valueize, _q21))
5278 : : {
5279 : 584 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
5280 : 507 : switch (gimple_assign_rhs_code (_a3))
5281 : : {
5282 : 344 : CASE_CONVERT:
5283 : 344 : {
5284 : 344 : tree _q50 = gimple_assign_rhs1 (_a3);
5285 : 344 : _q50 = do_valueize (valueize, _q50);
5286 : 344 : {
5287 : 344 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q50 };
5288 : 344 : if (gimple_simplify_392 (res_op, seq, valueize, type, captures, MAX_EXPR))
5289 : 24 : return true;
5290 : : }
5291 : 320 : break;
5292 : : }
5293 : : default:;
5294 : : }
5295 : : }
5296 : : break;
5297 : : default:;
5298 : : }
5299 : : break;
5300 : : }
5301 : : default:;
5302 : : }
5303 : : }
5304 : : break;
5305 : : default:;
5306 : : }
5307 : 68561254 : break;
5308 : : }
5309 : 105351 : case MIN_EXPR:
5310 : 105351 : {
5311 : 105351 : tree _q20 = gimple_assign_rhs1 (_a1);
5312 : 105351 : _q20 = do_valueize (valueize, _q20);
5313 : 105351 : tree _q21 = gimple_assign_rhs2 (_a1);
5314 : 105351 : _q21 = do_valueize (valueize, _q21);
5315 : 105351 : if (tree_swap_operands_p (_q20, _q21))
5316 : 10724 : std::swap (_q20, _q21);
5317 : 105351 : switch (TREE_CODE (_q20))
5318 : : {
5319 : 105351 : case SSA_NAME:
5320 : 105351 : if (gimple *_d2 = get_def (valueize, _q20))
5321 : : {
5322 : 100949 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
5323 : 114071 : switch (gimple_assign_rhs_code (_a2))
5324 : : {
5325 : 8704 : CASE_CONVERT:
5326 : 8704 : {
5327 : 8704 : tree _q30 = gimple_assign_rhs1 (_a2);
5328 : 8704 : _q30 = do_valueize (valueize, _q30);
5329 : 8704 : switch (TREE_CODE (_q21))
5330 : : {
5331 : 3154 : case SSA_NAME:
5332 : 3154 : if (gimple *_d3 = get_def (valueize, _q21))
5333 : : {
5334 : 3100 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
5335 : 1994 : switch (gimple_assign_rhs_code (_a3))
5336 : : {
5337 : 485 : CASE_CONVERT:
5338 : 485 : {
5339 : 485 : tree _q50 = gimple_assign_rhs1 (_a3);
5340 : 485 : _q50 = do_valueize (valueize, _q50);
5341 : 485 : {
5342 : 485 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q50 };
5343 : 485 : if (gimple_simplify_392 (res_op, seq, valueize, type, captures, MIN_EXPR))
5344 : 24 : return true;
5345 : : }
5346 : 461 : break;
5347 : : }
5348 : : default:;
5349 : : }
5350 : : }
5351 : : break;
5352 : : default:;
5353 : : }
5354 : : break;
5355 : : }
5356 : : default:;
5357 : : }
5358 : : }
5359 : : break;
5360 : : default:;
5361 : : }
5362 : 68561254 : break;
5363 : : }
5364 : 3881871 : case PLUS_EXPR:
5365 : 3881871 : {
5366 : 3881871 : tree _q20 = gimple_assign_rhs1 (_a1);
5367 : 3881871 : _q20 = do_valueize (valueize, _q20);
5368 : 3881871 : tree _q21 = gimple_assign_rhs2 (_a1);
5369 : 3881871 : _q21 = do_valueize (valueize, _q21);
5370 : 3881871 : if (tree_swap_operands_p (_q20, _q21))
5371 : 211397 : std::swap (_q20, _q21);
5372 : 3881871 : switch (TREE_CODE (_q20))
5373 : : {
5374 : 3881871 : case SSA_NAME:
5375 : 3881871 : if (gimple *_d2 = get_def (valueize, _q20))
5376 : : {
5377 : 3553639 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
5378 : 2932149 : switch (gimple_assign_rhs_code (_a2))
5379 : : {
5380 : 904652 : CASE_CONVERT:
5381 : 904652 : {
5382 : 904652 : tree _q30 = gimple_assign_rhs1 (_a2);
5383 : 904652 : _q30 = do_valueize (valueize, _q30);
5384 : 904652 : switch (TREE_CODE (_q21))
5385 : : {
5386 : 355761 : case SSA_NAME:
5387 : 355761 : if (gimple *_d3 = get_def (valueize, _q21))
5388 : : {
5389 : 328181 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
5390 : 300533 : switch (gimple_assign_rhs_code (_a3))
5391 : : {
5392 : 139562 : CASE_CONVERT:
5393 : 139562 : {
5394 : 139562 : tree _q50 = gimple_assign_rhs1 (_a3);
5395 : 139562 : _q50 = do_valueize (valueize, _q50);
5396 : 139562 : {
5397 : 139562 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
5398 : 139562 : if (gimple_simplify_393 (res_op, seq, valueize, type, captures, PLUS_EXPR))
5399 : 130 : return true;
5400 : : }
5401 : 139432 : break;
5402 : : }
5403 : : default:;
5404 : : }
5405 : : }
5406 : : break;
5407 : 904522 : default:;
5408 : : }
5409 : 904522 : {
5410 : 904522 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
5411 : 904522 : if (gimple_simplify_394 (res_op, seq, valueize, type, captures, PLUS_EXPR))
5412 : 1545 : return true;
5413 : : }
5414 : 902977 : break;
5415 : : }
5416 : : default:;
5417 : : }
5418 : : }
5419 : : break;
5420 : 3880196 : default:;
5421 : : }
5422 : 3880196 : switch (TREE_CODE (_q21))
5423 : : {
5424 : 1463039 : case SSA_NAME:
5425 : 1463039 : if (gimple *_d2 = get_def (valueize, _q21))
5426 : : {
5427 : 1318350 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
5428 : 1093520 : switch (gimple_assign_rhs_code (_a2))
5429 : : {
5430 : 341531 : CASE_CONVERT:
5431 : 341531 : {
5432 : 341531 : tree _q40 = gimple_assign_rhs1 (_a2);
5433 : 341531 : _q40 = do_valueize (valueize, _q40);
5434 : 341531 : {
5435 : 341531 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
5436 : 341531 : if (gimple_simplify_395 (res_op, seq, valueize, type, captures, PLUS_EXPR))
5437 : 0 : return true;
5438 : : }
5439 : 341531 : break;
5440 : : }
5441 : : default:;
5442 : : }
5443 : : }
5444 : : break;
5445 : 3880196 : default:;
5446 : : }
5447 : 3880196 : {
5448 : 3880196 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
5449 : 3880196 : if (gimple_simplify_396 (res_op, seq, valueize, type, captures, PLUS_EXPR))
5450 : 0 : return true;
5451 : : }
5452 : 3880196 : break;
5453 : : }
5454 : 471663 : case MINUS_EXPR:
5455 : 471663 : {
5456 : 471663 : tree _q20 = gimple_assign_rhs1 (_a1);
5457 : 471663 : _q20 = do_valueize (valueize, _q20);
5458 : 471663 : tree _q21 = gimple_assign_rhs2 (_a1);
5459 : 471663 : _q21 = do_valueize (valueize, _q21);
5460 : 471663 : switch (TREE_CODE (_q20))
5461 : : {
5462 : 359455 : case SSA_NAME:
5463 : 359455 : if (gimple *_d2 = get_def (valueize, _q20))
5464 : : {
5465 : 333717 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
5466 : 345545 : switch (gimple_assign_rhs_code (_a2))
5467 : : {
5468 : 101956 : CASE_CONVERT:
5469 : 101956 : {
5470 : 101956 : tree _q30 = gimple_assign_rhs1 (_a2);
5471 : 101956 : _q30 = do_valueize (valueize, _q30);
5472 : 101956 : switch (TREE_CODE (_q21))
5473 : : {
5474 : 97208 : case SSA_NAME:
5475 : 97208 : if (gimple *_d3 = get_def (valueize, _q21))
5476 : : {
5477 : 94600 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
5478 : 100364 : switch (gimple_assign_rhs_code (_a3))
5479 : : {
5480 : 73372 : CASE_CONVERT:
5481 : 73372 : {
5482 : 73372 : tree _q50 = gimple_assign_rhs1 (_a3);
5483 : 73372 : _q50 = do_valueize (valueize, _q50);
5484 : 73372 : {
5485 : 73372 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
5486 : 73372 : if (gimple_simplify_393 (res_op, seq, valueize, type, captures, MINUS_EXPR))
5487 : 77 : return true;
5488 : : }
5489 : 73295 : break;
5490 : : }
5491 : : default:;
5492 : : }
5493 : : }
5494 : : break;
5495 : 101879 : default:;
5496 : : }
5497 : 101879 : {
5498 : 101879 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
5499 : 101879 : if (gimple_simplify_394 (res_op, seq, valueize, type, captures, MINUS_EXPR))
5500 : 70 : return true;
5501 : : }
5502 : 101809 : break;
5503 : : }
5504 : : default:;
5505 : : }
5506 : : }
5507 : : break;
5508 : 471516 : default:;
5509 : : }
5510 : 471516 : switch (TREE_CODE (_q21))
5511 : : {
5512 : 457621 : case SSA_NAME:
5513 : 457621 : if (gimple *_d2 = get_def (valueize, _q21))
5514 : : {
5515 : 424859 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
5516 : 428272 : switch (gimple_assign_rhs_code (_a2))
5517 : : {
5518 : 128771 : CASE_CONVERT:
5519 : 128771 : {
5520 : 128771 : tree _q40 = gimple_assign_rhs1 (_a2);
5521 : 128771 : _q40 = do_valueize (valueize, _q40);
5522 : 128771 : {
5523 : 128771 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
5524 : 128771 : if (gimple_simplify_395 (res_op, seq, valueize, type, captures, MINUS_EXPR))
5525 : 0 : return true;
5526 : : }
5527 : 128771 : break;
5528 : : }
5529 : : default:;
5530 : : }
5531 : : }
5532 : : break;
5533 : 471516 : default:;
5534 : : }
5535 : 471516 : {
5536 : 471516 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
5537 : 471516 : if (gimple_simplify_396 (res_op, seq, valueize, type, captures, MINUS_EXPR))
5538 : 0 : return true;
5539 : : }
5540 : 471516 : break;
5541 : : }
5542 : 1585162 : case MULT_EXPR:
5543 : 1585162 : {
5544 : 1585162 : tree _q20 = gimple_assign_rhs1 (_a1);
5545 : 1585162 : _q20 = do_valueize (valueize, _q20);
5546 : 1585162 : tree _q21 = gimple_assign_rhs2 (_a1);
5547 : 1585162 : _q21 = do_valueize (valueize, _q21);
5548 : 1585162 : if (tree_swap_operands_p (_q20, _q21))
5549 : 53413 : std::swap (_q20, _q21);
5550 : 1585162 : switch (TREE_CODE (_q20))
5551 : : {
5552 : 1585074 : case SSA_NAME:
5553 : 1585074 : if (gimple *_d2 = get_def (valueize, _q20))
5554 : : {
5555 : 1477069 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
5556 : 1433348 : switch (gimple_assign_rhs_code (_a2))
5557 : : {
5558 : 266817 : CASE_CONVERT:
5559 : 266817 : {
5560 : 266817 : tree _q30 = gimple_assign_rhs1 (_a2);
5561 : 266817 : _q30 = do_valueize (valueize, _q30);
5562 : 266817 : switch (TREE_CODE (_q21))
5563 : : {
5564 : 104298 : case SSA_NAME:
5565 : 104298 : if (gimple *_d3 = get_def (valueize, _q21))
5566 : : {
5567 : 101721 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
5568 : 103858 : switch (gimple_assign_rhs_code (_a3))
5569 : : {
5570 : 65086 : CASE_CONVERT:
5571 : 65086 : {
5572 : 65086 : tree _q50 = gimple_assign_rhs1 (_a3);
5573 : 65086 : _q50 = do_valueize (valueize, _q50);
5574 : 65086 : {
5575 : 65086 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
5576 : 65086 : if (gimple_simplify_393 (res_op, seq, valueize, type, captures, MULT_EXPR))
5577 : 8 : return true;
5578 : : }
5579 : 65078 : break;
5580 : : }
5581 : : default:;
5582 : : }
5583 : : }
5584 : : break;
5585 : 266809 : default:;
5586 : : }
5587 : 266809 : {
5588 : 266809 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
5589 : 266809 : if (gimple_simplify_394 (res_op, seq, valueize, type, captures, MULT_EXPR))
5590 : 72 : return true;
5591 : : }
5592 : 266737 : break;
5593 : : }
5594 : : default:;
5595 : : }
5596 : : }
5597 : : break;
5598 : 1585082 : default:;
5599 : : }
5600 : 1585082 : switch (TREE_CODE (_q21))
5601 : : {
5602 : 772606 : case SSA_NAME:
5603 : 772606 : if (gimple *_d2 = get_def (valueize, _q21))
5604 : : {
5605 : 693043 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
5606 : 836495 : switch (gimple_assign_rhs_code (_a2))
5607 : : {
5608 : 126018 : CASE_CONVERT:
5609 : 126018 : {
5610 : 126018 : tree _q40 = gimple_assign_rhs1 (_a2);
5611 : 126018 : _q40 = do_valueize (valueize, _q40);
5612 : 126018 : {
5613 : 126018 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
5614 : 126018 : if (gimple_simplify_395 (res_op, seq, valueize, type, captures, MULT_EXPR))
5615 : 0 : return true;
5616 : : }
5617 : 126018 : break;
5618 : : }
5619 : : default:;
5620 : : }
5621 : : }
5622 : : break;
5623 : 1585082 : default:;
5624 : : }
5625 : 1585082 : {
5626 : 1585082 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
5627 : 1585082 : if (gimple_simplify_396 (res_op, seq, valueize, type, captures, MULT_EXPR))
5628 : 67 : return true;
5629 : : }
5630 : 1585015 : break;
5631 : : }
5632 : 19389 : case RDIV_EXPR:
5633 : 19389 : {
5634 : 19389 : tree _q20 = gimple_assign_rhs1 (_a1);
5635 : 19389 : _q20 = do_valueize (valueize, _q20);
5636 : 19389 : tree _q21 = gimple_assign_rhs2 (_a1);
5637 : 19389 : _q21 = do_valueize (valueize, _q21);
5638 : 19389 : switch (TREE_CODE (_q20))
5639 : : {
5640 : 14916 : case SSA_NAME:
5641 : 14916 : if (gimple *_d2 = get_def (valueize, _q20))
5642 : : {
5643 : 14296 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
5644 : 14243 : switch (gimple_assign_rhs_code (_a2))
5645 : : {
5646 : 11042 : CASE_CONVERT:
5647 : 11042 : {
5648 : 11042 : tree _q30 = gimple_assign_rhs1 (_a2);
5649 : 11042 : _q30 = do_valueize (valueize, _q30);
5650 : 11042 : switch (TREE_CODE (_q21))
5651 : : {
5652 : 9420 : case SSA_NAME:
5653 : 9420 : if (gimple *_d3 = get_def (valueize, _q21))
5654 : : {
5655 : 8844 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
5656 : 9233 : switch (gimple_assign_rhs_code (_a3))
5657 : : {
5658 : 7158 : CASE_CONVERT:
5659 : 7158 : {
5660 : 7158 : tree _q50 = gimple_assign_rhs1 (_a3);
5661 : 7158 : _q50 = do_valueize (valueize, _q50);
5662 : 7158 : {
5663 : 7158 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q50 };
5664 : 7158 : if (gimple_simplify_393 (res_op, seq, valueize, type, captures, RDIV_EXPR))
5665 : 0 : return true;
5666 : : }
5667 : 7158 : break;
5668 : : }
5669 : : default:;
5670 : : }
5671 : : }
5672 : : break;
5673 : 11042 : default:;
5674 : : }
5675 : 11042 : {
5676 : 11042 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q21, _q21 };
5677 : 11042 : if (gimple_simplify_394 (res_op, seq, valueize, type, captures, RDIV_EXPR))
5678 : 48 : return true;
5679 : : }
5680 : 10994 : break;
5681 : : }
5682 : : default:;
5683 : : }
5684 : : }
5685 : : break;
5686 : 19341 : default:;
5687 : : }
5688 : 19341 : switch (TREE_CODE (_q21))
5689 : : {
5690 : 16851 : case SSA_NAME:
5691 : 16851 : if (gimple *_d2 = get_def (valueize, _q21))
5692 : : {
5693 : 15574 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
5694 : 16419 : switch (gimple_assign_rhs_code (_a2))
5695 : : {
5696 : 10774 : CASE_CONVERT:
5697 : 10774 : {
5698 : 10774 : tree _q40 = gimple_assign_rhs1 (_a2);
5699 : 10774 : _q40 = do_valueize (valueize, _q40);
5700 : 10774 : {
5701 : 10774 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q40 };
5702 : 10774 : if (gimple_simplify_395 (res_op, seq, valueize, type, captures, RDIV_EXPR))
5703 : 7 : return true;
5704 : : }
5705 : 10767 : break;
5706 : : }
5707 : : default:;
5708 : : }
5709 : : }
5710 : : break;
5711 : 19334 : default:;
5712 : : }
5713 : 19334 : {
5714 : 19334 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q20, _q21, _q21 };
5715 : 19334 : if (gimple_simplify_396 (res_op, seq, valueize, type, captures, RDIV_EXPR))
5716 : 0 : return true;
5717 : : }
5718 : 19334 : break;
5719 : : }
5720 : 47838 : case NEGATE_EXPR:
5721 : 47838 : {
5722 : 47838 : tree _q20 = gimple_assign_rhs1 (_a1);
5723 : 47838 : _q20 = do_valueize (valueize, _q20);
5724 : 47838 : {
5725 : 47838 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
5726 : 47838 : if (gimple_simplify_397 (res_op, seq, valueize, type, captures))
5727 : 3 : return true;
5728 : : }
5729 : 47835 : break;
5730 : : }
5731 : : default:;
5732 : : }
5733 : 9963124 : else if (gcall *_c1 = dyn_cast <gcall *> (_d1))
5734 : 2209868 : switch (gimple_call_combined_fn (_c1))
5735 : : {
5736 : 262 : case CFN_BUILT_IN_RINTF:
5737 : 262 : if (gimple_call_num_args (_c1) == 1)
5738 : : {
5739 : 262 : tree _q20 = gimple_call_arg (_c1, 0);
5740 : 262 : _q20 = do_valueize (valueize, _q20);
5741 : 262 : switch (TREE_CODE (_q20))
5742 : : {
5743 : 262 : case SSA_NAME:
5744 : 262 : if (gimple *_d2 = get_def (valueize, _q20))
5745 : : {
5746 : 262 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
5747 : 134 : switch (gimple_assign_rhs_code (_a2))
5748 : : {
5749 : 126 : CASE_CONVERT:
5750 : 126 : {
5751 : 126 : tree _q30 = gimple_assign_rhs1 (_a2);
5752 : 126 : _q30 = do_valueize (valueize, _q30);
5753 : 126 : if (gimple_float16_value_p (_q30, valueize))
5754 : : {
5755 : 40 : {
5756 : 40 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
5757 : 40 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_RINTF, CFN_RINT))
5758 : 2 : return true;
5759 : : }
5760 : : }
5761 : : break;
5762 : : }
5763 : : default:;
5764 : : }
5765 : : }
5766 : : break;
5767 : : default:;
5768 : : }
5769 : : }
5770 : : break;
5771 : 38 : case CFN_BUILT_IN_RINTL:
5772 : 38 : if (gimple_call_num_args (_c1) == 1)
5773 : : {
5774 : 38 : tree _q20 = gimple_call_arg (_c1, 0);
5775 : 38 : _q20 = do_valueize (valueize, _q20);
5776 : 38 : switch (TREE_CODE (_q20))
5777 : : {
5778 : 38 : case SSA_NAME:
5779 : 38 : if (gimple *_d2 = get_def (valueize, _q20))
5780 : : {
5781 : 38 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
5782 : 38 : switch (gimple_assign_rhs_code (_a2))
5783 : : {
5784 : 38 : CASE_CONVERT:
5785 : 38 : {
5786 : 38 : tree _q30 = gimple_assign_rhs1 (_a2);
5787 : 38 : _q30 = do_valueize (valueize, _q30);
5788 : 38 : if (gimple_float16_value_p (_q30, valueize))
5789 : : {
5790 : 2 : {
5791 : 2 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
5792 : 2 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_RINTL, CFN_RINT))
5793 : 2 : return true;
5794 : : }
5795 : : }
5796 : : break;
5797 : : }
5798 : : default:;
5799 : : }
5800 : : }
5801 : : break;
5802 : : default:;
5803 : : }
5804 : : }
5805 : : break;
5806 : 71 : case CFN_BUILT_IN_ROUND:
5807 : 71 : if (gimple_call_num_args (_c1) == 1)
5808 : : {
5809 : 71 : tree _q20 = gimple_call_arg (_c1, 0);
5810 : 71 : _q20 = do_valueize (valueize, _q20);
5811 : 71 : switch (TREE_CODE (_q20))
5812 : : {
5813 : 71 : case SSA_NAME:
5814 : 71 : if (gimple *_d2 = get_def (valueize, _q20))
5815 : : {
5816 : 71 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
5817 : 35 : switch (gimple_assign_rhs_code (_a2))
5818 : : {
5819 : 35 : CASE_CONVERT:
5820 : 35 : {
5821 : 35 : tree _q30 = gimple_assign_rhs1 (_a2);
5822 : 35 : _q30 = do_valueize (valueize, _q30);
5823 : 35 : if (gimple_float16_value_p (_q30, valueize))
5824 : : {
5825 : 0 : {
5826 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
5827 : 0 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_ROUND, CFN_ROUND))
5828 : 0 : return true;
5829 : : }
5830 : : }
5831 : : break;
5832 : : }
5833 : : default:;
5834 : : }
5835 : : }
5836 : : break;
5837 : : default:;
5838 : : }
5839 : : }
5840 : : break;
5841 : 1288 : case CFN_BUILT_IN_SQRTF:
5842 : 1288 : if (gimple_call_num_args (_c1) == 1)
5843 : : {
5844 : 1288 : tree _q20 = gimple_call_arg (_c1, 0);
5845 : 1288 : _q20 = do_valueize (valueize, _q20);
5846 : 1288 : switch (TREE_CODE (_q20))
5847 : : {
5848 : 1288 : case SSA_NAME:
5849 : 1288 : if (gimple *_d2 = get_def (valueize, _q20))
5850 : : {
5851 : 1168 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
5852 : 1252 : switch (gimple_assign_rhs_code (_a2))
5853 : : {
5854 : 1048 : CASE_CONVERT:
5855 : 1048 : {
5856 : 1048 : tree _q30 = gimple_assign_rhs1 (_a2);
5857 : 1048 : _q30 = do_valueize (valueize, _q30);
5858 : 1048 : if (gimple_float16_value_p (_q30, valueize))
5859 : : {
5860 : 526 : {
5861 : 526 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
5862 : 526 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_SQRTF, CFN_SQRT))
5863 : 4 : return true;
5864 : : }
5865 : : }
5866 : : break;
5867 : : }
5868 : : default:;
5869 : : }
5870 : : }
5871 : : break;
5872 : : default:;
5873 : : }
5874 : : }
5875 : : break;
5876 : 1157 : case CFN_BUILT_IN_SQRTL:
5877 : 1157 : if (gimple_call_num_args (_c1) == 1)
5878 : : {
5879 : 1157 : tree _q20 = gimple_call_arg (_c1, 0);
5880 : 1157 : _q20 = do_valueize (valueize, _q20);
5881 : 1157 : switch (TREE_CODE (_q20))
5882 : : {
5883 : 1157 : case SSA_NAME:
5884 : 1157 : if (gimple *_d2 = get_def (valueize, _q20))
5885 : : {
5886 : 1135 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
5887 : 1135 : switch (gimple_assign_rhs_code (_a2))
5888 : : {
5889 : 1135 : CASE_CONVERT:
5890 : 1135 : {
5891 : 1135 : tree _q30 = gimple_assign_rhs1 (_a2);
5892 : 1135 : _q30 = do_valueize (valueize, _q30);
5893 : 1135 : if (gimple_float16_value_p (_q30, valueize))
5894 : : {
5895 : 4 : {
5896 : 4 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
5897 : 4 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_SQRTL, CFN_SQRT))
5898 : 4 : return true;
5899 : : }
5900 : : }
5901 : : break;
5902 : : }
5903 : : default:;
5904 : : }
5905 : : }
5906 : : break;
5907 : : default:;
5908 : : }
5909 : : }
5910 : : break;
5911 : 105 : case CFN_BUILT_IN_TRUNC:
5912 : 105 : if (gimple_call_num_args (_c1) == 1)
5913 : : {
5914 : 105 : tree _q20 = gimple_call_arg (_c1, 0);
5915 : 105 : _q20 = do_valueize (valueize, _q20);
5916 : 105 : switch (TREE_CODE (_q20))
5917 : : {
5918 : 105 : case SSA_NAME:
5919 : 105 : if (gimple *_d2 = get_def (valueize, _q20))
5920 : : {
5921 : 105 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
5922 : 69 : switch (gimple_assign_rhs_code (_a2))
5923 : : {
5924 : 43 : CASE_CONVERT:
5925 : 43 : {
5926 : 43 : tree _q30 = gimple_assign_rhs1 (_a2);
5927 : 43 : _q30 = do_valueize (valueize, _q30);
5928 : 43 : if (gimple_float16_value_p (_q30, valueize))
5929 : : {
5930 : 8 : {
5931 : 8 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
5932 : 8 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_TRUNC, CFN_TRUNC))
5933 : 8 : return true;
5934 : : }
5935 : : }
5936 : : break;
5937 : : }
5938 : : default:;
5939 : : }
5940 : : }
5941 : : break;
5942 : : default:;
5943 : : }
5944 : : }
5945 : : break;
5946 : 32 : case CFN_BUILT_IN_FMA:
5947 : 32 : if (gimple_call_num_args (_c1) == 3)
5948 : : {
5949 : 32 : tree _q20 = gimple_call_arg (_c1, 0);
5950 : 32 : _q20 = do_valueize (valueize, _q20);
5951 : 32 : tree _q21 = gimple_call_arg (_c1, 1);
5952 : 32 : _q21 = do_valueize (valueize, _q21);
5953 : 32 : tree _q22 = gimple_call_arg (_c1, 2);
5954 : 32 : _q22 = do_valueize (valueize, _q22);
5955 : 32 : if (tree_swap_operands_p (_q20, _q21))
5956 : 0 : std::swap (_q20, _q21);
5957 : 32 : switch (TREE_CODE (_q20))
5958 : : {
5959 : 4 : case SSA_NAME:
5960 : 4 : if (gimple *_d2 = get_def (valueize, _q20))
5961 : : {
5962 : 4 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
5963 : 4 : switch (gimple_assign_rhs_code (_a2))
5964 : : {
5965 : 4 : CASE_CONVERT:
5966 : 4 : {
5967 : 4 : tree _q30 = gimple_assign_rhs1 (_a2);
5968 : 4 : _q30 = do_valueize (valueize, _q30);
5969 : 4 : switch (TREE_CODE (_q21))
5970 : : {
5971 : 4 : case SSA_NAME:
5972 : 4 : if (gimple *_d3 = get_def (valueize, _q21))
5973 : : {
5974 : 4 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
5975 : 4 : switch (gimple_assign_rhs_code (_a3))
5976 : : {
5977 : 4 : CASE_CONVERT:
5978 : 4 : {
5979 : 4 : tree _q50 = gimple_assign_rhs1 (_a3);
5980 : 4 : _q50 = do_valueize (valueize, _q50);
5981 : 4 : switch (TREE_CODE (_q22))
5982 : : {
5983 : 4 : case SSA_NAME:
5984 : 4 : if (gimple *_d4 = get_def (valueize, _q22))
5985 : : {
5986 : 4 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
5987 : 4 : switch (gimple_assign_rhs_code (_a4))
5988 : : {
5989 : 4 : CASE_CONVERT:
5990 : 4 : {
5991 : 4 : tree _q70 = gimple_assign_rhs1 (_a4);
5992 : 4 : _q70 = do_valueize (valueize, _q70);
5993 : 4 : {
5994 : 4 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q30, _q50, _q70 };
5995 : 4 : if (gimple_simplify_391 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FMA, CFN_FMA))
5996 : 4 : return true;
5997 : : }
5998 : 0 : break;
5999 : : }
6000 : : default:;
6001 : : }
6002 : : }
6003 : : break;
6004 : : default:;
6005 : : }
6006 : : break;
6007 : : }
6008 : : default:;
6009 : : }
6010 : : }
6011 : : break;
6012 : : default:;
6013 : : }
6014 : : break;
6015 : : }
6016 : : default:;
6017 : : }
6018 : : }
6019 : : break;
6020 : : default:;
6021 : : }
6022 : : }
6023 : : break;
6024 : 345 : case CFN_BUILT_IN_ROUNDF:
6025 : 345 : if (gimple_call_num_args (_c1) == 1)
6026 : : {
6027 : 345 : tree _q20 = gimple_call_arg (_c1, 0);
6028 : 345 : _q20 = do_valueize (valueize, _q20);
6029 : 345 : switch (TREE_CODE (_q20))
6030 : : {
6031 : 345 : case SSA_NAME:
6032 : 345 : if (gimple *_d2 = get_def (valueize, _q20))
6033 : : {
6034 : 341 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6035 : 279 : switch (gimple_assign_rhs_code (_a2))
6036 : : {
6037 : 139 : CASE_CONVERT:
6038 : 139 : {
6039 : 139 : tree _q30 = gimple_assign_rhs1 (_a2);
6040 : 139 : _q30 = do_valueize (valueize, _q30);
6041 : 139 : if (gimple_float16_value_p (_q30, valueize))
6042 : : {
6043 : 38 : {
6044 : 38 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
6045 : 38 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_ROUNDF, CFN_ROUND))
6046 : 0 : return true;
6047 : : }
6048 : : }
6049 : : break;
6050 : : }
6051 : : default:;
6052 : : }
6053 : : }
6054 : : break;
6055 : : default:;
6056 : : }
6057 : : }
6058 : : break;
6059 : 36 : case CFN_BUILT_IN_ROUNDL:
6060 : 36 : if (gimple_call_num_args (_c1) == 1)
6061 : : {
6062 : 36 : tree _q20 = gimple_call_arg (_c1, 0);
6063 : 36 : _q20 = do_valueize (valueize, _q20);
6064 : 36 : switch (TREE_CODE (_q20))
6065 : : {
6066 : 36 : case SSA_NAME:
6067 : 36 : if (gimple *_d2 = get_def (valueize, _q20))
6068 : : {
6069 : 36 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6070 : 36 : switch (gimple_assign_rhs_code (_a2))
6071 : : {
6072 : 36 : CASE_CONVERT:
6073 : 36 : {
6074 : 36 : tree _q30 = gimple_assign_rhs1 (_a2);
6075 : 36 : _q30 = do_valueize (valueize, _q30);
6076 : 36 : if (gimple_float16_value_p (_q30, valueize))
6077 : : {
6078 : 0 : {
6079 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
6080 : 0 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_ROUNDL, CFN_ROUND))
6081 : 0 : return true;
6082 : : }
6083 : : }
6084 : : break;
6085 : : }
6086 : : default:;
6087 : : }
6088 : : }
6089 : : break;
6090 : : default:;
6091 : : }
6092 : : }
6093 : : break;
6094 : 119 : case CFN_BUILT_IN_CEIL:
6095 : 119 : if (gimple_call_num_args (_c1) == 1)
6096 : : {
6097 : 119 : tree _q20 = gimple_call_arg (_c1, 0);
6098 : 119 : _q20 = do_valueize (valueize, _q20);
6099 : 119 : switch (TREE_CODE (_q20))
6100 : : {
6101 : 119 : case SSA_NAME:
6102 : 119 : if (gimple *_d2 = get_def (valueize, _q20))
6103 : : {
6104 : 118 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6105 : 68 : switch (gimple_assign_rhs_code (_a2))
6106 : : {
6107 : 68 : CASE_CONVERT:
6108 : 68 : {
6109 : 68 : tree _q30 = gimple_assign_rhs1 (_a2);
6110 : 68 : _q30 = do_valueize (valueize, _q30);
6111 : 68 : if (gimple_float16_value_p (_q30, valueize))
6112 : : {
6113 : 8 : {
6114 : 8 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
6115 : 8 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_CEIL, CFN_CEIL))
6116 : 8 : return true;
6117 : : }
6118 : : }
6119 : : break;
6120 : : }
6121 : : default:;
6122 : : }
6123 : : }
6124 : : break;
6125 : : default:;
6126 : : }
6127 : : }
6128 : : break;
6129 : 228 : case CFN_BUILT_IN_FMAF:
6130 : 228 : if (gimple_call_num_args (_c1) == 3)
6131 : : {
6132 : 228 : tree _q20 = gimple_call_arg (_c1, 0);
6133 : 228 : _q20 = do_valueize (valueize, _q20);
6134 : 228 : tree _q21 = gimple_call_arg (_c1, 1);
6135 : 228 : _q21 = do_valueize (valueize, _q21);
6136 : 228 : tree _q22 = gimple_call_arg (_c1, 2);
6137 : 228 : _q22 = do_valueize (valueize, _q22);
6138 : 228 : if (tree_swap_operands_p (_q20, _q21))
6139 : 0 : std::swap (_q20, _q21);
6140 : 228 : switch (TREE_CODE (_q20))
6141 : : {
6142 : 78 : case SSA_NAME:
6143 : 78 : if (gimple *_d2 = get_def (valueize, _q20))
6144 : : {
6145 : 78 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6146 : 78 : switch (gimple_assign_rhs_code (_a2))
6147 : : {
6148 : 78 : CASE_CONVERT:
6149 : 78 : {
6150 : 78 : tree _q30 = gimple_assign_rhs1 (_a2);
6151 : 78 : _q30 = do_valueize (valueize, _q30);
6152 : 78 : switch (TREE_CODE (_q21))
6153 : : {
6154 : 78 : case SSA_NAME:
6155 : 78 : if (gimple *_d3 = get_def (valueize, _q21))
6156 : : {
6157 : 78 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
6158 : 78 : switch (gimple_assign_rhs_code (_a3))
6159 : : {
6160 : 78 : CASE_CONVERT:
6161 : 78 : {
6162 : 78 : tree _q50 = gimple_assign_rhs1 (_a3);
6163 : 78 : _q50 = do_valueize (valueize, _q50);
6164 : 78 : switch (TREE_CODE (_q22))
6165 : : {
6166 : 78 : case SSA_NAME:
6167 : 78 : if (gimple *_d4 = get_def (valueize, _q22))
6168 : : {
6169 : 78 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
6170 : 78 : switch (gimple_assign_rhs_code (_a4))
6171 : : {
6172 : 78 : CASE_CONVERT:
6173 : 78 : {
6174 : 78 : tree _q70 = gimple_assign_rhs1 (_a4);
6175 : 78 : _q70 = do_valueize (valueize, _q70);
6176 : 78 : {
6177 : 78 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q30, _q50, _q70 };
6178 : 78 : if (gimple_simplify_391 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FMAF, CFN_FMA))
6179 : 2 : return true;
6180 : : }
6181 : 76 : break;
6182 : : }
6183 : : default:;
6184 : : }
6185 : : }
6186 : : break;
6187 : : default:;
6188 : : }
6189 : : break;
6190 : : }
6191 : : default:;
6192 : : }
6193 : : }
6194 : : break;
6195 : : default:;
6196 : : }
6197 : : break;
6198 : : }
6199 : : default:;
6200 : : }
6201 : : }
6202 : : break;
6203 : : default:;
6204 : : }
6205 : : }
6206 : : break;
6207 : 18 : case CFN_BUILT_IN_FMAL:
6208 : 18 : if (gimple_call_num_args (_c1) == 3)
6209 : : {
6210 : 18 : tree _q20 = gimple_call_arg (_c1, 0);
6211 : 18 : _q20 = do_valueize (valueize, _q20);
6212 : 18 : tree _q21 = gimple_call_arg (_c1, 1);
6213 : 18 : _q21 = do_valueize (valueize, _q21);
6214 : 18 : tree _q22 = gimple_call_arg (_c1, 2);
6215 : 18 : _q22 = do_valueize (valueize, _q22);
6216 : 18 : if (tree_swap_operands_p (_q20, _q21))
6217 : 0 : std::swap (_q20, _q21);
6218 : 18 : switch (TREE_CODE (_q20))
6219 : : {
6220 : 18 : case SSA_NAME:
6221 : 18 : if (gimple *_d2 = get_def (valueize, _q20))
6222 : : {
6223 : 18 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6224 : 18 : switch (gimple_assign_rhs_code (_a2))
6225 : : {
6226 : 18 : CASE_CONVERT:
6227 : 18 : {
6228 : 18 : tree _q30 = gimple_assign_rhs1 (_a2);
6229 : 18 : _q30 = do_valueize (valueize, _q30);
6230 : 18 : switch (TREE_CODE (_q21))
6231 : : {
6232 : 18 : case SSA_NAME:
6233 : 18 : if (gimple *_d3 = get_def (valueize, _q21))
6234 : : {
6235 : 18 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
6236 : 18 : switch (gimple_assign_rhs_code (_a3))
6237 : : {
6238 : 18 : CASE_CONVERT:
6239 : 18 : {
6240 : 18 : tree _q50 = gimple_assign_rhs1 (_a3);
6241 : 18 : _q50 = do_valueize (valueize, _q50);
6242 : 18 : switch (TREE_CODE (_q22))
6243 : : {
6244 : 18 : case SSA_NAME:
6245 : 18 : if (gimple *_d4 = get_def (valueize, _q22))
6246 : : {
6247 : 18 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
6248 : 18 : switch (gimple_assign_rhs_code (_a4))
6249 : : {
6250 : 18 : CASE_CONVERT:
6251 : 18 : {
6252 : 18 : tree _q70 = gimple_assign_rhs1 (_a4);
6253 : 18 : _q70 = do_valueize (valueize, _q70);
6254 : 18 : {
6255 : 18 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q30, _q50, _q70 };
6256 : 18 : if (gimple_simplify_391 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FMAL, CFN_FMA))
6257 : 18 : return true;
6258 : : }
6259 : 0 : break;
6260 : : }
6261 : : default:;
6262 : : }
6263 : : }
6264 : : break;
6265 : : default:;
6266 : : }
6267 : : break;
6268 : : }
6269 : : default:;
6270 : : }
6271 : : }
6272 : : break;
6273 : : default:;
6274 : : }
6275 : : break;
6276 : : }
6277 : : default:;
6278 : : }
6279 : : }
6280 : : break;
6281 : : default:;
6282 : : }
6283 : : }
6284 : : break;
6285 : 74 : case CFN_BUILT_IN_RINT:
6286 : 74 : if (gimple_call_num_args (_c1) == 1)
6287 : : {
6288 : 74 : tree _q20 = gimple_call_arg (_c1, 0);
6289 : 74 : _q20 = do_valueize (valueize, _q20);
6290 : 74 : switch (TREE_CODE (_q20))
6291 : : {
6292 : 74 : case SSA_NAME:
6293 : 74 : if (gimple *_d2 = get_def (valueize, _q20))
6294 : : {
6295 : 74 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6296 : 38 : switch (gimple_assign_rhs_code (_a2))
6297 : : {
6298 : 38 : CASE_CONVERT:
6299 : 38 : {
6300 : 38 : tree _q30 = gimple_assign_rhs1 (_a2);
6301 : 38 : _q30 = do_valueize (valueize, _q30);
6302 : 38 : if (gimple_float16_value_p (_q30, valueize))
6303 : : {
6304 : 8 : {
6305 : 8 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
6306 : 8 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_RINT, CFN_RINT))
6307 : 8 : return true;
6308 : : }
6309 : : }
6310 : : break;
6311 : : }
6312 : : default:;
6313 : : }
6314 : : }
6315 : : break;
6316 : : default:;
6317 : : }
6318 : : }
6319 : : break;
6320 : 100 : case CFN_BUILT_IN_SQRT:
6321 : 100 : if (gimple_call_num_args (_c1) == 1)
6322 : : {
6323 : 100 : tree _q20 = gimple_call_arg (_c1, 0);
6324 : 100 : _q20 = do_valueize (valueize, _q20);
6325 : 100 : switch (TREE_CODE (_q20))
6326 : : {
6327 : 100 : case SSA_NAME:
6328 : 100 : if (gimple *_d2 = get_def (valueize, _q20))
6329 : : {
6330 : 97 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6331 : 97 : switch (gimple_assign_rhs_code (_a2))
6332 : : {
6333 : 19 : CASE_CONVERT:
6334 : 19 : {
6335 : 19 : tree _q30 = gimple_assign_rhs1 (_a2);
6336 : 19 : _q30 = do_valueize (valueize, _q30);
6337 : 19 : if (gimple_float16_value_p (_q30, valueize))
6338 : : {
6339 : 4 : {
6340 : 4 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
6341 : 4 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_SQRT, CFN_SQRT))
6342 : 4 : return true;
6343 : : }
6344 : : }
6345 : : break;
6346 : : }
6347 : : default:;
6348 : : }
6349 : : }
6350 : : break;
6351 : : default:;
6352 : : }
6353 : : }
6354 : : break;
6355 : 612 : case CFN_BUILT_IN_COPYSIGNF16:
6356 : 612 : if (gimple_call_num_args (_c1) == 2)
6357 : : {
6358 : 612 : tree _q20 = gimple_call_arg (_c1, 0);
6359 : 612 : _q20 = do_valueize (valueize, _q20);
6360 : 612 : tree _q21 = gimple_call_arg (_c1, 1);
6361 : 612 : _q21 = do_valueize (valueize, _q21);
6362 : 612 : switch (TREE_CODE (_q20))
6363 : : {
6364 : 428 : case SSA_NAME:
6365 : 428 : if (gimple *_d2 = get_def (valueize, _q20))
6366 : : {
6367 : 428 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6368 : 396 : switch (gimple_assign_rhs_code (_a2))
6369 : : {
6370 : 28 : CASE_CONVERT:
6371 : 28 : {
6372 : 28 : tree _q30 = gimple_assign_rhs1 (_a2);
6373 : 28 : _q30 = do_valueize (valueize, _q30);
6374 : 28 : switch (TREE_CODE (_q21))
6375 : : {
6376 : 28 : case SSA_NAME:
6377 : 28 : if (gimple *_d3 = get_def (valueize, _q21))
6378 : : {
6379 : 28 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
6380 : 0 : switch (gimple_assign_rhs_code (_a3))
6381 : : {
6382 : 0 : CASE_CONVERT:
6383 : 0 : {
6384 : 0 : tree _q50 = gimple_assign_rhs1 (_a3);
6385 : 0 : _q50 = do_valueize (valueize, _q50);
6386 : 0 : {
6387 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q50 };
6388 : 0 : if (gimple_simplify_390 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_COPYSIGNF16))
6389 : 0 : return true;
6390 : : }
6391 : 0 : break;
6392 : : }
6393 : : default:;
6394 : : }
6395 : : }
6396 : : break;
6397 : : default:;
6398 : : }
6399 : : break;
6400 : : }
6401 : : default:;
6402 : : }
6403 : : }
6404 : : break;
6405 : : default:;
6406 : : }
6407 : : }
6408 : : break;
6409 : 0 : case CFN_BUILT_IN_COPYSIGNF32:
6410 : 0 : if (gimple_call_num_args (_c1) == 2)
6411 : : {
6412 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
6413 : 0 : _q20 = do_valueize (valueize, _q20);
6414 : 0 : tree _q21 = gimple_call_arg (_c1, 1);
6415 : 0 : _q21 = do_valueize (valueize, _q21);
6416 : 0 : switch (TREE_CODE (_q20))
6417 : : {
6418 : 0 : case SSA_NAME:
6419 : 0 : if (gimple *_d2 = get_def (valueize, _q20))
6420 : : {
6421 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6422 : 0 : switch (gimple_assign_rhs_code (_a2))
6423 : : {
6424 : 0 : CASE_CONVERT:
6425 : 0 : {
6426 : 0 : tree _q30 = gimple_assign_rhs1 (_a2);
6427 : 0 : _q30 = do_valueize (valueize, _q30);
6428 : 0 : switch (TREE_CODE (_q21))
6429 : : {
6430 : 0 : case SSA_NAME:
6431 : 0 : if (gimple *_d3 = get_def (valueize, _q21))
6432 : : {
6433 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
6434 : 0 : switch (gimple_assign_rhs_code (_a3))
6435 : : {
6436 : 0 : CASE_CONVERT:
6437 : 0 : {
6438 : 0 : tree _q50 = gimple_assign_rhs1 (_a3);
6439 : 0 : _q50 = do_valueize (valueize, _q50);
6440 : 0 : {
6441 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q50 };
6442 : 0 : if (gimple_simplify_390 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_COPYSIGNF32))
6443 : 0 : return true;
6444 : : }
6445 : 0 : break;
6446 : : }
6447 : : default:;
6448 : : }
6449 : : }
6450 : : break;
6451 : : default:;
6452 : : }
6453 : : break;
6454 : : }
6455 : : default:;
6456 : : }
6457 : : }
6458 : : break;
6459 : : default:;
6460 : : }
6461 : : }
6462 : : break;
6463 : 0 : case CFN_BUILT_IN_COPYSIGNF64:
6464 : 0 : if (gimple_call_num_args (_c1) == 2)
6465 : : {
6466 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
6467 : 0 : _q20 = do_valueize (valueize, _q20);
6468 : 0 : tree _q21 = gimple_call_arg (_c1, 1);
6469 : 0 : _q21 = do_valueize (valueize, _q21);
6470 : 0 : switch (TREE_CODE (_q20))
6471 : : {
6472 : 0 : case SSA_NAME:
6473 : 0 : if (gimple *_d2 = get_def (valueize, _q20))
6474 : : {
6475 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6476 : 0 : switch (gimple_assign_rhs_code (_a2))
6477 : : {
6478 : 0 : CASE_CONVERT:
6479 : 0 : {
6480 : 0 : tree _q30 = gimple_assign_rhs1 (_a2);
6481 : 0 : _q30 = do_valueize (valueize, _q30);
6482 : 0 : switch (TREE_CODE (_q21))
6483 : : {
6484 : 0 : case SSA_NAME:
6485 : 0 : if (gimple *_d3 = get_def (valueize, _q21))
6486 : : {
6487 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
6488 : 0 : switch (gimple_assign_rhs_code (_a3))
6489 : : {
6490 : 0 : CASE_CONVERT:
6491 : 0 : {
6492 : 0 : tree _q50 = gimple_assign_rhs1 (_a3);
6493 : 0 : _q50 = do_valueize (valueize, _q50);
6494 : 0 : {
6495 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q50 };
6496 : 0 : if (gimple_simplify_390 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_COPYSIGNF64))
6497 : 0 : return true;
6498 : : }
6499 : 0 : break;
6500 : : }
6501 : : default:;
6502 : : }
6503 : : }
6504 : : break;
6505 : : default:;
6506 : : }
6507 : : break;
6508 : : }
6509 : : default:;
6510 : : }
6511 : : }
6512 : : break;
6513 : : default:;
6514 : : }
6515 : : }
6516 : : break;
6517 : 564 : case CFN_BUILT_IN_FLOORF:
6518 : 564 : if (gimple_call_num_args (_c1) == 1)
6519 : : {
6520 : 564 : tree _q20 = gimple_call_arg (_c1, 0);
6521 : 564 : _q20 = do_valueize (valueize, _q20);
6522 : 564 : switch (TREE_CODE (_q20))
6523 : : {
6524 : 564 : case SSA_NAME:
6525 : 564 : if (gimple *_d2 = get_def (valueize, _q20))
6526 : : {
6527 : 564 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6528 : 356 : switch (gimple_assign_rhs_code (_a2))
6529 : : {
6530 : 312 : CASE_CONVERT:
6531 : 312 : {
6532 : 312 : tree _q30 = gimple_assign_rhs1 (_a2);
6533 : 312 : _q30 = do_valueize (valueize, _q30);
6534 : 312 : if (gimple_float16_value_p (_q30, valueize))
6535 : : {
6536 : 130 : {
6537 : 130 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
6538 : 130 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FLOORF, CFN_FLOOR))
6539 : 2 : return true;
6540 : : }
6541 : : }
6542 : : break;
6543 : : }
6544 : : default:;
6545 : : }
6546 : : }
6547 : : break;
6548 : : default:;
6549 : : }
6550 : : }
6551 : : break;
6552 : 47 : case CFN_BUILT_IN_FLOORL:
6553 : 47 : if (gimple_call_num_args (_c1) == 1)
6554 : : {
6555 : 47 : tree _q20 = gimple_call_arg (_c1, 0);
6556 : 47 : _q20 = do_valueize (valueize, _q20);
6557 : 47 : switch (TREE_CODE (_q20))
6558 : : {
6559 : 47 : case SSA_NAME:
6560 : 47 : if (gimple *_d2 = get_def (valueize, _q20))
6561 : : {
6562 : 47 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6563 : 47 : switch (gimple_assign_rhs_code (_a2))
6564 : : {
6565 : 47 : CASE_CONVERT:
6566 : 47 : {
6567 : 47 : tree _q30 = gimple_assign_rhs1 (_a2);
6568 : 47 : _q30 = do_valueize (valueize, _q30);
6569 : 47 : if (gimple_float16_value_p (_q30, valueize))
6570 : : {
6571 : 2 : {
6572 : 2 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
6573 : 2 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FLOORL, CFN_FLOOR))
6574 : 2 : return true;
6575 : : }
6576 : : }
6577 : : break;
6578 : : }
6579 : : default:;
6580 : : }
6581 : : }
6582 : : break;
6583 : : default:;
6584 : : }
6585 : : }
6586 : : break;
6587 : 74 : case CFN_BUILT_IN_NEARBYINT:
6588 : 74 : if (gimple_call_num_args (_c1) == 1)
6589 : : {
6590 : 74 : tree _q20 = gimple_call_arg (_c1, 0);
6591 : 74 : _q20 = do_valueize (valueize, _q20);
6592 : 74 : switch (TREE_CODE (_q20))
6593 : : {
6594 : 74 : case SSA_NAME:
6595 : 74 : if (gimple *_d2 = get_def (valueize, _q20))
6596 : : {
6597 : 74 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6598 : 38 : switch (gimple_assign_rhs_code (_a2))
6599 : : {
6600 : 38 : CASE_CONVERT:
6601 : 38 : {
6602 : 38 : tree _q30 = gimple_assign_rhs1 (_a2);
6603 : 38 : _q30 = do_valueize (valueize, _q30);
6604 : 38 : if (gimple_float16_value_p (_q30, valueize))
6605 : : {
6606 : 8 : {
6607 : 8 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
6608 : 8 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_NEARBYINT, CFN_NEARBYINT))
6609 : 8 : return true;
6610 : : }
6611 : : }
6612 : : break;
6613 : : }
6614 : : default:;
6615 : : }
6616 : : }
6617 : : break;
6618 : : default:;
6619 : : }
6620 : : }
6621 : : break;
6622 : 258 : case CFN_BUILT_IN_NEARBYINTF:
6623 : 258 : if (gimple_call_num_args (_c1) == 1)
6624 : : {
6625 : 258 : tree _q20 = gimple_call_arg (_c1, 0);
6626 : 258 : _q20 = do_valueize (valueize, _q20);
6627 : 258 : switch (TREE_CODE (_q20))
6628 : : {
6629 : 258 : case SSA_NAME:
6630 : 258 : if (gimple *_d2 = get_def (valueize, _q20))
6631 : : {
6632 : 258 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6633 : 126 : switch (gimple_assign_rhs_code (_a2))
6634 : : {
6635 : 126 : CASE_CONVERT:
6636 : 126 : {
6637 : 126 : tree _q30 = gimple_assign_rhs1 (_a2);
6638 : 126 : _q30 = do_valueize (valueize, _q30);
6639 : 126 : if (gimple_float16_value_p (_q30, valueize))
6640 : : {
6641 : 40 : {
6642 : 40 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
6643 : 40 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_NEARBYINTF, CFN_NEARBYINT))
6644 : 2 : return true;
6645 : : }
6646 : : }
6647 : : break;
6648 : : }
6649 : : default:;
6650 : : }
6651 : : }
6652 : : break;
6653 : : default:;
6654 : : }
6655 : : }
6656 : : break;
6657 : 38 : case CFN_BUILT_IN_NEARBYINTL:
6658 : 38 : if (gimple_call_num_args (_c1) == 1)
6659 : : {
6660 : 38 : tree _q20 = gimple_call_arg (_c1, 0);
6661 : 38 : _q20 = do_valueize (valueize, _q20);
6662 : 38 : switch (TREE_CODE (_q20))
6663 : : {
6664 : 38 : case SSA_NAME:
6665 : 38 : if (gimple *_d2 = get_def (valueize, _q20))
6666 : : {
6667 : 38 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6668 : 38 : switch (gimple_assign_rhs_code (_a2))
6669 : : {
6670 : 38 : CASE_CONVERT:
6671 : 38 : {
6672 : 38 : tree _q30 = gimple_assign_rhs1 (_a2);
6673 : 38 : _q30 = do_valueize (valueize, _q30);
6674 : 38 : if (gimple_float16_value_p (_q30, valueize))
6675 : : {
6676 : 2 : {
6677 : 2 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
6678 : 2 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_NEARBYINTL, CFN_NEARBYINT))
6679 : 2 : return true;
6680 : : }
6681 : : }
6682 : : break;
6683 : : }
6684 : : default:;
6685 : : }
6686 : : }
6687 : : break;
6688 : : default:;
6689 : : }
6690 : : }
6691 : : break;
6692 : 2 : case CFN_BUILT_IN_ROUNDEVEN:
6693 : 2 : if (gimple_call_num_args (_c1) == 1)
6694 : : {
6695 : 2 : tree _q20 = gimple_call_arg (_c1, 0);
6696 : 2 : _q20 = do_valueize (valueize, _q20);
6697 : 2 : switch (TREE_CODE (_q20))
6698 : : {
6699 : 2 : case SSA_NAME:
6700 : 2 : if (gimple *_d2 = get_def (valueize, _q20))
6701 : : {
6702 : 2 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6703 : 2 : switch (gimple_assign_rhs_code (_a2))
6704 : : {
6705 : 2 : CASE_CONVERT:
6706 : 2 : {
6707 : 2 : tree _q30 = gimple_assign_rhs1 (_a2);
6708 : 2 : _q30 = do_valueize (valueize, _q30);
6709 : 2 : if (gimple_float16_value_p (_q30, valueize))
6710 : : {
6711 : 2 : {
6712 : 2 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
6713 : 2 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_ROUNDEVEN, CFN_ROUNDEVEN))
6714 : 2 : return true;
6715 : : }
6716 : : }
6717 : : break;
6718 : : }
6719 : : default:;
6720 : : }
6721 : : }
6722 : : break;
6723 : : default:;
6724 : : }
6725 : : }
6726 : : break;
6727 : 0 : case CFN_BUILT_IN_COPYSIGNF128X:
6728 : 0 : if (gimple_call_num_args (_c1) == 2)
6729 : : {
6730 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
6731 : 0 : _q20 = do_valueize (valueize, _q20);
6732 : 0 : tree _q21 = gimple_call_arg (_c1, 1);
6733 : 0 : _q21 = do_valueize (valueize, _q21);
6734 : 0 : switch (TREE_CODE (_q20))
6735 : : {
6736 : 0 : case SSA_NAME:
6737 : 0 : if (gimple *_d2 = get_def (valueize, _q20))
6738 : : {
6739 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6740 : 0 : switch (gimple_assign_rhs_code (_a2))
6741 : : {
6742 : 0 : CASE_CONVERT:
6743 : 0 : {
6744 : 0 : tree _q30 = gimple_assign_rhs1 (_a2);
6745 : 0 : _q30 = do_valueize (valueize, _q30);
6746 : 0 : switch (TREE_CODE (_q21))
6747 : : {
6748 : 0 : case SSA_NAME:
6749 : 0 : if (gimple *_d3 = get_def (valueize, _q21))
6750 : : {
6751 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
6752 : 0 : switch (gimple_assign_rhs_code (_a3))
6753 : : {
6754 : 0 : CASE_CONVERT:
6755 : 0 : {
6756 : 0 : tree _q50 = gimple_assign_rhs1 (_a3);
6757 : 0 : _q50 = do_valueize (valueize, _q50);
6758 : 0 : {
6759 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q50 };
6760 : 0 : if (gimple_simplify_390 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_COPYSIGNF128X))
6761 : 0 : return true;
6762 : : }
6763 : 0 : break;
6764 : : }
6765 : : default:;
6766 : : }
6767 : : }
6768 : : break;
6769 : : default:;
6770 : : }
6771 : : break;
6772 : : }
6773 : : default:;
6774 : : }
6775 : : }
6776 : : break;
6777 : : default:;
6778 : : }
6779 : : }
6780 : : break;
6781 : 0 : case CFN_BUILT_IN_COPYSIGNF128:
6782 : 0 : if (gimple_call_num_args (_c1) == 2)
6783 : : {
6784 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
6785 : 0 : _q20 = do_valueize (valueize, _q20);
6786 : 0 : tree _q21 = gimple_call_arg (_c1, 1);
6787 : 0 : _q21 = do_valueize (valueize, _q21);
6788 : 0 : switch (TREE_CODE (_q20))
6789 : : {
6790 : 0 : case SSA_NAME:
6791 : 0 : if (gimple *_d2 = get_def (valueize, _q20))
6792 : : {
6793 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6794 : 0 : switch (gimple_assign_rhs_code (_a2))
6795 : : {
6796 : 0 : CASE_CONVERT:
6797 : 0 : {
6798 : 0 : tree _q30 = gimple_assign_rhs1 (_a2);
6799 : 0 : _q30 = do_valueize (valueize, _q30);
6800 : 0 : switch (TREE_CODE (_q21))
6801 : : {
6802 : 0 : case SSA_NAME:
6803 : 0 : if (gimple *_d3 = get_def (valueize, _q21))
6804 : : {
6805 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
6806 : 0 : switch (gimple_assign_rhs_code (_a3))
6807 : : {
6808 : 0 : CASE_CONVERT:
6809 : 0 : {
6810 : 0 : tree _q50 = gimple_assign_rhs1 (_a3);
6811 : 0 : _q50 = do_valueize (valueize, _q50);
6812 : 0 : {
6813 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q50 };
6814 : 0 : if (gimple_simplify_390 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_COPYSIGNF128))
6815 : 0 : return true;
6816 : : }
6817 : 0 : break;
6818 : : }
6819 : : default:;
6820 : : }
6821 : : }
6822 : : break;
6823 : : default:;
6824 : : }
6825 : : break;
6826 : : }
6827 : : default:;
6828 : : }
6829 : : }
6830 : : break;
6831 : : default:;
6832 : : }
6833 : : }
6834 : : break;
6835 : 0 : case CFN_BUILT_IN_COPYSIGNF32X:
6836 : 0 : if (gimple_call_num_args (_c1) == 2)
6837 : : {
6838 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
6839 : 0 : _q20 = do_valueize (valueize, _q20);
6840 : 0 : tree _q21 = gimple_call_arg (_c1, 1);
6841 : 0 : _q21 = do_valueize (valueize, _q21);
6842 : 0 : switch (TREE_CODE (_q20))
6843 : : {
6844 : 0 : case SSA_NAME:
6845 : 0 : if (gimple *_d2 = get_def (valueize, _q20))
6846 : : {
6847 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6848 : 0 : switch (gimple_assign_rhs_code (_a2))
6849 : : {
6850 : 0 : CASE_CONVERT:
6851 : 0 : {
6852 : 0 : tree _q30 = gimple_assign_rhs1 (_a2);
6853 : 0 : _q30 = do_valueize (valueize, _q30);
6854 : 0 : switch (TREE_CODE (_q21))
6855 : : {
6856 : 0 : case SSA_NAME:
6857 : 0 : if (gimple *_d3 = get_def (valueize, _q21))
6858 : : {
6859 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
6860 : 0 : switch (gimple_assign_rhs_code (_a3))
6861 : : {
6862 : 0 : CASE_CONVERT:
6863 : 0 : {
6864 : 0 : tree _q50 = gimple_assign_rhs1 (_a3);
6865 : 0 : _q50 = do_valueize (valueize, _q50);
6866 : 0 : {
6867 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q50 };
6868 : 0 : if (gimple_simplify_390 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_COPYSIGNF32X))
6869 : 0 : return true;
6870 : : }
6871 : 0 : break;
6872 : : }
6873 : : default:;
6874 : : }
6875 : : }
6876 : : break;
6877 : : default:;
6878 : : }
6879 : : break;
6880 : : }
6881 : : default:;
6882 : : }
6883 : : }
6884 : : break;
6885 : : default:;
6886 : : }
6887 : : }
6888 : : break;
6889 : 0 : case CFN_BUILT_IN_COPYSIGNF64X:
6890 : 0 : if (gimple_call_num_args (_c1) == 2)
6891 : : {
6892 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
6893 : 0 : _q20 = do_valueize (valueize, _q20);
6894 : 0 : tree _q21 = gimple_call_arg (_c1, 1);
6895 : 0 : _q21 = do_valueize (valueize, _q21);
6896 : 0 : switch (TREE_CODE (_q20))
6897 : : {
6898 : 0 : case SSA_NAME:
6899 : 0 : if (gimple *_d2 = get_def (valueize, _q20))
6900 : : {
6901 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6902 : 0 : switch (gimple_assign_rhs_code (_a2))
6903 : : {
6904 : 0 : CASE_CONVERT:
6905 : 0 : {
6906 : 0 : tree _q30 = gimple_assign_rhs1 (_a2);
6907 : 0 : _q30 = do_valueize (valueize, _q30);
6908 : 0 : switch (TREE_CODE (_q21))
6909 : : {
6910 : 0 : case SSA_NAME:
6911 : 0 : if (gimple *_d3 = get_def (valueize, _q21))
6912 : : {
6913 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
6914 : 0 : switch (gimple_assign_rhs_code (_a3))
6915 : : {
6916 : 0 : CASE_CONVERT:
6917 : 0 : {
6918 : 0 : tree _q50 = gimple_assign_rhs1 (_a3);
6919 : 0 : _q50 = do_valueize (valueize, _q50);
6920 : 0 : {
6921 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q50 };
6922 : 0 : if (gimple_simplify_390 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_COPYSIGNF64X))
6923 : 0 : return true;
6924 : : }
6925 : 0 : break;
6926 : : }
6927 : : default:;
6928 : : }
6929 : : }
6930 : : break;
6931 : : default:;
6932 : : }
6933 : : break;
6934 : : }
6935 : : default:;
6936 : : }
6937 : : }
6938 : : break;
6939 : : default:;
6940 : : }
6941 : : }
6942 : : break;
6943 : 23 : case CFN_BUILT_IN_COPYSIGN:
6944 : 23 : if (gimple_call_num_args (_c1) == 2)
6945 : : {
6946 : 23 : tree _q20 = gimple_call_arg (_c1, 0);
6947 : 23 : _q20 = do_valueize (valueize, _q20);
6948 : 23 : tree _q21 = gimple_call_arg (_c1, 1);
6949 : 23 : _q21 = do_valueize (valueize, _q21);
6950 : 23 : switch (TREE_CODE (_q20))
6951 : : {
6952 : 23 : case SSA_NAME:
6953 : 23 : if (gimple *_d2 = get_def (valueize, _q20))
6954 : : {
6955 : 23 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
6956 : 8 : switch (gimple_assign_rhs_code (_a2))
6957 : : {
6958 : 8 : CASE_CONVERT:
6959 : 8 : {
6960 : 8 : tree _q30 = gimple_assign_rhs1 (_a2);
6961 : 8 : _q30 = do_valueize (valueize, _q30);
6962 : 8 : switch (TREE_CODE (_q21))
6963 : : {
6964 : 8 : case SSA_NAME:
6965 : 8 : if (gimple *_d3 = get_def (valueize, _q21))
6966 : : {
6967 : 8 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
6968 : 8 : switch (gimple_assign_rhs_code (_a3))
6969 : : {
6970 : 8 : CASE_CONVERT:
6971 : 8 : {
6972 : 8 : tree _q50 = gimple_assign_rhs1 (_a3);
6973 : 8 : _q50 = do_valueize (valueize, _q50);
6974 : 8 : {
6975 : 8 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q50 };
6976 : 8 : if (gimple_simplify_390 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_COPYSIGN))
6977 : 8 : return true;
6978 : : }
6979 : 0 : break;
6980 : : }
6981 : : default:;
6982 : : }
6983 : : }
6984 : : break;
6985 : : default:;
6986 : : }
6987 : : break;
6988 : : }
6989 : : default:;
6990 : : }
6991 : : }
6992 : : break;
6993 : : default:;
6994 : : }
6995 : : }
6996 : : break;
6997 : 2 : case CFN_BUILT_IN_ROUNDEVENF:
6998 : 2 : if (gimple_call_num_args (_c1) == 1)
6999 : : {
7000 : 2 : tree _q20 = gimple_call_arg (_c1, 0);
7001 : 2 : _q20 = do_valueize (valueize, _q20);
7002 : 2 : switch (TREE_CODE (_q20))
7003 : : {
7004 : 2 : case SSA_NAME:
7005 : 2 : if (gimple *_d2 = get_def (valueize, _q20))
7006 : : {
7007 : 2 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
7008 : 2 : switch (gimple_assign_rhs_code (_a2))
7009 : : {
7010 : 2 : CASE_CONVERT:
7011 : 2 : {
7012 : 2 : tree _q30 = gimple_assign_rhs1 (_a2);
7013 : 2 : _q30 = do_valueize (valueize, _q30);
7014 : 2 : if (gimple_float16_value_p (_q30, valueize))
7015 : : {
7016 : 2 : {
7017 : 2 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
7018 : 2 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_ROUNDEVENF, CFN_ROUNDEVEN))
7019 : 2 : return true;
7020 : : }
7021 : : }
7022 : : break;
7023 : : }
7024 : : default:;
7025 : : }
7026 : : }
7027 : : break;
7028 : : default:;
7029 : : }
7030 : : }
7031 : : break;
7032 : 2 : case CFN_BUILT_IN_ROUNDEVENL:
7033 : 2 : if (gimple_call_num_args (_c1) == 1)
7034 : : {
7035 : 2 : tree _q20 = gimple_call_arg (_c1, 0);
7036 : 2 : _q20 = do_valueize (valueize, _q20);
7037 : 2 : switch (TREE_CODE (_q20))
7038 : : {
7039 : 2 : case SSA_NAME:
7040 : 2 : if (gimple *_d2 = get_def (valueize, _q20))
7041 : : {
7042 : 2 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
7043 : 2 : switch (gimple_assign_rhs_code (_a2))
7044 : : {
7045 : 2 : CASE_CONVERT:
7046 : 2 : {
7047 : 2 : tree _q30 = gimple_assign_rhs1 (_a2);
7048 : 2 : _q30 = do_valueize (valueize, _q30);
7049 : 2 : if (gimple_float16_value_p (_q30, valueize))
7050 : : {
7051 : 2 : {
7052 : 2 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
7053 : 2 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_ROUNDEVENL, CFN_ROUNDEVEN))
7054 : 2 : return true;
7055 : : }
7056 : : }
7057 : : break;
7058 : : }
7059 : : default:;
7060 : : }
7061 : : }
7062 : : break;
7063 : : default:;
7064 : : }
7065 : : }
7066 : : break;
7067 : 347 : case CFN_BUILT_IN_TRUNCF:
7068 : 347 : if (gimple_call_num_args (_c1) == 1)
7069 : : {
7070 : 347 : tree _q20 = gimple_call_arg (_c1, 0);
7071 : 347 : _q20 = do_valueize (valueize, _q20);
7072 : 347 : switch (TREE_CODE (_q20))
7073 : : {
7074 : 347 : case SSA_NAME:
7075 : 347 : if (gimple *_d2 = get_def (valueize, _q20))
7076 : : {
7077 : 343 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
7078 : 281 : switch (gimple_assign_rhs_code (_a2))
7079 : : {
7080 : 141 : CASE_CONVERT:
7081 : 141 : {
7082 : 141 : tree _q30 = gimple_assign_rhs1 (_a2);
7083 : 141 : _q30 = do_valueize (valueize, _q30);
7084 : 141 : if (gimple_float16_value_p (_q30, valueize))
7085 : : {
7086 : 40 : {
7087 : 40 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
7088 : 40 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_TRUNCF, CFN_TRUNC))
7089 : 2 : return true;
7090 : : }
7091 : : }
7092 : : break;
7093 : : }
7094 : : default:;
7095 : : }
7096 : : }
7097 : : break;
7098 : : default:;
7099 : : }
7100 : : }
7101 : : break;
7102 : 38 : case CFN_BUILT_IN_TRUNCL:
7103 : 38 : if (gimple_call_num_args (_c1) == 1)
7104 : : {
7105 : 38 : tree _q20 = gimple_call_arg (_c1, 0);
7106 : 38 : _q20 = do_valueize (valueize, _q20);
7107 : 38 : switch (TREE_CODE (_q20))
7108 : : {
7109 : 38 : case SSA_NAME:
7110 : 38 : if (gimple *_d2 = get_def (valueize, _q20))
7111 : : {
7112 : 38 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
7113 : 38 : switch (gimple_assign_rhs_code (_a2))
7114 : : {
7115 : 38 : CASE_CONVERT:
7116 : 38 : {
7117 : 38 : tree _q30 = gimple_assign_rhs1 (_a2);
7118 : 38 : _q30 = do_valueize (valueize, _q30);
7119 : 38 : if (gimple_float16_value_p (_q30, valueize))
7120 : : {
7121 : 2 : {
7122 : 2 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
7123 : 2 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_TRUNCL, CFN_TRUNC))
7124 : 2 : return true;
7125 : : }
7126 : : }
7127 : : break;
7128 : : }
7129 : : default:;
7130 : : }
7131 : : }
7132 : : break;
7133 : : default:;
7134 : : }
7135 : : }
7136 : : break;
7137 : 436 : case CFN_BUILT_IN_COPYSIGNF:
7138 : 436 : if (gimple_call_num_args (_c1) == 2)
7139 : : {
7140 : 436 : tree _q20 = gimple_call_arg (_c1, 0);
7141 : 436 : _q20 = do_valueize (valueize, _q20);
7142 : 436 : tree _q21 = gimple_call_arg (_c1, 1);
7143 : 436 : _q21 = do_valueize (valueize, _q21);
7144 : 436 : switch (TREE_CODE (_q20))
7145 : : {
7146 : 436 : case SSA_NAME:
7147 : 436 : if (gimple *_d2 = get_def (valueize, _q20))
7148 : : {
7149 : 436 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
7150 : 488 : switch (gimple_assign_rhs_code (_a2))
7151 : : {
7152 : 360 : CASE_CONVERT:
7153 : 360 : {
7154 : 360 : tree _q30 = gimple_assign_rhs1 (_a2);
7155 : 360 : _q30 = do_valueize (valueize, _q30);
7156 : 360 : switch (TREE_CODE (_q21))
7157 : : {
7158 : 360 : case SSA_NAME:
7159 : 360 : if (gimple *_d3 = get_def (valueize, _q21))
7160 : : {
7161 : 354 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
7162 : 348 : switch (gimple_assign_rhs_code (_a3))
7163 : : {
7164 : 348 : CASE_CONVERT:
7165 : 348 : {
7166 : 348 : tree _q50 = gimple_assign_rhs1 (_a3);
7167 : 348 : _q50 = do_valueize (valueize, _q50);
7168 : 348 : {
7169 : 348 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q50 };
7170 : 348 : if (gimple_simplify_390 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_COPYSIGNF))
7171 : 4 : return true;
7172 : : }
7173 : 344 : break;
7174 : : }
7175 : : default:;
7176 : : }
7177 : : }
7178 : : break;
7179 : : default:;
7180 : : }
7181 : : break;
7182 : : }
7183 : : default:;
7184 : : }
7185 : : }
7186 : : break;
7187 : : default:;
7188 : : }
7189 : : }
7190 : : break;
7191 : 12 : case CFN_BUILT_IN_COPYSIGNL:
7192 : 12 : if (gimple_call_num_args (_c1) == 2)
7193 : : {
7194 : 12 : tree _q20 = gimple_call_arg (_c1, 0);
7195 : 12 : _q20 = do_valueize (valueize, _q20);
7196 : 12 : tree _q21 = gimple_call_arg (_c1, 1);
7197 : 12 : _q21 = do_valueize (valueize, _q21);
7198 : 12 : switch (TREE_CODE (_q20))
7199 : : {
7200 : 12 : case SSA_NAME:
7201 : 12 : if (gimple *_d2 = get_def (valueize, _q20))
7202 : : {
7203 : 12 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
7204 : 12 : switch (gimple_assign_rhs_code (_a2))
7205 : : {
7206 : 12 : CASE_CONVERT:
7207 : 12 : {
7208 : 12 : tree _q30 = gimple_assign_rhs1 (_a2);
7209 : 12 : _q30 = do_valueize (valueize, _q30);
7210 : 12 : switch (TREE_CODE (_q21))
7211 : : {
7212 : 12 : case SSA_NAME:
7213 : 12 : if (gimple *_d3 = get_def (valueize, _q21))
7214 : : {
7215 : 12 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
7216 : 12 : switch (gimple_assign_rhs_code (_a3))
7217 : : {
7218 : 12 : CASE_CONVERT:
7219 : 12 : {
7220 : 12 : tree _q50 = gimple_assign_rhs1 (_a3);
7221 : 12 : _q50 = do_valueize (valueize, _q50);
7222 : 12 : {
7223 : 12 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q50 };
7224 : 12 : if (gimple_simplify_390 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_COPYSIGNL))
7225 : 12 : return true;
7226 : : }
7227 : 0 : break;
7228 : : }
7229 : : default:;
7230 : : }
7231 : : }
7232 : : break;
7233 : : default:;
7234 : : }
7235 : : break;
7236 : : }
7237 : : default:;
7238 : : }
7239 : : }
7240 : : break;
7241 : : default:;
7242 : : }
7243 : : }
7244 : : break;
7245 : 524 : case CFN_BUILT_IN_CEILF:
7246 : 524 : if (gimple_call_num_args (_c1) == 1)
7247 : : {
7248 : 524 : tree _q20 = gimple_call_arg (_c1, 0);
7249 : 524 : _q20 = do_valueize (valueize, _q20);
7250 : 524 : switch (TREE_CODE (_q20))
7251 : : {
7252 : 524 : case SSA_NAME:
7253 : 524 : if (gimple *_d2 = get_def (valueize, _q20))
7254 : : {
7255 : 524 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
7256 : 466 : switch (gimple_assign_rhs_code (_a2))
7257 : : {
7258 : 130 : CASE_CONVERT:
7259 : 130 : {
7260 : 130 : tree _q30 = gimple_assign_rhs1 (_a2);
7261 : 130 : _q30 = do_valueize (valueize, _q30);
7262 : 130 : if (gimple_float16_value_p (_q30, valueize))
7263 : : {
7264 : 40 : {
7265 : 40 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
7266 : 40 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_CEILF, CFN_CEIL))
7267 : 2 : return true;
7268 : : }
7269 : : }
7270 : : break;
7271 : : }
7272 : : default:;
7273 : : }
7274 : : }
7275 : : break;
7276 : : default:;
7277 : : }
7278 : : }
7279 : : break;
7280 : 44 : case CFN_BUILT_IN_CEILL:
7281 : 44 : if (gimple_call_num_args (_c1) == 1)
7282 : : {
7283 : 44 : tree _q20 = gimple_call_arg (_c1, 0);
7284 : 44 : _q20 = do_valueize (valueize, _q20);
7285 : 44 : switch (TREE_CODE (_q20))
7286 : : {
7287 : 44 : case SSA_NAME:
7288 : 44 : if (gimple *_d2 = get_def (valueize, _q20))
7289 : : {
7290 : 44 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
7291 : 44 : switch (gimple_assign_rhs_code (_a2))
7292 : : {
7293 : 44 : CASE_CONVERT:
7294 : 44 : {
7295 : 44 : tree _q30 = gimple_assign_rhs1 (_a2);
7296 : 44 : _q30 = do_valueize (valueize, _q30);
7297 : 44 : if (gimple_float16_value_p (_q30, valueize))
7298 : : {
7299 : 2 : {
7300 : 2 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
7301 : 2 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_CEILL, CFN_CEIL))
7302 : 2 : return true;
7303 : : }
7304 : : }
7305 : : break;
7306 : : }
7307 : : default:;
7308 : : }
7309 : : }
7310 : : break;
7311 : : default:;
7312 : : }
7313 : : }
7314 : : break;
7315 : 0 : case CFN_COPYSIGN:
7316 : 0 : if (gimple_call_num_args (_c1) == 2)
7317 : : {
7318 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
7319 : 0 : _q20 = do_valueize (valueize, _q20);
7320 : 0 : tree _q21 = gimple_call_arg (_c1, 1);
7321 : 0 : _q21 = do_valueize (valueize, _q21);
7322 : 0 : switch (TREE_CODE (_q20))
7323 : : {
7324 : 0 : case SSA_NAME:
7325 : 0 : if (gimple *_d2 = get_def (valueize, _q20))
7326 : : {
7327 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
7328 : 0 : switch (gimple_assign_rhs_code (_a2))
7329 : : {
7330 : 0 : CASE_CONVERT:
7331 : 0 : {
7332 : 0 : tree _q30 = gimple_assign_rhs1 (_a2);
7333 : 0 : _q30 = do_valueize (valueize, _q30);
7334 : 0 : switch (TREE_CODE (_q21))
7335 : : {
7336 : 0 : case SSA_NAME:
7337 : 0 : if (gimple *_d3 = get_def (valueize, _q21))
7338 : : {
7339 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
7340 : 0 : switch (gimple_assign_rhs_code (_a3))
7341 : : {
7342 : 0 : CASE_CONVERT:
7343 : 0 : {
7344 : 0 : tree _q50 = gimple_assign_rhs1 (_a3);
7345 : 0 : _q50 = do_valueize (valueize, _q50);
7346 : 0 : {
7347 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q50 };
7348 : 0 : if (gimple_simplify_390 (res_op, seq, valueize, type, captures, CFN_COPYSIGN))
7349 : 0 : return true;
7350 : : }
7351 : 0 : break;
7352 : : }
7353 : : default:;
7354 : : }
7355 : : }
7356 : : break;
7357 : : default:;
7358 : : }
7359 : : break;
7360 : : }
7361 : : default:;
7362 : : }
7363 : : }
7364 : : break;
7365 : : default:;
7366 : : }
7367 : : }
7368 : : break;
7369 : 398 : case CFN_BUILT_IN_FLOOR:
7370 : 398 : if (gimple_call_num_args (_c1) == 1)
7371 : : {
7372 : 398 : tree _q20 = gimple_call_arg (_c1, 0);
7373 : 398 : _q20 = do_valueize (valueize, _q20);
7374 : 398 : switch (TREE_CODE (_q20))
7375 : : {
7376 : 398 : case SSA_NAME:
7377 : 398 : if (gimple *_d2 = get_def (valueize, _q20))
7378 : : {
7379 : 397 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
7380 : 414 : switch (gimple_assign_rhs_code (_a2))
7381 : : {
7382 : 185 : CASE_CONVERT:
7383 : 185 : {
7384 : 185 : tree _q30 = gimple_assign_rhs1 (_a2);
7385 : 185 : _q30 = do_valueize (valueize, _q30);
7386 : 185 : if (gimple_float16_value_p (_q30, valueize))
7387 : : {
7388 : 8 : {
7389 : 8 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
7390 : 8 : if (gimple_simplify_389 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FLOOR, CFN_FLOOR))
7391 : 8 : return true;
7392 : : }
7393 : : }
7394 : : break;
7395 : : }
7396 : : default:;
7397 : : }
7398 : : }
7399 : : break;
7400 : : default:;
7401 : : }
7402 : : }
7403 : : break;
7404 : : default:;
7405 : : }
7406 : : }
7407 : : break;
7408 : : default:;
7409 : : }
7410 : : return false;
7411 : : }
7412 : :
7413 : : bool
7414 : 115998821 : gimple_simplify_NE_EXPR (gimple_match_op *res_op, gimple_seq *seq,
7415 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
7416 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1)
7417 : : {
7418 : 115998821 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7419 : 115998821 : switch (TREE_CODE (_p1))
7420 : : {
7421 : 20575320 : case SSA_NAME:
7422 : 20575320 : if (gimple *_d1 = get_def (valueize, _p1))
7423 : : {
7424 : 6270797 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
7425 : 8951056 : switch (gimple_assign_rhs_code (_a1))
7426 : : {
7427 : 12880 : case NEGATE_EXPR:
7428 : 12880 : {
7429 : 12880 : tree _q30 = gimple_assign_rhs1 (_a1);
7430 : 12880 : _q30 = do_valueize (valueize, _q30);
7431 : 12880 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
7432 : : {
7433 : 270 : {
7434 : 270 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
7435 : 270 : if (gimple_simplify_203 (res_op, seq, valueize, type, captures, NE_EXPR))
7436 : 12 : return true;
7437 : : }
7438 : : }
7439 : : break;
7440 : : }
7441 : : default:;
7442 : : }
7443 : : }
7444 : : break;
7445 : 115998809 : default:;
7446 : : }
7447 : 115998809 : switch (TREE_CODE (_p0))
7448 : : {
7449 : 113004461 : case SSA_NAME:
7450 : 113004461 : if (gimple *_d1 = get_def (valueize, _p0))
7451 : : {
7452 : 37494434 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
7453 : 41076003 : switch (gimple_assign_rhs_code (_a1))
7454 : : {
7455 : 8335 : case NEGATE_EXPR:
7456 : 8335 : {
7457 : 8335 : tree _q20 = gimple_assign_rhs1 (_a1);
7458 : 8335 : _q20 = do_valueize (valueize, _q20);
7459 : 8335 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
7460 : : {
7461 : 101 : {
7462 : 101 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
7463 : 101 : if (gimple_simplify_203 (res_op, seq, valueize, type, captures, NE_EXPR))
7464 : 35 : return true;
7465 : : }
7466 : : }
7467 : : break;
7468 : : }
7469 : 0 : case CEIL_MOD_EXPR:
7470 : 0 : {
7471 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
7472 : 0 : _q20 = do_valueize (valueize, _q20);
7473 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
7474 : 0 : _q21 = do_valueize (valueize, _q21);
7475 : 0 : if (integer_pow2p (_q21))
7476 : : {
7477 : 0 : if (integer_zerop (_p1))
7478 : : {
7479 : 0 : {
7480 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7481 : 0 : if (gimple_simplify_204 (res_op, seq, valueize, type, captures, NE_EXPR, CEIL_MOD_EXPR))
7482 : 0 : return true;
7483 : : }
7484 : : }
7485 : : }
7486 : : break;
7487 : : }
7488 : 1856 : case FLOOR_MOD_EXPR:
7489 : 1856 : {
7490 : 1856 : tree _q20 = gimple_assign_rhs1 (_a1);
7491 : 1856 : _q20 = do_valueize (valueize, _q20);
7492 : 1856 : tree _q21 = gimple_assign_rhs2 (_a1);
7493 : 1856 : _q21 = do_valueize (valueize, _q21);
7494 : 1856 : if (integer_pow2p (_q21))
7495 : : {
7496 : 0 : if (integer_zerop (_p1))
7497 : : {
7498 : 0 : {
7499 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7500 : 0 : if (gimple_simplify_204 (res_op, seq, valueize, type, captures, NE_EXPR, FLOOR_MOD_EXPR))
7501 : 0 : return true;
7502 : : }
7503 : : }
7504 : : }
7505 : : break;
7506 : : }
7507 : 0 : case ROUND_MOD_EXPR:
7508 : 0 : {
7509 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
7510 : 0 : _q20 = do_valueize (valueize, _q20);
7511 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
7512 : 0 : _q21 = do_valueize (valueize, _q21);
7513 : 0 : if (integer_pow2p (_q21))
7514 : : {
7515 : 0 : if (integer_zerop (_p1))
7516 : : {
7517 : 0 : {
7518 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7519 : 0 : if (gimple_simplify_204 (res_op, seq, valueize, type, captures, NE_EXPR, ROUND_MOD_EXPR))
7520 : 0 : return true;
7521 : : }
7522 : : }
7523 : : }
7524 : : break;
7525 : : }
7526 : 76651 : case TRUNC_MOD_EXPR:
7527 : 76651 : {
7528 : 76651 : tree _q20 = gimple_assign_rhs1 (_a1);
7529 : 76651 : _q20 = do_valueize (valueize, _q20);
7530 : 76651 : tree _q21 = gimple_assign_rhs2 (_a1);
7531 : 76651 : _q21 = do_valueize (valueize, _q21);
7532 : 76651 : if (integer_pow2p (_q21))
7533 : : {
7534 : 3615 : if (integer_zerop (_p1))
7535 : : {
7536 : 1418 : {
7537 : 1418 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7538 : 1418 : if (gimple_simplify_204 (res_op, seq, valueize, type, captures, NE_EXPR, TRUNC_MOD_EXPR))
7539 : 585 : return true;
7540 : : }
7541 : : }
7542 : : }
7543 : : break;
7544 : : }
7545 : 11220 : case LSHIFT_EXPR:
7546 : 11220 : {
7547 : 11220 : tree _q20 = gimple_assign_rhs1 (_a1);
7548 : 11220 : _q20 = do_valueize (valueize, _q20);
7549 : 11220 : tree _q21 = gimple_assign_rhs2 (_a1);
7550 : 11220 : _q21 = do_valueize (valueize, _q21);
7551 : 11220 : if (gimple_zero_one_valued_p (_q20, valueize))
7552 : : {
7553 : 962 : switch (TREE_CODE (_q21))
7554 : : {
7555 : 228 : case INTEGER_CST:
7556 : 228 : {
7557 : 228 : if (integer_zerop (_p1))
7558 : : {
7559 : 95 : {
7560 : 95 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
7561 : 95 : if (tree_fits_shwi_p (captures[1])
7562 : 95 : && tree_to_shwi (captures[1]) > 0
7563 : 190 : && tree_to_shwi (captures[1]) < TYPE_PRECISION (TREE_TYPE (captures[0]))
7564 : : )
7565 : : {
7566 : 95 : gimple_seq *lseq = seq;
7567 : 95 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1792;
7568 : 95 : {
7569 : 95 : res_op->set_op (NOP_EXPR, type, 1);
7570 : 95 : res_op->ops[0] = captures[0];
7571 : 95 : res_op->resimplify (lseq, valueize);
7572 : 95 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1013, __FILE__, __LINE__, true);
7573 : 95 : return true;
7574 : : }
7575 : 0 : next_after_fail1792:;
7576 : : }
7577 : : }
7578 : : }
7579 : : break;
7580 : : }
7581 : : default:;
7582 : : }
7583 : : }
7584 : : break;
7585 : : }
7586 : 86093 : case MULT_EXPR:
7587 : 86093 : {
7588 : 86093 : tree _q20 = gimple_assign_rhs1 (_a1);
7589 : 86093 : _q20 = do_valueize (valueize, _q20);
7590 : 86093 : tree _q21 = gimple_assign_rhs2 (_a1);
7591 : 86093 : _q21 = do_valueize (valueize, _q21);
7592 : 86093 : if (tree_swap_operands_p (_q20, _q21))
7593 : 1260 : std::swap (_q20, _q21);
7594 : 86093 : switch (TREE_CODE (_p1))
7595 : : {
7596 : 37648 : case SSA_NAME:
7597 : 37648 : if (gimple *_d2 = get_def (valueize, _p1))
7598 : : {
7599 : 30662 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
7600 : 40494 : switch (gimple_assign_rhs_code (_a2))
7601 : : {
7602 : 4432 : case MULT_EXPR:
7603 : 4432 : {
7604 : 4432 : tree _q50 = gimple_assign_rhs1 (_a2);
7605 : 4432 : _q50 = do_valueize (valueize, _q50);
7606 : 4432 : tree _q51 = gimple_assign_rhs2 (_a2);
7607 : 4432 : _q51 = do_valueize (valueize, _q51);
7608 : 4432 : if (tree_swap_operands_p (_q50, _q51))
7609 : 376 : std::swap (_q50, _q51);
7610 : 4432 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7611 : : {
7612 : 1915 : {
7613 : 1915 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
7614 : 1915 : if (gimple_simplify_207 (res_op, seq, valueize, type, captures, NE_EXPR))
7615 : 157 : return true;
7616 : : }
7617 : : }
7618 : 4275 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
7619 : : {
7620 : 166 : {
7621 : 166 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
7622 : 166 : if (gimple_simplify_207 (res_op, seq, valueize, type, captures, NE_EXPR))
7623 : 0 : return true;
7624 : : }
7625 : : }
7626 : 4275 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7627 : : {
7628 : 75 : {
7629 : 75 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
7630 : 75 : if (gimple_simplify_207 (res_op, seq, valueize, type, captures, NE_EXPR))
7631 : 0 : return true;
7632 : : }
7633 : : }
7634 : 4275 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7635 : : {
7636 : 618 : {
7637 : 618 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
7638 : 618 : if (gimple_simplify_207 (res_op, seq, valueize, type, captures, NE_EXPR))
7639 : 0 : return true;
7640 : : }
7641 : : }
7642 : 85936 : break;
7643 : : }
7644 : : default:;
7645 : : }
7646 : : }
7647 : : break;
7648 : 85936 : default:;
7649 : : }
7650 : 85936 : switch (TREE_CODE (_q21))
7651 : : {
7652 : 55241 : case INTEGER_CST:
7653 : 55241 : {
7654 : 55241 : switch (TREE_CODE (_p1))
7655 : : {
7656 : 27918 : case SSA_NAME:
7657 : 27918 : if (gimple *_d2 = get_def (valueize, _p1))
7658 : : {
7659 : 21368 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
7660 : 27709 : switch (gimple_assign_rhs_code (_a2))
7661 : : {
7662 : 2257 : case MULT_EXPR:
7663 : 2257 : {
7664 : 2257 : tree _q50 = gimple_assign_rhs1 (_a2);
7665 : 2257 : _q50 = do_valueize (valueize, _q50);
7666 : 2257 : tree _q51 = gimple_assign_rhs2 (_a2);
7667 : 2257 : _q51 = do_valueize (valueize, _q51);
7668 : 2257 : if (tree_swap_operands_p (_q50, _q51))
7669 : 290 : std::swap (_q50, _q51);
7670 : 2257 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
7671 : : {
7672 : 777 : {
7673 : 777 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
7674 : 777 : if (gimple_simplify_208 (res_op, seq, valueize, type, captures, NE_EXPR))
7675 : 6 : return true;
7676 : : }
7677 : : }
7678 : 115974769 : break;
7679 : : }
7680 : : default:;
7681 : : }
7682 : : }
7683 : : break;
7684 : : default:;
7685 : : }
7686 : : break;
7687 : : }
7688 : : default:;
7689 : : }
7690 : 115974769 : break;
7691 : : }
7692 : 2019703 : CASE_CONVERT:
7693 : 2019703 : {
7694 : 2019703 : tree _q20 = gimple_assign_rhs1 (_a1);
7695 : 2019703 : _q20 = do_valueize (valueize, _q20);
7696 : 2019703 : switch (TREE_CODE (_q20))
7697 : : {
7698 : 2004261 : case SSA_NAME:
7699 : 2004261 : if (gimple *_d2 = get_def (valueize, _q20))
7700 : : {
7701 : 1968901 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
7702 : 2451370 : switch (gimple_assign_rhs_code (_a2))
7703 : : {
7704 : 45329 : case EXACT_DIV_EXPR:
7705 : 45329 : {
7706 : 45329 : tree _q30 = gimple_assign_rhs1 (_a2);
7707 : 45329 : _q30 = do_valueize (valueize, _q30);
7708 : 45329 : tree _q31 = gimple_assign_rhs2 (_a2);
7709 : 45329 : _q31 = do_valueize (valueize, _q31);
7710 : 45329 : switch (TREE_CODE (_q31))
7711 : : {
7712 : 45329 : case INTEGER_CST:
7713 : 45329 : {
7714 : 45329 : switch (TREE_CODE (_p1))
7715 : : {
7716 : 676 : case SSA_NAME:
7717 : 676 : if (gimple *_d3 = get_def (valueize, _p1))
7718 : : {
7719 : 633 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
7720 : 993 : switch (gimple_assign_rhs_code (_a3))
7721 : : {
7722 : 91 : CASE_CONVERT:
7723 : 91 : {
7724 : 91 : tree _q60 = gimple_assign_rhs1 (_a3);
7725 : 91 : _q60 = do_valueize (valueize, _q60);
7726 : 91 : switch (TREE_CODE (_q60))
7727 : : {
7728 : 91 : case SSA_NAME:
7729 : 91 : if (gimple *_d4 = get_def (valueize, _q60))
7730 : : {
7731 : 91 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
7732 : 91 : switch (gimple_assign_rhs_code (_a4))
7733 : : {
7734 : 91 : case EXACT_DIV_EXPR:
7735 : 91 : {
7736 : 91 : tree _q70 = gimple_assign_rhs1 (_a4);
7737 : 91 : _q70 = do_valueize (valueize, _q70);
7738 : 91 : tree _q71 = gimple_assign_rhs2 (_a4);
7739 : 91 : _q71 = do_valueize (valueize, _q71);
7740 : 91 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
7741 : : {
7742 : 91 : {
7743 : 91 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q70 };
7744 : 91 : if (gimple_simplify_209 (res_op, seq, valueize, type, captures, NE_EXPR))
7745 : 26 : return true;
7746 : : }
7747 : : }
7748 : : break;
7749 : : }
7750 : : default:;
7751 : : }
7752 : : }
7753 : : break;
7754 : : default:;
7755 : : }
7756 : : break;
7757 : : }
7758 : : default:;
7759 : : }
7760 : : }
7761 : : break;
7762 : : default:;
7763 : : }
7764 : : break;
7765 : : }
7766 : : default:;
7767 : : }
7768 : : break;
7769 : : }
7770 : : default:;
7771 : : }
7772 : : }
7773 : : break;
7774 : 2019677 : default:;
7775 : : }
7776 : 2019677 : switch (TREE_CODE (_p1))
7777 : : {
7778 : 514814 : case SSA_NAME:
7779 : 514814 : if (gimple *_d2 = get_def (valueize, _p1))
7780 : : {
7781 : 464756 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
7782 : 538839 : switch (gimple_assign_rhs_code (_a2))
7783 : : {
7784 : 97344 : case PLUS_EXPR:
7785 : 97344 : {
7786 : 97344 : tree _q40 = gimple_assign_rhs1 (_a2);
7787 : 97344 : _q40 = do_valueize (valueize, _q40);
7788 : 97344 : tree _q41 = gimple_assign_rhs2 (_a2);
7789 : 97344 : _q41 = do_valueize (valueize, _q41);
7790 : 97344 : if (tree_swap_operands_p (_q40, _q41))
7791 : 755 : std::swap (_q40, _q41);
7792 : 97344 : switch (TREE_CODE (_q41))
7793 : : {
7794 : 9153 : case SSA_NAME:
7795 : 9153 : if (gimple *_d3 = get_def (valueize, _q41))
7796 : : {
7797 : 8633 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
7798 : 7306 : switch (gimple_assign_rhs_code (_a3))
7799 : : {
7800 : 5239 : CASE_CONVERT:
7801 : 5239 : {
7802 : 5239 : tree _q60 = gimple_assign_rhs1 (_a3);
7803 : 5239 : _q60 = do_valueize (valueize, _q60);
7804 : 5239 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7805 : : {
7806 : 23 : {
7807 : 23 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q40, _q20 };
7808 : 23 : if (gimple_simplify_211 (res_op, seq, valueize, type, captures, NE_EXPR))
7809 : 1 : return true;
7810 : : }
7811 : : }
7812 : : break;
7813 : : }
7814 : : default:;
7815 : : }
7816 : : }
7817 : : break;
7818 : 97343 : default:;
7819 : : }
7820 : 97343 : switch (TREE_CODE (_q40))
7821 : : {
7822 : 97343 : case SSA_NAME:
7823 : 97343 : if (gimple *_d3 = get_def (valueize, _q40))
7824 : : {
7825 : 94219 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
7826 : 48932 : switch (gimple_assign_rhs_code (_a3))
7827 : : {
7828 : 26356 : CASE_CONVERT:
7829 : 26356 : {
7830 : 26356 : tree _q50 = gimple_assign_rhs1 (_a3);
7831 : 26356 : _q50 = do_valueize (valueize, _q50);
7832 : 26356 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7833 : : {
7834 : 305 : {
7835 : 305 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q41, _q20 };
7836 : 305 : if (gimple_simplify_211 (res_op, seq, valueize, type, captures, NE_EXPR))
7837 : 69 : return true;
7838 : : }
7839 : : }
7840 : : break;
7841 : : }
7842 : : default:;
7843 : : }
7844 : : }
7845 : : break;
7846 : 97274 : default:;
7847 : : }
7848 : 97274 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
7849 : : {
7850 : 0 : {
7851 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q40, _q20 };
7852 : 0 : if (gimple_simplify_211 (res_op, seq, valueize, type, captures, NE_EXPR))
7853 : 0 : return true;
7854 : : }
7855 : : }
7856 : 97274 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
7857 : : {
7858 : 0 : {
7859 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q41, _q20 };
7860 : 0 : if (gimple_simplify_211 (res_op, seq, valueize, type, captures, NE_EXPR))
7861 : 0 : return true;
7862 : : }
7863 : : }
7864 : 2019607 : break;
7865 : : }
7866 : : default:;
7867 : : }
7868 : : }
7869 : : break;
7870 : 2019607 : default:;
7871 : : }
7872 : 2019607 : {
7873 : 2019607 : tree _p1_pops[1];
7874 : 2019607 : if (gimple_nop_convert (_p1, _p1_pops, valueize))
7875 : : {
7876 : 27187 : tree _q40 = _p1_pops[0];
7877 : 27187 : switch (TREE_CODE (_q40))
7878 : : {
7879 : 23794 : case SSA_NAME:
7880 : 23794 : if (gimple *_d2 = get_def (valueize, _q40))
7881 : : {
7882 : 23276 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
7883 : 29641 : switch (gimple_assign_rhs_code (_a2))
7884 : : {
7885 : 7893 : case PLUS_EXPR:
7886 : 7893 : {
7887 : 7893 : tree _q50 = gimple_assign_rhs1 (_a2);
7888 : 7893 : _q50 = do_valueize (valueize, _q50);
7889 : 7893 : tree _q51 = gimple_assign_rhs2 (_a2);
7890 : 7893 : _q51 = do_valueize (valueize, _q51);
7891 : 7893 : if (tree_swap_operands_p (_q50, _q51))
7892 : 195 : std::swap (_q50, _q51);
7893 : 7893 : switch (TREE_CODE (_q51))
7894 : : {
7895 : 3656 : case SSA_NAME:
7896 : 3656 : if (gimple *_d3 = get_def (valueize, _q51))
7897 : : {
7898 : 3651 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
7899 : 3488 : switch (gimple_assign_rhs_code (_a3))
7900 : : {
7901 : 2543 : CASE_CONVERT:
7902 : 2543 : {
7903 : 2543 : tree _q70 = gimple_assign_rhs1 (_a3);
7904 : 2543 : _q70 = do_valueize (valueize, _q70);
7905 : 2543 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
7906 : : {
7907 : 0 : {
7908 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q20 };
7909 : 0 : if (gimple_simplify_210 (res_op, seq, valueize, type, captures, NE_EXPR))
7910 : 0 : return true;
7911 : : }
7912 : : }
7913 : : break;
7914 : : }
7915 : : default:;
7916 : : }
7917 : : }
7918 : : break;
7919 : 7893 : default:;
7920 : : }
7921 : 7893 : switch (TREE_CODE (_q50))
7922 : : {
7923 : 7893 : case SSA_NAME:
7924 : 7893 : if (gimple *_d3 = get_def (valueize, _q50))
7925 : : {
7926 : 7144 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
7927 : 5597 : switch (gimple_assign_rhs_code (_a3))
7928 : : {
7929 : 2798 : CASE_CONVERT:
7930 : 2798 : {
7931 : 2798 : tree _q60 = gimple_assign_rhs1 (_a3);
7932 : 2798 : _q60 = do_valueize (valueize, _q60);
7933 : 2798 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
7934 : : {
7935 : 26 : {
7936 : 26 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q51, _q20 };
7937 : 26 : if (gimple_simplify_210 (res_op, seq, valueize, type, captures, NE_EXPR))
7938 : 0 : return true;
7939 : : }
7940 : : }
7941 : : break;
7942 : : }
7943 : : default:;
7944 : : }
7945 : : }
7946 : : break;
7947 : 7893 : default:;
7948 : : }
7949 : 7893 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
7950 : : {
7951 : 24 : {
7952 : 24 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q20 };
7953 : 24 : if (gimple_simplify_210 (res_op, seq, valueize, type, captures, NE_EXPR))
7954 : 24 : return true;
7955 : : }
7956 : : }
7957 : 7869 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
7958 : : {
7959 : 0 : {
7960 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q51, _q20 };
7961 : 0 : if (gimple_simplify_210 (res_op, seq, valueize, type, captures, NE_EXPR))
7962 : 0 : return true;
7963 : : }
7964 : : }
7965 : 2019583 : break;
7966 : : }
7967 : : default:;
7968 : : }
7969 : : }
7970 : : break;
7971 : : default:;
7972 : : }
7973 : : }
7974 : : }
7975 : 2019583 : break;
7976 : : }
7977 : 20151 : case EXACT_DIV_EXPR:
7978 : 20151 : {
7979 : 20151 : tree _q20 = gimple_assign_rhs1 (_a1);
7980 : 20151 : _q20 = do_valueize (valueize, _q20);
7981 : 20151 : tree _q21 = gimple_assign_rhs2 (_a1);
7982 : 20151 : _q21 = do_valueize (valueize, _q21);
7983 : 20151 : switch (TREE_CODE (_q21))
7984 : : {
7985 : 20151 : case INTEGER_CST:
7986 : 20151 : {
7987 : 20151 : switch (TREE_CODE (_p1))
7988 : : {
7989 : 2097 : case SSA_NAME:
7990 : 2097 : if (gimple *_d2 = get_def (valueize, _p1))
7991 : : {
7992 : 1999 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
7993 : 1163 : switch (gimple_assign_rhs_code (_a2))
7994 : : {
7995 : 818 : case EXACT_DIV_EXPR:
7996 : 818 : {
7997 : 818 : tree _q50 = gimple_assign_rhs1 (_a2);
7998 : 818 : _q50 = do_valueize (valueize, _q50);
7999 : 818 : tree _q51 = gimple_assign_rhs2 (_a2);
8000 : 818 : _q51 = do_valueize (valueize, _q51);
8001 : 818 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8002 : : {
8003 : 778 : {
8004 : 778 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
8005 : 778 : if (gimple_simplify_209 (res_op, seq, valueize, type, captures, NE_EXPR))
8006 : 778 : return true;
8007 : : }
8008 : : }
8009 : : break;
8010 : : }
8011 : : default:;
8012 : : }
8013 : : }
8014 : : break;
8015 : : default:;
8016 : : }
8017 : : break;
8018 : : }
8019 : : default:;
8020 : : }
8021 : : break;
8022 : : }
8023 : 20456 : case TRUNC_DIV_EXPR:
8024 : 20456 : {
8025 : 20456 : tree _q20 = gimple_assign_rhs1 (_a1);
8026 : 20456 : _q20 = do_valueize (valueize, _q20);
8027 : 20456 : tree _q21 = gimple_assign_rhs2 (_a1);
8028 : 20456 : _q21 = do_valueize (valueize, _q21);
8029 : 20456 : switch (TREE_CODE (_q21))
8030 : : {
8031 : 11462 : case INTEGER_CST:
8032 : 11462 : {
8033 : 11462 : switch (TREE_CODE (_p1))
8034 : : {
8035 : 9549 : case INTEGER_CST:
8036 : 9549 : {
8037 : 9549 : {
8038 : 9549 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
8039 : 9549 : if (gimple_simplify_212 (res_op, seq, valueize, type, captures, NE_EXPR))
8040 : 941 : return true;
8041 : : }
8042 : 8608 : break;
8043 : : }
8044 : : default:;
8045 : : }
8046 : : break;
8047 : : }
8048 : : default:;
8049 : : }
8050 : : break;
8051 : : }
8052 : 1382589 : case PLUS_EXPR:
8053 : 1382589 : {
8054 : 1382589 : tree _q20 = gimple_assign_rhs1 (_a1);
8055 : 1382589 : _q20 = do_valueize (valueize, _q20);
8056 : 1382589 : tree _q21 = gimple_assign_rhs2 (_a1);
8057 : 1382589 : _q21 = do_valueize (valueize, _q21);
8058 : 1382589 : if (tree_swap_operands_p (_q20, _q21))
8059 : 8078 : std::swap (_q20, _q21);
8060 : 1382589 : switch (TREE_CODE (_p1))
8061 : : {
8062 : 430803 : case SSA_NAME:
8063 : 430803 : if (gimple *_d2 = get_def (valueize, _p1))
8064 : : {
8065 : 355983 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
8066 : 421567 : switch (gimple_assign_rhs_code (_a2))
8067 : : {
8068 : 181047 : case PLUS_EXPR:
8069 : 181047 : {
8070 : 181047 : tree _q50 = gimple_assign_rhs1 (_a2);
8071 : 181047 : _q50 = do_valueize (valueize, _q50);
8072 : 181047 : tree _q51 = gimple_assign_rhs2 (_a2);
8073 : 181047 : _q51 = do_valueize (valueize, _q51);
8074 : 181047 : if (tree_swap_operands_p (_q50, _q51))
8075 : 790 : std::swap (_q50, _q51);
8076 : 181047 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8077 : : {
8078 : 10803 : {
8079 : 10803 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
8080 : 21606 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8081 : 21551 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
8082 : 9270 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
8083 : : )
8084 : : {
8085 : 10748 : gimple_seq *lseq = seq;
8086 : 10748 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1793;
8087 : 10748 : {
8088 : 10748 : res_op->set_op (NE_EXPR, type, 2);
8089 : 10748 : res_op->ops[0] = captures[0];
8090 : 10748 : res_op->ops[1] = captures[2];
8091 : 10748 : res_op->resimplify (lseq, valueize);
8092 : 10748 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 954, __FILE__, __LINE__, true);
8093 : 10748 : return true;
8094 : : }
8095 : 0 : next_after_fail1793:;
8096 : : }
8097 : : }
8098 : : }
8099 : 170299 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8100 : : {
8101 : 92 : {
8102 : 92 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
8103 : 184 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8104 : 184 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
8105 : 16 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
8106 : : )
8107 : : {
8108 : 92 : gimple_seq *lseq = seq;
8109 : 92 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1794;
8110 : 92 : {
8111 : 92 : res_op->set_op (NE_EXPR, type, 2);
8112 : 92 : res_op->ops[0] = captures[0];
8113 : 92 : res_op->ops[1] = captures[2];
8114 : 92 : res_op->resimplify (lseq, valueize);
8115 : 92 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 954, __FILE__, __LINE__, true);
8116 : 92 : return true;
8117 : : }
8118 : 0 : next_after_fail1794:;
8119 : : }
8120 : : }
8121 : : }
8122 : 170207 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
8123 : : {
8124 : 1 : {
8125 : 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
8126 : 2 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8127 : 2 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
8128 : 1 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
8129 : : )
8130 : : {
8131 : 1 : gimple_seq *lseq = seq;
8132 : 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1795;
8133 : 1 : {
8134 : 1 : res_op->set_op (NE_EXPR, type, 2);
8135 : 1 : res_op->ops[0] = captures[0];
8136 : 1 : res_op->ops[1] = captures[2];
8137 : 1 : res_op->resimplify (lseq, valueize);
8138 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 954, __FILE__, __LINE__, true);
8139 : 1 : return true;
8140 : : }
8141 : 0 : next_after_fail1795:;
8142 : : }
8143 : : }
8144 : : }
8145 : 170206 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8146 : : {
8147 : 215 : {
8148 : 215 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
8149 : 430 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8150 : 375 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
8151 : 125 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
8152 : : )
8153 : : {
8154 : 160 : gimple_seq *lseq = seq;
8155 : 160 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1796;
8156 : 160 : {
8157 : 160 : res_op->set_op (NE_EXPR, type, 2);
8158 : 160 : res_op->ops[0] = captures[0];
8159 : 160 : res_op->ops[1] = captures[2];
8160 : 160 : res_op->resimplify (lseq, valueize);
8161 : 160 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 954, __FILE__, __LINE__, true);
8162 : 160 : return true;
8163 : : }
8164 : 0 : next_after_fail1796:;
8165 : : }
8166 : : }
8167 : : }
8168 : 1371588 : break;
8169 : : }
8170 : : default:;
8171 : : }
8172 : : }
8173 : : break;
8174 : 1371588 : default:;
8175 : : }
8176 : 1371588 : switch (TREE_CODE (_q21))
8177 : : {
8178 : 137976 : case SSA_NAME:
8179 : 137976 : if (gimple *_d2 = get_def (valueize, _q21))
8180 : : {
8181 : 132455 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
8182 : 126811 : switch (gimple_assign_rhs_code (_a2))
8183 : : {
8184 : 31891 : CASE_CONVERT:
8185 : 31891 : {
8186 : 31891 : tree _q40 = gimple_assign_rhs1 (_a2);
8187 : 31891 : _q40 = do_valueize (valueize, _q40);
8188 : 31891 : switch (TREE_CODE (_p1))
8189 : : {
8190 : 15219 : case SSA_NAME:
8191 : 15219 : if (gimple *_d3 = get_def (valueize, _p1))
8192 : : {
8193 : 13338 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
8194 : 14226 : switch (gimple_assign_rhs_code (_a3))
8195 : : {
8196 : 1973 : CASE_CONVERT:
8197 : 1973 : {
8198 : 1973 : tree _q60 = gimple_assign_rhs1 (_a3);
8199 : 1973 : _q60 = do_valueize (valueize, _q60);
8200 : 1973 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
8201 : : {
8202 : 10 : {
8203 : 10 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40 };
8204 : 10 : if (gimple_simplify_211 (res_op, seq, valueize, type, captures, NE_EXPR))
8205 : 8 : return true;
8206 : : }
8207 : : }
8208 : : break;
8209 : : }
8210 : : default:;
8211 : : }
8212 : : }
8213 : : break;
8214 : : default:;
8215 : : }
8216 : : break;
8217 : : }
8218 : : default:;
8219 : : }
8220 : : }
8221 : : break;
8222 : 1371580 : default:;
8223 : : }
8224 : 1371580 : switch (TREE_CODE (_q20))
8225 : : {
8226 : 1371577 : case SSA_NAME:
8227 : 1371577 : if (gimple *_d2 = get_def (valueize, _q20))
8228 : : {
8229 : 1321319 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
8230 : 477340 : switch (gimple_assign_rhs_code (_a2))
8231 : : {
8232 : 149267 : CASE_CONVERT:
8233 : 149267 : {
8234 : 149267 : tree _q30 = gimple_assign_rhs1 (_a2);
8235 : 149267 : _q30 = do_valueize (valueize, _q30);
8236 : 149267 : switch (TREE_CODE (_p1))
8237 : : {
8238 : 112048 : case SSA_NAME:
8239 : 112048 : if (gimple *_d3 = get_def (valueize, _p1))
8240 : : {
8241 : 64120 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
8242 : 62999 : switch (gimple_assign_rhs_code (_a3))
8243 : : {
8244 : 3262 : CASE_CONVERT:
8245 : 3262 : {
8246 : 3262 : tree _q60 = gimple_assign_rhs1 (_a3);
8247 : 3262 : _q60 = do_valueize (valueize, _q60);
8248 : 3262 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
8249 : : {
8250 : 4 : {
8251 : 4 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q30 };
8252 : 4 : if (gimple_simplify_211 (res_op, seq, valueize, type, captures, NE_EXPR))
8253 : 4 : return true;
8254 : : }
8255 : : }
8256 : : break;
8257 : : }
8258 : : default:;
8259 : : }
8260 : : }
8261 : : break;
8262 : 149263 : default:;
8263 : : }
8264 : 149263 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
8265 : : {
8266 : 0 : {
8267 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q30 };
8268 : 0 : if (gimple_simplify_211 (res_op, seq, valueize, type, captures, NE_EXPR))
8269 : 0 : return true;
8270 : : }
8271 : : }
8272 : : break;
8273 : : }
8274 : : default:;
8275 : : }
8276 : : }
8277 : : break;
8278 : 1371576 : default:;
8279 : : }
8280 : 1371576 : switch (TREE_CODE (_q21))
8281 : : {
8282 : 137964 : case SSA_NAME:
8283 : 137964 : if (gimple *_d2 = get_def (valueize, _q21))
8284 : : {
8285 : 132443 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
8286 : 126799 : switch (gimple_assign_rhs_code (_a2))
8287 : : {
8288 : 31879 : CASE_CONVERT:
8289 : 31879 : {
8290 : 31879 : tree _q40 = gimple_assign_rhs1 (_a2);
8291 : 31879 : _q40 = do_valueize (valueize, _q40);
8292 : 31879 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
8293 : : {
8294 : 0 : {
8295 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40 };
8296 : 0 : if (gimple_simplify_211 (res_op, seq, valueize, type, captures, NE_EXPR))
8297 : 0 : return true;
8298 : : }
8299 : : }
8300 : : break;
8301 : : }
8302 : : default:;
8303 : : }
8304 : : }
8305 : : break;
8306 : 1371576 : default:;
8307 : : }
8308 : 1371576 : switch (TREE_CODE (_p1))
8309 : : {
8310 : 419790 : case SSA_NAME:
8311 : 419790 : if (gimple *_d2 = get_def (valueize, _p1))
8312 : : {
8313 : 344970 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
8314 : 410554 : switch (gimple_assign_rhs_code (_a2))
8315 : : {
8316 : 45544 : CASE_CONVERT:
8317 : 45544 : {
8318 : 45544 : tree _q50 = gimple_assign_rhs1 (_a2);
8319 : 45544 : _q50 = do_valueize (valueize, _q50);
8320 : 45544 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
8321 : : {
8322 : 0 : {
8323 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
8324 : 0 : if (gimple_simplify_211 (res_op, seq, valueize, type, captures, NE_EXPR))
8325 : 0 : return true;
8326 : : }
8327 : : }
8328 : 45544 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8329 : : {
8330 : 0 : {
8331 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q20 };
8332 : 0 : if (gimple_simplify_211 (res_op, seq, valueize, type, captures, NE_EXPR))
8333 : 0 : return true;
8334 : : }
8335 : : }
8336 : : break;
8337 : : }
8338 : : default:;
8339 : : }
8340 : : }
8341 : : break;
8342 : 1371576 : default:;
8343 : : }
8344 : 1371576 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
8345 : : {
8346 : 48135 : {
8347 : 48135 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
8348 : 48135 : if (gimple_simplify_211 (res_op, seq, valueize, type, captures, NE_EXPR))
8349 : 3295 : return true;
8350 : : }
8351 : : }
8352 : 1368281 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
8353 : : {
8354 : 384 : {
8355 : 384 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q20 };
8356 : 384 : if (gimple_simplify_211 (res_op, seq, valueize, type, captures, NE_EXPR))
8357 : 274 : return true;
8358 : : }
8359 : : }
8360 : 115974769 : break;
8361 : : }
8362 : 187089 : case POINTER_PLUS_EXPR:
8363 : 187089 : {
8364 : 187089 : tree _q20 = gimple_assign_rhs1 (_a1);
8365 : 187089 : _q20 = do_valueize (valueize, _q20);
8366 : 187089 : tree _q21 = gimple_assign_rhs2 (_a1);
8367 : 187089 : _q21 = do_valueize (valueize, _q21);
8368 : 187089 : switch (TREE_CODE (_p1))
8369 : : {
8370 : 142940 : case SSA_NAME:
8371 : 142940 : if (gimple *_d2 = get_def (valueize, _p1))
8372 : : {
8373 : 138059 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
8374 : 115746 : switch (gimple_assign_rhs_code (_a2))
8375 : : {
8376 : 42055 : case POINTER_PLUS_EXPR:
8377 : 42055 : {
8378 : 42055 : tree _q50 = gimple_assign_rhs1 (_a2);
8379 : 42055 : _q50 = do_valueize (valueize, _q50);
8380 : 42055 : tree _q51 = gimple_assign_rhs2 (_a2);
8381 : 42055 : _q51 = do_valueize (valueize, _q51);
8382 : 42055 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8383 : : {
8384 : 3314 : {
8385 : 3314 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
8386 : 3314 : if (gimple_simplify_213 (res_op, seq, valueize, type, captures, NE_EXPR))
8387 : 3314 : return true;
8388 : : }
8389 : : }
8390 : : break;
8391 : : }
8392 : : default:;
8393 : : }
8394 : : }
8395 : : break;
8396 : 183775 : default:;
8397 : : }
8398 : 183775 : switch (TREE_CODE (_q20))
8399 : : {
8400 : 171493 : case SSA_NAME:
8401 : 171493 : if (gimple *_d2 = get_def (valueize, _q20))
8402 : : {
8403 : 160241 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
8404 : 142312 : switch (gimple_assign_rhs_code (_a2))
8405 : : {
8406 : 579 : CASE_CONVERT:
8407 : 579 : {
8408 : 579 : tree _q30 = gimple_assign_rhs1 (_a2);
8409 : 579 : _q30 = do_valueize (valueize, _q30);
8410 : 579 : switch (TREE_CODE (_p1))
8411 : : {
8412 : 579 : case SSA_NAME:
8413 : 579 : if (gimple *_d3 = get_def (valueize, _p1))
8414 : : {
8415 : 549 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
8416 : 569 : switch (gimple_assign_rhs_code (_a3))
8417 : : {
8418 : 31 : CASE_CONVERT:
8419 : 31 : {
8420 : 31 : tree _q60 = gimple_assign_rhs1 (_a3);
8421 : 31 : _q60 = do_valueize (valueize, _q60);
8422 : 31 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
8423 : : {
8424 : 0 : {
8425 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q30, _q21 };
8426 : 0 : if (gimple_simplify_214 (res_op, seq, valueize, type, captures, NE_EXPR))
8427 : 0 : return true;
8428 : : }
8429 : : }
8430 : : break;
8431 : : }
8432 : : default:;
8433 : : }
8434 : : }
8435 : : break;
8436 : 579 : default:;
8437 : : }
8438 : 579 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
8439 : : {
8440 : 0 : {
8441 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q30, _q21 };
8442 : 0 : if (gimple_simplify_214 (res_op, seq, valueize, type, captures, NE_EXPR))
8443 : 0 : return true;
8444 : : }
8445 : : }
8446 : : break;
8447 : : }
8448 : : default:;
8449 : : }
8450 : : }
8451 : : break;
8452 : 183775 : default:;
8453 : : }
8454 : 183775 : switch (TREE_CODE (_p1))
8455 : : {
8456 : 139626 : case SSA_NAME:
8457 : 139626 : if (gimple *_d2 = get_def (valueize, _p1))
8458 : : {
8459 : 134745 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
8460 : 112432 : switch (gimple_assign_rhs_code (_a2))
8461 : : {
8462 : 2187 : CASE_CONVERT:
8463 : 2187 : {
8464 : 2187 : tree _q50 = gimple_assign_rhs1 (_a2);
8465 : 2187 : _q50 = do_valueize (valueize, _q50);
8466 : 2187 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8467 : : {
8468 : 0 : {
8469 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
8470 : 0 : if (gimple_simplify_214 (res_op, seq, valueize, type, captures, NE_EXPR))
8471 : 0 : return true;
8472 : : }
8473 : : }
8474 : : break;
8475 : : }
8476 : : default:;
8477 : : }
8478 : : }
8479 : : break;
8480 : 183775 : default:;
8481 : : }
8482 : 183775 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
8483 : : {
8484 : 12323 : {
8485 : 12323 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
8486 : 12323 : if (gimple_simplify_214 (res_op, seq, valueize, type, captures, NE_EXPR))
8487 : 3009 : return true;
8488 : : }
8489 : : }
8490 : : break;
8491 : : }
8492 : 188272 : case MINUS_EXPR:
8493 : 188272 : {
8494 : 188272 : tree _q20 = gimple_assign_rhs1 (_a1);
8495 : 188272 : _q20 = do_valueize (valueize, _q20);
8496 : 188272 : tree _q21 = gimple_assign_rhs2 (_a1);
8497 : 188272 : _q21 = do_valueize (valueize, _q21);
8498 : 188272 : switch (TREE_CODE (_p1))
8499 : : {
8500 : 60538 : case SSA_NAME:
8501 : 60538 : if (gimple *_d2 = get_def (valueize, _p1))
8502 : : {
8503 : 57023 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
8504 : 57380 : switch (gimple_assign_rhs_code (_a2))
8505 : : {
8506 : 25842 : case MINUS_EXPR:
8507 : 25842 : {
8508 : 25842 : tree _q50 = gimple_assign_rhs1 (_a2);
8509 : 25842 : _q50 = do_valueize (valueize, _q50);
8510 : 25842 : tree _q51 = gimple_assign_rhs2 (_a2);
8511 : 25842 : _q51 = do_valueize (valueize, _q51);
8512 : 25842 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8513 : : {
8514 : 761 : {
8515 : 761 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
8516 : 1522 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8517 : 986 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
8518 : 200 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
8519 : : )
8520 : : {
8521 : 225 : gimple_seq *lseq = seq;
8522 : 225 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1797;
8523 : 225 : {
8524 : 225 : res_op->set_op (NE_EXPR, type, 2);
8525 : 225 : res_op->ops[0] = captures[0];
8526 : 225 : res_op->ops[1] = captures[2];
8527 : 225 : res_op->resimplify (lseq, valueize);
8528 : 225 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 955, __FILE__, __LINE__, true);
8529 : 225 : return true;
8530 : : }
8531 : 0 : next_after_fail1797:;
8532 : : }
8533 : : }
8534 : : }
8535 : 25617 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8536 : : {
8537 : 529 : {
8538 : 529 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
8539 : 1058 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
8540 : 537 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
8541 : 4 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1])))
8542 : : )
8543 : : {
8544 : 8 : gimple_seq *lseq = seq;
8545 : 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1798;
8546 : 8 : {
8547 : 8 : res_op->set_op (NE_EXPR, type, 2);
8548 : 8 : res_op->ops[0] = captures[2];
8549 : 8 : res_op->ops[1] = captures[1];
8550 : 8 : res_op->resimplify (lseq, valueize);
8551 : 8 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 956, __FILE__, __LINE__, true);
8552 : 8 : return true;
8553 : : }
8554 : 0 : next_after_fail1798:;
8555 : : }
8556 : : }
8557 : : }
8558 : : break;
8559 : : }
8560 : : default:;
8561 : : }
8562 : : }
8563 : : break;
8564 : 188039 : default:;
8565 : : }
8566 : 188039 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
8567 : : {
8568 : 4230 : {
8569 : 4230 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
8570 : 4230 : if (gimple_simplify_215 (res_op, seq, valueize, type, captures, NE_EXPR))
8571 : 120 : return true;
8572 : : }
8573 : : }
8574 : : break;
8575 : : }
8576 : 64873 : case POINTER_DIFF_EXPR:
8577 : 64873 : {
8578 : 64873 : tree _q20 = gimple_assign_rhs1 (_a1);
8579 : 64873 : _q20 = do_valueize (valueize, _q20);
8580 : 64873 : tree _q21 = gimple_assign_rhs2 (_a1);
8581 : 64873 : _q21 = do_valueize (valueize, _q21);
8582 : 64873 : switch (TREE_CODE (_p1))
8583 : : {
8584 : 10056 : case SSA_NAME:
8585 : 10056 : if (gimple *_d2 = get_def (valueize, _p1))
8586 : : {
8587 : 9842 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
8588 : 9062 : switch (gimple_assign_rhs_code (_a2))
8589 : : {
8590 : 8191 : case POINTER_DIFF_EXPR:
8591 : 8191 : {
8592 : 8191 : tree _q50 = gimple_assign_rhs1 (_a2);
8593 : 8191 : _q50 = do_valueize (valueize, _q50);
8594 : 8191 : tree _q51 = gimple_assign_rhs2 (_a2);
8595 : 8191 : _q51 = do_valueize (valueize, _q51);
8596 : 8191 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
8597 : : {
8598 : 65 : {
8599 : 65 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
8600 : 65 : if (gimple_simplify_216 (res_op, seq, valueize, type, captures, NE_EXPR))
8601 : 65 : return true;
8602 : : }
8603 : : }
8604 : 8126 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
8605 : : {
8606 : 0 : {
8607 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
8608 : 0 : if (gimple_simplify_217 (res_op, seq, valueize, type, captures, NE_EXPR))
8609 : 0 : return true;
8610 : : }
8611 : : }
8612 : : break;
8613 : : }
8614 : : default:;
8615 : : }
8616 : : }
8617 : : break;
8618 : : default:;
8619 : : }
8620 : : break;
8621 : : }
8622 : : default:;
8623 : : }
8624 : : }
8625 : : break;
8626 : 115974769 : default:;
8627 : : }
8628 : 115974769 : {
8629 : 115974769 : tree _p0_pops[1];
8630 : 115974769 : if (gimple_logical_inverted_value (_p0, _p0_pops, valueize))
8631 : : {
8632 : 643389 : tree _q20 = _p0_pops[0];
8633 : 643389 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
8634 : : {
8635 : 0 : if (gimple_truth_valued_p (_p1, valueize))
8636 : : {
8637 : 0 : {
8638 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8639 : 0 : if (gimple_simplify_205 (res_op, seq, valueize, type, captures, NE_EXPR))
8640 : 0 : return true;
8641 : : }
8642 : : }
8643 : : }
8644 : : }
8645 : : }
8646 : 115974769 : {
8647 : 115974769 : tree _p0_pops[1];
8648 : 115974769 : if (gimple_nop_convert (_p0, _p0_pops, valueize))
8649 : : {
8650 : 473823 : tree _q20 = _p0_pops[0];
8651 : 473823 : switch (TREE_CODE (_q20))
8652 : : {
8653 : 458873 : case SSA_NAME:
8654 : 458873 : if (gimple *_d1 = get_def (valueize, _q20))
8655 : : {
8656 : 443687 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
8657 : 511401 : switch (gimple_assign_rhs_code (_a1))
8658 : : {
8659 : 47142 : case PLUS_EXPR:
8660 : 47142 : {
8661 : 47142 : tree _q30 = gimple_assign_rhs1 (_a1);
8662 : 47142 : _q30 = do_valueize (valueize, _q30);
8663 : 47142 : tree _q31 = gimple_assign_rhs2 (_a1);
8664 : 47142 : _q31 = do_valueize (valueize, _q31);
8665 : 47142 : if (tree_swap_operands_p (_q30, _q31))
8666 : 1386 : std::swap (_q30, _q31);
8667 : 47142 : switch (TREE_CODE (_q31))
8668 : : {
8669 : 5698 : case SSA_NAME:
8670 : 5698 : if (gimple *_d2 = get_def (valueize, _q31))
8671 : : {
8672 : 5589 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
8673 : 5295 : switch (gimple_assign_rhs_code (_a2))
8674 : : {
8675 : 2960 : CASE_CONVERT:
8676 : 2960 : {
8677 : 2960 : tree _q50 = gimple_assign_rhs1 (_a2);
8678 : 2960 : _q50 = do_valueize (valueize, _q50);
8679 : 2960 : switch (TREE_CODE (_p1))
8680 : : {
8681 : 687 : case SSA_NAME:
8682 : 687 : if (gimple *_d3 = get_def (valueize, _p1))
8683 : : {
8684 : 647 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
8685 : 667 : switch (gimple_assign_rhs_code (_a3))
8686 : : {
8687 : 255 : CASE_CONVERT:
8688 : 255 : {
8689 : 255 : tree _q70 = gimple_assign_rhs1 (_a3);
8690 : 255 : _q70 = do_valueize (valueize, _q70);
8691 : 255 : if ((_q70 == _q50 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q50, 0) && types_match (_q70, _q50)))
8692 : : {
8693 : 0 : {
8694 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50 };
8695 : 0 : if (gimple_simplify_210 (res_op, seq, valueize, type, captures, NE_EXPR))
8696 : 0 : return true;
8697 : : }
8698 : : }
8699 : : break;
8700 : : }
8701 : : default:;
8702 : : }
8703 : : }
8704 : : break;
8705 : : default:;
8706 : : }
8707 : : break;
8708 : : }
8709 : : default:;
8710 : : }
8711 : : }
8712 : : break;
8713 : 47142 : default:;
8714 : : }
8715 : 47142 : switch (TREE_CODE (_q30))
8716 : : {
8717 : 47142 : case SSA_NAME:
8718 : 47142 : if (gimple *_d2 = get_def (valueize, _q30))
8719 : : {
8720 : 45074 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
8721 : 42128 : switch (gimple_assign_rhs_code (_a2))
8722 : : {
8723 : 24792 : CASE_CONVERT:
8724 : 24792 : {
8725 : 24792 : tree _q40 = gimple_assign_rhs1 (_a2);
8726 : 24792 : _q40 = do_valueize (valueize, _q40);
8727 : 24792 : switch (TREE_CODE (_p1))
8728 : : {
8729 : 14627 : case SSA_NAME:
8730 : 14627 : if (gimple *_d3 = get_def (valueize, _p1))
8731 : : {
8732 : 8907 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
8733 : 10009 : switch (gimple_assign_rhs_code (_a3))
8734 : : {
8735 : 389 : CASE_CONVERT:
8736 : 389 : {
8737 : 389 : tree _q70 = gimple_assign_rhs1 (_a3);
8738 : 389 : _q70 = do_valueize (valueize, _q70);
8739 : 389 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
8740 : : {
8741 : 0 : {
8742 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q40 };
8743 : 0 : if (gimple_simplify_210 (res_op, seq, valueize, type, captures, NE_EXPR))
8744 : 0 : return true;
8745 : : }
8746 : : }
8747 : : break;
8748 : : }
8749 : : default:;
8750 : : }
8751 : : }
8752 : : break;
8753 : 24792 : default:;
8754 : : }
8755 : 24792 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
8756 : : {
8757 : 28 : {
8758 : 28 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q40 };
8759 : 28 : if (gimple_simplify_210 (res_op, seq, valueize, type, captures, NE_EXPR))
8760 : 9 : return true;
8761 : : }
8762 : : }
8763 : : break;
8764 : : }
8765 : : default:;
8766 : : }
8767 : : }
8768 : : break;
8769 : 47133 : default:;
8770 : : }
8771 : 47133 : switch (TREE_CODE (_q31))
8772 : : {
8773 : 5690 : case SSA_NAME:
8774 : 5690 : if (gimple *_d2 = get_def (valueize, _q31))
8775 : : {
8776 : 5581 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
8777 : 5287 : switch (gimple_assign_rhs_code (_a2))
8778 : : {
8779 : 2960 : CASE_CONVERT:
8780 : 2960 : {
8781 : 2960 : tree _q50 = gimple_assign_rhs1 (_a2);
8782 : 2960 : _q50 = do_valueize (valueize, _q50);
8783 : 2960 : if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
8784 : : {
8785 : 5 : {
8786 : 5 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50 };
8787 : 5 : if (gimple_simplify_210 (res_op, seq, valueize, type, captures, NE_EXPR))
8788 : 4 : return true;
8789 : : }
8790 : : }
8791 : : break;
8792 : : }
8793 : : default:;
8794 : : }
8795 : : }
8796 : : break;
8797 : 47129 : default:;
8798 : : }
8799 : 47129 : switch (TREE_CODE (_p1))
8800 : : {
8801 : 29089 : case SSA_NAME:
8802 : 29089 : if (gimple *_d2 = get_def (valueize, _p1))
8803 : : {
8804 : 23174 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
8805 : 32124 : switch (gimple_assign_rhs_code (_a2))
8806 : : {
8807 : 3014 : CASE_CONVERT:
8808 : 3014 : {
8809 : 3014 : tree _q60 = gimple_assign_rhs1 (_a2);
8810 : 3014 : _q60 = do_valueize (valueize, _q60);
8811 : 3014 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
8812 : : {
8813 : 10 : {
8814 : 10 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
8815 : 10 : if (gimple_simplify_210 (res_op, seq, valueize, type, captures, NE_EXPR))
8816 : 10 : return true;
8817 : : }
8818 : : }
8819 : 3004 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
8820 : : {
8821 : 0 : {
8822 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q30 };
8823 : 0 : if (gimple_simplify_210 (res_op, seq, valueize, type, captures, NE_EXPR))
8824 : 0 : return true;
8825 : : }
8826 : : }
8827 : : break;
8828 : : }
8829 : : default:;
8830 : : }
8831 : : }
8832 : : break;
8833 : 47119 : default:;
8834 : : }
8835 : 47119 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
8836 : : {
8837 : 0 : {
8838 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
8839 : 0 : if (gimple_simplify_210 (res_op, seq, valueize, type, captures, NE_EXPR))
8840 : 0 : return true;
8841 : : }
8842 : : }
8843 : 47119 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
8844 : : {
8845 : 0 : {
8846 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q30 };
8847 : 0 : if (gimple_simplify_210 (res_op, seq, valueize, type, captures, NE_EXPR))
8848 : 0 : return true;
8849 : : }
8850 : : }
8851 : 115974744 : break;
8852 : : }
8853 : 1345 : case POINTER_PLUS_EXPR:
8854 : 1345 : {
8855 : 1345 : tree _q30 = gimple_assign_rhs1 (_a1);
8856 : 1345 : _q30 = do_valueize (valueize, _q30);
8857 : 1345 : tree _q31 = gimple_assign_rhs2 (_a1);
8858 : 1345 : _q31 = do_valueize (valueize, _q31);
8859 : 1345 : switch (TREE_CODE (_q30))
8860 : : {
8861 : 251 : case SSA_NAME:
8862 : 251 : if (gimple *_d2 = get_def (valueize, _q30))
8863 : : {
8864 : 231 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
8865 : 256 : switch (gimple_assign_rhs_code (_a2))
8866 : : {
8867 : 0 : CASE_CONVERT:
8868 : 0 : {
8869 : 0 : tree _q40 = gimple_assign_rhs1 (_a2);
8870 : 0 : _q40 = do_valueize (valueize, _q40);
8871 : 0 : switch (TREE_CODE (_p1))
8872 : : {
8873 : 0 : case SSA_NAME:
8874 : 0 : if (gimple *_d3 = get_def (valueize, _p1))
8875 : : {
8876 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
8877 : 0 : switch (gimple_assign_rhs_code (_a3))
8878 : : {
8879 : 0 : CASE_CONVERT:
8880 : 0 : {
8881 : 0 : tree _q70 = gimple_assign_rhs1 (_a3);
8882 : 0 : _q70 = do_valueize (valueize, _q70);
8883 : 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
8884 : : {
8885 : 0 : {
8886 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31 };
8887 : 0 : if (gimple_simplify_218 (res_op, seq, valueize, type, captures, NE_EXPR))
8888 : 0 : return true;
8889 : : }
8890 : : }
8891 : : break;
8892 : : }
8893 : : default:;
8894 : : }
8895 : : }
8896 : : break;
8897 : 0 : default:;
8898 : : }
8899 : 0 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
8900 : : {
8901 : 0 : {
8902 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31 };
8903 : 0 : if (gimple_simplify_218 (res_op, seq, valueize, type, captures, NE_EXPR))
8904 : 0 : return true;
8905 : : }
8906 : : }
8907 : : break;
8908 : : }
8909 : : default:;
8910 : : }
8911 : : }
8912 : : break;
8913 : 1345 : default:;
8914 : : }
8915 : 1345 : switch (TREE_CODE (_p1))
8916 : : {
8917 : 1345 : case SSA_NAME:
8918 : 1345 : if (gimple *_d2 = get_def (valueize, _p1))
8919 : : {
8920 : 1337 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
8921 : 1305 : switch (gimple_assign_rhs_code (_a2))
8922 : : {
8923 : 1102 : CASE_CONVERT:
8924 : 1102 : {
8925 : 1102 : tree _q60 = gimple_assign_rhs1 (_a2);
8926 : 1102 : _q60 = do_valueize (valueize, _q60);
8927 : 1102 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
8928 : : {
8929 : 2 : {
8930 : 2 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
8931 : 2 : if (gimple_simplify_218 (res_op, seq, valueize, type, captures, NE_EXPR))
8932 : 2 : return true;
8933 : : }
8934 : : }
8935 : : break;
8936 : : }
8937 : : default:;
8938 : : }
8939 : : }
8940 : : break;
8941 : 1343 : default:;
8942 : : }
8943 : 1343 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
8944 : : {
8945 : 0 : {
8946 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
8947 : 0 : if (gimple_simplify_218 (res_op, seq, valueize, type, captures, NE_EXPR))
8948 : 0 : return true;
8949 : : }
8950 : : }
8951 : : break;
8952 : : }
8953 : : default:;
8954 : : }
8955 : : }
8956 : : break;
8957 : : default:;
8958 : : }
8959 : : }
8960 : : }
8961 : 115974744 : if (gimple_truth_valued_p (_p0, valueize))
8962 : : {
8963 : 29272050 : {
8964 : 29272050 : tree _p1_pops[1];
8965 : 29272050 : if (gimple_logical_inverted_value (_p1, _p1_pops, valueize))
8966 : : {
8967 : 5971 : tree _q30 = _p1_pops[0];
8968 : 5971 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
8969 : : {
8970 : 0 : {
8971 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8972 : 0 : if (gimple_simplify_205 (res_op, seq, valueize, type, captures, NE_EXPR))
8973 : 0 : return true;
8974 : : }
8975 : : }
8976 : : }
8977 : : }
8978 : : }
8979 : 115974744 : switch (TREE_CODE (_p1))
8980 : : {
8981 : 20556252 : case SSA_NAME:
8982 : 20556252 : if (gimple *_d1 = get_def (valueize, _p1))
8983 : : {
8984 : 6251763 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
8985 : 8932644 : switch (gimple_assign_rhs_code (_a1))
8986 : : {
8987 : 553891 : case PLUS_EXPR:
8988 : 553891 : {
8989 : 553891 : tree _q30 = gimple_assign_rhs1 (_a1);
8990 : 553891 : _q30 = do_valueize (valueize, _q30);
8991 : 553891 : tree _q31 = gimple_assign_rhs2 (_a1);
8992 : 553891 : _q31 = do_valueize (valueize, _q31);
8993 : 553891 : if (tree_swap_operands_p (_q30, _q31))
8994 : 4067 : std::swap (_q30, _q31);
8995 : 553891 : switch (TREE_CODE (_q31))
8996 : : {
8997 : 86368 : case SSA_NAME:
8998 : 86368 : if (gimple *_d2 = get_def (valueize, _q31))
8999 : : {
9000 : 81120 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
9001 : 82448 : switch (gimple_assign_rhs_code (_a2))
9002 : : {
9003 : 15247 : CASE_CONVERT:
9004 : 15247 : {
9005 : 15247 : tree _q50 = gimple_assign_rhs1 (_a2);
9006 : 15247 : _q50 = do_valueize (valueize, _q50);
9007 : 15247 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
9008 : : {
9009 : 0 : {
9010 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0 };
9011 : 0 : if (gimple_simplify_211 (res_op, seq, valueize, type, captures, NE_EXPR))
9012 : 0 : return true;
9013 : : }
9014 : : }
9015 : : break;
9016 : : }
9017 : : default:;
9018 : : }
9019 : : }
9020 : : break;
9021 : 553891 : default:;
9022 : : }
9023 : 553891 : switch (TREE_CODE (_q30))
9024 : : {
9025 : 553891 : case SSA_NAME:
9026 : 553891 : if (gimple *_d2 = get_def (valueize, _q30))
9027 : : {
9028 : 499044 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
9029 : 286630 : switch (gimple_assign_rhs_code (_a2))
9030 : : {
9031 : 147691 : CASE_CONVERT:
9032 : 147691 : {
9033 : 147691 : tree _q40 = gimple_assign_rhs1 (_a2);
9034 : 147691 : _q40 = do_valueize (valueize, _q40);
9035 : 147691 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
9036 : : {
9037 : 0 : {
9038 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q31, _p0 };
9039 : 0 : if (gimple_simplify_211 (res_op, seq, valueize, type, captures, NE_EXPR))
9040 : 0 : return true;
9041 : : }
9042 : : }
9043 : : break;
9044 : : }
9045 : : default:;
9046 : : }
9047 : : }
9048 : : break;
9049 : 553891 : default:;
9050 : : }
9051 : 553891 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
9052 : : {
9053 : 798 : {
9054 : 798 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0 };
9055 : 798 : if (gimple_simplify_211 (res_op, seq, valueize, type, captures, NE_EXPR))
9056 : 76 : return true;
9057 : : }
9058 : : }
9059 : 553815 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9060 : : {
9061 : 2002 : {
9062 : 2002 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q31, _p0 };
9063 : 2002 : if (gimple_simplify_211 (res_op, seq, valueize, type, captures, NE_EXPR))
9064 : 585 : return true;
9065 : : }
9066 : : }
9067 : 115974083 : break;
9068 : : }
9069 : : default:;
9070 : : }
9071 : : }
9072 : : break;
9073 : 115974083 : default:;
9074 : : }
9075 : 115974083 : {
9076 : 115974083 : tree _p1_pops[1];
9077 : 115974083 : if (gimple_nop_convert (_p1, _p1_pops, valueize))
9078 : : {
9079 : 196763 : tree _q30 = _p1_pops[0];
9080 : 196763 : switch (TREE_CODE (_q30))
9081 : : {
9082 : 187394 : case SSA_NAME:
9083 : 187394 : if (gimple *_d1 = get_def (valueize, _q30))
9084 : : {
9085 : 174018 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
9086 : 195671 : switch (gimple_assign_rhs_code (_a1))
9087 : : {
9088 : 55494 : case PLUS_EXPR:
9089 : 55494 : {
9090 : 55494 : tree _q40 = gimple_assign_rhs1 (_a1);
9091 : 55494 : _q40 = do_valueize (valueize, _q40);
9092 : 55494 : tree _q41 = gimple_assign_rhs2 (_a1);
9093 : 55494 : _q41 = do_valueize (valueize, _q41);
9094 : 55494 : if (tree_swap_operands_p (_q40, _q41))
9095 : 468 : std::swap (_q40, _q41);
9096 : 55494 : switch (TREE_CODE (_q41))
9097 : : {
9098 : 6574 : case SSA_NAME:
9099 : 6574 : if (gimple *_d2 = get_def (valueize, _q41))
9100 : : {
9101 : 6288 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
9102 : 5384 : switch (gimple_assign_rhs_code (_a2))
9103 : : {
9104 : 3198 : CASE_CONVERT:
9105 : 3198 : {
9106 : 3198 : tree _q60 = gimple_assign_rhs1 (_a2);
9107 : 3198 : _q60 = do_valueize (valueize, _q60);
9108 : 3198 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
9109 : : {
9110 : 8 : {
9111 : 8 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0 };
9112 : 8 : if (gimple_simplify_210 (res_op, seq, valueize, type, captures, NE_EXPR))
9113 : 0 : return true;
9114 : : }
9115 : : }
9116 : : break;
9117 : : }
9118 : : default:;
9119 : : }
9120 : : }
9121 : : break;
9122 : 55494 : default:;
9123 : : }
9124 : 55494 : switch (TREE_CODE (_q40))
9125 : : {
9126 : 55494 : case SSA_NAME:
9127 : 55494 : if (gimple *_d2 = get_def (valueize, _q40))
9128 : : {
9129 : 47360 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
9130 : 36811 : switch (gimple_assign_rhs_code (_a2))
9131 : : {
9132 : 31277 : CASE_CONVERT:
9133 : 31277 : {
9134 : 31277 : tree _q50 = gimple_assign_rhs1 (_a2);
9135 : 31277 : _q50 = do_valueize (valueize, _q50);
9136 : 31277 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
9137 : : {
9138 : 25 : {
9139 : 25 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q41, _p0 };
9140 : 25 : if (gimple_simplify_210 (res_op, seq, valueize, type, captures, NE_EXPR))
9141 : 0 : return true;
9142 : : }
9143 : : }
9144 : : break;
9145 : : }
9146 : : default:;
9147 : : }
9148 : : }
9149 : : break;
9150 : 55494 : default:;
9151 : : }
9152 : 55494 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
9153 : : {
9154 : 0 : {
9155 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0 };
9156 : 0 : if (gimple_simplify_210 (res_op, seq, valueize, type, captures, NE_EXPR))
9157 : 0 : return true;
9158 : : }
9159 : : }
9160 : 55494 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
9161 : : {
9162 : 0 : {
9163 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q41, _p0 };
9164 : 0 : if (gimple_simplify_210 (res_op, seq, valueize, type, captures, NE_EXPR))
9165 : 0 : return true;
9166 : : }
9167 : : }
9168 : 115974083 : break;
9169 : : }
9170 : : default:;
9171 : : }
9172 : : }
9173 : : break;
9174 : : default:;
9175 : : }
9176 : : }
9177 : : }
9178 : 115974083 : switch (TREE_CODE (_p0))
9179 : : {
9180 : 112979735 : case SSA_NAME:
9181 : 112979735 : if (gimple *_d1 = get_def (valueize, _p0))
9182 : : {
9183 : 37469708 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
9184 : 41051690 : switch (gimple_assign_rhs_code (_a1))
9185 : : {
9186 : 2019532 : CASE_CONVERT:
9187 : 2019532 : {
9188 : 2019532 : tree _q20 = gimple_assign_rhs1 (_a1);
9189 : 2019532 : _q20 = do_valueize (valueize, _q20);
9190 : 2019532 : switch (TREE_CODE (_p1))
9191 : : {
9192 : 514669 : case SSA_NAME:
9193 : 514669 : if (gimple *_d2 = get_def (valueize, _p1))
9194 : : {
9195 : 464617 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
9196 : 538707 : switch (gimple_assign_rhs_code (_a2))
9197 : : {
9198 : 1755 : case POINTER_PLUS_EXPR:
9199 : 1755 : {
9200 : 1755 : tree _q40 = gimple_assign_rhs1 (_a2);
9201 : 1755 : _q40 = do_valueize (valueize, _q40);
9202 : 1755 : tree _q41 = gimple_assign_rhs2 (_a2);
9203 : 1755 : _q41 = do_valueize (valueize, _q41);
9204 : 1755 : switch (TREE_CODE (_q40))
9205 : : {
9206 : 1725 : case SSA_NAME:
9207 : 1725 : if (gimple *_d3 = get_def (valueize, _q40))
9208 : : {
9209 : 1650 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
9210 : 475 : switch (gimple_assign_rhs_code (_a3))
9211 : : {
9212 : 81 : CASE_CONVERT:
9213 : 81 : {
9214 : 81 : tree _q50 = gimple_assign_rhs1 (_a3);
9215 : 81 : _q50 = do_valueize (valueize, _q50);
9216 : 81 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9217 : : {
9218 : 16 : {
9219 : 16 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q20, _q41 };
9220 : 16 : if (gimple_simplify_214 (res_op, seq, valueize, type, captures, NE_EXPR))
9221 : 16 : return true;
9222 : : }
9223 : : }
9224 : : break;
9225 : : }
9226 : : default:;
9227 : : }
9228 : : }
9229 : : break;
9230 : 1739 : default:;
9231 : : }
9232 : 1739 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
9233 : : {
9234 : 0 : {
9235 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q20, _q41 };
9236 : 0 : if (gimple_simplify_214 (res_op, seq, valueize, type, captures, NE_EXPR))
9237 : 0 : return true;
9238 : : }
9239 : : }
9240 : : break;
9241 : : }
9242 : : default:;
9243 : : }
9244 : : }
9245 : : break;
9246 : 2019516 : default:;
9247 : : }
9248 : 2019516 : {
9249 : 2019516 : tree _p1_pops[1];
9250 : 2019516 : if (gimple_nop_convert (_p1, _p1_pops, valueize))
9251 : : {
9252 : 27151 : tree _q40 = _p1_pops[0];
9253 : 27151 : switch (TREE_CODE (_q40))
9254 : : {
9255 : 23758 : case SSA_NAME:
9256 : 23758 : if (gimple *_d2 = get_def (valueize, _q40))
9257 : : {
9258 : 23240 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
9259 : 29617 : switch (gimple_assign_rhs_code (_a2))
9260 : : {
9261 : 88 : case POINTER_PLUS_EXPR:
9262 : 88 : {
9263 : 88 : tree _q50 = gimple_assign_rhs1 (_a2);
9264 : 88 : _q50 = do_valueize (valueize, _q50);
9265 : 88 : tree _q51 = gimple_assign_rhs2 (_a2);
9266 : 88 : _q51 = do_valueize (valueize, _q51);
9267 : 88 : switch (TREE_CODE (_q50))
9268 : : {
9269 : 88 : case SSA_NAME:
9270 : 88 : if (gimple *_d3 = get_def (valueize, _q50))
9271 : : {
9272 : 88 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
9273 : 30 : switch (gimple_assign_rhs_code (_a3))
9274 : : {
9275 : 0 : CASE_CONVERT:
9276 : 0 : {
9277 : 0 : tree _q60 = gimple_assign_rhs1 (_a3);
9278 : 0 : _q60 = do_valueize (valueize, _q60);
9279 : 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
9280 : : {
9281 : 0 : {
9282 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q20, _q51 };
9283 : 0 : if (gimple_simplify_218 (res_op, seq, valueize, type, captures, NE_EXPR))
9284 : 0 : return true;
9285 : : }
9286 : : }
9287 : : break;
9288 : : }
9289 : : default:;
9290 : : }
9291 : : }
9292 : : break;
9293 : 88 : default:;
9294 : : }
9295 : 88 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
9296 : : {
9297 : 6 : {
9298 : 6 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q20, _q51 };
9299 : 6 : if (gimple_simplify_218 (res_op, seq, valueize, type, captures, NE_EXPR))
9300 : 6 : return true;
9301 : : }
9302 : : }
9303 : : break;
9304 : : }
9305 : : default:;
9306 : : }
9307 : : }
9308 : : break;
9309 : : default:;
9310 : : }
9311 : : }
9312 : : }
9313 : 2019510 : break;
9314 : : }
9315 : : default:;
9316 : : }
9317 : : }
9318 : : break;
9319 : 115974061 : default:;
9320 : : }
9321 : 115974061 : switch (TREE_CODE (_p1))
9322 : : {
9323 : 20555569 : case SSA_NAME:
9324 : 20555569 : if (gimple *_d1 = get_def (valueize, _p1))
9325 : : {
9326 : 6251080 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
9327 : 8931961 : switch (gimple_assign_rhs_code (_a1))
9328 : : {
9329 : 278646 : case POINTER_PLUS_EXPR:
9330 : 278646 : {
9331 : 278646 : tree _q30 = gimple_assign_rhs1 (_a1);
9332 : 278646 : _q30 = do_valueize (valueize, _q30);
9333 : 278646 : tree _q31 = gimple_assign_rhs2 (_a1);
9334 : 278646 : _q31 = do_valueize (valueize, _q31);
9335 : 278646 : switch (TREE_CODE (_q30))
9336 : : {
9337 : 275835 : case SSA_NAME:
9338 : 275835 : if (gimple *_d2 = get_def (valueize, _q30))
9339 : : {
9340 : 240835 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
9341 : 175568 : switch (gimple_assign_rhs_code (_a2))
9342 : : {
9343 : 205 : CASE_CONVERT:
9344 : 205 : {
9345 : 205 : tree _q40 = gimple_assign_rhs1 (_a2);
9346 : 205 : _q40 = do_valueize (valueize, _q40);
9347 : 205 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
9348 : : {
9349 : 0 : {
9350 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _p0, _q31 };
9351 : 0 : if (gimple_simplify_214 (res_op, seq, valueize, type, captures, NE_EXPR))
9352 : 0 : return true;
9353 : : }
9354 : : }
9355 : : break;
9356 : : }
9357 : : default:;
9358 : : }
9359 : : }
9360 : : break;
9361 : 278646 : default:;
9362 : : }
9363 : 278646 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9364 : : {
9365 : 19699 : {
9366 : 19699 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _p0, _q31 };
9367 : 19699 : if (gimple_simplify_214 (res_op, seq, valueize, type, captures, NE_EXPR))
9368 : 7459 : return true;
9369 : : }
9370 : : }
9371 : : break;
9372 : : }
9373 : : default:;
9374 : : }
9375 : : }
9376 : : break;
9377 : 115966602 : default:;
9378 : : }
9379 : 115966602 : {
9380 : 115966602 : tree _p1_pops[1];
9381 : 115966602 : if (gimple_nop_convert (_p1, _p1_pops, valueize))
9382 : : {
9383 : 196757 : tree _q30 = _p1_pops[0];
9384 : 196757 : switch (TREE_CODE (_q30))
9385 : : {
9386 : 187388 : case SSA_NAME:
9387 : 187388 : if (gimple *_d1 = get_def (valueize, _q30))
9388 : : {
9389 : 174012 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
9390 : 195665 : switch (gimple_assign_rhs_code (_a1))
9391 : : {
9392 : 234 : case POINTER_PLUS_EXPR:
9393 : 234 : {
9394 : 234 : tree _q40 = gimple_assign_rhs1 (_a1);
9395 : 234 : _q40 = do_valueize (valueize, _q40);
9396 : 234 : tree _q41 = gimple_assign_rhs2 (_a1);
9397 : 234 : _q41 = do_valueize (valueize, _q41);
9398 : 234 : switch (TREE_CODE (_q40))
9399 : : {
9400 : 228 : case SSA_NAME:
9401 : 228 : if (gimple *_d2 = get_def (valueize, _q40))
9402 : : {
9403 : 221 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
9404 : 194 : switch (gimple_assign_rhs_code (_a2))
9405 : : {
9406 : 0 : CASE_CONVERT:
9407 : 0 : {
9408 : 0 : tree _q50 = gimple_assign_rhs1 (_a2);
9409 : 0 : _q50 = do_valueize (valueize, _q50);
9410 : 0 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
9411 : : {
9412 : 0 : {
9413 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _p0, _q41 };
9414 : 0 : if (gimple_simplify_218 (res_op, seq, valueize, type, captures, NE_EXPR))
9415 : 0 : return true;
9416 : : }
9417 : : }
9418 : : break;
9419 : : }
9420 : : default:;
9421 : : }
9422 : : }
9423 : : break;
9424 : 234 : default:;
9425 : : }
9426 : 234 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
9427 : : {
9428 : 0 : {
9429 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _p0, _q41 };
9430 : 0 : if (gimple_simplify_218 (res_op, seq, valueize, type, captures, NE_EXPR))
9431 : 0 : return true;
9432 : : }
9433 : : }
9434 : : break;
9435 : : }
9436 : : default:;
9437 : : }
9438 : : }
9439 : : break;
9440 : : default:;
9441 : : }
9442 : : }
9443 : : }
9444 : 115966602 : switch (TREE_CODE (_p0))
9445 : : {
9446 : 112972275 : case SSA_NAME:
9447 : 112972275 : if (gimple *_d1 = get_def (valueize, _p0))
9448 : : {
9449 : 37462258 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
9450 : 41041481 : switch (gimple_assign_rhs_code (_a1))
9451 : : {
9452 : 29802 : case ADDR_EXPR:
9453 : 29802 : {
9454 : 29802 : switch (TREE_CODE (_p1))
9455 : : {
9456 : 21914 : case SSA_NAME:
9457 : 21914 : if (gimple *_d2 = get_def (valueize, _p1))
9458 : : {
9459 : 20905 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
9460 : 27403 : switch (gimple_assign_rhs_code (_a2))
9461 : : {
9462 : 900 : case POINTER_PLUS_EXPR:
9463 : 900 : {
9464 : 900 : tree _q30 = gimple_assign_rhs1 (_a2);
9465 : 900 : _q30 = do_valueize (valueize, _q30);
9466 : 900 : tree _q31 = gimple_assign_rhs2 (_a2);
9467 : 900 : _q31 = do_valueize (valueize, _q31);
9468 : 900 : {
9469 : 900 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q31 };
9470 : 900 : if (gimple_simplify_219 (res_op, seq, valueize, type, captures, NE_EXPR))
9471 : 259 : return true;
9472 : : }
9473 : 641 : break;
9474 : : }
9475 : : default:;
9476 : : }
9477 : : }
9478 : : break;
9479 : : default:;
9480 : : }
9481 : : break;
9482 : : }
9483 : 180483 : case POINTER_PLUS_EXPR:
9484 : 180483 : {
9485 : 180483 : tree _q20 = gimple_assign_rhs1 (_a1);
9486 : 180483 : _q20 = do_valueize (valueize, _q20);
9487 : 180483 : tree _q21 = gimple_assign_rhs2 (_a1);
9488 : 180483 : _q21 = do_valueize (valueize, _q21);
9489 : 180483 : switch (TREE_CODE (_p1))
9490 : : {
9491 : 136363 : case SSA_NAME:
9492 : 136363 : if (gimple *_d2 = get_def (valueize, _p1))
9493 : : {
9494 : 131492 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
9495 : 109837 : switch (gimple_assign_rhs_code (_a2))
9496 : : {
9497 : 511 : case ADDR_EXPR:
9498 : 511 : {
9499 : 511 : {
9500 : 511 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q20, _q21 };
9501 : 511 : if (gimple_simplify_219 (res_op, seq, valueize, type, captures, NE_EXPR))
9502 : 60 : return true;
9503 : : }
9504 : 451 : break;
9505 : : }
9506 : : default:;
9507 : : }
9508 : : }
9509 : : break;
9510 : 35833 : case ADDR_EXPR:
9511 : 35833 : {
9512 : 35833 : {
9513 : 35833 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q20, _q21 };
9514 : 35833 : if (gimple_simplify_219 (res_op, seq, valueize, type, captures, NE_EXPR))
9515 : 281 : return true;
9516 : : }
9517 : 35552 : break;
9518 : : }
9519 : 180142 : default:;
9520 : : }
9521 : 180142 : switch (TREE_CODE (_q20))
9522 : : {
9523 : 168172 : case SSA_NAME:
9524 : 168172 : if (gimple *_d2 = get_def (valueize, _q20))
9525 : : {
9526 : 156930 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
9527 : 139549 : switch (gimple_assign_rhs_code (_a2))
9528 : : {
9529 : 414 : case ADDR_EXPR:
9530 : 414 : {
9531 : 414 : switch (TREE_CODE (_p1))
9532 : : {
9533 : 330 : case SSA_NAME:
9534 : 330 : if (gimple *_d3 = get_def (valueize, _p1))
9535 : : {
9536 : 313 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
9537 : 167 : switch (gimple_assign_rhs_code (_a3))
9538 : : {
9539 : 123 : case POINTER_PLUS_EXPR:
9540 : 123 : {
9541 : 123 : tree _q50 = gimple_assign_rhs1 (_a3);
9542 : 123 : _q50 = do_valueize (valueize, _q50);
9543 : 123 : tree _q51 = gimple_assign_rhs2 (_a3);
9544 : 123 : _q51 = do_valueize (valueize, _q51);
9545 : 123 : switch (TREE_CODE (_q50))
9546 : : {
9547 : 123 : case SSA_NAME:
9548 : 123 : if (gimple *_d4 = get_def (valueize, _q50))
9549 : : {
9550 : 107 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
9551 : 18 : switch (gimple_assign_rhs_code (_a4))
9552 : : {
9553 : 4 : case ADDR_EXPR:
9554 : 4 : {
9555 : 4 : {
9556 : 4 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51 };
9557 : 4 : if (gimple_simplify_220 (res_op, seq, valueize, type, captures, NE_EXPR))
9558 : 4 : return true;
9559 : : }
9560 : 0 : break;
9561 : : }
9562 : : default:;
9563 : : }
9564 : : }
9565 : : break;
9566 : 0 : case ADDR_EXPR:
9567 : 0 : {
9568 : 0 : {
9569 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51 };
9570 : 0 : if (gimple_simplify_220 (res_op, seq, valueize, type, captures, NE_EXPR))
9571 : 0 : return true;
9572 : : }
9573 : 0 : break;
9574 : : }
9575 : : default:;
9576 : : }
9577 : : break;
9578 : : }
9579 : : default:;
9580 : : }
9581 : : }
9582 : : break;
9583 : : default:;
9584 : : }
9585 : : break;
9586 : : }
9587 : : default:;
9588 : : }
9589 : : }
9590 : : break;
9591 : 11968 : case ADDR_EXPR:
9592 : 11968 : {
9593 : 11968 : switch (TREE_CODE (_p1))
9594 : : {
9595 : 11968 : case SSA_NAME:
9596 : 11968 : if (gimple *_d2 = get_def (valueize, _p1))
9597 : : {
9598 : 11680 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
9599 : 7409 : switch (gimple_assign_rhs_code (_a2))
9600 : : {
9601 : 400 : case POINTER_PLUS_EXPR:
9602 : 400 : {
9603 : 400 : tree _q50 = gimple_assign_rhs1 (_a2);
9604 : 400 : _q50 = do_valueize (valueize, _q50);
9605 : 400 : tree _q51 = gimple_assign_rhs2 (_a2);
9606 : 400 : _q51 = do_valueize (valueize, _q51);
9607 : 400 : switch (TREE_CODE (_q50))
9608 : : {
9609 : 368 : case SSA_NAME:
9610 : 368 : if (gimple *_d3 = get_def (valueize, _q50))
9611 : : {
9612 : 359 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
9613 : 44 : switch (gimple_assign_rhs_code (_a3))
9614 : : {
9615 : 0 : case ADDR_EXPR:
9616 : 0 : {
9617 : 0 : {
9618 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51 };
9619 : 0 : if (gimple_simplify_220 (res_op, seq, valueize, type, captures, NE_EXPR))
9620 : 0 : return true;
9621 : : }
9622 : 0 : break;
9623 : : }
9624 : : default:;
9625 : : }
9626 : : }
9627 : : break;
9628 : 32 : case ADDR_EXPR:
9629 : 32 : {
9630 : 32 : {
9631 : 32 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51 };
9632 : 32 : if (gimple_simplify_220 (res_op, seq, valueize, type, captures, NE_EXPR))
9633 : 12 : return true;
9634 : : }
9635 : 20 : break;
9636 : : }
9637 : : default:;
9638 : : }
9639 : : break;
9640 : : }
9641 : : default:;
9642 : : }
9643 : : }
9644 : : break;
9645 : : default:;
9646 : : }
9647 : : break;
9648 : : }
9649 : : default:;
9650 : : }
9651 : : break;
9652 : : }
9653 : : default:;
9654 : : }
9655 : : }
9656 : : break;
9657 : 619816 : case ADDR_EXPR:
9658 : 619816 : {
9659 : 619816 : switch (TREE_CODE (_p1))
9660 : : {
9661 : 517421 : case SSA_NAME:
9662 : 517421 : if (gimple *_d1 = get_def (valueize, _p1))
9663 : : {
9664 : 161540 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
9665 : 188802 : switch (gimple_assign_rhs_code (_a1))
9666 : : {
9667 : 15632 : case POINTER_PLUS_EXPR:
9668 : 15632 : {
9669 : 15632 : tree _q30 = gimple_assign_rhs1 (_a1);
9670 : 15632 : _q30 = do_valueize (valueize, _q30);
9671 : 15632 : tree _q31 = gimple_assign_rhs2 (_a1);
9672 : 15632 : _q31 = do_valueize (valueize, _q31);
9673 : 15632 : {
9674 : 15632 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q31 };
9675 : 15632 : if (gimple_simplify_219 (res_op, seq, valueize, type, captures, NE_EXPR))
9676 : 1352 : return true;
9677 : : }
9678 : 14280 : break;
9679 : : }
9680 : : default:;
9681 : : }
9682 : : }
9683 : : break;
9684 : : default:;
9685 : : }
9686 : : break;
9687 : : }
9688 : 115964634 : default:;
9689 : : }
9690 : 115964634 : switch (TREE_CODE (_p1))
9691 : : {
9692 : 20546423 : case SSA_NAME:
9693 : 20546423 : if (gimple *_d1 = get_def (valueize, _p1))
9694 : : {
9695 : 6241934 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
9696 : 8922755 : switch (gimple_assign_rhs_code (_a1))
9697 : : {
9698 : 150101 : case MINUS_EXPR:
9699 : 150101 : {
9700 : 150101 : tree _q30 = gimple_assign_rhs1 (_a1);
9701 : 150101 : _q30 = do_valueize (valueize, _q30);
9702 : 150101 : tree _q31 = gimple_assign_rhs2 (_a1);
9703 : 150101 : _q31 = do_valueize (valueize, _q31);
9704 : 150101 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
9705 : : {
9706 : 5772 : {
9707 : 5772 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
9708 : 5772 : if (gimple_simplify_215 (res_op, seq, valueize, type, captures, NE_EXPR))
9709 : 1490 : return true;
9710 : : }
9711 : : }
9712 : : break;
9713 : : }
9714 : : default:;
9715 : : }
9716 : : }
9717 : : break;
9718 : 115963144 : default:;
9719 : : }
9720 : 115963144 : switch (TREE_CODE (_p0))
9721 : : {
9722 : 112970169 : case SSA_NAME:
9723 : 112970169 : if (gimple *_d1 = get_def (valueize, _p0))
9724 : : {
9725 : 37460152 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
9726 : 41037854 : switch (gimple_assign_rhs_code (_a1))
9727 : : {
9728 : 19515 : case TRUNC_DIV_EXPR:
9729 : 19515 : {
9730 : 19515 : tree _q20 = gimple_assign_rhs1 (_a1);
9731 : 19515 : _q20 = do_valueize (valueize, _q20);
9732 : 19515 : tree _q21 = gimple_assign_rhs2 (_a1);
9733 : 19515 : _q21 = do_valueize (valueize, _q21);
9734 : 19515 : if (integer_zerop (_p1))
9735 : : {
9736 : 9452 : {
9737 : 9452 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9738 : 9452 : if (gimple_simplify_221 (res_op, seq, valueize, type, captures, NE_EXPR, GE_EXPR))
9739 : 227 : return true;
9740 : : }
9741 : : }
9742 : : break;
9743 : : }
9744 : 2019510 : CASE_CONVERT:
9745 : 2019510 : {
9746 : 2019510 : tree _q20 = gimple_assign_rhs1 (_a1);
9747 : 2019510 : _q20 = do_valueize (valueize, _q20);
9748 : 2019510 : switch (TREE_CODE (_p1))
9749 : : {
9750 : 514647 : case SSA_NAME:
9751 : 514647 : if (gimple *_d2 = get_def (valueize, _p1))
9752 : : {
9753 : 464595 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
9754 : 538685 : switch (gimple_assign_rhs_code (_a2))
9755 : : {
9756 : 74087 : CASE_CONVERT:
9757 : 74087 : {
9758 : 74087 : tree _q40 = gimple_assign_rhs1 (_a2);
9759 : 74087 : _q40 = do_valueize (valueize, _q40);
9760 : 74087 : switch (TREE_CODE (_q40))
9761 : : {
9762 : 70694 : case SSA_NAME:
9763 : 70694 : if (gimple *_d3 = get_def (valueize, _q40))
9764 : : {
9765 : 69992 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
9766 : 79658 : switch (gimple_assign_rhs_code (_a3))
9767 : : {
9768 : 430 : case MINUS_EXPR:
9769 : 430 : {
9770 : 430 : tree _q50 = gimple_assign_rhs1 (_a3);
9771 : 430 : _q50 = do_valueize (valueize, _q50);
9772 : 430 : tree _q51 = gimple_assign_rhs2 (_a3);
9773 : 430 : _q51 = do_valueize (valueize, _q51);
9774 : 430 : switch (TREE_CODE (_q50))
9775 : : {
9776 : 2 : case INTEGER_CST:
9777 : 2 : {
9778 : 2 : switch (TREE_CODE (_q51))
9779 : : {
9780 : 2 : case SSA_NAME:
9781 : 2 : if (gimple *_d4 = get_def (valueize, _q51))
9782 : : {
9783 : 2 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
9784 : 2 : switch (gimple_assign_rhs_code (_a4))
9785 : : {
9786 : 2 : CASE_CONVERT:
9787 : 2 : {
9788 : 2 : tree _q70 = gimple_assign_rhs1 (_a4);
9789 : 2 : _q70 = do_valueize (valueize, _q70);
9790 : 2 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
9791 : : {
9792 : 0 : {
9793 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
9794 : 0 : if (gimple_simplify_222 (res_op, seq, valueize, type, captures, NE_EXPR))
9795 : 0 : return true;
9796 : : }
9797 : : }
9798 : : break;
9799 : : }
9800 : : default:;
9801 : : }
9802 : : }
9803 : : break;
9804 : : default:;
9805 : : }
9806 : : break;
9807 : : }
9808 : : default:;
9809 : : }
9810 : : break;
9811 : : }
9812 : : default:;
9813 : : }
9814 : : }
9815 : : break;
9816 : : default:;
9817 : : }
9818 : : break;
9819 : : }
9820 : : default:;
9821 : : }
9822 : : }
9823 : : break;
9824 : 2019510 : default:;
9825 : : }
9826 : 2019510 : switch (TREE_CODE (_q20))
9827 : : {
9828 : 2004068 : case SSA_NAME:
9829 : 2004068 : if (gimple *_d2 = get_def (valueize, _q20))
9830 : : {
9831 : 1968708 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
9832 : 2451225 : switch (gimple_assign_rhs_code (_a2))
9833 : : {
9834 : 10879 : case MINUS_EXPR:
9835 : 10879 : {
9836 : 10879 : tree _q30 = gimple_assign_rhs1 (_a2);
9837 : 10879 : _q30 = do_valueize (valueize, _q30);
9838 : 10879 : tree _q31 = gimple_assign_rhs2 (_a2);
9839 : 10879 : _q31 = do_valueize (valueize, _q31);
9840 : 10879 : switch (TREE_CODE (_q30))
9841 : : {
9842 : 1186 : case INTEGER_CST:
9843 : 1186 : {
9844 : 1186 : switch (TREE_CODE (_q31))
9845 : : {
9846 : 1186 : case SSA_NAME:
9847 : 1186 : if (gimple *_d3 = get_def (valueize, _q31))
9848 : : {
9849 : 1102 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
9850 : 875 : switch (gimple_assign_rhs_code (_a3))
9851 : : {
9852 : 109 : CASE_CONVERT:
9853 : 109 : {
9854 : 109 : tree _q50 = gimple_assign_rhs1 (_a3);
9855 : 109 : _q50 = do_valueize (valueize, _q50);
9856 : 109 : switch (TREE_CODE (_p1))
9857 : : {
9858 : 20 : case SSA_NAME:
9859 : 20 : if (gimple *_d4 = get_def (valueize, _p1))
9860 : : {
9861 : 20 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
9862 : 16 : switch (gimple_assign_rhs_code (_a4))
9863 : : {
9864 : 2 : CASE_CONVERT:
9865 : 2 : {
9866 : 2 : tree _q70 = gimple_assign_rhs1 (_a4);
9867 : 2 : _q70 = do_valueize (valueize, _q70);
9868 : 2 : if ((_q70 == _q50 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q50, 0) && types_match (_q70, _q50)))
9869 : : {
9870 : 0 : {
9871 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
9872 : 0 : if (gimple_simplify_222 (res_op, seq, valueize, type, captures, NE_EXPR))
9873 : 0 : return true;
9874 : : }
9875 : : }
9876 : : break;
9877 : : }
9878 : : default:;
9879 : : }
9880 : : }
9881 : : break;
9882 : 109 : default:;
9883 : : }
9884 : 109 : if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
9885 : : {
9886 : 0 : {
9887 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
9888 : 0 : if (gimple_simplify_222 (res_op, seq, valueize, type, captures, NE_EXPR))
9889 : 0 : return true;
9890 : : }
9891 : : }
9892 : : break;
9893 : : }
9894 : : default:;
9895 : : }
9896 : : }
9897 : : break;
9898 : 1186 : default:;
9899 : : }
9900 : 1186 : switch (TREE_CODE (_p1))
9901 : : {
9902 : 322 : case SSA_NAME:
9903 : 322 : if (gimple *_d3 = get_def (valueize, _p1))
9904 : : {
9905 : 314 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
9906 : 468 : switch (gimple_assign_rhs_code (_a3))
9907 : : {
9908 : 2 : CASE_CONVERT:
9909 : 2 : {
9910 : 2 : tree _q60 = gimple_assign_rhs1 (_a3);
9911 : 2 : _q60 = do_valueize (valueize, _q60);
9912 : 2 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
9913 : : {
9914 : 0 : {
9915 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q30 };
9916 : 0 : if (gimple_simplify_222 (res_op, seq, valueize, type, captures, NE_EXPR))
9917 : 0 : return true;
9918 : : }
9919 : : }
9920 : : break;
9921 : : }
9922 : : default:;
9923 : : }
9924 : : }
9925 : : break;
9926 : 1186 : default:;
9927 : : }
9928 : 1186 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
9929 : : {
9930 : 0 : {
9931 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q30 };
9932 : 0 : if (gimple_simplify_222 (res_op, seq, valueize, type, captures, NE_EXPR))
9933 : 0 : return true;
9934 : : }
9935 : : }
9936 : : break;
9937 : : }
9938 : : default:;
9939 : : }
9940 : : break;
9941 : : }
9942 : : default:;
9943 : : }
9944 : : }
9945 : : break;
9946 : 2019510 : default:;
9947 : : }
9948 : 2019510 : switch (TREE_CODE (_p1))
9949 : : {
9950 : 514647 : case SSA_NAME:
9951 : 514647 : if (gimple *_d2 = get_def (valueize, _p1))
9952 : : {
9953 : 464595 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
9954 : 538685 : switch (gimple_assign_rhs_code (_a2))
9955 : : {
9956 : 74087 : CASE_CONVERT:
9957 : 74087 : {
9958 : 74087 : tree _q40 = gimple_assign_rhs1 (_a2);
9959 : 74087 : _q40 = do_valueize (valueize, _q40);
9960 : 74087 : switch (TREE_CODE (_q40))
9961 : : {
9962 : 70694 : case SSA_NAME:
9963 : 70694 : if (gimple *_d3 = get_def (valueize, _q40))
9964 : : {
9965 : 69992 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
9966 : 79658 : switch (gimple_assign_rhs_code (_a3))
9967 : : {
9968 : 430 : case MINUS_EXPR:
9969 : 430 : {
9970 : 430 : tree _q50 = gimple_assign_rhs1 (_a3);
9971 : 430 : _q50 = do_valueize (valueize, _q50);
9972 : 430 : tree _q51 = gimple_assign_rhs2 (_a3);
9973 : 430 : _q51 = do_valueize (valueize, _q51);
9974 : 430 : switch (TREE_CODE (_q50))
9975 : : {
9976 : 2 : case INTEGER_CST:
9977 : 2 : {
9978 : 2 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
9979 : : {
9980 : 0 : {
9981 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
9982 : 0 : if (gimple_simplify_222 (res_op, seq, valueize, type, captures, NE_EXPR))
9983 : 0 : return true;
9984 : : }
9985 : : }
9986 : : break;
9987 : : }
9988 : : default:;
9989 : : }
9990 : : break;
9991 : : }
9992 : : default:;
9993 : : }
9994 : : }
9995 : : break;
9996 : : default:;
9997 : : }
9998 : : break;
9999 : : }
10000 : 87688 : case MINUS_EXPR:
10001 : 87688 : {
10002 : 87688 : tree _q40 = gimple_assign_rhs1 (_a2);
10003 : 87688 : _q40 = do_valueize (valueize, _q40);
10004 : 87688 : tree _q41 = gimple_assign_rhs2 (_a2);
10005 : 87688 : _q41 = do_valueize (valueize, _q41);
10006 : 87688 : switch (TREE_CODE (_q40))
10007 : : {
10008 : 1649 : case INTEGER_CST:
10009 : 1649 : {
10010 : 1649 : switch (TREE_CODE (_q41))
10011 : : {
10012 : 1649 : case SSA_NAME:
10013 : 1649 : if (gimple *_d3 = get_def (valueize, _q41))
10014 : : {
10015 : 1613 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
10016 : 1313 : switch (gimple_assign_rhs_code (_a3))
10017 : : {
10018 : 1079 : CASE_CONVERT:
10019 : 1079 : {
10020 : 1079 : tree _q60 = gimple_assign_rhs1 (_a3);
10021 : 1079 : _q60 = do_valueize (valueize, _q60);
10022 : 1079 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
10023 : : {
10024 : 0 : {
10025 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
10026 : 0 : if (gimple_simplify_222 (res_op, seq, valueize, type, captures, NE_EXPR))
10027 : 0 : return true;
10028 : : }
10029 : : }
10030 : : break;
10031 : : }
10032 : : default:;
10033 : : }
10034 : : }
10035 : : break;
10036 : 1649 : default:;
10037 : : }
10038 : 1649 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
10039 : : {
10040 : 0 : {
10041 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
10042 : 0 : if (gimple_simplify_222 (res_op, seq, valueize, type, captures, NE_EXPR))
10043 : 0 : return true;
10044 : : }
10045 : : }
10046 : : break;
10047 : : }
10048 : : default:;
10049 : : }
10050 : : break;
10051 : : }
10052 : : default:;
10053 : : }
10054 : : }
10055 : : break;
10056 : : default:;
10057 : : }
10058 : : break;
10059 : : }
10060 : 187813 : case MINUS_EXPR:
10061 : 187813 : {
10062 : 187813 : tree _q20 = gimple_assign_rhs1 (_a1);
10063 : 187813 : _q20 = do_valueize (valueize, _q20);
10064 : 187813 : tree _q21 = gimple_assign_rhs2 (_a1);
10065 : 187813 : _q21 = do_valueize (valueize, _q21);
10066 : 187813 : switch (TREE_CODE (_q20))
10067 : : {
10068 : 19243 : case INTEGER_CST:
10069 : 19243 : {
10070 : 19243 : switch (TREE_CODE (_q21))
10071 : : {
10072 : 19243 : case SSA_NAME:
10073 : 19243 : if (gimple *_d2 = get_def (valueize, _q21))
10074 : : {
10075 : 19182 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
10076 : 17242 : switch (gimple_assign_rhs_code (_a2))
10077 : : {
10078 : 14752 : CASE_CONVERT:
10079 : 14752 : {
10080 : 14752 : tree _q40 = gimple_assign_rhs1 (_a2);
10081 : 14752 : _q40 = do_valueize (valueize, _q40);
10082 : 14752 : switch (TREE_CODE (_p1))
10083 : : {
10084 : 299 : case SSA_NAME:
10085 : 299 : if (gimple *_d3 = get_def (valueize, _p1))
10086 : : {
10087 : 280 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
10088 : 258 : switch (gimple_assign_rhs_code (_a3))
10089 : : {
10090 : 67 : CASE_CONVERT:
10091 : 67 : {
10092 : 67 : tree _q60 = gimple_assign_rhs1 (_a3);
10093 : 67 : _q60 = do_valueize (valueize, _q60);
10094 : 67 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
10095 : : {
10096 : 0 : {
10097 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
10098 : 0 : if (gimple_simplify_222 (res_op, seq, valueize, type, captures, NE_EXPR))
10099 : 0 : return true;
10100 : : }
10101 : : }
10102 : : break;
10103 : : }
10104 : : default:;
10105 : : }
10106 : : }
10107 : : break;
10108 : 14752 : default:;
10109 : : }
10110 : 14752 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
10111 : : {
10112 : 0 : {
10113 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
10114 : 0 : if (gimple_simplify_222 (res_op, seq, valueize, type, captures, NE_EXPR))
10115 : 0 : return true;
10116 : : }
10117 : : }
10118 : : break;
10119 : : }
10120 : : default:;
10121 : : }
10122 : : }
10123 : : break;
10124 : 19243 : default:;
10125 : : }
10126 : 19243 : switch (TREE_CODE (_p1))
10127 : : {
10128 : 1734 : case SSA_NAME:
10129 : 1734 : if (gimple *_d2 = get_def (valueize, _p1))
10130 : : {
10131 : 1703 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
10132 : 1668 : switch (gimple_assign_rhs_code (_a2))
10133 : : {
10134 : 854 : CASE_CONVERT:
10135 : 854 : {
10136 : 854 : tree _q50 = gimple_assign_rhs1 (_a2);
10137 : 854 : _q50 = do_valueize (valueize, _q50);
10138 : 854 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10139 : : {
10140 : 0 : {
10141 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10142 : 0 : if (gimple_simplify_222 (res_op, seq, valueize, type, captures, NE_EXPR))
10143 : 0 : return true;
10144 : : }
10145 : : }
10146 : : break;
10147 : : }
10148 : : default:;
10149 : : }
10150 : : }
10151 : : break;
10152 : 19243 : default:;
10153 : : }
10154 : 19243 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
10155 : : {
10156 : 0 : {
10157 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10158 : 0 : if (gimple_simplify_222 (res_op, seq, valueize, type, captures, NE_EXPR))
10159 : 0 : return true;
10160 : : }
10161 : : }
10162 : : break;
10163 : : }
10164 : : default:;
10165 : : }
10166 : : break;
10167 : : }
10168 : : default:;
10169 : : }
10170 : : }
10171 : : break;
10172 : 115962917 : default:;
10173 : : }
10174 : 115962917 : switch (TREE_CODE (_p1))
10175 : : {
10176 : 20544933 : case SSA_NAME:
10177 : 20544933 : if (gimple *_d1 = get_def (valueize, _p1))
10178 : : {
10179 : 6240444 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
10180 : 8921265 : switch (gimple_assign_rhs_code (_a1))
10181 : : {
10182 : 341135 : CASE_CONVERT:
10183 : 341135 : {
10184 : 341135 : tree _q30 = gimple_assign_rhs1 (_a1);
10185 : 341135 : _q30 = do_valueize (valueize, _q30);
10186 : 341135 : switch (TREE_CODE (_q30))
10187 : : {
10188 : 331766 : case SSA_NAME:
10189 : 331766 : if (gimple *_d2 = get_def (valueize, _q30))
10190 : : {
10191 : 312775 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
10192 : 333234 : switch (gimple_assign_rhs_code (_a2))
10193 : : {
10194 : 6218 : case MINUS_EXPR:
10195 : 6218 : {
10196 : 6218 : tree _q40 = gimple_assign_rhs1 (_a2);
10197 : 6218 : _q40 = do_valueize (valueize, _q40);
10198 : 6218 : tree _q41 = gimple_assign_rhs2 (_a2);
10199 : 6218 : _q41 = do_valueize (valueize, _q41);
10200 : 6218 : switch (TREE_CODE (_q40))
10201 : : {
10202 : 1972 : case INTEGER_CST:
10203 : 1972 : {
10204 : 1972 : switch (TREE_CODE (_q41))
10205 : : {
10206 : 1972 : case SSA_NAME:
10207 : 1972 : if (gimple *_d3 = get_def (valueize, _q41))
10208 : : {
10209 : 1744 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
10210 : 1023 : switch (gimple_assign_rhs_code (_a3))
10211 : : {
10212 : 896 : CASE_CONVERT:
10213 : 896 : {
10214 : 896 : tree _q60 = gimple_assign_rhs1 (_a3);
10215 : 896 : _q60 = do_valueize (valueize, _q60);
10216 : 896 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
10217 : : {
10218 : 0 : {
10219 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
10220 : 0 : if (gimple_simplify_222 (res_op, seq, valueize, type, captures, NE_EXPR))
10221 : 0 : return true;
10222 : : }
10223 : : }
10224 : : break;
10225 : : }
10226 : : default:;
10227 : : }
10228 : : }
10229 : : break;
10230 : 1972 : default:;
10231 : : }
10232 : 1972 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
10233 : : {
10234 : 0 : {
10235 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
10236 : 0 : if (gimple_simplify_222 (res_op, seq, valueize, type, captures, NE_EXPR))
10237 : 0 : return true;
10238 : : }
10239 : : }
10240 : : break;
10241 : : }
10242 : : default:;
10243 : : }
10244 : : break;
10245 : : }
10246 : : default:;
10247 : : }
10248 : : }
10249 : : break;
10250 : : default:;
10251 : : }
10252 : : break;
10253 : : }
10254 : 148611 : case MINUS_EXPR:
10255 : 148611 : {
10256 : 148611 : tree _q30 = gimple_assign_rhs1 (_a1);
10257 : 148611 : _q30 = do_valueize (valueize, _q30);
10258 : 148611 : tree _q31 = gimple_assign_rhs2 (_a1);
10259 : 148611 : _q31 = do_valueize (valueize, _q31);
10260 : 148611 : switch (TREE_CODE (_q30))
10261 : : {
10262 : 3253 : case INTEGER_CST:
10263 : 3253 : {
10264 : 3253 : switch (TREE_CODE (_q31))
10265 : : {
10266 : 3253 : case SSA_NAME:
10267 : 3253 : if (gimple *_d2 = get_def (valueize, _q31))
10268 : : {
10269 : 3081 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
10270 : 2242 : switch (gimple_assign_rhs_code (_a2))
10271 : : {
10272 : 1295 : CASE_CONVERT:
10273 : 1295 : {
10274 : 1295 : tree _q50 = gimple_assign_rhs1 (_a2);
10275 : 1295 : _q50 = do_valueize (valueize, _q50);
10276 : 1295 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
10277 : : {
10278 : 0 : {
10279 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
10280 : 0 : if (gimple_simplify_222 (res_op, seq, valueize, type, captures, NE_EXPR))
10281 : 0 : return true;
10282 : : }
10283 : : }
10284 : : break;
10285 : : }
10286 : : default:;
10287 : : }
10288 : : }
10289 : : break;
10290 : 3253 : default:;
10291 : : }
10292 : 3253 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
10293 : : {
10294 : 0 : {
10295 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
10296 : 0 : if (gimple_simplify_222 (res_op, seq, valueize, type, captures, NE_EXPR))
10297 : 0 : return true;
10298 : : }
10299 : : }
10300 : : break;
10301 : : }
10302 : : default:;
10303 : : }
10304 : : break;
10305 : : }
10306 : : default:;
10307 : : }
10308 : : }
10309 : : break;
10310 : 115962917 : default:;
10311 : : }
10312 : 115962917 : switch (TREE_CODE (_p0))
10313 : : {
10314 : 112969942 : case SSA_NAME:
10315 : 112969942 : if (gimple *_d1 = get_def (valueize, _p0))
10316 : : {
10317 : 37459925 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
10318 : 41037627 : switch (gimple_assign_rhs_code (_a1))
10319 : : {
10320 : 192750 : case LT_EXPR:
10321 : 192750 : {
10322 : 192750 : tree _q20 = gimple_assign_rhs1 (_a1);
10323 : 192750 : _q20 = do_valueize (valueize, _q20);
10324 : 192750 : tree _q21 = gimple_assign_rhs2 (_a1);
10325 : 192750 : _q21 = do_valueize (valueize, _q21);
10326 : 192750 : switch (TREE_CODE (_p1))
10327 : : {
10328 : 1518 : case SSA_NAME:
10329 : 1518 : if (gimple *_d2 = get_def (valueize, _p1))
10330 : : {
10331 : 1497 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
10332 : 1295 : switch (gimple_assign_rhs_code (_a2))
10333 : : {
10334 : 18 : case GT_EXPR:
10335 : 18 : {
10336 : 18 : tree _q50 = gimple_assign_rhs1 (_a2);
10337 : 18 : _q50 = do_valueize (valueize, _q50);
10338 : 18 : tree _q51 = gimple_assign_rhs2 (_a2);
10339 : 18 : _q51 = do_valueize (valueize, _q51);
10340 : 18 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10341 : : {
10342 : 14 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10343 : : {
10344 : 14 : {
10345 : 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10346 : 14 : const enum tree_code cmp1 = LT_EXPR;
10347 : 14 : const enum tree_code cmp2 = GT_EXPR;
10348 : 14 : const enum tree_code rcmp = NE_EXPR;
10349 : 14 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10350 : : )
10351 : : {
10352 : 14 : gimple_seq *lseq = seq;
10353 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1799;
10354 : 14 : {
10355 : 14 : res_op->set_op (rcmp, type, 2);
10356 : 14 : res_op->ops[0] = captures[0];
10357 : 14 : res_op->ops[1] = captures[1];
10358 : 14 : res_op->resimplify (lseq, valueize);
10359 : 14 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10360 : 14 : return true;
10361 : : }
10362 : 0 : next_after_fail1799:;
10363 : : }
10364 : : }
10365 : 0 : {
10366 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10367 : 0 : const enum tree_code cmp1 = LT_EXPR;
10368 : 0 : const enum tree_code cmp2 = GT_EXPR;
10369 : 0 : const enum tree_code rcmp = NE_EXPR;
10370 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10371 : : )
10372 : : {
10373 : 0 : gimple_seq *lseq = seq;
10374 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1800;
10375 : 0 : {
10376 : 0 : res_op->set_op (rcmp, type, 2);
10377 : 0 : res_op->ops[0] = captures[0];
10378 : 0 : res_op->ops[1] = captures[1];
10379 : 0 : res_op->resimplify (lseq, valueize);
10380 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10381 : 0 : return true;
10382 : : }
10383 : 0 : next_after_fail1800:;
10384 : : }
10385 : : }
10386 : : }
10387 : : }
10388 : : break;
10389 : : }
10390 : 193 : case EQ_EXPR:
10391 : 193 : {
10392 : 193 : tree _q50 = gimple_assign_rhs1 (_a2);
10393 : 193 : _q50 = do_valueize (valueize, _q50);
10394 : 193 : tree _q51 = gimple_assign_rhs2 (_a2);
10395 : 193 : _q51 = do_valueize (valueize, _q51);
10396 : 193 : if (tree_swap_operands_p (_q50, _q51))
10397 : 0 : std::swap (_q50, _q51);
10398 : 193 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10399 : : {
10400 : 14 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10401 : : {
10402 : 14 : {
10403 : 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10404 : 14 : const enum tree_code cmp1 = LT_EXPR;
10405 : 14 : const enum tree_code cmp2 = EQ_EXPR;
10406 : 14 : const enum tree_code rcmp = LE_EXPR;
10407 : 14 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10408 : : )
10409 : : {
10410 : 14 : gimple_seq *lseq = seq;
10411 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1801;
10412 : 14 : {
10413 : 14 : res_op->set_op (rcmp, type, 2);
10414 : 14 : res_op->ops[0] = captures[0];
10415 : 14 : res_op->ops[1] = captures[1];
10416 : 14 : res_op->resimplify (lseq, valueize);
10417 : 14 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10418 : 14 : return true;
10419 : : }
10420 : 0 : next_after_fail1801:;
10421 : : }
10422 : : }
10423 : : }
10424 : : }
10425 : 179 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10426 : : {
10427 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10428 : : {
10429 : 0 : {
10430 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10431 : 0 : const enum tree_code cmp1 = LT_EXPR;
10432 : 0 : const enum tree_code cmp2 = EQ_EXPR;
10433 : 0 : const enum tree_code rcmp = LE_EXPR;
10434 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10435 : : )
10436 : : {
10437 : 0 : gimple_seq *lseq = seq;
10438 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1802;
10439 : 0 : {
10440 : 0 : res_op->set_op (rcmp, type, 2);
10441 : 0 : res_op->ops[0] = captures[0];
10442 : 0 : res_op->ops[1] = captures[1];
10443 : 0 : res_op->resimplify (lseq, valueize);
10444 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10445 : 0 : return true;
10446 : : }
10447 : 0 : next_after_fail1802:;
10448 : : }
10449 : : }
10450 : : }
10451 : : }
10452 : 115955457 : break;
10453 : : }
10454 : 115 : case NE_EXPR:
10455 : 115 : {
10456 : 115 : tree _q50 = gimple_assign_rhs1 (_a2);
10457 : 115 : _q50 = do_valueize (valueize, _q50);
10458 : 115 : tree _q51 = gimple_assign_rhs2 (_a2);
10459 : 115 : _q51 = do_valueize (valueize, _q51);
10460 : 115 : if (tree_swap_operands_p (_q50, _q51))
10461 : 13 : std::swap (_q50, _q51);
10462 : 115 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10463 : : {
10464 : 53 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10465 : : {
10466 : 14 : {
10467 : 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10468 : 14 : const enum tree_code cmp1 = LT_EXPR;
10469 : 14 : const enum tree_code cmp2 = NE_EXPR;
10470 : 14 : const enum tree_code rcmp = GT_EXPR;
10471 : 14 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10472 : : )
10473 : : {
10474 : 14 : gimple_seq *lseq = seq;
10475 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1803;
10476 : 14 : {
10477 : 14 : res_op->set_op (rcmp, type, 2);
10478 : 14 : res_op->ops[0] = captures[0];
10479 : 14 : res_op->ops[1] = captures[1];
10480 : 14 : res_op->resimplify (lseq, valueize);
10481 : 14 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10482 : 14 : return true;
10483 : : }
10484 : 0 : next_after_fail1803:;
10485 : : }
10486 : : }
10487 : : }
10488 : : }
10489 : 101 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10490 : : {
10491 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10492 : : {
10493 : 0 : {
10494 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10495 : 0 : const enum tree_code cmp1 = LT_EXPR;
10496 : 0 : const enum tree_code cmp2 = NE_EXPR;
10497 : 0 : const enum tree_code rcmp = GT_EXPR;
10498 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10499 : : )
10500 : : {
10501 : 0 : gimple_seq *lseq = seq;
10502 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1804;
10503 : 0 : {
10504 : 0 : res_op->set_op (rcmp, type, 2);
10505 : 0 : res_op->ops[0] = captures[0];
10506 : 0 : res_op->ops[1] = captures[1];
10507 : 0 : res_op->resimplify (lseq, valueize);
10508 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10509 : 0 : return true;
10510 : : }
10511 : 0 : next_after_fail1804:;
10512 : : }
10513 : : }
10514 : : }
10515 : : }
10516 : 115955457 : break;
10517 : : }
10518 : 516 : case LT_EXPR:
10519 : 516 : {
10520 : 516 : tree _q50 = gimple_assign_rhs1 (_a2);
10521 : 516 : _q50 = do_valueize (valueize, _q50);
10522 : 516 : tree _q51 = gimple_assign_rhs2 (_a2);
10523 : 516 : _q51 = do_valueize (valueize, _q51);
10524 : 516 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10525 : : {
10526 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10527 : : {
10528 : 0 : {
10529 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10530 : 0 : const enum tree_code cmp1 = LT_EXPR;
10531 : 0 : const enum tree_code cmp2 = GT_EXPR;
10532 : 0 : const enum tree_code rcmp = NE_EXPR;
10533 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10534 : : )
10535 : : {
10536 : 0 : gimple_seq *lseq = seq;
10537 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1805;
10538 : 0 : {
10539 : 0 : res_op->set_op (rcmp, type, 2);
10540 : 0 : res_op->ops[0] = captures[0];
10541 : 0 : res_op->ops[1] = captures[1];
10542 : 0 : res_op->resimplify (lseq, valueize);
10543 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10544 : 0 : return true;
10545 : : }
10546 : 0 : next_after_fail1805:;
10547 : : }
10548 : : }
10549 : 0 : {
10550 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10551 : 0 : const enum tree_code cmp1 = LT_EXPR;
10552 : 0 : const enum tree_code cmp2 = GT_EXPR;
10553 : 0 : const enum tree_code rcmp = NE_EXPR;
10554 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10555 : : )
10556 : : {
10557 : 0 : gimple_seq *lseq = seq;
10558 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1806;
10559 : 0 : {
10560 : 0 : res_op->set_op (rcmp, type, 2);
10561 : 0 : res_op->ops[0] = captures[0];
10562 : 0 : res_op->ops[1] = captures[1];
10563 : 0 : res_op->resimplify (lseq, valueize);
10564 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10565 : 0 : return true;
10566 : : }
10567 : 0 : next_after_fail1806:;
10568 : : }
10569 : : }
10570 : : }
10571 : : }
10572 : : break;
10573 : : }
10574 : : default:;
10575 : : }
10576 : : }
10577 : : break;
10578 : : default:;
10579 : : }
10580 : : break;
10581 : : }
10582 : 88599 : case LE_EXPR:
10583 : 88599 : {
10584 : 88599 : tree _q20 = gimple_assign_rhs1 (_a1);
10585 : 88599 : _q20 = do_valueize (valueize, _q20);
10586 : 88599 : tree _q21 = gimple_assign_rhs2 (_a1);
10587 : 88599 : _q21 = do_valueize (valueize, _q21);
10588 : 88599 : switch (TREE_CODE (_p1))
10589 : : {
10590 : 2727 : case SSA_NAME:
10591 : 2727 : if (gimple *_d2 = get_def (valueize, _p1))
10592 : : {
10593 : 2698 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
10594 : 2660 : switch (gimple_assign_rhs_code (_a2))
10595 : : {
10596 : 67 : case GE_EXPR:
10597 : 67 : {
10598 : 67 : tree _q50 = gimple_assign_rhs1 (_a2);
10599 : 67 : _q50 = do_valueize (valueize, _q50);
10600 : 67 : tree _q51 = gimple_assign_rhs2 (_a2);
10601 : 67 : _q51 = do_valueize (valueize, _q51);
10602 : 67 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10603 : : {
10604 : 14 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10605 : : {
10606 : 14 : {
10607 : 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10608 : 14 : const enum tree_code cmp1 = LE_EXPR;
10609 : 14 : const enum tree_code cmp2 = GE_EXPR;
10610 : 14 : const enum tree_code rcmp = NE_EXPR;
10611 : 14 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10612 : : )
10613 : : {
10614 : 14 : gimple_seq *lseq = seq;
10615 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1807;
10616 : 14 : {
10617 : 14 : res_op->set_op (rcmp, type, 2);
10618 : 14 : res_op->ops[0] = captures[0];
10619 : 14 : res_op->ops[1] = captures[1];
10620 : 14 : res_op->resimplify (lseq, valueize);
10621 : 14 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10622 : 14 : return true;
10623 : : }
10624 : 0 : next_after_fail1807:;
10625 : : }
10626 : : }
10627 : 0 : {
10628 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10629 : 0 : const enum tree_code cmp1 = LE_EXPR;
10630 : 0 : const enum tree_code cmp2 = GE_EXPR;
10631 : 0 : const enum tree_code rcmp = NE_EXPR;
10632 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10633 : : )
10634 : : {
10635 : 0 : gimple_seq *lseq = seq;
10636 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1808;
10637 : 0 : {
10638 : 0 : res_op->set_op (rcmp, type, 2);
10639 : 0 : res_op->ops[0] = captures[0];
10640 : 0 : res_op->ops[1] = captures[1];
10641 : 0 : res_op->resimplify (lseq, valueize);
10642 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10643 : 0 : return true;
10644 : : }
10645 : 0 : next_after_fail1808:;
10646 : : }
10647 : : }
10648 : : }
10649 : : }
10650 : : break;
10651 : : }
10652 : 277 : case EQ_EXPR:
10653 : 277 : {
10654 : 277 : tree _q50 = gimple_assign_rhs1 (_a2);
10655 : 277 : _q50 = do_valueize (valueize, _q50);
10656 : 277 : tree _q51 = gimple_assign_rhs2 (_a2);
10657 : 277 : _q51 = do_valueize (valueize, _q51);
10658 : 277 : if (tree_swap_operands_p (_q50, _q51))
10659 : 13 : std::swap (_q50, _q51);
10660 : 277 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10661 : : {
10662 : 53 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10663 : : {
10664 : 14 : {
10665 : 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10666 : 14 : const enum tree_code cmp1 = LE_EXPR;
10667 : 14 : const enum tree_code cmp2 = EQ_EXPR;
10668 : 14 : const enum tree_code rcmp = LT_EXPR;
10669 : 14 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10670 : : )
10671 : : {
10672 : 14 : gimple_seq *lseq = seq;
10673 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1809;
10674 : 14 : {
10675 : 14 : res_op->set_op (rcmp, type, 2);
10676 : 14 : res_op->ops[0] = captures[0];
10677 : 14 : res_op->ops[1] = captures[1];
10678 : 14 : res_op->resimplify (lseq, valueize);
10679 : 14 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10680 : 14 : return true;
10681 : : }
10682 : 0 : next_after_fail1809:;
10683 : : }
10684 : : }
10685 : : }
10686 : : }
10687 : 263 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10688 : : {
10689 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10690 : : {
10691 : 0 : {
10692 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10693 : 0 : const enum tree_code cmp1 = LE_EXPR;
10694 : 0 : const enum tree_code cmp2 = EQ_EXPR;
10695 : 0 : const enum tree_code rcmp = LT_EXPR;
10696 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10697 : : )
10698 : : {
10699 : 0 : gimple_seq *lseq = seq;
10700 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1810;
10701 : 0 : {
10702 : 0 : res_op->set_op (rcmp, type, 2);
10703 : 0 : res_op->ops[0] = captures[0];
10704 : 0 : res_op->ops[1] = captures[1];
10705 : 0 : res_op->resimplify (lseq, valueize);
10706 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10707 : 0 : return true;
10708 : : }
10709 : 0 : next_after_fail1810:;
10710 : : }
10711 : : }
10712 : : }
10713 : : }
10714 : 115955457 : break;
10715 : : }
10716 : 113 : case NE_EXPR:
10717 : 113 : {
10718 : 113 : tree _q50 = gimple_assign_rhs1 (_a2);
10719 : 113 : _q50 = do_valueize (valueize, _q50);
10720 : 113 : tree _q51 = gimple_assign_rhs2 (_a2);
10721 : 113 : _q51 = do_valueize (valueize, _q51);
10722 : 113 : if (tree_swap_operands_p (_q50, _q51))
10723 : 0 : std::swap (_q50, _q51);
10724 : 113 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10725 : : {
10726 : 14 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10727 : : {
10728 : 14 : {
10729 : 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10730 : 14 : const enum tree_code cmp1 = LE_EXPR;
10731 : 14 : const enum tree_code cmp2 = NE_EXPR;
10732 : 14 : const enum tree_code rcmp = GE_EXPR;
10733 : 14 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10734 : : )
10735 : : {
10736 : 14 : gimple_seq *lseq = seq;
10737 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1811;
10738 : 14 : {
10739 : 14 : res_op->set_op (rcmp, type, 2);
10740 : 14 : res_op->ops[0] = captures[0];
10741 : 14 : res_op->ops[1] = captures[1];
10742 : 14 : res_op->resimplify (lseq, valueize);
10743 : 14 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10744 : 14 : return true;
10745 : : }
10746 : 0 : next_after_fail1811:;
10747 : : }
10748 : : }
10749 : : }
10750 : : }
10751 : 99 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10752 : : {
10753 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10754 : : {
10755 : 0 : {
10756 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10757 : 0 : const enum tree_code cmp1 = LE_EXPR;
10758 : 0 : const enum tree_code cmp2 = NE_EXPR;
10759 : 0 : const enum tree_code rcmp = GE_EXPR;
10760 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10761 : : )
10762 : : {
10763 : 0 : gimple_seq *lseq = seq;
10764 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1812;
10765 : 0 : {
10766 : 0 : res_op->set_op (rcmp, type, 2);
10767 : 0 : res_op->ops[0] = captures[0];
10768 : 0 : res_op->ops[1] = captures[1];
10769 : 0 : res_op->resimplify (lseq, valueize);
10770 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10771 : 0 : return true;
10772 : : }
10773 : 0 : next_after_fail1812:;
10774 : : }
10775 : : }
10776 : : }
10777 : : }
10778 : 115955457 : break;
10779 : : }
10780 : 1171 : case LE_EXPR:
10781 : 1171 : {
10782 : 1171 : tree _q50 = gimple_assign_rhs1 (_a2);
10783 : 1171 : _q50 = do_valueize (valueize, _q50);
10784 : 1171 : tree _q51 = gimple_assign_rhs2 (_a2);
10785 : 1171 : _q51 = do_valueize (valueize, _q51);
10786 : 1171 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10787 : : {
10788 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10789 : : {
10790 : 0 : {
10791 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10792 : 0 : const enum tree_code cmp1 = LE_EXPR;
10793 : 0 : const enum tree_code cmp2 = GE_EXPR;
10794 : 0 : const enum tree_code rcmp = NE_EXPR;
10795 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10796 : : )
10797 : : {
10798 : 0 : gimple_seq *lseq = seq;
10799 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1813;
10800 : 0 : {
10801 : 0 : res_op->set_op (rcmp, type, 2);
10802 : 0 : res_op->ops[0] = captures[0];
10803 : 0 : res_op->ops[1] = captures[1];
10804 : 0 : res_op->resimplify (lseq, valueize);
10805 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10806 : 0 : return true;
10807 : : }
10808 : 0 : next_after_fail1813:;
10809 : : }
10810 : : }
10811 : 0 : {
10812 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10813 : 0 : const enum tree_code cmp1 = LE_EXPR;
10814 : 0 : const enum tree_code cmp2 = GE_EXPR;
10815 : 0 : const enum tree_code rcmp = NE_EXPR;
10816 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10817 : : )
10818 : : {
10819 : 0 : gimple_seq *lseq = seq;
10820 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1814;
10821 : 0 : {
10822 : 0 : res_op->set_op (rcmp, type, 2);
10823 : 0 : res_op->ops[0] = captures[0];
10824 : 0 : res_op->ops[1] = captures[1];
10825 : 0 : res_op->resimplify (lseq, valueize);
10826 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10827 : 0 : return true;
10828 : : }
10829 : 0 : next_after_fail1814:;
10830 : : }
10831 : : }
10832 : : }
10833 : : }
10834 : : break;
10835 : : }
10836 : : default:;
10837 : : }
10838 : : }
10839 : : break;
10840 : : default:;
10841 : : }
10842 : : break;
10843 : : }
10844 : 213356 : case GT_EXPR:
10845 : 213356 : {
10846 : 213356 : tree _q20 = gimple_assign_rhs1 (_a1);
10847 : 213356 : _q20 = do_valueize (valueize, _q20);
10848 : 213356 : tree _q21 = gimple_assign_rhs2 (_a1);
10849 : 213356 : _q21 = do_valueize (valueize, _q21);
10850 : 213356 : switch (TREE_CODE (_p1))
10851 : : {
10852 : 1311 : case SSA_NAME:
10853 : 1311 : if (gimple *_d2 = get_def (valueize, _p1))
10854 : : {
10855 : 1284 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
10856 : 1230 : switch (gimple_assign_rhs_code (_a2))
10857 : : {
10858 : 106 : case GT_EXPR:
10859 : 106 : {
10860 : 106 : tree _q50 = gimple_assign_rhs1 (_a2);
10861 : 106 : _q50 = do_valueize (valueize, _q50);
10862 : 106 : tree _q51 = gimple_assign_rhs2 (_a2);
10863 : 106 : _q51 = do_valueize (valueize, _q51);
10864 : 106 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10865 : : {
10866 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10867 : : {
10868 : 0 : {
10869 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10870 : 0 : const enum tree_code cmp1 = LT_EXPR;
10871 : 0 : const enum tree_code cmp2 = GT_EXPR;
10872 : 0 : const enum tree_code rcmp = NE_EXPR;
10873 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10874 : : )
10875 : : {
10876 : 0 : gimple_seq *lseq = seq;
10877 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1815;
10878 : 0 : {
10879 : 0 : res_op->set_op (rcmp, type, 2);
10880 : 0 : res_op->ops[0] = captures[0];
10881 : 0 : res_op->ops[1] = captures[1];
10882 : 0 : res_op->resimplify (lseq, valueize);
10883 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10884 : 0 : return true;
10885 : : }
10886 : 0 : next_after_fail1815:;
10887 : : }
10888 : : }
10889 : 0 : {
10890 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10891 : 0 : const enum tree_code cmp1 = LT_EXPR;
10892 : 0 : const enum tree_code cmp2 = GT_EXPR;
10893 : 0 : const enum tree_code rcmp = NE_EXPR;
10894 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10895 : : )
10896 : : {
10897 : 0 : gimple_seq *lseq = seq;
10898 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1816;
10899 : 0 : {
10900 : 0 : res_op->set_op (rcmp, type, 2);
10901 : 0 : res_op->ops[0] = captures[0];
10902 : 0 : res_op->ops[1] = captures[1];
10903 : 0 : res_op->resimplify (lseq, valueize);
10904 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10905 : 0 : return true;
10906 : : }
10907 : 0 : next_after_fail1816:;
10908 : : }
10909 : : }
10910 : : }
10911 : : }
10912 : : break;
10913 : : }
10914 : 176 : case EQ_EXPR:
10915 : 176 : {
10916 : 176 : tree _q50 = gimple_assign_rhs1 (_a2);
10917 : 176 : _q50 = do_valueize (valueize, _q50);
10918 : 176 : tree _q51 = gimple_assign_rhs2 (_a2);
10919 : 176 : _q51 = do_valueize (valueize, _q51);
10920 : 176 : if (tree_swap_operands_p (_q50, _q51))
10921 : 0 : std::swap (_q50, _q51);
10922 : 176 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10923 : : {
10924 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10925 : : {
10926 : 0 : {
10927 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10928 : 0 : const enum tree_code cmp1 = LT_EXPR;
10929 : 0 : const enum tree_code cmp2 = EQ_EXPR;
10930 : 0 : const enum tree_code rcmp = LE_EXPR;
10931 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10932 : : )
10933 : : {
10934 : 0 : gimple_seq *lseq = seq;
10935 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1817;
10936 : 0 : {
10937 : 0 : res_op->set_op (rcmp, type, 2);
10938 : 0 : res_op->ops[0] = captures[0];
10939 : 0 : res_op->ops[1] = captures[1];
10940 : 0 : res_op->resimplify (lseq, valueize);
10941 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10942 : 0 : return true;
10943 : : }
10944 : 0 : next_after_fail1817:;
10945 : : }
10946 : : }
10947 : : }
10948 : : }
10949 : 176 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
10950 : : {
10951 : 14 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
10952 : : {
10953 : 14 : {
10954 : 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10955 : 14 : const enum tree_code cmp1 = LT_EXPR;
10956 : 14 : const enum tree_code cmp2 = EQ_EXPR;
10957 : 14 : const enum tree_code rcmp = LE_EXPR;
10958 : 14 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10959 : : )
10960 : : {
10961 : 14 : gimple_seq *lseq = seq;
10962 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1818;
10963 : 14 : {
10964 : 14 : res_op->set_op (rcmp, type, 2);
10965 : 14 : res_op->ops[0] = captures[0];
10966 : 14 : res_op->ops[1] = captures[1];
10967 : 14 : res_op->resimplify (lseq, valueize);
10968 : 14 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
10969 : 14 : return true;
10970 : : }
10971 : 0 : next_after_fail1818:;
10972 : : }
10973 : : }
10974 : : }
10975 : : }
10976 : 115955457 : break;
10977 : : }
10978 : 223 : case NE_EXPR:
10979 : 223 : {
10980 : 223 : tree _q50 = gimple_assign_rhs1 (_a2);
10981 : 223 : _q50 = do_valueize (valueize, _q50);
10982 : 223 : tree _q51 = gimple_assign_rhs2 (_a2);
10983 : 223 : _q51 = do_valueize (valueize, _q51);
10984 : 223 : if (tree_swap_operands_p (_q50, _q51))
10985 : 13 : std::swap (_q50, _q51);
10986 : 223 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
10987 : : {
10988 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
10989 : : {
10990 : 0 : {
10991 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
10992 : 0 : const enum tree_code cmp1 = LT_EXPR;
10993 : 0 : const enum tree_code cmp2 = NE_EXPR;
10994 : 0 : const enum tree_code rcmp = GT_EXPR;
10995 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
10996 : : )
10997 : : {
10998 : 0 : gimple_seq *lseq = seq;
10999 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1819;
11000 : 0 : {
11001 : 0 : res_op->set_op (rcmp, type, 2);
11002 : 0 : res_op->ops[0] = captures[0];
11003 : 0 : res_op->ops[1] = captures[1];
11004 : 0 : res_op->resimplify (lseq, valueize);
11005 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11006 : 0 : return true;
11007 : : }
11008 : 0 : next_after_fail1819:;
11009 : : }
11010 : : }
11011 : : }
11012 : : }
11013 : 223 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
11014 : : {
11015 : 53 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11016 : : {
11017 : 14 : {
11018 : 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11019 : 14 : const enum tree_code cmp1 = LT_EXPR;
11020 : 14 : const enum tree_code cmp2 = NE_EXPR;
11021 : 14 : const enum tree_code rcmp = GT_EXPR;
11022 : 14 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11023 : : )
11024 : : {
11025 : 14 : gimple_seq *lseq = seq;
11026 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1820;
11027 : 14 : {
11028 : 14 : res_op->set_op (rcmp, type, 2);
11029 : 14 : res_op->ops[0] = captures[0];
11030 : 14 : res_op->ops[1] = captures[1];
11031 : 14 : res_op->resimplify (lseq, valueize);
11032 : 14 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11033 : 14 : return true;
11034 : : }
11035 : 0 : next_after_fail1820:;
11036 : : }
11037 : : }
11038 : : }
11039 : : }
11040 : 115955457 : break;
11041 : : }
11042 : 116 : case LT_EXPR:
11043 : 116 : {
11044 : 116 : tree _q50 = gimple_assign_rhs1 (_a2);
11045 : 116 : _q50 = do_valueize (valueize, _q50);
11046 : 116 : tree _q51 = gimple_assign_rhs2 (_a2);
11047 : 116 : _q51 = do_valueize (valueize, _q51);
11048 : 116 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
11049 : : {
11050 : 14 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11051 : : {
11052 : 14 : {
11053 : 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11054 : 14 : const enum tree_code cmp1 = LT_EXPR;
11055 : 14 : const enum tree_code cmp2 = GT_EXPR;
11056 : 14 : const enum tree_code rcmp = NE_EXPR;
11057 : 14 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11058 : : )
11059 : : {
11060 : 14 : gimple_seq *lseq = seq;
11061 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1821;
11062 : 14 : {
11063 : 14 : res_op->set_op (rcmp, type, 2);
11064 : 14 : res_op->ops[0] = captures[0];
11065 : 14 : res_op->ops[1] = captures[1];
11066 : 14 : res_op->resimplify (lseq, valueize);
11067 : 14 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11068 : 14 : return true;
11069 : : }
11070 : 0 : next_after_fail1821:;
11071 : : }
11072 : : }
11073 : 0 : {
11074 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11075 : 0 : const enum tree_code cmp1 = LT_EXPR;
11076 : 0 : const enum tree_code cmp2 = GT_EXPR;
11077 : 0 : const enum tree_code rcmp = NE_EXPR;
11078 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11079 : : )
11080 : : {
11081 : 0 : gimple_seq *lseq = seq;
11082 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1822;
11083 : 0 : {
11084 : 0 : res_op->set_op (rcmp, type, 2);
11085 : 0 : res_op->ops[0] = captures[0];
11086 : 0 : res_op->ops[1] = captures[1];
11087 : 0 : res_op->resimplify (lseq, valueize);
11088 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11089 : 0 : return true;
11090 : : }
11091 : 0 : next_after_fail1822:;
11092 : : }
11093 : : }
11094 : : }
11095 : : }
11096 : : break;
11097 : : }
11098 : : default:;
11099 : : }
11100 : : }
11101 : : break;
11102 : : default:;
11103 : : }
11104 : : break;
11105 : : }
11106 : 112836 : case GE_EXPR:
11107 : 112836 : {
11108 : 112836 : tree _q20 = gimple_assign_rhs1 (_a1);
11109 : 112836 : _q20 = do_valueize (valueize, _q20);
11110 : 112836 : tree _q21 = gimple_assign_rhs2 (_a1);
11111 : 112836 : _q21 = do_valueize (valueize, _q21);
11112 : 112836 : switch (TREE_CODE (_p1))
11113 : : {
11114 : 2338 : case SSA_NAME:
11115 : 2338 : if (gimple *_d2 = get_def (valueize, _p1))
11116 : : {
11117 : 2308 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
11118 : 2280 : switch (gimple_assign_rhs_code (_a2))
11119 : : {
11120 : 71 : case GE_EXPR:
11121 : 71 : {
11122 : 71 : tree _q50 = gimple_assign_rhs1 (_a2);
11123 : 71 : _q50 = do_valueize (valueize, _q50);
11124 : 71 : tree _q51 = gimple_assign_rhs2 (_a2);
11125 : 71 : _q51 = do_valueize (valueize, _q51);
11126 : 71 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
11127 : : {
11128 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
11129 : : {
11130 : 0 : {
11131 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11132 : 0 : const enum tree_code cmp1 = LE_EXPR;
11133 : 0 : const enum tree_code cmp2 = GE_EXPR;
11134 : 0 : const enum tree_code rcmp = NE_EXPR;
11135 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11136 : : )
11137 : : {
11138 : 0 : gimple_seq *lseq = seq;
11139 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1823;
11140 : 0 : {
11141 : 0 : res_op->set_op (rcmp, type, 2);
11142 : 0 : res_op->ops[0] = captures[0];
11143 : 0 : res_op->ops[1] = captures[1];
11144 : 0 : res_op->resimplify (lseq, valueize);
11145 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11146 : 0 : return true;
11147 : : }
11148 : 0 : next_after_fail1823:;
11149 : : }
11150 : : }
11151 : 0 : {
11152 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11153 : 0 : const enum tree_code cmp1 = LE_EXPR;
11154 : 0 : const enum tree_code cmp2 = GE_EXPR;
11155 : 0 : const enum tree_code rcmp = NE_EXPR;
11156 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11157 : : )
11158 : : {
11159 : 0 : gimple_seq *lseq = seq;
11160 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1824;
11161 : 0 : {
11162 : 0 : res_op->set_op (rcmp, type, 2);
11163 : 0 : res_op->ops[0] = captures[0];
11164 : 0 : res_op->ops[1] = captures[1];
11165 : 0 : res_op->resimplify (lseq, valueize);
11166 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11167 : 0 : return true;
11168 : : }
11169 : 0 : next_after_fail1824:;
11170 : : }
11171 : : }
11172 : : }
11173 : : }
11174 : : break;
11175 : : }
11176 : 277 : case EQ_EXPR:
11177 : 277 : {
11178 : 277 : tree _q50 = gimple_assign_rhs1 (_a2);
11179 : 277 : _q50 = do_valueize (valueize, _q50);
11180 : 277 : tree _q51 = gimple_assign_rhs2 (_a2);
11181 : 277 : _q51 = do_valueize (valueize, _q51);
11182 : 277 : if (tree_swap_operands_p (_q50, _q51))
11183 : 13 : std::swap (_q50, _q51);
11184 : 277 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
11185 : : {
11186 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
11187 : : {
11188 : 0 : {
11189 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11190 : 0 : const enum tree_code cmp1 = LE_EXPR;
11191 : 0 : const enum tree_code cmp2 = EQ_EXPR;
11192 : 0 : const enum tree_code rcmp = LT_EXPR;
11193 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11194 : : )
11195 : : {
11196 : 0 : gimple_seq *lseq = seq;
11197 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1825;
11198 : 0 : {
11199 : 0 : res_op->set_op (rcmp, type, 2);
11200 : 0 : res_op->ops[0] = captures[0];
11201 : 0 : res_op->ops[1] = captures[1];
11202 : 0 : res_op->resimplify (lseq, valueize);
11203 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11204 : 0 : return true;
11205 : : }
11206 : 0 : next_after_fail1825:;
11207 : : }
11208 : : }
11209 : : }
11210 : : }
11211 : 277 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
11212 : : {
11213 : 53 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11214 : : {
11215 : 14 : {
11216 : 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11217 : 14 : const enum tree_code cmp1 = LE_EXPR;
11218 : 14 : const enum tree_code cmp2 = EQ_EXPR;
11219 : 14 : const enum tree_code rcmp = LT_EXPR;
11220 : 14 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11221 : : )
11222 : : {
11223 : 14 : gimple_seq *lseq = seq;
11224 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1826;
11225 : 14 : {
11226 : 14 : res_op->set_op (rcmp, type, 2);
11227 : 14 : res_op->ops[0] = captures[0];
11228 : 14 : res_op->ops[1] = captures[1];
11229 : 14 : res_op->resimplify (lseq, valueize);
11230 : 14 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11231 : 14 : return true;
11232 : : }
11233 : 0 : next_after_fail1826:;
11234 : : }
11235 : : }
11236 : : }
11237 : : }
11238 : 115955457 : break;
11239 : : }
11240 : 14 : case NE_EXPR:
11241 : 14 : {
11242 : 14 : tree _q50 = gimple_assign_rhs1 (_a2);
11243 : 14 : _q50 = do_valueize (valueize, _q50);
11244 : 14 : tree _q51 = gimple_assign_rhs2 (_a2);
11245 : 14 : _q51 = do_valueize (valueize, _q51);
11246 : 14 : if (tree_swap_operands_p (_q50, _q51))
11247 : 0 : std::swap (_q50, _q51);
11248 : 14 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
11249 : : {
11250 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
11251 : : {
11252 : 0 : {
11253 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11254 : 0 : const enum tree_code cmp1 = LE_EXPR;
11255 : 0 : const enum tree_code cmp2 = NE_EXPR;
11256 : 0 : const enum tree_code rcmp = GE_EXPR;
11257 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11258 : : )
11259 : : {
11260 : 0 : gimple_seq *lseq = seq;
11261 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1827;
11262 : 0 : {
11263 : 0 : res_op->set_op (rcmp, type, 2);
11264 : 0 : res_op->ops[0] = captures[0];
11265 : 0 : res_op->ops[1] = captures[1];
11266 : 0 : res_op->resimplify (lseq, valueize);
11267 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11268 : 0 : return true;
11269 : : }
11270 : 0 : next_after_fail1827:;
11271 : : }
11272 : : }
11273 : : }
11274 : : }
11275 : 14 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
11276 : : {
11277 : 14 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11278 : : {
11279 : 14 : {
11280 : 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11281 : 14 : const enum tree_code cmp1 = LE_EXPR;
11282 : 14 : const enum tree_code cmp2 = NE_EXPR;
11283 : 14 : const enum tree_code rcmp = GE_EXPR;
11284 : 14 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11285 : : )
11286 : : {
11287 : 14 : gimple_seq *lseq = seq;
11288 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1828;
11289 : 14 : {
11290 : 14 : res_op->set_op (rcmp, type, 2);
11291 : 14 : res_op->ops[0] = captures[0];
11292 : 14 : res_op->ops[1] = captures[1];
11293 : 14 : res_op->resimplify (lseq, valueize);
11294 : 14 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11295 : 14 : return true;
11296 : : }
11297 : 0 : next_after_fail1828:;
11298 : : }
11299 : : }
11300 : : }
11301 : : }
11302 : 115955457 : break;
11303 : : }
11304 : 69 : case LE_EXPR:
11305 : 69 : {
11306 : 69 : tree _q50 = gimple_assign_rhs1 (_a2);
11307 : 69 : _q50 = do_valueize (valueize, _q50);
11308 : 69 : tree _q51 = gimple_assign_rhs2 (_a2);
11309 : 69 : _q51 = do_valueize (valueize, _q51);
11310 : 69 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
11311 : : {
11312 : 14 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11313 : : {
11314 : 14 : {
11315 : 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11316 : 14 : const enum tree_code cmp1 = LE_EXPR;
11317 : 14 : const enum tree_code cmp2 = GE_EXPR;
11318 : 14 : const enum tree_code rcmp = NE_EXPR;
11319 : 14 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11320 : : )
11321 : : {
11322 : 14 : gimple_seq *lseq = seq;
11323 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1829;
11324 : 14 : {
11325 : 14 : res_op->set_op (rcmp, type, 2);
11326 : 14 : res_op->ops[0] = captures[0];
11327 : 14 : res_op->ops[1] = captures[1];
11328 : 14 : res_op->resimplify (lseq, valueize);
11329 : 14 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11330 : 14 : return true;
11331 : : }
11332 : 0 : next_after_fail1829:;
11333 : : }
11334 : : }
11335 : 0 : {
11336 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11337 : 0 : const enum tree_code cmp1 = LE_EXPR;
11338 : 0 : const enum tree_code cmp2 = GE_EXPR;
11339 : 0 : const enum tree_code rcmp = NE_EXPR;
11340 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11341 : : )
11342 : : {
11343 : 0 : gimple_seq *lseq = seq;
11344 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1830;
11345 : 0 : {
11346 : 0 : res_op->set_op (rcmp, type, 2);
11347 : 0 : res_op->ops[0] = captures[0];
11348 : 0 : res_op->ops[1] = captures[1];
11349 : 0 : res_op->resimplify (lseq, valueize);
11350 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11351 : 0 : return true;
11352 : : }
11353 : 0 : next_after_fail1830:;
11354 : : }
11355 : : }
11356 : : }
11357 : : }
11358 : : break;
11359 : : }
11360 : : default:;
11361 : : }
11362 : : }
11363 : : break;
11364 : : default:;
11365 : : }
11366 : : break;
11367 : : }
11368 : 439328 : case EQ_EXPR:
11369 : 439328 : {
11370 : 439328 : tree _q20 = gimple_assign_rhs1 (_a1);
11371 : 439328 : _q20 = do_valueize (valueize, _q20);
11372 : 439328 : tree _q21 = gimple_assign_rhs2 (_a1);
11373 : 439328 : _q21 = do_valueize (valueize, _q21);
11374 : 439328 : if (tree_swap_operands_p (_q20, _q21))
11375 : 8379 : std::swap (_q20, _q21);
11376 : 439328 : switch (TREE_CODE (_p1))
11377 : : {
11378 : 6896 : case SSA_NAME:
11379 : 6896 : if (gimple *_d2 = get_def (valueize, _p1))
11380 : : {
11381 : 6785 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
11382 : 7040 : switch (gimple_assign_rhs_code (_a2))
11383 : : {
11384 : 20 : case LT_EXPR:
11385 : 20 : {
11386 : 20 : tree _q50 = gimple_assign_rhs1 (_a2);
11387 : 20 : _q50 = do_valueize (valueize, _q50);
11388 : 20 : tree _q51 = gimple_assign_rhs2 (_a2);
11389 : 20 : _q51 = do_valueize (valueize, _q51);
11390 : 20 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
11391 : : {
11392 : 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11393 : : {
11394 : 0 : {
11395 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11396 : 0 : const enum tree_code cmp1 = LT_EXPR;
11397 : 0 : const enum tree_code cmp2 = EQ_EXPR;
11398 : 0 : const enum tree_code rcmp = LE_EXPR;
11399 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11400 : : )
11401 : : {
11402 : 0 : gimple_seq *lseq = seq;
11403 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1831;
11404 : 0 : {
11405 : 0 : res_op->set_op (rcmp, type, 2);
11406 : 0 : res_op->ops[0] = captures[0];
11407 : 0 : res_op->ops[1] = captures[1];
11408 : 0 : res_op->resimplify (lseq, valueize);
11409 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11410 : 0 : return true;
11411 : : }
11412 : 0 : next_after_fail1831:;
11413 : : }
11414 : : }
11415 : : }
11416 : : }
11417 : 20 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
11418 : : {
11419 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
11420 : : {
11421 : 0 : {
11422 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11423 : 0 : const enum tree_code cmp1 = LT_EXPR;
11424 : 0 : const enum tree_code cmp2 = EQ_EXPR;
11425 : 0 : const enum tree_code rcmp = LE_EXPR;
11426 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11427 : : )
11428 : : {
11429 : 0 : gimple_seq *lseq = seq;
11430 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1832;
11431 : 0 : {
11432 : 0 : res_op->set_op (rcmp, type, 2);
11433 : 0 : res_op->ops[0] = captures[0];
11434 : 0 : res_op->ops[1] = captures[1];
11435 : 0 : res_op->resimplify (lseq, valueize);
11436 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11437 : 0 : return true;
11438 : : }
11439 : 0 : next_after_fail1832:;
11440 : : }
11441 : : }
11442 : : }
11443 : : }
11444 : : break;
11445 : : }
11446 : 136 : case LE_EXPR:
11447 : 136 : {
11448 : 136 : tree _q50 = gimple_assign_rhs1 (_a2);
11449 : 136 : _q50 = do_valueize (valueize, _q50);
11450 : 136 : tree _q51 = gimple_assign_rhs2 (_a2);
11451 : 136 : _q51 = do_valueize (valueize, _q51);
11452 : 136 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
11453 : : {
11454 : 14 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11455 : : {
11456 : 0 : {
11457 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11458 : 0 : const enum tree_code cmp1 = LE_EXPR;
11459 : 0 : const enum tree_code cmp2 = EQ_EXPR;
11460 : 0 : const enum tree_code rcmp = LT_EXPR;
11461 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11462 : : )
11463 : : {
11464 : 0 : gimple_seq *lseq = seq;
11465 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1833;
11466 : 0 : {
11467 : 0 : res_op->set_op (rcmp, type, 2);
11468 : 0 : res_op->ops[0] = captures[0];
11469 : 0 : res_op->ops[1] = captures[1];
11470 : 0 : res_op->resimplify (lseq, valueize);
11471 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11472 : 0 : return true;
11473 : : }
11474 : 0 : next_after_fail1833:;
11475 : : }
11476 : : }
11477 : : }
11478 : : }
11479 : 136 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
11480 : : {
11481 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
11482 : : {
11483 : 0 : {
11484 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11485 : 0 : const enum tree_code cmp1 = LE_EXPR;
11486 : 0 : const enum tree_code cmp2 = EQ_EXPR;
11487 : 0 : const enum tree_code rcmp = LT_EXPR;
11488 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11489 : : )
11490 : : {
11491 : 0 : gimple_seq *lseq = seq;
11492 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1834;
11493 : 0 : {
11494 : 0 : res_op->set_op (rcmp, type, 2);
11495 : 0 : res_op->ops[0] = captures[0];
11496 : 0 : res_op->ops[1] = captures[1];
11497 : 0 : res_op->resimplify (lseq, valueize);
11498 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11499 : 0 : return true;
11500 : : }
11501 : 0 : next_after_fail1834:;
11502 : : }
11503 : : }
11504 : : }
11505 : : }
11506 : : break;
11507 : : }
11508 : 20 : case GT_EXPR:
11509 : 20 : {
11510 : 20 : tree _q50 = gimple_assign_rhs1 (_a2);
11511 : 20 : _q50 = do_valueize (valueize, _q50);
11512 : 20 : tree _q51 = gimple_assign_rhs2 (_a2);
11513 : 20 : _q51 = do_valueize (valueize, _q51);
11514 : 20 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
11515 : : {
11516 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
11517 : : {
11518 : 0 : {
11519 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11520 : 0 : const enum tree_code cmp1 = LT_EXPR;
11521 : 0 : const enum tree_code cmp2 = EQ_EXPR;
11522 : 0 : const enum tree_code rcmp = LE_EXPR;
11523 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11524 : : )
11525 : : {
11526 : 0 : gimple_seq *lseq = seq;
11527 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1835;
11528 : 0 : {
11529 : 0 : res_op->set_op (rcmp, type, 2);
11530 : 0 : res_op->ops[0] = captures[0];
11531 : 0 : res_op->ops[1] = captures[1];
11532 : 0 : res_op->resimplify (lseq, valueize);
11533 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11534 : 0 : return true;
11535 : : }
11536 : 0 : next_after_fail1835:;
11537 : : }
11538 : : }
11539 : : }
11540 : : }
11541 : 20 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
11542 : : {
11543 : 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11544 : : {
11545 : 0 : {
11546 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11547 : 0 : const enum tree_code cmp1 = LT_EXPR;
11548 : 0 : const enum tree_code cmp2 = EQ_EXPR;
11549 : 0 : const enum tree_code rcmp = LE_EXPR;
11550 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11551 : : )
11552 : : {
11553 : 0 : gimple_seq *lseq = seq;
11554 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1836;
11555 : 0 : {
11556 : 0 : res_op->set_op (rcmp, type, 2);
11557 : 0 : res_op->ops[0] = captures[0];
11558 : 0 : res_op->ops[1] = captures[1];
11559 : 0 : res_op->resimplify (lseq, valueize);
11560 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11561 : 0 : return true;
11562 : : }
11563 : 0 : next_after_fail1836:;
11564 : : }
11565 : : }
11566 : : }
11567 : : }
11568 : : break;
11569 : : }
11570 : 34 : case GE_EXPR:
11571 : 34 : {
11572 : 34 : tree _q50 = gimple_assign_rhs1 (_a2);
11573 : 34 : _q50 = do_valueize (valueize, _q50);
11574 : 34 : tree _q51 = gimple_assign_rhs2 (_a2);
11575 : 34 : _q51 = do_valueize (valueize, _q51);
11576 : 34 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
11577 : : {
11578 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
11579 : : {
11580 : 0 : {
11581 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11582 : 0 : const enum tree_code cmp1 = LE_EXPR;
11583 : 0 : const enum tree_code cmp2 = EQ_EXPR;
11584 : 0 : const enum tree_code rcmp = LT_EXPR;
11585 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11586 : : )
11587 : : {
11588 : 0 : gimple_seq *lseq = seq;
11589 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1837;
11590 : 0 : {
11591 : 0 : res_op->set_op (rcmp, type, 2);
11592 : 0 : res_op->ops[0] = captures[0];
11593 : 0 : res_op->ops[1] = captures[1];
11594 : 0 : res_op->resimplify (lseq, valueize);
11595 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11596 : 0 : return true;
11597 : : }
11598 : 0 : next_after_fail1837:;
11599 : : }
11600 : : }
11601 : : }
11602 : : }
11603 : 34 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
11604 : : {
11605 : 14 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11606 : : {
11607 : 0 : {
11608 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11609 : 0 : const enum tree_code cmp1 = LE_EXPR;
11610 : 0 : const enum tree_code cmp2 = EQ_EXPR;
11611 : 0 : const enum tree_code rcmp = LT_EXPR;
11612 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11613 : : )
11614 : : {
11615 : 0 : gimple_seq *lseq = seq;
11616 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1838;
11617 : 0 : {
11618 : 0 : res_op->set_op (rcmp, type, 2);
11619 : 0 : res_op->ops[0] = captures[0];
11620 : 0 : res_op->ops[1] = captures[1];
11621 : 0 : res_op->resimplify (lseq, valueize);
11622 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11623 : 0 : return true;
11624 : : }
11625 : 0 : next_after_fail1838:;
11626 : : }
11627 : : }
11628 : : }
11629 : : }
11630 : : break;
11631 : : }
11632 : : default:;
11633 : : }
11634 : : }
11635 : : break;
11636 : : default:;
11637 : : }
11638 : 115955457 : break;
11639 : : }
11640 : 402868 : case NE_EXPR:
11641 : 402868 : {
11642 : 402868 : tree _q20 = gimple_assign_rhs1 (_a1);
11643 : 402868 : _q20 = do_valueize (valueize, _q20);
11644 : 402868 : tree _q21 = gimple_assign_rhs2 (_a1);
11645 : 402868 : _q21 = do_valueize (valueize, _q21);
11646 : 402868 : if (tree_swap_operands_p (_q20, _q21))
11647 : 4493 : std::swap (_q20, _q21);
11648 : 402868 : switch (TREE_CODE (_p1))
11649 : : {
11650 : 11387 : case SSA_NAME:
11651 : 11387 : if (gimple *_d2 = get_def (valueize, _p1))
11652 : : {
11653 : 11156 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
11654 : 9658 : switch (gimple_assign_rhs_code (_a2))
11655 : : {
11656 : 14 : case LT_EXPR:
11657 : 14 : {
11658 : 14 : tree _q50 = gimple_assign_rhs1 (_a2);
11659 : 14 : _q50 = do_valueize (valueize, _q50);
11660 : 14 : tree _q51 = gimple_assign_rhs2 (_a2);
11661 : 14 : _q51 = do_valueize (valueize, _q51);
11662 : 14 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
11663 : : {
11664 : 14 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11665 : : {
11666 : 0 : {
11667 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11668 : 0 : const enum tree_code cmp1 = LT_EXPR;
11669 : 0 : const enum tree_code cmp2 = NE_EXPR;
11670 : 0 : const enum tree_code rcmp = GT_EXPR;
11671 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11672 : : )
11673 : : {
11674 : 0 : gimple_seq *lseq = seq;
11675 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1839;
11676 : 0 : {
11677 : 0 : res_op->set_op (rcmp, type, 2);
11678 : 0 : res_op->ops[0] = captures[0];
11679 : 0 : res_op->ops[1] = captures[1];
11680 : 0 : res_op->resimplify (lseq, valueize);
11681 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11682 : 0 : return true;
11683 : : }
11684 : 0 : next_after_fail1839:;
11685 : : }
11686 : : }
11687 : : }
11688 : : }
11689 : 14 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
11690 : : {
11691 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
11692 : : {
11693 : 0 : {
11694 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11695 : 0 : const enum tree_code cmp1 = LT_EXPR;
11696 : 0 : const enum tree_code cmp2 = NE_EXPR;
11697 : 0 : const enum tree_code rcmp = GT_EXPR;
11698 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11699 : : )
11700 : : {
11701 : 0 : gimple_seq *lseq = seq;
11702 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1840;
11703 : 0 : {
11704 : 0 : res_op->set_op (rcmp, type, 2);
11705 : 0 : res_op->ops[0] = captures[0];
11706 : 0 : res_op->ops[1] = captures[1];
11707 : 0 : res_op->resimplify (lseq, valueize);
11708 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11709 : 0 : return true;
11710 : : }
11711 : 0 : next_after_fail1840:;
11712 : : }
11713 : : }
11714 : : }
11715 : : }
11716 : : break;
11717 : : }
11718 : 1134 : case LE_EXPR:
11719 : 1134 : {
11720 : 1134 : tree _q50 = gimple_assign_rhs1 (_a2);
11721 : 1134 : _q50 = do_valueize (valueize, _q50);
11722 : 1134 : tree _q51 = gimple_assign_rhs2 (_a2);
11723 : 1134 : _q51 = do_valueize (valueize, _q51);
11724 : 1134 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
11725 : : {
11726 : 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11727 : : {
11728 : 0 : {
11729 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11730 : 0 : const enum tree_code cmp1 = LE_EXPR;
11731 : 0 : const enum tree_code cmp2 = NE_EXPR;
11732 : 0 : const enum tree_code rcmp = GE_EXPR;
11733 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11734 : : )
11735 : : {
11736 : 0 : gimple_seq *lseq = seq;
11737 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1841;
11738 : 0 : {
11739 : 0 : res_op->set_op (rcmp, type, 2);
11740 : 0 : res_op->ops[0] = captures[0];
11741 : 0 : res_op->ops[1] = captures[1];
11742 : 0 : res_op->resimplify (lseq, valueize);
11743 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11744 : 0 : return true;
11745 : : }
11746 : 0 : next_after_fail1841:;
11747 : : }
11748 : : }
11749 : : }
11750 : : }
11751 : 1134 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
11752 : : {
11753 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
11754 : : {
11755 : 0 : {
11756 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11757 : 0 : const enum tree_code cmp1 = LE_EXPR;
11758 : 0 : const enum tree_code cmp2 = NE_EXPR;
11759 : 0 : const enum tree_code rcmp = GE_EXPR;
11760 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11761 : : )
11762 : : {
11763 : 0 : gimple_seq *lseq = seq;
11764 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1842;
11765 : 0 : {
11766 : 0 : res_op->set_op (rcmp, type, 2);
11767 : 0 : res_op->ops[0] = captures[0];
11768 : 0 : res_op->ops[1] = captures[1];
11769 : 0 : res_op->resimplify (lseq, valueize);
11770 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11771 : 0 : return true;
11772 : : }
11773 : 0 : next_after_fail1842:;
11774 : : }
11775 : : }
11776 : : }
11777 : : }
11778 : : break;
11779 : : }
11780 : 1154 : case GT_EXPR:
11781 : 1154 : {
11782 : 1154 : tree _q50 = gimple_assign_rhs1 (_a2);
11783 : 1154 : _q50 = do_valueize (valueize, _q50);
11784 : 1154 : tree _q51 = gimple_assign_rhs2 (_a2);
11785 : 1154 : _q51 = do_valueize (valueize, _q51);
11786 : 1154 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
11787 : : {
11788 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
11789 : : {
11790 : 0 : {
11791 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11792 : 0 : const enum tree_code cmp1 = LT_EXPR;
11793 : 0 : const enum tree_code cmp2 = NE_EXPR;
11794 : 0 : const enum tree_code rcmp = GT_EXPR;
11795 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11796 : : )
11797 : : {
11798 : 0 : gimple_seq *lseq = seq;
11799 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1843;
11800 : 0 : {
11801 : 0 : res_op->set_op (rcmp, type, 2);
11802 : 0 : res_op->ops[0] = captures[0];
11803 : 0 : res_op->ops[1] = captures[1];
11804 : 0 : res_op->resimplify (lseq, valueize);
11805 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11806 : 0 : return true;
11807 : : }
11808 : 0 : next_after_fail1843:;
11809 : : }
11810 : : }
11811 : : }
11812 : : }
11813 : 1154 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
11814 : : {
11815 : 14 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11816 : : {
11817 : 0 : {
11818 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11819 : 0 : const enum tree_code cmp1 = LT_EXPR;
11820 : 0 : const enum tree_code cmp2 = NE_EXPR;
11821 : 0 : const enum tree_code rcmp = GT_EXPR;
11822 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11823 : : )
11824 : : {
11825 : 0 : gimple_seq *lseq = seq;
11826 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1844;
11827 : 0 : {
11828 : 0 : res_op->set_op (rcmp, type, 2);
11829 : 0 : res_op->ops[0] = captures[0];
11830 : 0 : res_op->ops[1] = captures[1];
11831 : 0 : res_op->resimplify (lseq, valueize);
11832 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11833 : 0 : return true;
11834 : : }
11835 : 0 : next_after_fail1844:;
11836 : : }
11837 : : }
11838 : : }
11839 : : }
11840 : : break;
11841 : : }
11842 : 0 : case GE_EXPR:
11843 : 0 : {
11844 : 0 : tree _q50 = gimple_assign_rhs1 (_a2);
11845 : 0 : _q50 = do_valueize (valueize, _q50);
11846 : 0 : tree _q51 = gimple_assign_rhs2 (_a2);
11847 : 0 : _q51 = do_valueize (valueize, _q51);
11848 : 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
11849 : : {
11850 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
11851 : : {
11852 : 0 : {
11853 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11854 : 0 : const enum tree_code cmp1 = LE_EXPR;
11855 : 0 : const enum tree_code cmp2 = NE_EXPR;
11856 : 0 : const enum tree_code rcmp = GE_EXPR;
11857 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11858 : : )
11859 : : {
11860 : 0 : gimple_seq *lseq = seq;
11861 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1845;
11862 : 0 : {
11863 : 0 : res_op->set_op (rcmp, type, 2);
11864 : 0 : res_op->ops[0] = captures[0];
11865 : 0 : res_op->ops[1] = captures[1];
11866 : 0 : res_op->resimplify (lseq, valueize);
11867 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11868 : 0 : return true;
11869 : : }
11870 : 0 : next_after_fail1845:;
11871 : : }
11872 : : }
11873 : : }
11874 : : }
11875 : 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
11876 : : {
11877 : 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11878 : : {
11879 : 0 : {
11880 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11881 : 0 : const enum tree_code cmp1 = LE_EXPR;
11882 : 0 : const enum tree_code cmp2 = NE_EXPR;
11883 : 0 : const enum tree_code rcmp = GE_EXPR;
11884 : 0 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0]))
11885 : : )
11886 : : {
11887 : 0 : gimple_seq *lseq = seq;
11888 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1846;
11889 : 0 : {
11890 : 0 : res_op->set_op (rcmp, type, 2);
11891 : 0 : res_op->ops[0] = captures[0];
11892 : 0 : res_op->ops[1] = captures[1];
11893 : 0 : res_op->resimplify (lseq, valueize);
11894 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 924, __FILE__, __LINE__, true);
11895 : 0 : return true;
11896 : : }
11897 : 0 : next_after_fail1846:;
11898 : : }
11899 : : }
11900 : : }
11901 : : }
11902 : : break;
11903 : : }
11904 : : default:;
11905 : : }
11906 : : }
11907 : : break;
11908 : : default:;
11909 : : }
11910 : 115955457 : break;
11911 : : }
11912 : 25794 : case MIN_EXPR:
11913 : 25794 : {
11914 : 25794 : tree _q20 = gimple_assign_rhs1 (_a1);
11915 : 25794 : _q20 = do_valueize (valueize, _q20);
11916 : 25794 : tree _q21 = gimple_assign_rhs2 (_a1);
11917 : 25794 : _q21 = do_valueize (valueize, _q21);
11918 : 25794 : if (tree_swap_operands_p (_q20, _q21))
11919 : 3404 : std::swap (_q20, _q21);
11920 : 25794 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
11921 : : {
11922 : 16 : {
11923 : 16 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11924 : 16 : if (gimple_simplify_225 (res_op, seq, valueize, type, captures, MIN_EXPR, NE_EXPR, GT_EXPR))
11925 : 16 : return true;
11926 : : }
11927 : : }
11928 : 25778 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
11929 : : {
11930 : 3378 : {
11931 : 3378 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11932 : 3378 : if (gimple_simplify_225 (res_op, seq, valueize, type, captures, MIN_EXPR, NE_EXPR, GT_EXPR))
11933 : 2818 : return true;
11934 : : }
11935 : : }
11936 : 22960 : switch (TREE_CODE (_q21))
11937 : : {
11938 : 1347 : case INTEGER_CST:
11939 : 1347 : {
11940 : 1347 : switch (TREE_CODE (_p1))
11941 : : {
11942 : 623 : case INTEGER_CST:
11943 : 623 : {
11944 : 623 : {
11945 : 623 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
11946 : 623 : if (gimple_simplify_226 (res_op, seq, valueize, type, captures, NE_EXPR))
11947 : 623 : return true;
11948 : : }
11949 : 0 : break;
11950 : : }
11951 : : default:;
11952 : : }
11953 : : break;
11954 : : }
11955 : : default:;
11956 : : }
11957 : 115955457 : break;
11958 : : }
11959 : 11249 : case MAX_EXPR:
11960 : 11249 : {
11961 : 11249 : tree _q20 = gimple_assign_rhs1 (_a1);
11962 : 11249 : _q20 = do_valueize (valueize, _q20);
11963 : 11249 : tree _q21 = gimple_assign_rhs2 (_a1);
11964 : 11249 : _q21 = do_valueize (valueize, _q21);
11965 : 11249 : if (tree_swap_operands_p (_q20, _q21))
11966 : 81 : std::swap (_q20, _q21);
11967 : 11249 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
11968 : : {
11969 : 29 : {
11970 : 29 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11971 : 29 : if (gimple_simplify_225 (res_op, seq, valueize, type, captures, MAX_EXPR, NE_EXPR, LT_EXPR))
11972 : 29 : return true;
11973 : : }
11974 : : }
11975 : 11220 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
11976 : : {
11977 : 3164 : {
11978 : 3164 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11979 : 3164 : if (gimple_simplify_225 (res_op, seq, valueize, type, captures, MAX_EXPR, NE_EXPR, LT_EXPR))
11980 : 2796 : return true;
11981 : : }
11982 : : }
11983 : 8424 : switch (TREE_CODE (_q21))
11984 : : {
11985 : 6397 : case INTEGER_CST:
11986 : 6397 : {
11987 : 6397 : switch (TREE_CODE (_p1))
11988 : : {
11989 : 1010 : case INTEGER_CST:
11990 : 1010 : {
11991 : 1010 : {
11992 : 1010 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
11993 : 1010 : if (gimple_simplify_227 (res_op, seq, valueize, type, captures, NE_EXPR))
11994 : 1010 : return true;
11995 : : }
11996 : 0 : break;
11997 : : }
11998 : : default:;
11999 : : }
12000 : : break;
12001 : : }
12002 : : default:;
12003 : : }
12004 : 115955457 : break;
12005 : : }
12006 : : default:;
12007 : : }
12008 : : }
12009 : : break;
12010 : 115955457 : default:;
12011 : : }
12012 : 115955457 : {
12013 : 115955457 : tree _p0_pops[1];
12014 : 115955457 : if (gimple_with_possible_nonzero_bits2 (_p0, _p0_pops, valueize))
12015 : : {
12016 : 106940246 : tree _q20 = _p0_pops[0];
12017 : 106940246 : {
12018 : 106940246 : tree _p1_pops[1];
12019 : 106940246 : if (gimple_with_certain_nonzero_bits2 (_p1, _p1_pops, valueize))
12020 : : {
12021 : 87066949 : tree _q40 = _p1_pops[0];
12022 : 87066949 : {
12023 : 87066949 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
12024 : 87066949 : if (gimple_simplify_223 (res_op, seq, valueize, type, captures, NE_EXPR))
12025 : 3051 : return true;
12026 : : }
12027 : : }
12028 : : }
12029 : : }
12030 : : }
12031 : 115952406 : {
12032 : 115952406 : tree _p0_pops[1];
12033 : 115952406 : if (gimple_with_certain_nonzero_bits2 (_p0, _p0_pops, valueize))
12034 : : {
12035 : 2135 : tree _q20 = _p0_pops[0];
12036 : 2135 : {
12037 : 2135 : tree _p1_pops[1];
12038 : 2135 : if (gimple_with_possible_nonzero_bits2 (_p1, _p1_pops, valueize))
12039 : : {
12040 : 2135 : tree _q40 = _p1_pops[0];
12041 : 2135 : {
12042 : 2135 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
12043 : 2135 : if (gimple_simplify_223 (res_op, seq, valueize, type, captures, NE_EXPR))
12044 : 169 : return true;
12045 : : }
12046 : : }
12047 : : }
12048 : : }
12049 : : }
12050 : 115952237 : switch (TREE_CODE (_p1))
12051 : : {
12052 : 20544644 : case SSA_NAME:
12053 : 20544644 : if (gimple *_d1 = get_def (valueize, _p1))
12054 : : {
12055 : 6240155 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
12056 : 8920951 : switch (gimple_assign_rhs_code (_a1))
12057 : : {
12058 : 4525 : case MIN_EXPR:
12059 : 4525 : {
12060 : 4525 : tree _q30 = gimple_assign_rhs1 (_a1);
12061 : 4525 : _q30 = do_valueize (valueize, _q30);
12062 : 4525 : tree _q31 = gimple_assign_rhs2 (_a1);
12063 : 4525 : _q31 = do_valueize (valueize, _q31);
12064 : 4525 : if (tree_swap_operands_p (_q30, _q31))
12065 : 842 : std::swap (_q30, _q31);
12066 : 4525 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
12067 : : {
12068 : 86 : {
12069 : 86 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
12070 : 86 : if (gimple_simplify_225 (res_op, seq, valueize, type, captures, MIN_EXPR, NE_EXPR, GT_EXPR))
12071 : 86 : return true;
12072 : : }
12073 : : }
12074 : 4439 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
12075 : : {
12076 : 54 : {
12077 : 54 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
12078 : 54 : if (gimple_simplify_225 (res_op, seq, valueize, type, captures, MIN_EXPR, NE_EXPR, GT_EXPR))
12079 : 54 : return true;
12080 : : }
12081 : : }
12082 : 115952000 : break;
12083 : : }
12084 : 4768 : case MAX_EXPR:
12085 : 4768 : {
12086 : 4768 : tree _q30 = gimple_assign_rhs1 (_a1);
12087 : 4768 : _q30 = do_valueize (valueize, _q30);
12088 : 4768 : tree _q31 = gimple_assign_rhs2 (_a1);
12089 : 4768 : _q31 = do_valueize (valueize, _q31);
12090 : 4768 : if (tree_swap_operands_p (_q30, _q31))
12091 : 22 : std::swap (_q30, _q31);
12092 : 4768 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
12093 : : {
12094 : 83 : {
12095 : 83 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
12096 : 83 : if (gimple_simplify_225 (res_op, seq, valueize, type, captures, MAX_EXPR, NE_EXPR, LT_EXPR))
12097 : 83 : return true;
12098 : : }
12099 : : }
12100 : 4685 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
12101 : : {
12102 : 14 : {
12103 : 14 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
12104 : 14 : if (gimple_simplify_225 (res_op, seq, valueize, type, captures, MAX_EXPR, NE_EXPR, LT_EXPR))
12105 : 14 : return true;
12106 : : }
12107 : : }
12108 : 115952000 : break;
12109 : : }
12110 : : default:;
12111 : : }
12112 : : }
12113 : : break;
12114 : 115952000 : default:;
12115 : : }
12116 : 115952000 : switch (TREE_CODE (_p0))
12117 : : {
12118 : 112959025 : case SSA_NAME:
12119 : 112959025 : if (gimple *_d1 = get_def (valueize, _p0))
12120 : : {
12121 : 37450113 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
12122 : 41028419 : switch (gimple_assign_rhs_code (_a1))
12123 : : {
12124 : 2456276 : case BIT_AND_EXPR:
12125 : 2456276 : {
12126 : 2456276 : tree _q20 = gimple_assign_rhs1 (_a1);
12127 : 2456276 : _q20 = do_valueize (valueize, _q20);
12128 : 2456276 : tree _q21 = gimple_assign_rhs2 (_a1);
12129 : 2456276 : _q21 = do_valueize (valueize, _q21);
12130 : 2456276 : if (tree_swap_operands_p (_q20, _q21))
12131 : 55181 : std::swap (_q20, _q21);
12132 : 2456276 : switch (TREE_CODE (_q20))
12133 : : {
12134 : 2456276 : case SSA_NAME:
12135 : 2456276 : if (gimple *_d2 = get_def (valueize, _q20))
12136 : : {
12137 : 2385836 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12138 : 2756206 : switch (gimple_assign_rhs_code (_a2))
12139 : : {
12140 : 34584 : case LSHIFT_EXPR:
12141 : 34584 : {
12142 : 34584 : tree _q30 = gimple_assign_rhs1 (_a2);
12143 : 34584 : _q30 = do_valueize (valueize, _q30);
12144 : 34584 : tree _q31 = gimple_assign_rhs2 (_a2);
12145 : 34584 : _q31 = do_valueize (valueize, _q31);
12146 : 34584 : if (integer_pow2p (_q30))
12147 : : {
12148 : 33948 : if (integer_pow2p (_q21))
12149 : : {
12150 : 2151 : if (integer_zerop (_p1))
12151 : : {
12152 : 2151 : {
12153 : 2151 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q21 };
12154 : 2151 : if (gimple_simplify_228 (res_op, seq, valueize, type, captures, NE_EXPR, EQ_EXPR))
12155 : 2151 : return true;
12156 : : }
12157 : : }
12158 : : }
12159 : : }
12160 : 32433 : switch (TREE_CODE (_q31))
12161 : : {
12162 : 462 : case INTEGER_CST:
12163 : 462 : {
12164 : 462 : switch (TREE_CODE (_q21))
12165 : : {
12166 : 429 : case INTEGER_CST:
12167 : 429 : {
12168 : 429 : switch (TREE_CODE (_p1))
12169 : : {
12170 : 429 : case INTEGER_CST:
12171 : 429 : {
12172 : 429 : {
12173 : 429 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1 };
12174 : 429 : if (gimple_simplify_229 (res_op, seq, valueize, type, captures, NE_EXPR))
12175 : 18 : return true;
12176 : : }
12177 : 411 : break;
12178 : : }
12179 : : default:;
12180 : : }
12181 : : break;
12182 : : }
12183 : : default:;
12184 : : }
12185 : : break;
12186 : : }
12187 : 32415 : default:;
12188 : : }
12189 : 32415 : if (integer_onep (_q30))
12190 : : {
12191 : 31854 : if (integer_pow2p (_q21))
12192 : : {
12193 : 0 : if (integer_zerop (_p1))
12194 : : {
12195 : 0 : {
12196 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q21 };
12197 : 0 : if (gimple_simplify_230 (res_op, seq, valueize, type, captures, NE_EXPR, EQ_EXPR))
12198 : 0 : return true;
12199 : : }
12200 : : }
12201 : : }
12202 : : }
12203 : : break;
12204 : : }
12205 : 43828 : case RSHIFT_EXPR:
12206 : 43828 : {
12207 : 43828 : tree _q30 = gimple_assign_rhs1 (_a2);
12208 : 43828 : _q30 = do_valueize (valueize, _q30);
12209 : 43828 : tree _q31 = gimple_assign_rhs2 (_a2);
12210 : 43828 : _q31 = do_valueize (valueize, _q31);
12211 : 43828 : if (integer_pow2p (_q30))
12212 : : {
12213 : 1497 : if (integer_pow2p (_q21))
12214 : : {
12215 : 517 : if (integer_zerop (_p1))
12216 : : {
12217 : 517 : {
12218 : 517 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q21 };
12219 : 517 : if (gimple_simplify_231 (res_op, seq, valueize, type, captures, NE_EXPR, EQ_EXPR))
12220 : 517 : return true;
12221 : : }
12222 : : }
12223 : : }
12224 : : }
12225 : 43311 : switch (TREE_CODE (_q31))
12226 : : {
12227 : 9104 : case INTEGER_CST:
12228 : 9104 : {
12229 : 9104 : switch (TREE_CODE (_q21))
12230 : : {
12231 : 8628 : case INTEGER_CST:
12232 : 8628 : {
12233 : 8628 : switch (TREE_CODE (_p1))
12234 : : {
12235 : 6888 : case INTEGER_CST:
12236 : 6888 : {
12237 : 6888 : {
12238 : 6888 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1 };
12239 : 6888 : if (gimple_simplify_232 (res_op, seq, valueize, type, captures, NE_EXPR))
12240 : 143 : return true;
12241 : : }
12242 : 6745 : break;
12243 : : }
12244 : : default:;
12245 : : }
12246 : : break;
12247 : : }
12248 : : default:;
12249 : : }
12250 : : break;
12251 : : }
12252 : : default:;
12253 : : }
12254 : : break;
12255 : : }
12256 : : default:;
12257 : : }
12258 : : }
12259 : : break;
12260 : 2453447 : default:;
12261 : : }
12262 : 2453447 : {
12263 : 2453447 : tree _q20_pops[1];
12264 : 2453447 : if (gimple_nop_convert (_q20, _q20_pops, valueize))
12265 : : {
12266 : 52561 : tree _q30 = _q20_pops[0];
12267 : 52561 : switch (TREE_CODE (_q30))
12268 : : {
12269 : 52506 : case SSA_NAME:
12270 : 52506 : if (gimple *_d2 = get_def (valueize, _q30))
12271 : : {
12272 : 50919 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12273 : 64792 : switch (gimple_assign_rhs_code (_a2))
12274 : : {
12275 : 11565 : case LSHIFT_EXPR:
12276 : 11565 : {
12277 : 11565 : tree _q40 = gimple_assign_rhs1 (_a2);
12278 : 11565 : _q40 = do_valueize (valueize, _q40);
12279 : 11565 : tree _q41 = gimple_assign_rhs2 (_a2);
12280 : 11565 : _q41 = do_valueize (valueize, _q41);
12281 : 11565 : if (integer_onep (_q40))
12282 : : {
12283 : 11565 : if (integer_pow2p (_q21))
12284 : : {
12285 : 8 : if (integer_zerop (_p1))
12286 : : {
12287 : 6 : {
12288 : 6 : tree captures[2] ATTRIBUTE_UNUSED = { _q41, _q21 };
12289 : 6 : if (gimple_simplify_230 (res_op, seq, valueize, type, captures, NE_EXPR, EQ_EXPR))
12290 : 6 : return true;
12291 : : }
12292 : : }
12293 : : }
12294 : : }
12295 : : break;
12296 : : }
12297 : : default:;
12298 : : }
12299 : : }
12300 : : break;
12301 : : default:;
12302 : : }
12303 : : }
12304 : : }
12305 : 2453441 : break;
12306 : : }
12307 : 42037 : case RSHIFT_EXPR:
12308 : 42037 : {
12309 : 42037 : tree _q20 = gimple_assign_rhs1 (_a1);
12310 : 42037 : _q20 = do_valueize (valueize, _q20);
12311 : 42037 : tree _q21 = gimple_assign_rhs2 (_a1);
12312 : 42037 : _q21 = do_valueize (valueize, _q21);
12313 : 42037 : if (integer_onep (_q20))
12314 : : {
12315 : 45 : if (integer_zerop (_p1))
12316 : : {
12317 : 30 : {
12318 : 30 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
12319 : 30 : if (gimple_simplify_233 (res_op, seq, valueize, type, captures, NE_EXPR, EQ_EXPR))
12320 : 30 : return true;
12321 : : }
12322 : : }
12323 : : }
12324 : : break;
12325 : : }
12326 : 11125 : case LSHIFT_EXPR:
12327 : 11125 : {
12328 : 11125 : tree _q20 = gimple_assign_rhs1 (_a1);
12329 : 11125 : _q20 = do_valueize (valueize, _q20);
12330 : 11125 : tree _q21 = gimple_assign_rhs2 (_a1);
12331 : 11125 : _q21 = do_valueize (valueize, _q21);
12332 : 11125 : switch (TREE_CODE (_q20))
12333 : : {
12334 : 849 : case INTEGER_CST:
12335 : 849 : {
12336 : 849 : switch (TREE_CODE (_p1))
12337 : : {
12338 : 496 : case INTEGER_CST:
12339 : 496 : {
12340 : 496 : {
12341 : 496 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
12342 : 496 : if (gimple_simplify_234 (res_op, seq, valueize, type, captures, NE_EXPR))
12343 : 29 : return true;
12344 : : }
12345 : 467 : break;
12346 : : }
12347 : : default:;
12348 : : }
12349 : : break;
12350 : : }
12351 : : default:;
12352 : : }
12353 : : break;
12354 : : }
12355 : 596 : case LROTATE_EXPR:
12356 : 596 : {
12357 : 596 : tree _q20 = gimple_assign_rhs1 (_a1);
12358 : 596 : _q20 = do_valueize (valueize, _q20);
12359 : 596 : tree _q21 = gimple_assign_rhs2 (_a1);
12360 : 596 : _q21 = do_valueize (valueize, _q21);
12361 : 596 : switch (TREE_CODE (_p1))
12362 : : {
12363 : 0 : case SSA_NAME:
12364 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
12365 : : {
12366 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12367 : 0 : switch (gimple_assign_rhs_code (_a2))
12368 : : {
12369 : 0 : case LROTATE_EXPR:
12370 : 0 : {
12371 : 0 : tree _q50 = gimple_assign_rhs1 (_a2);
12372 : 0 : _q50 = do_valueize (valueize, _q50);
12373 : 0 : tree _q51 = gimple_assign_rhs2 (_a2);
12374 : 0 : _q51 = do_valueize (valueize, _q51);
12375 : 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
12376 : : {
12377 : 0 : {
12378 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
12379 : 0 : if (gimple_simplify_235 (res_op, seq, valueize, type, captures, LROTATE_EXPR, RROTATE_EXPR, NE_EXPR))
12380 : 0 : return true;
12381 : : }
12382 : : }
12383 : : break;
12384 : : }
12385 : : default:;
12386 : : }
12387 : : }
12388 : : break;
12389 : 596 : default:;
12390 : : }
12391 : 596 : switch (TREE_CODE (_q21))
12392 : : {
12393 : 0 : case INTEGER_CST:
12394 : 0 : {
12395 : 0 : switch (TREE_CODE (_p1))
12396 : : {
12397 : 0 : case INTEGER_CST:
12398 : 0 : {
12399 : 0 : {
12400 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
12401 : 0 : if (gimple_simplify_236 (res_op, seq, valueize, type, captures, LROTATE_EXPR, RROTATE_EXPR, NE_EXPR))
12402 : 0 : return true;
12403 : : }
12404 : 0 : break;
12405 : : }
12406 : : default:;
12407 : : }
12408 : : break;
12409 : : }
12410 : 596 : default:;
12411 : : }
12412 : 596 : switch (TREE_CODE (_p1))
12413 : : {
12414 : 596 : case INTEGER_CST:
12415 : 596 : {
12416 : 596 : {
12417 : 596 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
12418 : 596 : if (gimple_simplify_237 (res_op, seq, valueize, type, captures, LROTATE_EXPR, RROTATE_EXPR, NE_EXPR))
12419 : 0 : return true;
12420 : : }
12421 : 596 : break;
12422 : : }
12423 : : default:;
12424 : : }
12425 : : break;
12426 : : }
12427 : 722 : case RROTATE_EXPR:
12428 : 722 : {
12429 : 722 : tree _q20 = gimple_assign_rhs1 (_a1);
12430 : 722 : _q20 = do_valueize (valueize, _q20);
12431 : 722 : tree _q21 = gimple_assign_rhs2 (_a1);
12432 : 722 : _q21 = do_valueize (valueize, _q21);
12433 : 722 : switch (TREE_CODE (_p1))
12434 : : {
12435 : 124 : case SSA_NAME:
12436 : 124 : if (gimple *_d2 = get_def (valueize, _p1))
12437 : : {
12438 : 118 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12439 : 200 : switch (gimple_assign_rhs_code (_a2))
12440 : : {
12441 : 0 : case RROTATE_EXPR:
12442 : 0 : {
12443 : 0 : tree _q50 = gimple_assign_rhs1 (_a2);
12444 : 0 : _q50 = do_valueize (valueize, _q50);
12445 : 0 : tree _q51 = gimple_assign_rhs2 (_a2);
12446 : 0 : _q51 = do_valueize (valueize, _q51);
12447 : 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
12448 : : {
12449 : 0 : {
12450 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
12451 : 0 : if (gimple_simplify_235 (res_op, seq, valueize, type, captures, RROTATE_EXPR, LROTATE_EXPR, NE_EXPR))
12452 : 0 : return true;
12453 : : }
12454 : : }
12455 : : break;
12456 : : }
12457 : : default:;
12458 : : }
12459 : : }
12460 : : break;
12461 : 722 : default:;
12462 : : }
12463 : 722 : switch (TREE_CODE (_q21))
12464 : : {
12465 : 134 : case INTEGER_CST:
12466 : 134 : {
12467 : 134 : switch (TREE_CODE (_p1))
12468 : : {
12469 : 10 : case INTEGER_CST:
12470 : 10 : {
12471 : 10 : {
12472 : 10 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
12473 : 10 : if (gimple_simplify_236 (res_op, seq, valueize, type, captures, RROTATE_EXPR, LROTATE_EXPR, NE_EXPR))
12474 : 10 : return true;
12475 : : }
12476 : 0 : break;
12477 : : }
12478 : : default:;
12479 : : }
12480 : : break;
12481 : : }
12482 : 712 : default:;
12483 : : }
12484 : 712 : switch (TREE_CODE (_p1))
12485 : : {
12486 : 588 : case INTEGER_CST:
12487 : 588 : {
12488 : 588 : {
12489 : 588 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
12490 : 588 : if (gimple_simplify_237 (res_op, seq, valueize, type, captures, RROTATE_EXPR, LROTATE_EXPR, NE_EXPR))
12491 : 0 : return true;
12492 : : }
12493 : 588 : break;
12494 : : }
12495 : : default:;
12496 : : }
12497 : : break;
12498 : : }
12499 : 358 : case VEC_COND_EXPR:
12500 : 358 : {
12501 : 358 : tree _q20 = gimple_assign_rhs1 (_a1);
12502 : 358 : _q20 = do_valueize (valueize, _q20);
12503 : 358 : tree _q21 = gimple_assign_rhs2 (_a1);
12504 : 358 : _q21 = do_valueize (valueize, _q21);
12505 : 358 : tree _q22 = gimple_assign_rhs3 (_a1);
12506 : 358 : _q22 = do_valueize (valueize, _q22);
12507 : 358 : switch (TREE_CODE (_p1))
12508 : : {
12509 : 348 : case SSA_NAME:
12510 : 348 : if (gimple *_d2 = get_def (valueize, _p1))
12511 : : {
12512 : 348 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12513 : 696 : switch (gimple_assign_rhs_code (_a2))
12514 : : {
12515 : 0 : case VEC_COND_EXPR:
12516 : 0 : {
12517 : 0 : tree _q60 = gimple_assign_rhs1 (_a2);
12518 : 0 : _q60 = do_valueize (valueize, _q60);
12519 : 0 : tree _q61 = gimple_assign_rhs2 (_a2);
12520 : 0 : _q61 = do_valueize (valueize, _q61);
12521 : 0 : tree _q62 = gimple_assign_rhs3 (_a2);
12522 : 0 : _q62 = do_valueize (valueize, _q62);
12523 : 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
12524 : : {
12525 : 0 : {
12526 : 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
12527 : 0 : if (TREE_CODE_CLASS (NE_EXPR) != tcc_comparison
12528 : 0 : || types_match (type, TREE_TYPE (captures[2]))
12529 : 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]), ERROR_MARK)
12530 : : || (optimize_vectors_before_lowering_p ()
12531 : 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]),
12532 : 0 : TREE_TYPE (captures[1]), ERROR_MARK))
12533 : : )
12534 : : {
12535 : 0 : gimple_seq *lseq = seq;
12536 : 0 : if (lseq
12537 : 0 : && (!single_use (captures[0])
12538 : 0 : || !single_use (captures[4])))
12539 : 0 : lseq = NULL;
12540 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1847;
12541 : 0 : {
12542 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
12543 : 0 : res_op->ops[0] = captures[1];
12544 : 0 : {
12545 : 0 : tree _o1[2], _r1;
12546 : 0 : _o1[0] = captures[2];
12547 : 0 : _o1[1] = captures[5];
12548 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NE_EXPR, type, _o1[0], _o1[1]);
12549 : 0 : tem_op.resimplify (NULL, valueize);
12550 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
12551 : 0 : if (!_r1) goto next_after_fail1847;
12552 : 0 : res_op->ops[1] = _r1;
12553 : : }
12554 : 0 : {
12555 : 0 : tree _o1[2], _r1;
12556 : 0 : _o1[0] = captures[3];
12557 : 0 : _o1[1] = captures[6];
12558 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NE_EXPR, type, _o1[0], _o1[1]);
12559 : 0 : tem_op.resimplify (NULL, valueize);
12560 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
12561 : 0 : if (!_r1) goto next_after_fail1847;
12562 : 0 : res_op->ops[2] = _r1;
12563 : : }
12564 : 0 : res_op->resimplify (lseq, valueize);
12565 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 925, __FILE__, __LINE__, true);
12566 : 0 : return true;
12567 : : }
12568 : 0 : next_after_fail1847:;
12569 : : }
12570 : : }
12571 : : }
12572 : : break;
12573 : : }
12574 : : default:;
12575 : : }
12576 : : }
12577 : : break;
12578 : 358 : default:;
12579 : : }
12580 : 358 : {
12581 : 358 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
12582 : 358 : if (TREE_CODE_CLASS (NE_EXPR) != tcc_comparison
12583 : 358 : || types_match (type, TREE_TYPE (captures[2]))
12584 : 358 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]), ERROR_MARK)
12585 : : || (optimize_vectors_before_lowering_p ()
12586 : 10 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]),
12587 : 10 : TREE_TYPE (captures[1]), ERROR_MARK))
12588 : : )
12589 : : {
12590 : 150 : gimple_seq *lseq = seq;
12591 : 150 : if (lseq
12592 : 96 : && (!single_use (captures[0])))
12593 : 54 : lseq = NULL;
12594 : 150 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1848;
12595 : 150 : {
12596 : 150 : res_op->set_op (VEC_COND_EXPR, type, 3);
12597 : 150 : res_op->ops[0] = captures[1];
12598 : 150 : {
12599 : 150 : tree _o1[2], _r1;
12600 : 150 : _o1[0] = captures[2];
12601 : 150 : _o1[1] = captures[4];
12602 : 150 : gimple_match_op tem_op (res_op->cond.any_else (), NE_EXPR, type, _o1[0], _o1[1]);
12603 : 150 : tem_op.resimplify (NULL, valueize);
12604 : 150 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
12605 : 150 : if (!_r1) goto next_after_fail1848;
12606 : 6 : res_op->ops[1] = _r1;
12607 : : }
12608 : 6 : {
12609 : 6 : tree _o1[2], _r1;
12610 : 6 : _o1[0] = captures[3];
12611 : 6 : _o1[1] = captures[4];
12612 : 6 : gimple_match_op tem_op (res_op->cond.any_else (), NE_EXPR, type, _o1[0], _o1[1]);
12613 : 6 : tem_op.resimplify (NULL, valueize);
12614 : 6 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
12615 : 6 : if (!_r1) goto next_after_fail1848;
12616 : 6 : res_op->ops[2] = _r1;
12617 : : }
12618 : 6 : res_op->resimplify (lseq, valueize);
12619 : 6 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 926, __FILE__, __LINE__, true);
12620 : 6 : return true;
12621 : : }
12622 : 352 : next_after_fail1848:;
12623 : : }
12624 : : }
12625 : 352 : break;
12626 : : }
12627 : : default:;
12628 : : }
12629 : 12209622 : else if (gcall *_c1 = dyn_cast <gcall *> (_d1))
12630 : 7049873 : switch (gimple_call_combined_fn (_c1))
12631 : : {
12632 : 1 : case CFN_BUILT_IN_BSWAP128:
12633 : 1 : if (gimple_call_num_args (_c1) == 1)
12634 : : {
12635 : 1 : tree _q20 = gimple_call_arg (_c1, 0);
12636 : 1 : _q20 = do_valueize (valueize, _q20);
12637 : 1 : switch (TREE_CODE (_p1))
12638 : : {
12639 : 1 : case SSA_NAME:
12640 : 1 : if (gimple *_d2 = get_def (valueize, _p1))
12641 : : {
12642 : 1 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
12643 : 1 : switch (gimple_call_combined_fn (_c2))
12644 : : {
12645 : 0 : case CFN_BUILT_IN_BSWAP128:
12646 : 0 : if (gimple_call_num_args (_c2) == 1)
12647 : : {
12648 : 0 : tree _q40 = gimple_call_arg (_c2, 0);
12649 : 0 : _q40 = do_valueize (valueize, _q40);
12650 : 0 : {
12651 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
12652 : 0 : if (gimple_simplify_239 (res_op, seq, valueize, type, captures, NE_EXPR, CFN_BUILT_IN_BSWAP128))
12653 : 0 : return true;
12654 : : }
12655 : : }
12656 : : break;
12657 : : default:;
12658 : : }
12659 : : }
12660 : : break;
12661 : 0 : case INTEGER_CST:
12662 : 0 : {
12663 : 0 : {
12664 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
12665 : 0 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, NE_EXPR, CFN_BUILT_IN_BSWAP128))
12666 : 0 : return true;
12667 : : }
12668 : 0 : break;
12669 : : }
12670 : : default:;
12671 : : }
12672 : : }
12673 : : break;
12674 : 94 : case CFN_BUILT_IN_BSWAP16:
12675 : 94 : if (gimple_call_num_args (_c1) == 1)
12676 : : {
12677 : 94 : tree _q20 = gimple_call_arg (_c1, 0);
12678 : 94 : _q20 = do_valueize (valueize, _q20);
12679 : 94 : switch (TREE_CODE (_p1))
12680 : : {
12681 : 33 : case SSA_NAME:
12682 : 33 : if (gimple *_d2 = get_def (valueize, _p1))
12683 : : {
12684 : 33 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
12685 : 1 : switch (gimple_call_combined_fn (_c2))
12686 : : {
12687 : 0 : case CFN_BUILT_IN_BSWAP16:
12688 : 0 : if (gimple_call_num_args (_c2) == 1)
12689 : : {
12690 : 0 : tree _q40 = gimple_call_arg (_c2, 0);
12691 : 0 : _q40 = do_valueize (valueize, _q40);
12692 : 0 : {
12693 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
12694 : 0 : if (gimple_simplify_239 (res_op, seq, valueize, type, captures, NE_EXPR, CFN_BUILT_IN_BSWAP16))
12695 : 0 : return true;
12696 : : }
12697 : : }
12698 : : break;
12699 : : default:;
12700 : : }
12701 : : }
12702 : : break;
12703 : 61 : case INTEGER_CST:
12704 : 61 : {
12705 : 61 : {
12706 : 61 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
12707 : 61 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, NE_EXPR, CFN_BUILT_IN_BSWAP16))
12708 : 61 : return true;
12709 : : }
12710 : 0 : break;
12711 : : }
12712 : : default:;
12713 : : }
12714 : : }
12715 : : break;
12716 : 139 : case CFN_BUILT_IN_BSWAP32:
12717 : 139 : if (gimple_call_num_args (_c1) == 1)
12718 : : {
12719 : 139 : tree _q20 = gimple_call_arg (_c1, 0);
12720 : 139 : _q20 = do_valueize (valueize, _q20);
12721 : 139 : switch (TREE_CODE (_p1))
12722 : : {
12723 : 81 : case SSA_NAME:
12724 : 81 : if (gimple *_d2 = get_def (valueize, _p1))
12725 : : {
12726 : 81 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
12727 : 43 : switch (gimple_call_combined_fn (_c2))
12728 : : {
12729 : 0 : case CFN_BUILT_IN_BSWAP32:
12730 : 0 : if (gimple_call_num_args (_c2) == 1)
12731 : : {
12732 : 0 : tree _q40 = gimple_call_arg (_c2, 0);
12733 : 0 : _q40 = do_valueize (valueize, _q40);
12734 : 0 : {
12735 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
12736 : 0 : if (gimple_simplify_239 (res_op, seq, valueize, type, captures, NE_EXPR, CFN_BUILT_IN_BSWAP32))
12737 : 0 : return true;
12738 : : }
12739 : : }
12740 : : break;
12741 : : default:;
12742 : : }
12743 : : }
12744 : : break;
12745 : 58 : case INTEGER_CST:
12746 : 58 : {
12747 : 58 : {
12748 : 58 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
12749 : 58 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, NE_EXPR, CFN_BUILT_IN_BSWAP32))
12750 : 58 : return true;
12751 : : }
12752 : 0 : break;
12753 : : }
12754 : : default:;
12755 : : }
12756 : : }
12757 : : break;
12758 : 55 : case CFN_BUILT_IN_BSWAP64:
12759 : 55 : if (gimple_call_num_args (_c1) == 1)
12760 : : {
12761 : 55 : tree _q20 = gimple_call_arg (_c1, 0);
12762 : 55 : _q20 = do_valueize (valueize, _q20);
12763 : 55 : switch (TREE_CODE (_p1))
12764 : : {
12765 : 33 : case SSA_NAME:
12766 : 33 : if (gimple *_d2 = get_def (valueize, _p1))
12767 : : {
12768 : 33 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
12769 : 1 : switch (gimple_call_combined_fn (_c2))
12770 : : {
12771 : 0 : case CFN_BUILT_IN_BSWAP64:
12772 : 0 : if (gimple_call_num_args (_c2) == 1)
12773 : : {
12774 : 0 : tree _q40 = gimple_call_arg (_c2, 0);
12775 : 0 : _q40 = do_valueize (valueize, _q40);
12776 : 0 : {
12777 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
12778 : 0 : if (gimple_simplify_239 (res_op, seq, valueize, type, captures, NE_EXPR, CFN_BUILT_IN_BSWAP64))
12779 : 0 : return true;
12780 : : }
12781 : : }
12782 : : break;
12783 : : default:;
12784 : : }
12785 : : }
12786 : : break;
12787 : 22 : case INTEGER_CST:
12788 : 22 : {
12789 : 22 : {
12790 : 22 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
12791 : 22 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, NE_EXPR, CFN_BUILT_IN_BSWAP64))
12792 : 22 : return true;
12793 : : }
12794 : 0 : break;
12795 : : }
12796 : : default:;
12797 : : }
12798 : : }
12799 : : break;
12800 : : default:;
12801 : : }
12802 : : }
12803 : : break;
12804 : 115948949 : default:;
12805 : : }
12806 : 115948949 : switch (TREE_CODE (_p1))
12807 : : {
12808 : 20544407 : case SSA_NAME:
12809 : 20544407 : if (gimple *_d1 = get_def (valueize, _p1))
12810 : : {
12811 : 6239918 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
12812 : 8920714 : switch (gimple_assign_rhs_code (_a1))
12813 : : {
12814 : 50 : case VEC_COND_EXPR:
12815 : 50 : {
12816 : 50 : tree _q30 = gimple_assign_rhs1 (_a1);
12817 : 50 : _q30 = do_valueize (valueize, _q30);
12818 : 50 : tree _q31 = gimple_assign_rhs2 (_a1);
12819 : 50 : _q31 = do_valueize (valueize, _q31);
12820 : 50 : tree _q32 = gimple_assign_rhs3 (_a1);
12821 : 50 : _q32 = do_valueize (valueize, _q32);
12822 : 50 : {
12823 : 50 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
12824 : 50 : if (TREE_CODE_CLASS (NE_EXPR) != tcc_comparison
12825 : 50 : || types_match (type, TREE_TYPE (captures[3]))
12826 : 50 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]), ERROR_MARK)
12827 : : || (optimize_vectors_before_lowering_p ()
12828 : 4 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]),
12829 : 4 : TREE_TYPE (captures[2]), ERROR_MARK))
12830 : : )
12831 : : {
12832 : 34 : gimple_seq *lseq = seq;
12833 : 34 : if (lseq
12834 : 12 : && (!single_use (captures[1])))
12835 : 34 : lseq = NULL;
12836 : 34 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1849;
12837 : 34 : {
12838 : 34 : res_op->set_op (VEC_COND_EXPR, type, 3);
12839 : 34 : res_op->ops[0] = captures[2];
12840 : 34 : {
12841 : 34 : tree _o1[2], _r1;
12842 : 34 : _o1[0] = captures[0];
12843 : 34 : _o1[1] = captures[3];
12844 : 34 : gimple_match_op tem_op (res_op->cond.any_else (), NE_EXPR, type, _o1[0], _o1[1]);
12845 : 34 : tem_op.resimplify (NULL, valueize);
12846 : 34 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
12847 : 34 : if (!_r1) goto next_after_fail1849;
12848 : 0 : res_op->ops[1] = _r1;
12849 : : }
12850 : 0 : {
12851 : 0 : tree _o1[2], _r1;
12852 : 0 : _o1[0] = captures[0];
12853 : 0 : _o1[1] = captures[4];
12854 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NE_EXPR, type, _o1[0], _o1[1]);
12855 : 0 : tem_op.resimplify (NULL, valueize);
12856 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
12857 : 0 : if (!_r1) goto next_after_fail1849;
12858 : 0 : res_op->ops[2] = _r1;
12859 : : }
12860 : 0 : res_op->resimplify (lseq, valueize);
12861 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
12862 : 0 : return true;
12863 : : }
12864 : 50 : next_after_fail1849:;
12865 : : }
12866 : : }
12867 : 50 : break;
12868 : : }
12869 : : default:;
12870 : : }
12871 : : }
12872 : : break;
12873 : 115948949 : default:;
12874 : : }
12875 : 115948949 : switch (TREE_CODE (_p0))
12876 : : {
12877 : 112955974 : case SSA_NAME:
12878 : 112955974 : if (gimple *_d1 = get_def (valueize, _p0))
12879 : : {
12880 : 37447062 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
12881 : 41025509 : switch (gimple_assign_rhs_code (_a1))
12882 : : {
12883 : 192708 : case LT_EXPR:
12884 : 192708 : {
12885 : 192708 : tree _q20 = gimple_assign_rhs1 (_a1);
12886 : 192708 : _q20 = do_valueize (valueize, _q20);
12887 : 192708 : tree _q21 = gimple_assign_rhs2 (_a1);
12888 : 192708 : _q21 = do_valueize (valueize, _q21);
12889 : 192708 : if (integer_zerop (_p1))
12890 : : {
12891 : 183394 : {
12892 : 183394 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
12893 : 183394 : if (gimple_simplify_294 (res_op, seq, valueize, type, captures, LT_EXPR, GE_EXPR, UNGE_EXPR))
12894 : 158989 : return true;
12895 : : }
12896 : : }
12897 : 33719 : if (integer_truep (_p1))
12898 : : {
12899 : 7838 : {
12900 : 7838 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
12901 : 7838 : if (gimple_simplify_295 (res_op, seq, valueize, type, captures, LT_EXPR, GE_EXPR, UNGE_EXPR))
12902 : 6487 : return true;
12903 : : }
12904 : : }
12905 : : break;
12906 : : }
12907 : 88557 : case LE_EXPR:
12908 : 88557 : {
12909 : 88557 : tree _q20 = gimple_assign_rhs1 (_a1);
12910 : 88557 : _q20 = do_valueize (valueize, _q20);
12911 : 88557 : tree _q21 = gimple_assign_rhs2 (_a1);
12912 : 88557 : _q21 = do_valueize (valueize, _q21);
12913 : 88557 : if (integer_zerop (_p1))
12914 : : {
12915 : 78428 : {
12916 : 78428 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
12917 : 78428 : if (gimple_simplify_294 (res_op, seq, valueize, type, captures, LE_EXPR, GT_EXPR, UNGT_EXPR))
12918 : 69007 : return true;
12919 : : }
12920 : : }
12921 : 19550 : if (integer_truep (_p1))
12922 : : {
12923 : 7444 : {
12924 : 7444 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
12925 : 7444 : if (gimple_simplify_295 (res_op, seq, valueize, type, captures, LE_EXPR, GT_EXPR, UNGT_EXPR))
12926 : 6313 : return true;
12927 : : }
12928 : : }
12929 : : break;
12930 : : }
12931 : 439328 : case EQ_EXPR:
12932 : 439328 : {
12933 : 439328 : tree _q20 = gimple_assign_rhs1 (_a1);
12934 : 439328 : _q20 = do_valueize (valueize, _q20);
12935 : 439328 : tree _q21 = gimple_assign_rhs2 (_a1);
12936 : 439328 : _q21 = do_valueize (valueize, _q21);
12937 : 439328 : if (tree_swap_operands_p (_q20, _q21))
12938 : 8379 : std::swap (_q20, _q21);
12939 : 439328 : if (integer_zerop (_p1))
12940 : : {
12941 : 385759 : {
12942 : 385759 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
12943 : 385759 : if (gimple_simplify_294 (res_op, seq, valueize, type, captures, EQ_EXPR, NE_EXPR, NE_EXPR))
12944 : 339615 : return true;
12945 : : }
12946 : : }
12947 : 99713 : if (integer_truep (_p1))
12948 : : {
12949 : 46673 : {
12950 : 46673 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
12951 : 46673 : if (gimple_simplify_295 (res_op, seq, valueize, type, captures, EQ_EXPR, NE_EXPR, NE_EXPR))
12952 : 46616 : return true;
12953 : : }
12954 : : }
12955 : 114653880 : break;
12956 : : }
12957 : 402868 : case NE_EXPR:
12958 : 402868 : {
12959 : 402868 : tree _q20 = gimple_assign_rhs1 (_a1);
12960 : 402868 : _q20 = do_valueize (valueize, _q20);
12961 : 402868 : tree _q21 = gimple_assign_rhs2 (_a1);
12962 : 402868 : _q21 = do_valueize (valueize, _q21);
12963 : 402868 : if (tree_swap_operands_p (_q20, _q21))
12964 : 4493 : std::swap (_q20, _q21);
12965 : 402868 : if (integer_zerop (_p1))
12966 : : {
12967 : 371924 : {
12968 : 371924 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
12969 : 371924 : if (gimple_simplify_294 (res_op, seq, valueize, type, captures, NE_EXPR, EQ_EXPR, EQ_EXPR))
12970 : 354249 : return true;
12971 : : }
12972 : : }
12973 : 48619 : if (integer_truep (_p1))
12974 : : {
12975 : 19557 : {
12976 : 19557 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
12977 : 19557 : if (gimple_simplify_295 (res_op, seq, valueize, type, captures, NE_EXPR, EQ_EXPR, EQ_EXPR))
12978 : 18816 : return true;
12979 : : }
12980 : : }
12981 : 114653880 : break;
12982 : : }
12983 : 112794 : case GE_EXPR:
12984 : 112794 : {
12985 : 112794 : tree _q20 = gimple_assign_rhs1 (_a1);
12986 : 112794 : _q20 = do_valueize (valueize, _q20);
12987 : 112794 : tree _q21 = gimple_assign_rhs2 (_a1);
12988 : 112794 : _q21 = do_valueize (valueize, _q21);
12989 : 112794 : if (integer_zerop (_p1))
12990 : : {
12991 : 105260 : {
12992 : 105260 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
12993 : 105260 : if (gimple_simplify_294 (res_op, seq, valueize, type, captures, GE_EXPR, LT_EXPR, UNLT_EXPR))
12994 : 103150 : return true;
12995 : : }
12996 : : }
12997 : 9644 : if (integer_truep (_p1))
12998 : : {
12999 : 5238 : {
13000 : 5238 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13001 : 5238 : if (gimple_simplify_295 (res_op, seq, valueize, type, captures, GE_EXPR, LT_EXPR, UNLT_EXPR))
13002 : 3795 : return true;
13003 : : }
13004 : : }
13005 : : break;
13006 : : }
13007 : 213314 : case GT_EXPR:
13008 : 213314 : {
13009 : 213314 : tree _q20 = gimple_assign_rhs1 (_a1);
13010 : 213314 : _q20 = do_valueize (valueize, _q20);
13011 : 213314 : tree _q21 = gimple_assign_rhs2 (_a1);
13012 : 213314 : _q21 = do_valueize (valueize, _q21);
13013 : 213314 : if (integer_zerop (_p1))
13014 : : {
13015 : 206726 : {
13016 : 206726 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13017 : 206726 : if (gimple_simplify_294 (res_op, seq, valueize, type, captures, GT_EXPR, LE_EXPR, UNLE_EXPR))
13018 : 143523 : return true;
13019 : : }
13020 : : }
13021 : 69791 : if (integer_truep (_p1))
13022 : : {
13023 : 5319 : {
13024 : 5319 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13025 : 5319 : if (gimple_simplify_295 (res_op, seq, valueize, type, captures, GT_EXPR, LE_EXPR, UNLE_EXPR))
13026 : 4306 : return true;
13027 : : }
13028 : : }
13029 : : break;
13030 : : }
13031 : 8780 : case UNORDERED_EXPR:
13032 : 8780 : {
13033 : 8780 : tree _q20 = gimple_assign_rhs1 (_a1);
13034 : 8780 : _q20 = do_valueize (valueize, _q20);
13035 : 8780 : tree _q21 = gimple_assign_rhs2 (_a1);
13036 : 8780 : _q21 = do_valueize (valueize, _q21);
13037 : 8780 : if (tree_swap_operands_p (_q20, _q21))
13038 : 6 : std::swap (_q20, _q21);
13039 : 8780 : if (integer_zerop (_p1))
13040 : : {
13041 : 5143 : {
13042 : 5143 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13043 : 5143 : if (gimple_simplify_294 (res_op, seq, valueize, type, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR))
13044 : 5143 : return true;
13045 : : }
13046 : : }
13047 : 3637 : if (integer_truep (_p1))
13048 : : {
13049 : 527 : {
13050 : 527 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13051 : 527 : if (gimple_simplify_295 (res_op, seq, valueize, type, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR))
13052 : 527 : return true;
13053 : : }
13054 : : }
13055 : 114653880 : break;
13056 : : }
13057 : 523 : case ORDERED_EXPR:
13058 : 523 : {
13059 : 523 : tree _q20 = gimple_assign_rhs1 (_a1);
13060 : 523 : _q20 = do_valueize (valueize, _q20);
13061 : 523 : tree _q21 = gimple_assign_rhs2 (_a1);
13062 : 523 : _q21 = do_valueize (valueize, _q21);
13063 : 523 : if (tree_swap_operands_p (_q20, _q21))
13064 : 0 : std::swap (_q20, _q21);
13065 : 523 : if (integer_zerop (_p1))
13066 : : {
13067 : 508 : {
13068 : 508 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13069 : 508 : if (gimple_simplify_294 (res_op, seq, valueize, type, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR))
13070 : 508 : return true;
13071 : : }
13072 : : }
13073 : 15 : if (integer_truep (_p1))
13074 : : {
13075 : 0 : {
13076 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13077 : 0 : if (gimple_simplify_295 (res_op, seq, valueize, type, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR))
13078 : 0 : return true;
13079 : : }
13080 : : }
13081 : 114653880 : break;
13082 : : }
13083 : 2084 : case UNLT_EXPR:
13084 : 2084 : {
13085 : 2084 : tree _q20 = gimple_assign_rhs1 (_a1);
13086 : 2084 : _q20 = do_valueize (valueize, _q20);
13087 : 2084 : tree _q21 = gimple_assign_rhs2 (_a1);
13088 : 2084 : _q21 = do_valueize (valueize, _q21);
13089 : 2084 : if (integer_zerop (_p1))
13090 : : {
13091 : 842 : {
13092 : 842 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13093 : 842 : if (gimple_simplify_294 (res_op, seq, valueize, type, captures, UNLT_EXPR, GE_EXPR, GE_EXPR))
13094 : 842 : return true;
13095 : : }
13096 : : }
13097 : 1242 : if (integer_truep (_p1))
13098 : : {
13099 : 1242 : {
13100 : 1242 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13101 : 1242 : if (gimple_simplify_295 (res_op, seq, valueize, type, captures, UNLT_EXPR, GE_EXPR, GE_EXPR))
13102 : 0 : return true;
13103 : : }
13104 : : }
13105 : : break;
13106 : : }
13107 : 6796 : case UNLE_EXPR:
13108 : 6796 : {
13109 : 6796 : tree _q20 = gimple_assign_rhs1 (_a1);
13110 : 6796 : _q20 = do_valueize (valueize, _q20);
13111 : 6796 : tree _q21 = gimple_assign_rhs2 (_a1);
13112 : 6796 : _q21 = do_valueize (valueize, _q21);
13113 : 6796 : if (integer_zerop (_p1))
13114 : : {
13115 : 2213 : {
13116 : 2213 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13117 : 2213 : if (gimple_simplify_294 (res_op, seq, valueize, type, captures, UNLE_EXPR, GT_EXPR, GT_EXPR))
13118 : 2213 : return true;
13119 : : }
13120 : : }
13121 : 4583 : if (integer_truep (_p1))
13122 : : {
13123 : 4583 : {
13124 : 4583 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13125 : 4583 : if (gimple_simplify_295 (res_op, seq, valueize, type, captures, UNLE_EXPR, GT_EXPR, GT_EXPR))
13126 : 0 : return true;
13127 : : }
13128 : : }
13129 : : break;
13130 : : }
13131 : 9529 : case UNGT_EXPR:
13132 : 9529 : {
13133 : 9529 : tree _q20 = gimple_assign_rhs1 (_a1);
13134 : 9529 : _q20 = do_valueize (valueize, _q20);
13135 : 9529 : tree _q21 = gimple_assign_rhs2 (_a1);
13136 : 9529 : _q21 = do_valueize (valueize, _q21);
13137 : 9529 : if (integer_zerop (_p1))
13138 : : {
13139 : 2523 : {
13140 : 2523 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13141 : 2523 : if (gimple_simplify_294 (res_op, seq, valueize, type, captures, UNGT_EXPR, LE_EXPR, LE_EXPR))
13142 : 2523 : return true;
13143 : : }
13144 : : }
13145 : 7006 : if (integer_truep (_p1))
13146 : : {
13147 : 6847 : {
13148 : 6847 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13149 : 6847 : if (gimple_simplify_295 (res_op, seq, valueize, type, captures, UNGT_EXPR, LE_EXPR, LE_EXPR))
13150 : 0 : return true;
13151 : : }
13152 : : }
13153 : : break;
13154 : : }
13155 : 3924 : case UNGE_EXPR:
13156 : 3924 : {
13157 : 3924 : tree _q20 = gimple_assign_rhs1 (_a1);
13158 : 3924 : _q20 = do_valueize (valueize, _q20);
13159 : 3924 : tree _q21 = gimple_assign_rhs2 (_a1);
13160 : 3924 : _q21 = do_valueize (valueize, _q21);
13161 : 3924 : if (integer_zerop (_p1))
13162 : : {
13163 : 2294 : {
13164 : 2294 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13165 : 2294 : if (gimple_simplify_294 (res_op, seq, valueize, type, captures, UNGE_EXPR, LT_EXPR, LT_EXPR))
13166 : 2294 : return true;
13167 : : }
13168 : : }
13169 : 1630 : if (integer_truep (_p1))
13170 : : {
13171 : 1392 : {
13172 : 1392 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13173 : 1392 : if (gimple_simplify_295 (res_op, seq, valueize, type, captures, UNGE_EXPR, LT_EXPR, LT_EXPR))
13174 : 0 : return true;
13175 : : }
13176 : : }
13177 : : break;
13178 : : }
13179 : 806 : case UNEQ_EXPR:
13180 : 806 : {
13181 : 806 : tree _q20 = gimple_assign_rhs1 (_a1);
13182 : 806 : _q20 = do_valueize (valueize, _q20);
13183 : 806 : tree _q21 = gimple_assign_rhs2 (_a1);
13184 : 806 : _q21 = do_valueize (valueize, _q21);
13185 : 806 : if (tree_swap_operands_p (_q20, _q21))
13186 : 6 : std::swap (_q20, _q21);
13187 : 806 : if (integer_zerop (_p1))
13188 : : {
13189 : 372 : {
13190 : 372 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13191 : 372 : if (gimple_simplify_294 (res_op, seq, valueize, type, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR))
13192 : 372 : return true;
13193 : : }
13194 : : }
13195 : 434 : if (integer_truep (_p1))
13196 : : {
13197 : 434 : {
13198 : 434 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13199 : 434 : if (gimple_simplify_295 (res_op, seq, valueize, type, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR))
13200 : 0 : return true;
13201 : : }
13202 : : }
13203 : 114653880 : break;
13204 : : }
13205 : 0 : case LTGT_EXPR:
13206 : 0 : {
13207 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
13208 : 0 : _q20 = do_valueize (valueize, _q20);
13209 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
13210 : 0 : _q21 = do_valueize (valueize, _q21);
13211 : 0 : if (tree_swap_operands_p (_q20, _q21))
13212 : 0 : std::swap (_q20, _q21);
13213 : 0 : if (integer_zerop (_p1))
13214 : : {
13215 : 0 : {
13216 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13217 : 0 : if (gimple_simplify_294 (res_op, seq, valueize, type, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR))
13218 : 0 : return true;
13219 : : }
13220 : : }
13221 : 0 : if (integer_truep (_p1))
13222 : : {
13223 : 0 : {
13224 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13225 : 0 : if (gimple_simplify_295 (res_op, seq, valueize, type, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR))
13226 : 0 : return true;
13227 : : }
13228 : : }
13229 : 114653880 : break;
13230 : : }
13231 : 187805 : case MINUS_EXPR:
13232 : 187805 : {
13233 : 187805 : tree _q20 = gimple_assign_rhs1 (_a1);
13234 : 187805 : _q20 = do_valueize (valueize, _q20);
13235 : 187805 : tree _q21 = gimple_assign_rhs2 (_a1);
13236 : 187805 : _q21 = do_valueize (valueize, _q21);
13237 : 187805 : if (integer_zerop (_p1))
13238 : : {
13239 : 84296 : {
13240 : 84296 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13241 : 84296 : if (gimple_simplify_243 (res_op, seq, valueize, type, captures, NE_EXPR))
13242 : 7867 : return true;
13243 : : }
13244 : : }
13245 : : break;
13246 : : }
13247 : 64808 : case POINTER_DIFF_EXPR:
13248 : 64808 : {
13249 : 64808 : tree _q20 = gimple_assign_rhs1 (_a1);
13250 : 64808 : _q20 = do_valueize (valueize, _q20);
13251 : 64808 : tree _q21 = gimple_assign_rhs2 (_a1);
13252 : 64808 : _q21 = do_valueize (valueize, _q21);
13253 : 64808 : if (integer_zerop (_p1))
13254 : : {
13255 : 43282 : {
13256 : 43282 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
13257 : 43282 : if (gimple_simplify_244 (res_op, seq, valueize, type, captures, NE_EXPR))
13258 : 15713 : return true;
13259 : : }
13260 : : }
13261 : : break;
13262 : : }
13263 : 85727 : case MULT_EXPR:
13264 : 85727 : {
13265 : 85727 : tree _q20 = gimple_assign_rhs1 (_a1);
13266 : 85727 : _q20 = do_valueize (valueize, _q20);
13267 : 85727 : tree _q21 = gimple_assign_rhs2 (_a1);
13268 : 85727 : _q21 = do_valueize (valueize, _q21);
13269 : 85727 : if (tree_swap_operands_p (_q20, _q21))
13270 : 1254 : std::swap (_q20, _q21);
13271 : 85727 : switch (TREE_CODE (_q21))
13272 : : {
13273 : 55038 : case INTEGER_CST:
13274 : 55038 : {
13275 : 55038 : switch (TREE_CODE (_p1))
13276 : : {
13277 : 27152 : case INTEGER_CST:
13278 : 27152 : {
13279 : 27152 : {
13280 : 27152 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
13281 : 27152 : if (gimple_simplify_246 (res_op, seq, valueize, type, captures, NE_EXPR))
13282 : 2201 : return true;
13283 : : }
13284 : 24951 : break;
13285 : : }
13286 : 52837 : default:;
13287 : : }
13288 : 52837 : if (integer_zerop (_p1))
13289 : : {
13290 : 13297 : {
13291 : 13297 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
13292 : 13297 : if (gimple_simplify_245 (res_op, seq, valueize, type, captures, NE_EXPR, NE_EXPR))
13293 : 0 : return true;
13294 : : }
13295 : : }
13296 : : break;
13297 : : }
13298 : : default:;
13299 : : }
13300 : 114653880 : break;
13301 : : }
13302 : : default:;
13303 : : }
13304 : : }
13305 : : break;
13306 : 114653880 : default:;
13307 : : }
13308 : 114653880 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
13309 : : {
13310 : 67964 : {
13311 : 67964 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
13312 : 67964 : if (gimple_simplify_296 (res_op, seq, valueize, type, captures, NE_EXPR))
13313 : 27938 : return true;
13314 : : }
13315 : : }
13316 : 114625942 : switch (TREE_CODE (_p1))
13317 : : {
13318 : 20526107 : case SSA_NAME:
13319 : 20526107 : if (gimple *_d1 = get_def (valueize, _p1))
13320 : : {
13321 : 6225065 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
13322 : 8907519 : switch (gimple_assign_rhs_code (_a1))
13323 : : {
13324 : 3168 : case BIT_NOT_EXPR:
13325 : 3168 : {
13326 : 3168 : tree _q30 = gimple_assign_rhs1 (_a1);
13327 : 3168 : _q30 = do_valueize (valueize, _q30);
13328 : 3168 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
13329 : : {
13330 : 0 : {
13331 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
13332 : 0 : if (gimple_simplify_248 (res_op, seq, valueize, type, captures, NE_EXPR))
13333 : 0 : return true;
13334 : : }
13335 : : }
13336 : : break;
13337 : : }
13338 : : default:;
13339 : : }
13340 : : }
13341 : : break;
13342 : 114625942 : default:;
13343 : : }
13344 : 114625942 : switch (TREE_CODE (_p0))
13345 : : {
13346 : 111642605 : case SSA_NAME:
13347 : 111642605 : if (gimple *_d1 = get_def (valueize, _p0))
13348 : : {
13349 : 36137140 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
13350 : 39717245 : switch (gimple_assign_rhs_code (_a1))
13351 : : {
13352 : 448798 : case BIT_NOT_EXPR:
13353 : 448798 : {
13354 : 448798 : tree _q20 = gimple_assign_rhs1 (_a1);
13355 : 448798 : _q20 = do_valueize (valueize, _q20);
13356 : 448798 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
13357 : : {
13358 : 0 : {
13359 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
13360 : 0 : if (gimple_simplify_248 (res_op, seq, valueize, type, captures, NE_EXPR))
13361 : 0 : return true;
13362 : : }
13363 : : }
13364 : 448798 : switch (TREE_CODE (_p1))
13365 : : {
13366 : 2443 : case SSA_NAME:
13367 : 2443 : if (gimple *_d2 = get_def (valueize, _p1))
13368 : : {
13369 : 2246 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13370 : 1838 : switch (gimple_assign_rhs_code (_a2))
13371 : : {
13372 : 1223 : case BIT_NOT_EXPR:
13373 : 1223 : {
13374 : 1223 : tree _q40 = gimple_assign_rhs1 (_a2);
13375 : 1223 : _q40 = do_valueize (valueize, _q40);
13376 : 1223 : {
13377 : 1223 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _p1, _q40 };
13378 : 1223 : if (gimple_simplify_249 (res_op, seq, valueize, type, captures, NE_EXPR))
13379 : 915 : return true;
13380 : : }
13381 : 308 : break;
13382 : : }
13383 : : default:;
13384 : : }
13385 : : }
13386 : : break;
13387 : 447883 : default:;
13388 : : }
13389 : 447883 : {
13390 : 447883 : tree _p1_pops[1];
13391 : 447883 : if (gimple_nop_convert (_p1, _p1_pops, valueize))
13392 : : {
13393 : 0 : tree _q40 = _p1_pops[0];
13394 : 0 : switch (TREE_CODE (_q40))
13395 : : {
13396 : 0 : case SSA_NAME:
13397 : 0 : if (gimple *_d2 = get_def (valueize, _q40))
13398 : : {
13399 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13400 : 0 : switch (gimple_assign_rhs_code (_a2))
13401 : : {
13402 : 0 : case BIT_NOT_EXPR:
13403 : 0 : {
13404 : 0 : tree _q50 = gimple_assign_rhs1 (_a2);
13405 : 0 : _q50 = do_valueize (valueize, _q50);
13406 : 0 : {
13407 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40, _q50 };
13408 : 0 : if (gimple_simplify_249 (res_op, seq, valueize, type, captures, NE_EXPR))
13409 : 0 : return true;
13410 : : }
13411 : 0 : break;
13412 : : }
13413 : : default:;
13414 : : }
13415 : : }
13416 : : break;
13417 : : default:;
13418 : : }
13419 : : }
13420 : : }
13421 : 447883 : if (CONSTANT_CLASS_P (_p1))
13422 : : {
13423 : 446355 : {
13424 : 446355 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
13425 : 446355 : if (gimple_simplify_250 (res_op, seq, valueize, type, captures, NE_EXPR, NE_EXPR))
13426 : 410025 : return true;
13427 : : }
13428 : : }
13429 : : break;
13430 : : }
13431 : : default:;
13432 : : }
13433 : : }
13434 : : break;
13435 : 114215002 : default:;
13436 : : }
13437 : 114215002 : {
13438 : 114215002 : tree _p0_pops[1];
13439 : 114215002 : if (gimple_nop_convert (_p0, _p0_pops, valueize))
13440 : : {
13441 : 473324 : tree _q20 = _p0_pops[0];
13442 : 473324 : switch (TREE_CODE (_q20))
13443 : : {
13444 : 458577 : case SSA_NAME:
13445 : 458577 : if (gimple *_d1 = get_def (valueize, _q20))
13446 : : {
13447 : 443391 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
13448 : 511122 : switch (gimple_assign_rhs_code (_a1))
13449 : : {
13450 : 1524 : case BIT_NOT_EXPR:
13451 : 1524 : {
13452 : 1524 : tree _q30 = gimple_assign_rhs1 (_a1);
13453 : 1524 : _q30 = do_valueize (valueize, _q30);
13454 : 1524 : switch (TREE_CODE (_p1))
13455 : : {
13456 : 31 : case SSA_NAME:
13457 : 31 : if (gimple *_d2 = get_def (valueize, _p1))
13458 : : {
13459 : 31 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13460 : 57 : switch (gimple_assign_rhs_code (_a2))
13461 : : {
13462 : 0 : case BIT_NOT_EXPR:
13463 : 0 : {
13464 : 0 : tree _q50 = gimple_assign_rhs1 (_a2);
13465 : 0 : _q50 = do_valueize (valueize, _q50);
13466 : 0 : {
13467 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _p1, _q50 };
13468 : 0 : if (gimple_simplify_251 (res_op, seq, valueize, type, captures, NE_EXPR))
13469 : 0 : return true;
13470 : : }
13471 : 0 : break;
13472 : : }
13473 : : default:;
13474 : : }
13475 : : }
13476 : : break;
13477 : 1524 : default:;
13478 : : }
13479 : 1524 : {
13480 : 1524 : tree _p1_pops[1];
13481 : 1524 : if (gimple_nop_convert (_p1, _p1_pops, valueize))
13482 : : {
13483 : 5 : tree _q50 = _p1_pops[0];
13484 : 5 : switch (TREE_CODE (_q50))
13485 : : {
13486 : 5 : case SSA_NAME:
13487 : 5 : if (gimple *_d2 = get_def (valueize, _q50))
13488 : : {
13489 : 5 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13490 : 5 : switch (gimple_assign_rhs_code (_a2))
13491 : : {
13492 : 5 : case BIT_NOT_EXPR:
13493 : 5 : {
13494 : 5 : tree _q60 = gimple_assign_rhs1 (_a2);
13495 : 5 : _q60 = do_valueize (valueize, _q60);
13496 : 5 : {
13497 : 5 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50, _q60 };
13498 : 5 : if (gimple_simplify_251 (res_op, seq, valueize, type, captures, NE_EXPR))
13499 : 0 : return true;
13500 : : }
13501 : 5 : break;
13502 : : }
13503 : : default:;
13504 : : }
13505 : : }
13506 : : break;
13507 : : default:;
13508 : : }
13509 : : }
13510 : : }
13511 : 1524 : if (CONSTANT_CLASS_P (_p1))
13512 : : {
13513 : 1493 : {
13514 : 1493 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
13515 : 1493 : if (gimple_simplify_250 (res_op, seq, valueize, type, captures, NE_EXPR, NE_EXPR))
13516 : 146 : return true;
13517 : : }
13518 : : }
13519 : : break;
13520 : : }
13521 : : default:;
13522 : : }
13523 : : }
13524 : : break;
13525 : : default:;
13526 : : }
13527 : : }
13528 : : }
13529 : 114214856 : switch (TREE_CODE (_p1))
13530 : : {
13531 : 3806469 : case REAL_CST:
13532 : 3806469 : {
13533 : 3806469 : {
13534 : 3806469 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
13535 : 3806469 : if (gimple_simplify_252 (res_op, seq, valueize, type, captures, NE_EXPR))
13536 : 1734 : return true;
13537 : : }
13538 : 3804735 : break;
13539 : : }
13540 : 114213122 : default:;
13541 : : }
13542 : 114213122 : switch (TREE_CODE (_p0))
13543 : : {
13544 : 111230433 : case SSA_NAME:
13545 : 111230433 : if (gimple *_d1 = get_def (valueize, _p0))
13546 : : {
13547 : 35725268 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
13548 : 39305899 : switch (gimple_assign_rhs_code (_a1))
13549 : : {
13550 : 1367864 : case PLUS_EXPR:
13551 : 1367864 : {
13552 : 1367864 : tree _q20 = gimple_assign_rhs1 (_a1);
13553 : 1367864 : _q20 = do_valueize (valueize, _q20);
13554 : 1367864 : tree _q21 = gimple_assign_rhs2 (_a1);
13555 : 1367864 : _q21 = do_valueize (valueize, _q21);
13556 : 1367864 : if (tree_swap_operands_p (_q20, _q21))
13557 : 7984 : std::swap (_q20, _q21);
13558 : 1367864 : switch (TREE_CODE (_q21))
13559 : : {
13560 : 12765 : case REAL_CST:
13561 : 12765 : {
13562 : 12765 : switch (TREE_CODE (_p1))
13563 : : {
13564 : 12052 : case REAL_CST:
13565 : 12052 : {
13566 : 12052 : {
13567 : 12052 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
13568 : 12052 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, PLUS_EXPR, NE_EXPR))
13569 : 9 : return true;
13570 : : }
13571 : 12043 : break;
13572 : : }
13573 : : default:;
13574 : : }
13575 : : break;
13576 : : }
13577 : : default:;
13578 : : }
13579 : 113957224 : break;
13580 : : }
13581 : 179932 : case MINUS_EXPR:
13582 : 179932 : {
13583 : 179932 : tree _q20 = gimple_assign_rhs1 (_a1);
13584 : 179932 : _q20 = do_valueize (valueize, _q20);
13585 : 179932 : tree _q21 = gimple_assign_rhs2 (_a1);
13586 : 179932 : _q21 = do_valueize (valueize, _q21);
13587 : 179932 : switch (TREE_CODE (_q21))
13588 : : {
13589 : 10127 : case REAL_CST:
13590 : 10127 : {
13591 : 10127 : switch (TREE_CODE (_p1))
13592 : : {
13593 : 9561 : case REAL_CST:
13594 : 9561 : {
13595 : 9561 : {
13596 : 9561 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
13597 : 9561 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, MINUS_EXPR, NE_EXPR))
13598 : 12 : return true;
13599 : : }
13600 : 9549 : break;
13601 : : }
13602 : : default:;
13603 : : }
13604 : : break;
13605 : : }
13606 : 179920 : default:;
13607 : : }
13608 : 179920 : switch (TREE_CODE (_q20))
13609 : : {
13610 : 1287 : case REAL_CST:
13611 : 1287 : {
13612 : 1287 : switch (TREE_CODE (_p1))
13613 : : {
13614 : 1287 : case REAL_CST:
13615 : 1287 : {
13616 : 1287 : {
13617 : 1287 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
13618 : 1287 : if (gimple_simplify_254 (res_op, seq, valueize, type, captures, NE_EXPR))
13619 : 0 : return true;
13620 : : }
13621 : 1287 : break;
13622 : : }
13623 : : default:;
13624 : : }
13625 : : break;
13626 : : }
13627 : : default:;
13628 : : }
13629 : : break;
13630 : : }
13631 : 10600 : case FLOAT_EXPR:
13632 : 10600 : {
13633 : 10600 : tree _q20 = gimple_assign_rhs1 (_a1);
13634 : 10600 : _q20 = do_valueize (valueize, _q20);
13635 : 10600 : switch (TREE_CODE (_p1))
13636 : : {
13637 : 5728 : case SSA_NAME:
13638 : 5728 : if (gimple *_d2 = get_def (valueize, _p1))
13639 : : {
13640 : 5615 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13641 : 8377 : switch (gimple_assign_rhs_code (_a2))
13642 : : {
13643 : 1887 : case FLOAT_EXPR:
13644 : 1887 : {
13645 : 1887 : tree _q40 = gimple_assign_rhs1 (_a2);
13646 : 1887 : _q40 = do_valueize (valueize, _q40);
13647 : 1887 : {
13648 : 1887 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
13649 : 1887 : if (gimple_simplify_257 (res_op, seq, valueize, type, captures, NE_EXPR, NE_EXPR))
13650 : 180 : return true;
13651 : : }
13652 : 1707 : break;
13653 : : }
13654 : : default:;
13655 : : }
13656 : : }
13657 : : break;
13658 : 4865 : case REAL_CST:
13659 : 4865 : {
13660 : 4865 : {
13661 : 4865 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
13662 : 4865 : if (gimple_simplify_258 (res_op, seq, valueize, type, captures, NE_EXPR, NE_EXPR))
13663 : 74 : return true;
13664 : : }
13665 : 4791 : break;
13666 : : }
13667 : : default:;
13668 : : }
13669 : : break;
13670 : : }
13671 : 19373 : case EXACT_DIV_EXPR:
13672 : 19373 : {
13673 : 19373 : tree _q20 = gimple_assign_rhs1 (_a1);
13674 : 19373 : _q20 = do_valueize (valueize, _q20);
13675 : 19373 : tree _q21 = gimple_assign_rhs2 (_a1);
13676 : 19373 : _q21 = do_valueize (valueize, _q21);
13677 : 19373 : switch (TREE_CODE (_p1))
13678 : : {
13679 : 18054 : case INTEGER_CST:
13680 : 18054 : {
13681 : 18054 : {
13682 : 18054 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
13683 : 18054 : if (gimple_simplify_259 (res_op, seq, valueize, type, captures, NE_EXPR))
13684 : 18054 : return true;
13685 : : }
13686 : 0 : break;
13687 : : }
13688 : : default:;
13689 : : }
13690 : : break;
13691 : : }
13692 : 8294 : case NEGATE_EXPR:
13693 : 8294 : {
13694 : 8294 : tree _q20 = gimple_assign_rhs1 (_a1);
13695 : 8294 : _q20 = do_valueize (valueize, _q20);
13696 : 8294 : switch (TREE_CODE (_p1))
13697 : : {
13698 : 6553 : case SSA_NAME:
13699 : 6553 : if (gimple *_d2 = get_def (valueize, _p1))
13700 : : {
13701 : 6460 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13702 : 6795 : switch (gimple_assign_rhs_code (_a2))
13703 : : {
13704 : 201 : case NEGATE_EXPR:
13705 : 201 : {
13706 : 201 : tree _q40 = gimple_assign_rhs1 (_a2);
13707 : 201 : _q40 = do_valueize (valueize, _q40);
13708 : 201 : {
13709 : 201 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
13710 : 201 : if (gimple_simplify_260 (res_op, seq, valueize, type, captures, NE_EXPR, NE_EXPR))
13711 : 201 : return true;
13712 : : }
13713 : 0 : break;
13714 : : }
13715 : : default:;
13716 : : }
13717 : : }
13718 : : break;
13719 : 8093 : default:;
13720 : : }
13721 : 8093 : if (CONSTANT_CLASS_P (_p1))
13722 : : {
13723 : 1741 : {
13724 : 1741 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
13725 : 1741 : if (gimple_simplify_261 (res_op, seq, valueize, type, captures, NE_EXPR, NE_EXPR))
13726 : 1741 : return true;
13727 : : }
13728 : : }
13729 : : break;
13730 : : }
13731 : 7211 : case ABS_EXPR:
13732 : 7211 : {
13733 : 7211 : tree _q20 = gimple_assign_rhs1 (_a1);
13734 : 7211 : _q20 = do_valueize (valueize, _q20);
13735 : 7211 : if (zerop (_p1))
13736 : : {
13737 : 705 : {
13738 : 705 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
13739 : 705 : const enum tree_code eqne = NE_EXPR;
13740 : 705 : gimple_seq *lseq = seq;
13741 : 705 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1850;
13742 : 705 : {
13743 : 705 : res_op->set_op (eqne, type, 2);
13744 : 705 : res_op->ops[0] = captures[0];
13745 : 705 : res_op->ops[1] = build_zero_cst (TREE_TYPE (captures[0]));
13746 : 705 : res_op->resimplify (lseq, valueize);
13747 : 705 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1009, __FILE__, __LINE__, true);
13748 : 705 : return true;
13749 : : }
13750 : 0 : next_after_fail1850:;
13751 : : }
13752 : : }
13753 : : break;
13754 : : }
13755 : 119 : case ABSU_EXPR:
13756 : 119 : {
13757 : 119 : tree _q20 = gimple_assign_rhs1 (_a1);
13758 : 119 : _q20 = do_valueize (valueize, _q20);
13759 : 119 : if (zerop (_p1))
13760 : : {
13761 : 18 : {
13762 : 18 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
13763 : 18 : const enum tree_code eqne = NE_EXPR;
13764 : 18 : gimple_seq *lseq = seq;
13765 : 18 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1851;
13766 : 18 : {
13767 : 18 : res_op->set_op (eqne, type, 2);
13768 : 18 : res_op->ops[0] = captures[0];
13769 : 18 : res_op->ops[1] = build_zero_cst (TREE_TYPE (captures[0]));
13770 : 18 : res_op->resimplify (lseq, valueize);
13771 : 18 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1009, __FILE__, __LINE__, true);
13772 : 18 : return true;
13773 : : }
13774 : 0 : next_after_fail1851:;
13775 : : }
13776 : : }
13777 : : break;
13778 : : }
13779 : 2016631 : CASE_CONVERT:
13780 : 2016631 : {
13781 : 2016631 : tree _q20 = gimple_assign_rhs1 (_a1);
13782 : 2016631 : _q20 = do_valueize (valueize, _q20);
13783 : 2016631 : switch (TREE_CODE (_p1))
13784 : : {
13785 : 512795 : case SSA_NAME:
13786 : 512795 : if (gimple *_d2 = get_def (valueize, _p1))
13787 : : {
13788 : 462743 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13789 : 536833 : switch (gimple_assign_rhs_code (_a2))
13790 : : {
13791 : 72273 : CASE_CONVERT:
13792 : 72273 : {
13793 : 72273 : tree _q40 = gimple_assign_rhs1 (_a2);
13794 : 72273 : _q40 = do_valueize (valueize, _q40);
13795 : 72273 : {
13796 : 72273 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
13797 : 72273 : if (gimple_simplify_262 (res_op, seq, valueize, type, captures, NE_EXPR))
13798 : 9808 : return true;
13799 : : }
13800 : 62465 : break;
13801 : : }
13802 : : default:;
13803 : : }
13804 : : }
13805 : : break;
13806 : 2006823 : default:;
13807 : : }
13808 : 2006823 : {
13809 : 2006823 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
13810 : 2006823 : if (gimple_simplify_263 (res_op, seq, valueize, type, captures, NE_EXPR))
13811 : 218553 : return true;
13812 : : }
13813 : 1788270 : switch (TREE_CODE (_q20))
13814 : : {
13815 : 1773031 : case SSA_NAME:
13816 : 1773031 : if (gimple *_d2 = get_def (valueize, _q20))
13817 : : {
13818 : 1739010 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13819 : 2178286 : switch (gimple_assign_rhs_code (_a2))
13820 : : {
13821 : 3739 : case BIT_IOR_EXPR:
13822 : 3739 : {
13823 : 3739 : tree _q30 = gimple_assign_rhs1 (_a2);
13824 : 3739 : _q30 = do_valueize (valueize, _q30);
13825 : 3739 : tree _q31 = gimple_assign_rhs2 (_a2);
13826 : 3739 : _q31 = do_valueize (valueize, _q31);
13827 : 3739 : if (tree_swap_operands_p (_q30, _q31))
13828 : 33 : std::swap (_q30, _q31);
13829 : 3739 : switch (TREE_CODE (_q31))
13830 : : {
13831 : 44 : case INTEGER_CST:
13832 : 44 : {
13833 : 44 : switch (TREE_CODE (_p1))
13834 : : {
13835 : 32 : case INTEGER_CST:
13836 : 32 : {
13837 : 32 : {
13838 : 32 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _p1 };
13839 : 32 : if (gimple_simplify_264 (res_op, seq, valueize, type, captures, NE_EXPR))
13840 : 0 : return true;
13841 : : }
13842 : 32 : break;
13843 : : }
13844 : : default:;
13845 : : }
13846 : : break;
13847 : : }
13848 : : default:;
13849 : : }
13850 : 113957224 : break;
13851 : : }
13852 : : default:;
13853 : : }
13854 : : }
13855 : : break;
13856 : : default:;
13857 : : }
13858 : : break;
13859 : : }
13860 : 29414 : case ADDR_EXPR:
13861 : 29414 : {
13862 : 29414 : switch (TREE_CODE (_p1))
13863 : : {
13864 : 21526 : case SSA_NAME:
13865 : 21526 : {
13866 : 21526 : {
13867 : 21526 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
13868 : 21526 : if (gimple_simplify_265 (res_op, seq, valueize, type, captures, NE_EXPR))
13869 : 0 : return true;
13870 : : }
13871 : 21526 : break;
13872 : : }
13873 : : default:;
13874 : : }
13875 : : break;
13876 : : }
13877 : 862296 : case BIT_IOR_EXPR:
13878 : 862296 : {
13879 : 862296 : tree _q20 = gimple_assign_rhs1 (_a1);
13880 : 862296 : _q20 = do_valueize (valueize, _q20);
13881 : 862296 : tree _q21 = gimple_assign_rhs2 (_a1);
13882 : 862296 : _q21 = do_valueize (valueize, _q21);
13883 : 862296 : if (tree_swap_operands_p (_q20, _q21))
13884 : 55294 : std::swap (_q20, _q21);
13885 : 862296 : switch (TREE_CODE (_q21))
13886 : : {
13887 : 1960 : case INTEGER_CST:
13888 : 1960 : {
13889 : 1960 : switch (TREE_CODE (_p1))
13890 : : {
13891 : 749 : case INTEGER_CST:
13892 : 749 : {
13893 : 749 : {
13894 : 749 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
13895 : 749 : if (gimple_simplify_264 (res_op, seq, valueize, type, captures, NE_EXPR))
13896 : 0 : return true;
13897 : : }
13898 : 749 : break;
13899 : : }
13900 : : default:;
13901 : : }
13902 : : break;
13903 : : }
13904 : : default:;
13905 : : }
13906 : 113957224 : break;
13907 : : }
13908 : 9600 : case BIT_XOR_EXPR:
13909 : 9600 : {
13910 : 9600 : tree _q20 = gimple_assign_rhs1 (_a1);
13911 : 9600 : _q20 = do_valueize (valueize, _q20);
13912 : 9600 : tree _q21 = gimple_assign_rhs2 (_a1);
13913 : 9600 : _q21 = do_valueize (valueize, _q21);
13914 : 9600 : if (tree_swap_operands_p (_q20, _q21))
13915 : 375 : std::swap (_q20, _q21);
13916 : 9600 : if (integer_zerop (_p1))
13917 : : {
13918 : 6370 : {
13919 : 6370 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
13920 : 6370 : if (gimple_simplify_266 (res_op, seq, valueize, type, captures, NE_EXPR))
13921 : 6370 : return true;
13922 : : }
13923 : : }
13924 : 3230 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
13925 : : {
13926 : 0 : {
13927 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
13928 : 0 : if (gimple_simplify_267 (res_op, seq, valueize, type, captures, NE_EXPR))
13929 : 0 : return true;
13930 : : }
13931 : : }
13932 : 3230 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
13933 : : {
13934 : 74 : {
13935 : 74 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
13936 : 74 : if (gimple_simplify_267 (res_op, seq, valueize, type, captures, NE_EXPR))
13937 : 74 : return true;
13938 : : }
13939 : : }
13940 : 113957224 : break;
13941 : : }
13942 : : default:;
13943 : : }
13944 : 12202288 : else if (gcall *_c1 = dyn_cast <gcall *> (_d1))
13945 : 7046336 : switch (gimple_call_combined_fn (_c1))
13946 : : {
13947 : 98 : case CFN_BUILT_IN_SQRTF:
13948 : 98 : if (gimple_call_num_args (_c1) == 1)
13949 : : {
13950 : 98 : tree _q20 = gimple_call_arg (_c1, 0);
13951 : 98 : _q20 = do_valueize (valueize, _q20);
13952 : 98 : switch (TREE_CODE (_p1))
13953 : : {
13954 : 86 : case SSA_NAME:
13955 : 86 : if (gimple *_d2 = get_def (valueize, _p1))
13956 : : {
13957 : 86 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
13958 : 86 : switch (gimple_call_combined_fn (_c2))
13959 : : {
13960 : 2 : case CFN_BUILT_IN_SQRTF:
13961 : 2 : if (gimple_call_num_args (_c2) == 1)
13962 : : {
13963 : 2 : tree _q40 = gimple_call_arg (_c2, 0);
13964 : 2 : _q40 = do_valueize (valueize, _q40);
13965 : 2 : {
13966 : 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
13967 : 2 : if (gimple_simplify_256 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_SQRTF, NE_EXPR))
13968 : 2 : return true;
13969 : : }
13970 : : }
13971 : : break;
13972 : : default:;
13973 : : }
13974 : : }
13975 : : break;
13976 : 12 : case REAL_CST:
13977 : 12 : {
13978 : 12 : {
13979 : 12 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
13980 : 12 : if (gimple_simplify_255 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_SQRTF, NE_EXPR))
13981 : 12 : return true;
13982 : : }
13983 : 0 : break;
13984 : : }
13985 : : default:;
13986 : : }
13987 : : }
13988 : : break;
13989 : 98 : case CFN_BUILT_IN_SQRTL:
13990 : 98 : if (gimple_call_num_args (_c1) == 1)
13991 : : {
13992 : 98 : tree _q20 = gimple_call_arg (_c1, 0);
13993 : 98 : _q20 = do_valueize (valueize, _q20);
13994 : 98 : switch (TREE_CODE (_p1))
13995 : : {
13996 : 86 : case SSA_NAME:
13997 : 86 : if (gimple *_d2 = get_def (valueize, _p1))
13998 : : {
13999 : 86 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
14000 : 86 : switch (gimple_call_combined_fn (_c2))
14001 : : {
14002 : 2 : case CFN_BUILT_IN_SQRTL:
14003 : 2 : if (gimple_call_num_args (_c2) == 1)
14004 : : {
14005 : 2 : tree _q40 = gimple_call_arg (_c2, 0);
14006 : 2 : _q40 = do_valueize (valueize, _q40);
14007 : 2 : {
14008 : 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
14009 : 2 : if (gimple_simplify_256 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_SQRTL, NE_EXPR))
14010 : 2 : return true;
14011 : : }
14012 : : }
14013 : : break;
14014 : : default:;
14015 : : }
14016 : : }
14017 : : break;
14018 : 12 : case REAL_CST:
14019 : 12 : {
14020 : 12 : {
14021 : 12 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
14022 : 12 : if (gimple_simplify_255 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_SQRTL, NE_EXPR))
14023 : 12 : return true;
14024 : : }
14025 : 0 : break;
14026 : : }
14027 : : default:;
14028 : : }
14029 : : }
14030 : : break;
14031 : 122 : case CFN_BUILT_IN_SQRT:
14032 : 122 : if (gimple_call_num_args (_c1) == 1)
14033 : : {
14034 : 122 : tree _q20 = gimple_call_arg (_c1, 0);
14035 : 122 : _q20 = do_valueize (valueize, _q20);
14036 : 122 : switch (TREE_CODE (_p1))
14037 : : {
14038 : 110 : case SSA_NAME:
14039 : 110 : if (gimple *_d2 = get_def (valueize, _p1))
14040 : : {
14041 : 110 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
14042 : 98 : switch (gimple_call_combined_fn (_c2))
14043 : : {
14044 : 12 : case CFN_BUILT_IN_SQRT:
14045 : 12 : if (gimple_call_num_args (_c2) == 1)
14046 : : {
14047 : 12 : tree _q40 = gimple_call_arg (_c2, 0);
14048 : 12 : _q40 = do_valueize (valueize, _q40);
14049 : 12 : {
14050 : 12 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
14051 : 12 : if (gimple_simplify_256 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_SQRT, NE_EXPR))
14052 : 4 : return true;
14053 : : }
14054 : : }
14055 : : break;
14056 : : default:;
14057 : : }
14058 : : }
14059 : : break;
14060 : 12 : case REAL_CST:
14061 : 12 : {
14062 : 12 : {
14063 : 12 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
14064 : 12 : if (gimple_simplify_255 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_SQRT, NE_EXPR))
14065 : 12 : return true;
14066 : : }
14067 : 0 : break;
14068 : : }
14069 : : default:;
14070 : : }
14071 : : }
14072 : : break;
14073 : 0 : case CFN_SQRT:
14074 : 0 : if (gimple_call_num_args (_c1) == 1)
14075 : : {
14076 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
14077 : 0 : _q20 = do_valueize (valueize, _q20);
14078 : 0 : switch (TREE_CODE (_p1))
14079 : : {
14080 : 0 : case SSA_NAME:
14081 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
14082 : : {
14083 : 0 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
14084 : 0 : switch (gimple_call_combined_fn (_c2))
14085 : : {
14086 : 0 : case CFN_SQRT:
14087 : 0 : if (gimple_call_num_args (_c2) == 1)
14088 : : {
14089 : 0 : tree _q40 = gimple_call_arg (_c2, 0);
14090 : 0 : _q40 = do_valueize (valueize, _q40);
14091 : 0 : {
14092 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
14093 : 0 : if (gimple_simplify_256 (res_op, seq, valueize, type, captures, CFN_SQRT, NE_EXPR))
14094 : 0 : return true;
14095 : : }
14096 : : }
14097 : : break;
14098 : : default:;
14099 : : }
14100 : : }
14101 : : break;
14102 : 0 : case REAL_CST:
14103 : 0 : {
14104 : 0 : {
14105 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
14106 : 0 : if (gimple_simplify_255 (res_op, seq, valueize, type, captures, CFN_SQRT, NE_EXPR))
14107 : 0 : return true;
14108 : : }
14109 : 0 : break;
14110 : : }
14111 : : default:;
14112 : : }
14113 : : }
14114 : : break;
14115 : : default:;
14116 : : }
14117 : : }
14118 : : break;
14119 : 608834 : case ADDR_EXPR:
14120 : 608834 : {
14121 : 608834 : switch (TREE_CODE (_p1))
14122 : : {
14123 : 516069 : case SSA_NAME:
14124 : 516069 : {
14125 : 516069 : {
14126 : 516069 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
14127 : 516069 : if (gimple_simplify_265 (res_op, seq, valueize, type, captures, NE_EXPR))
14128 : 55 : return true;
14129 : : }
14130 : 516014 : break;
14131 : : }
14132 : : default:;
14133 : : }
14134 : : break;
14135 : : }
14136 : 113957224 : default:;
14137 : : }
14138 : 113957224 : switch (TREE_CODE (_p1))
14139 : : {
14140 : 20514940 : case SSA_NAME:
14141 : 20514940 : if (gimple *_d1 = get_def (valueize, _p1))
14142 : : {
14143 : 6213949 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
14144 : 8896415 : switch (gimple_assign_rhs_code (_a1))
14145 : : {
14146 : 7991 : case BIT_XOR_EXPR:
14147 : 7991 : {
14148 : 7991 : tree _q30 = gimple_assign_rhs1 (_a1);
14149 : 7991 : _q30 = do_valueize (valueize, _q30);
14150 : 7991 : tree _q31 = gimple_assign_rhs2 (_a1);
14151 : 7991 : _q31 = do_valueize (valueize, _q31);
14152 : 7991 : if (tree_swap_operands_p (_q30, _q31))
14153 : 299 : std::swap (_q30, _q31);
14154 : 7991 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
14155 : : {
14156 : 2 : {
14157 : 2 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
14158 : 2 : if (gimple_simplify_267 (res_op, seq, valueize, type, captures, NE_EXPR))
14159 : 2 : return true;
14160 : : }
14161 : : }
14162 : 7989 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
14163 : : {
14164 : 14 : {
14165 : 14 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
14166 : 14 : if (gimple_simplify_267 (res_op, seq, valueize, type, captures, NE_EXPR))
14167 : 14 : return true;
14168 : : }
14169 : : }
14170 : 113957208 : break;
14171 : : }
14172 : : default:;
14173 : : }
14174 : : }
14175 : : break;
14176 : 113957208 : default:;
14177 : : }
14178 : 113957208 : switch (TREE_CODE (_p0))
14179 : : {
14180 : 110974574 : case SSA_NAME:
14181 : 110974574 : if (gimple *_d1 = get_def (valueize, _p0))
14182 : : {
14183 : 35469409 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
14184 : 39050084 : switch (gimple_assign_rhs_code (_a1))
14185 : : {
14186 : 2453311 : case BIT_AND_EXPR:
14187 : 2453311 : {
14188 : 2453311 : tree _q20 = gimple_assign_rhs1 (_a1);
14189 : 2453311 : _q20 = do_valueize (valueize, _q20);
14190 : 2453311 : tree _q21 = gimple_assign_rhs2 (_a1);
14191 : 2453311 : _q21 = do_valueize (valueize, _q21);
14192 : 2453311 : if (tree_swap_operands_p (_q20, _q21))
14193 : 55181 : std::swap (_q20, _q21);
14194 : 2453311 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
14195 : : {
14196 : 193 : {
14197 : 193 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
14198 : 193 : if (gimple_simplify_268 (res_op, seq, valueize, type, captures, NE_EXPR))
14199 : 95 : return true;
14200 : : }
14201 : : }
14202 : 2453216 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
14203 : : {
14204 : 11250 : {
14205 : 11250 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
14206 : 11250 : if (gimple_simplify_268 (res_op, seq, valueize, type, captures, NE_EXPR))
14207 : 4 : return true;
14208 : : }
14209 : : }
14210 : 113957109 : break;
14211 : : }
14212 : : default:;
14213 : : }
14214 : : }
14215 : : break;
14216 : 113957109 : default:;
14217 : : }
14218 : 113957109 : switch (TREE_CODE (_p1))
14219 : : {
14220 : 20514825 : case SSA_NAME:
14221 : 20514825 : if (gimple *_d1 = get_def (valueize, _p1))
14222 : : {
14223 : 6213834 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
14224 : 8896298 : switch (gimple_assign_rhs_code (_a1))
14225 : : {
14226 : 23290 : case BIT_AND_EXPR:
14227 : 23290 : {
14228 : 23290 : tree _q30 = gimple_assign_rhs1 (_a1);
14229 : 23290 : _q30 = do_valueize (valueize, _q30);
14230 : 23290 : tree _q31 = gimple_assign_rhs2 (_a1);
14231 : 23290 : _q31 = do_valueize (valueize, _q31);
14232 : 23290 : if (tree_swap_operands_p (_q30, _q31))
14233 : 233 : std::swap (_q30, _q31);
14234 : 23290 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
14235 : : {
14236 : 1174 : {
14237 : 1174 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
14238 : 1174 : if (gimple_simplify_268 (res_op, seq, valueize, type, captures, NE_EXPR))
14239 : 465 : return true;
14240 : : }
14241 : : }
14242 : 22825 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
14243 : : {
14244 : 126 : {
14245 : 126 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
14246 : 126 : if (gimple_simplify_268 (res_op, seq, valueize, type, captures, NE_EXPR))
14247 : 3 : return true;
14248 : : }
14249 : : }
14250 : 113956641 : break;
14251 : : }
14252 : : default:;
14253 : : }
14254 : : }
14255 : : break;
14256 : 113956641 : default:;
14257 : : }
14258 : 113956641 : switch (TREE_CODE (_p0))
14259 : : {
14260 : 110974007 : case SSA_NAME:
14261 : 110974007 : if (gimple *_d1 = get_def (valueize, _p0))
14262 : : {
14263 : 35468850 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
14264 : 39049593 : switch (gimple_assign_rhs_code (_a1))
14265 : : {
14266 : 1788252 : CASE_CONVERT:
14267 : 1788252 : {
14268 : 1788252 : tree _q20 = gimple_assign_rhs1 (_a1);
14269 : 1788252 : _q20 = do_valueize (valueize, _q20);
14270 : 1788252 : switch (TREE_CODE (_q20))
14271 : : {
14272 : 1773013 : case SSA_NAME:
14273 : 1773013 : if (gimple *_d2 = get_def (valueize, _q20))
14274 : : {
14275 : 1738992 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14276 : 2178270 : switch (gimple_assign_rhs_code (_a2))
14277 : : {
14278 : 10400 : case BIT_AND_EXPR:
14279 : 10400 : {
14280 : 10400 : tree _q30 = gimple_assign_rhs1 (_a2);
14281 : 10400 : _q30 = do_valueize (valueize, _q30);
14282 : 10400 : tree _q31 = gimple_assign_rhs2 (_a2);
14283 : 10400 : _q31 = do_valueize (valueize, _q31);
14284 : 10400 : if (tree_swap_operands_p (_q30, _q31))
14285 : 96 : std::swap (_q30, _q31);
14286 : 10400 : switch (TREE_CODE (_q30))
14287 : : {
14288 : 10400 : case SSA_NAME:
14289 : 10400 : if (gimple *_d3 = get_def (valueize, _q30))
14290 : : {
14291 : 10058 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
14292 : 14908 : switch (gimple_assign_rhs_code (_a3))
14293 : : {
14294 : 141 : CASE_CONVERT:
14295 : 141 : {
14296 : 141 : tree _q40 = gimple_assign_rhs1 (_a3);
14297 : 141 : _q40 = do_valueize (valueize, _q40);
14298 : 141 : switch (TREE_CODE (_q31))
14299 : : {
14300 : 71 : case INTEGER_CST:
14301 : 71 : {
14302 : 71 : switch (TREE_CODE (_p1))
14303 : : {
14304 : 1 : case SSA_NAME:
14305 : 1 : if (gimple *_d4 = get_def (valueize, _p1))
14306 : : {
14307 : 1 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
14308 : 2 : switch (gimple_assign_rhs_code (_a4))
14309 : : {
14310 : 0 : CASE_CONVERT:
14311 : 0 : {
14312 : 0 : tree _q70 = gimple_assign_rhs1 (_a4);
14313 : 0 : _q70 = do_valueize (valueize, _q70);
14314 : 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
14315 : : {
14316 : 0 : {
14317 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q40, _q31 };
14318 : 0 : if (gimple_simplify_269 (res_op, seq, valueize, type, captures, NE_EXPR))
14319 : 0 : return true;
14320 : : }
14321 : : }
14322 : : break;
14323 : : }
14324 : : default:;
14325 : : }
14326 : : }
14327 : : break;
14328 : : default:;
14329 : : }
14330 : : break;
14331 : : }
14332 : : default:;
14333 : : }
14334 : : break;
14335 : : }
14336 : : default:;
14337 : : }
14338 : : }
14339 : : break;
14340 : : default:;
14341 : : }
14342 : 1788252 : break;
14343 : : }
14344 : : default:;
14345 : : }
14346 : : }
14347 : : break;
14348 : 1788252 : default:;
14349 : : }
14350 : 1788252 : switch (TREE_CODE (_p1))
14351 : : {
14352 : 502969 : case SSA_NAME:
14353 : 502969 : if (gimple *_d2 = get_def (valueize, _p1))
14354 : : {
14355 : 452917 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14356 : 527007 : switch (gimple_assign_rhs_code (_a2))
14357 : : {
14358 : 62465 : CASE_CONVERT:
14359 : 62465 : {
14360 : 62465 : tree _q40 = gimple_assign_rhs1 (_a2);
14361 : 62465 : _q40 = do_valueize (valueize, _q40);
14362 : 62465 : switch (TREE_CODE (_q40))
14363 : : {
14364 : 59279 : case SSA_NAME:
14365 : 59279 : if (gimple *_d3 = get_def (valueize, _q40))
14366 : : {
14367 : 58593 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
14368 : 63906 : switch (gimple_assign_rhs_code (_a3))
14369 : : {
14370 : 318 : case BIT_AND_EXPR:
14371 : 318 : {
14372 : 318 : tree _q50 = gimple_assign_rhs1 (_a3);
14373 : 318 : _q50 = do_valueize (valueize, _q50);
14374 : 318 : tree _q51 = gimple_assign_rhs2 (_a3);
14375 : 318 : _q51 = do_valueize (valueize, _q51);
14376 : 318 : if (tree_swap_operands_p (_q50, _q51))
14377 : 2 : std::swap (_q50, _q51);
14378 : 318 : switch (TREE_CODE (_q50))
14379 : : {
14380 : 318 : case SSA_NAME:
14381 : 318 : if (gimple *_d4 = get_def (valueize, _q50))
14382 : : {
14383 : 312 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
14384 : 514 : switch (gimple_assign_rhs_code (_a4))
14385 : : {
14386 : 0 : CASE_CONVERT:
14387 : 0 : {
14388 : 0 : tree _q60 = gimple_assign_rhs1 (_a4);
14389 : 0 : _q60 = do_valueize (valueize, _q60);
14390 : 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
14391 : : {
14392 : 0 : switch (TREE_CODE (_q51))
14393 : : {
14394 : 0 : case INTEGER_CST:
14395 : 0 : {
14396 : 0 : {
14397 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q50, _q20, _q51 };
14398 : 0 : if (gimple_simplify_269 (res_op, seq, valueize, type, captures, NE_EXPR))
14399 : 0 : return true;
14400 : : }
14401 : 0 : break;
14402 : : }
14403 : : default:;
14404 : : }
14405 : : }
14406 : : break;
14407 : : }
14408 : : default:;
14409 : : }
14410 : : }
14411 : : break;
14412 : : default:;
14413 : : }
14414 : 113956586 : break;
14415 : : }
14416 : : default:;
14417 : : }
14418 : : }
14419 : : break;
14420 : : default:;
14421 : : }
14422 : : break;
14423 : : }
14424 : : default:;
14425 : : }
14426 : : }
14427 : : break;
14428 : : default:;
14429 : : }
14430 : : break;
14431 : : }
14432 : 862296 : case BIT_IOR_EXPR:
14433 : 862296 : {
14434 : 862296 : tree _q20 = gimple_assign_rhs1 (_a1);
14435 : 862296 : _q20 = do_valueize (valueize, _q20);
14436 : 862296 : tree _q21 = gimple_assign_rhs2 (_a1);
14437 : 862296 : _q21 = do_valueize (valueize, _q21);
14438 : 862296 : if (tree_swap_operands_p (_q20, _q21))
14439 : 55294 : std::swap (_q20, _q21);
14440 : 862296 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
14441 : : {
14442 : 250 : {
14443 : 250 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
14444 : 250 : if (gimple_simplify_270 (res_op, seq, valueize, type, captures, NE_EXPR))
14445 : 55 : return true;
14446 : : }
14447 : : }
14448 : 862241 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
14449 : : {
14450 : 78 : {
14451 : 78 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
14452 : 78 : if (gimple_simplify_270 (res_op, seq, valueize, type, captures, NE_EXPR))
14453 : 0 : return true;
14454 : : }
14455 : : }
14456 : 113956586 : break;
14457 : : }
14458 : : default:;
14459 : : }
14460 : : }
14461 : : break;
14462 : 113956586 : default:;
14463 : : }
14464 : 113956586 : switch (TREE_CODE (_p1))
14465 : : {
14466 : 20514357 : case SSA_NAME:
14467 : 20514357 : if (gimple *_d1 = get_def (valueize, _p1))
14468 : : {
14469 : 6213366 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
14470 : 8895830 : switch (gimple_assign_rhs_code (_a1))
14471 : : {
14472 : 6053 : case BIT_IOR_EXPR:
14473 : 6053 : {
14474 : 6053 : tree _q30 = gimple_assign_rhs1 (_a1);
14475 : 6053 : _q30 = do_valueize (valueize, _q30);
14476 : 6053 : tree _q31 = gimple_assign_rhs2 (_a1);
14477 : 6053 : _q31 = do_valueize (valueize, _q31);
14478 : 6053 : if (tree_swap_operands_p (_q30, _q31))
14479 : 205 : std::swap (_q30, _q31);
14480 : 6053 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
14481 : : {
14482 : 139 : {
14483 : 139 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
14484 : 139 : if (gimple_simplify_270 (res_op, seq, valueize, type, captures, NE_EXPR))
14485 : 0 : return true;
14486 : : }
14487 : : }
14488 : 6053 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
14489 : : {
14490 : 930 : {
14491 : 930 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _p0 };
14492 : 930 : if (gimple_simplify_270 (res_op, seq, valueize, type, captures, NE_EXPR))
14493 : 0 : return true;
14494 : : }
14495 : : }
14496 : 113956586 : break;
14497 : : }
14498 : : default:;
14499 : : }
14500 : : }
14501 : : break;
14502 : 113956586 : default:;
14503 : : }
14504 : 113956586 : switch (TREE_CODE (_p0))
14505 : : {
14506 : 110973952 : case SSA_NAME:
14507 : 110973952 : if (gimple *_d1 = get_def (valueize, _p0))
14508 : : {
14509 : 35468795 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
14510 : 39049538 : switch (gimple_assign_rhs_code (_a1))
14511 : : {
14512 : 1788252 : CASE_CONVERT:
14513 : 1788252 : {
14514 : 1788252 : tree _q20 = gimple_assign_rhs1 (_a1);
14515 : 1788252 : _q20 = do_valueize (valueize, _q20);
14516 : 1788252 : switch (TREE_CODE (_q20))
14517 : : {
14518 : 1773013 : case SSA_NAME:
14519 : 1773013 : if (gimple *_d2 = get_def (valueize, _q20))
14520 : : {
14521 : 1738992 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14522 : 2178270 : switch (gimple_assign_rhs_code (_a2))
14523 : : {
14524 : 1234 : case BIT_XOR_EXPR:
14525 : 1234 : {
14526 : 1234 : tree _q30 = gimple_assign_rhs1 (_a2);
14527 : 1234 : _q30 = do_valueize (valueize, _q30);
14528 : 1234 : tree _q31 = gimple_assign_rhs2 (_a2);
14529 : 1234 : _q31 = do_valueize (valueize, _q31);
14530 : 1234 : if (tree_swap_operands_p (_q30, _q31))
14531 : 13 : std::swap (_q30, _q31);
14532 : 1234 : switch (TREE_CODE (_q31))
14533 : : {
14534 : 967 : case INTEGER_CST:
14535 : 967 : {
14536 : 967 : switch (TREE_CODE (_p1))
14537 : : {
14538 : 963 : case INTEGER_CST:
14539 : 963 : {
14540 : 963 : {
14541 : 963 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _p1 };
14542 : 963 : if (gimple_simplify_271 (res_op, seq, valueize, type, captures, NE_EXPR))
14543 : 0 : return true;
14544 : : }
14545 : 963 : break;
14546 : : }
14547 : : default:;
14548 : : }
14549 : : break;
14550 : : }
14551 : : default:;
14552 : : }
14553 : 113956518 : break;
14554 : : }
14555 : : default:;
14556 : : }
14557 : : }
14558 : : break;
14559 : : default:;
14560 : : }
14561 : : break;
14562 : : }
14563 : 3156 : case BIT_XOR_EXPR:
14564 : 3156 : {
14565 : 3156 : tree _q20 = gimple_assign_rhs1 (_a1);
14566 : 3156 : _q20 = do_valueize (valueize, _q20);
14567 : 3156 : tree _q21 = gimple_assign_rhs2 (_a1);
14568 : 3156 : _q21 = do_valueize (valueize, _q21);
14569 : 3156 : if (tree_swap_operands_p (_q20, _q21))
14570 : 179 : std::swap (_q20, _q21);
14571 : 3156 : switch (TREE_CODE (_q21))
14572 : : {
14573 : 222 : case INTEGER_CST:
14574 : 222 : {
14575 : 222 : switch (TREE_CODE (_p1))
14576 : : {
14577 : 68 : case INTEGER_CST:
14578 : 68 : {
14579 : 68 : {
14580 : 68 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
14581 : 68 : if (gimple_simplify_271 (res_op, seq, valueize, type, captures, NE_EXPR))
14582 : 68 : return true;
14583 : : }
14584 : 0 : break;
14585 : : }
14586 : : default:;
14587 : : }
14588 : : break;
14589 : : }
14590 : : default:;
14591 : : }
14592 : 113956518 : break;
14593 : : }
14594 : : default:;
14595 : : }
14596 : : }
14597 : : break;
14598 : 113956518 : default:;
14599 : : }
14600 : 113956518 : {
14601 : 113956518 : tree _p0_pops[1];
14602 : 113956518 : if (gimple_nop_convert (_p0, _p0_pops, valueize))
14603 : : {
14604 : 335556 : tree _q20 = _p0_pops[0];
14605 : 335556 : if (integer_zerop (_p1))
14606 : : {
14607 : 147858 : {
14608 : 147858 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
14609 : 147858 : if (gimple_simplify_272 (res_op, seq, valueize, type, captures, NE_EXPR))
14610 : 121 : return true;
14611 : : }
14612 : : }
14613 : : }
14614 : : }
14615 : 113956397 : if (integer_zerop (_p1))
14616 : : {
14617 : 63674398 : {
14618 : 63674398 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
14619 : 63674398 : if (gimple_simplify_272 (res_op, seq, valueize, type, captures, NE_EXPR))
14620 : 19706 : return true;
14621 : : }
14622 : : }
14623 : 113936691 : switch (TREE_CODE (_p0))
14624 : : {
14625 : 110967518 : case SSA_NAME:
14626 : 110967518 : if (gimple *_d1 = get_def (valueize, _p0))
14627 : : {
14628 : 35464924 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
14629 : 39046847 : switch (gimple_assign_rhs_code (_a1))
14630 : : {
14631 : 2453211 : case BIT_AND_EXPR:
14632 : 2453211 : {
14633 : 2453211 : tree _q20 = gimple_assign_rhs1 (_a1);
14634 : 2453211 : _q20 = do_valueize (valueize, _q20);
14635 : 2453211 : tree _q21 = gimple_assign_rhs2 (_a1);
14636 : 2453211 : _q21 = do_valueize (valueize, _q21);
14637 : 2453211 : if (tree_swap_operands_p (_q20, _q21))
14638 : 55181 : std::swap (_q20, _q21);
14639 : 2453211 : switch (TREE_CODE (_p1))
14640 : : {
14641 : 38452 : case SSA_NAME:
14642 : 38452 : if (gimple *_d2 = get_def (valueize, _p1))
14643 : : {
14644 : 37572 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14645 : 47129 : switch (gimple_assign_rhs_code (_a2))
14646 : : {
14647 : 1575 : case BIT_AND_EXPR:
14648 : 1575 : {
14649 : 1575 : tree _q50 = gimple_assign_rhs1 (_a2);
14650 : 1575 : _q50 = do_valueize (valueize, _q50);
14651 : 1575 : tree _q51 = gimple_assign_rhs2 (_a2);
14652 : 1575 : _q51 = do_valueize (valueize, _q51);
14653 : 1575 : if (tree_swap_operands_p (_q50, _q51))
14654 : 38 : std::swap (_q50, _q51);
14655 : 1575 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
14656 : : {
14657 : 798 : {
14658 : 798 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
14659 : 798 : if (gimple_simplify_273 (res_op, seq, valueize, type, captures, NE_EXPR))
14660 : 40 : return true;
14661 : : }
14662 : : }
14663 : 1535 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
14664 : : {
14665 : 69 : {
14666 : 69 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
14667 : 69 : if (gimple_simplify_273 (res_op, seq, valueize, type, captures, NE_EXPR))
14668 : 0 : return true;
14669 : : }
14670 : : }
14671 : 1535 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
14672 : : {
14673 : 3 : {
14674 : 3 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q50 };
14675 : 3 : if (gimple_simplify_273 (res_op, seq, valueize, type, captures, NE_EXPR))
14676 : 0 : return true;
14677 : : }
14678 : : }
14679 : 1535 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
14680 : : {
14681 : 26 : {
14682 : 26 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q51 };
14683 : 26 : if (gimple_simplify_273 (res_op, seq, valueize, type, captures, NE_EXPR))
14684 : 0 : return true;
14685 : : }
14686 : : }
14687 : 2453171 : break;
14688 : : }
14689 : : default:;
14690 : : }
14691 : : }
14692 : : break;
14693 : 2453171 : default:;
14694 : : }
14695 : 2453171 : if (integer_pow2p (_q21))
14696 : : {
14697 : 750243 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
14698 : : {
14699 : 547 : {
14700 : 547 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
14701 : 547 : if (gimple_simplify_274 (res_op, seq, valueize, type, captures, NE_EXPR, EQ_EXPR))
14702 : 547 : return true;
14703 : : }
14704 : : }
14705 : : }
14706 : 113935736 : break;
14707 : : }
14708 : 5849 : case GE_EXPR:
14709 : 5849 : {
14710 : 5849 : tree _q20 = gimple_assign_rhs1 (_a1);
14711 : 5849 : _q20 = do_valueize (valueize, _q20);
14712 : 5849 : tree _q21 = gimple_assign_rhs2 (_a1);
14713 : 5849 : _q21 = do_valueize (valueize, _q21);
14714 : 5849 : if (integer_zerop (_q21))
14715 : : {
14716 : 1127 : switch (TREE_CODE (_p1))
14717 : : {
14718 : 4 : case SSA_NAME:
14719 : 4 : if (gimple *_d2 = get_def (valueize, _p1))
14720 : : {
14721 : 4 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14722 : 4 : switch (gimple_assign_rhs_code (_a2))
14723 : : {
14724 : 2 : case GE_EXPR:
14725 : 2 : {
14726 : 2 : tree _q50 = gimple_assign_rhs1 (_a2);
14727 : 2 : _q50 = do_valueize (valueize, _q50);
14728 : 2 : tree _q51 = gimple_assign_rhs2 (_a2);
14729 : 2 : _q51 = do_valueize (valueize, _q51);
14730 : 2 : if (integer_zerop (_q51))
14731 : : {
14732 : 2 : {
14733 : 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
14734 : 2 : if (gimple_simplify_275 (res_op, seq, valueize, type, captures, GE_EXPR, NE_EXPR, LT_EXPR))
14735 : 1 : return true;
14736 : : }
14737 : : }
14738 : : break;
14739 : : }
14740 : 2 : case LT_EXPR:
14741 : 2 : {
14742 : 2 : tree _q50 = gimple_assign_rhs1 (_a2);
14743 : 2 : _q50 = do_valueize (valueize, _q50);
14744 : 2 : tree _q51 = gimple_assign_rhs2 (_a2);
14745 : 2 : _q51 = do_valueize (valueize, _q51);
14746 : 2 : if (integer_zerop (_q51))
14747 : : {
14748 : 2 : {
14749 : 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
14750 : 2 : if (gimple_simplify_276 (res_op, seq, valueize, type, captures, NE_EXPR, GE_EXPR))
14751 : 1 : return true;
14752 : : }
14753 : : }
14754 : : break;
14755 : : }
14756 : : default:;
14757 : : }
14758 : : }
14759 : : break;
14760 : : default:;
14761 : : }
14762 : : }
14763 : : break;
14764 : : }
14765 : 27232 : case LT_EXPR:
14766 : 27232 : {
14767 : 27232 : tree _q20 = gimple_assign_rhs1 (_a1);
14768 : 27232 : _q20 = do_valueize (valueize, _q20);
14769 : 27232 : tree _q21 = gimple_assign_rhs2 (_a1);
14770 : 27232 : _q21 = do_valueize (valueize, _q21);
14771 : 27232 : if (integer_zerop (_q21))
14772 : : {
14773 : 20345 : switch (TREE_CODE (_p1))
14774 : : {
14775 : 245 : case SSA_NAME:
14776 : 245 : if (gimple *_d2 = get_def (valueize, _p1))
14777 : : {
14778 : 239 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14779 : 105 : switch (gimple_assign_rhs_code (_a2))
14780 : : {
14781 : 46 : case LT_EXPR:
14782 : 46 : {
14783 : 46 : tree _q50 = gimple_assign_rhs1 (_a2);
14784 : 46 : _q50 = do_valueize (valueize, _q50);
14785 : 46 : tree _q51 = gimple_assign_rhs2 (_a2);
14786 : 46 : _q51 = do_valueize (valueize, _q51);
14787 : 46 : if (integer_zerop (_q51))
14788 : : {
14789 : 46 : {
14790 : 46 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
14791 : 46 : if (gimple_simplify_275 (res_op, seq, valueize, type, captures, LT_EXPR, NE_EXPR, LT_EXPR))
14792 : 19 : return true;
14793 : : }
14794 : : }
14795 : : break;
14796 : : }
14797 : 56 : case GE_EXPR:
14798 : 56 : {
14799 : 56 : tree _q50 = gimple_assign_rhs1 (_a2);
14800 : 56 : _q50 = do_valueize (valueize, _q50);
14801 : 56 : tree _q51 = gimple_assign_rhs2 (_a2);
14802 : 56 : _q51 = do_valueize (valueize, _q51);
14803 : 56 : if (integer_zerop (_q51))
14804 : : {
14805 : 56 : {
14806 : 56 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
14807 : 56 : if (gimple_simplify_277 (res_op, seq, valueize, type, captures, NE_EXPR, GE_EXPR))
14808 : 3 : return true;
14809 : : }
14810 : : }
14811 : : break;
14812 : : }
14813 : : default:;
14814 : : }
14815 : : }
14816 : : break;
14817 : : default:;
14818 : : }
14819 : : }
14820 : : break;
14821 : : }
14822 : 9271 : case COND_EXPR:
14823 : 9271 : {
14824 : 9271 : tree _q20 = gimple_assign_rhs1 (_a1);
14825 : 9271 : _q20 = do_valueize (valueize, _q20);
14826 : 9271 : tree _q21 = gimple_assign_rhs2 (_a1);
14827 : 9271 : _q21 = do_valueize (valueize, _q21);
14828 : 9271 : tree _q22 = gimple_assign_rhs3 (_a1);
14829 : 9271 : _q22 = do_valueize (valueize, _q22);
14830 : 9271 : {
14831 : 9271 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _p1 };
14832 : 9271 : if (gimple_simplify_278 (res_op, seq, valueize, type, captures, NE_EXPR))
14833 : 344 : return true;
14834 : : }
14835 : 8927 : break;
14836 : : }
14837 : : default:;
14838 : : }
14839 : : }
14840 : : break;
14841 : 113935736 : default:;
14842 : : }
14843 : 113935736 : switch (TREE_CODE (_p1))
14844 : : {
14845 : 20514293 : case SSA_NAME:
14846 : 20514293 : if (gimple *_d1 = get_def (valueize, _p1))
14847 : : {
14848 : 6213302 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
14849 : 8895766 : switch (gimple_assign_rhs_code (_a1))
14850 : : {
14851 : 3525 : case COND_EXPR:
14852 : 3525 : {
14853 : 3525 : tree _q30 = gimple_assign_rhs1 (_a1);
14854 : 3525 : _q30 = do_valueize (valueize, _q30);
14855 : 3525 : tree _q31 = gimple_assign_rhs2 (_a1);
14856 : 3525 : _q31 = do_valueize (valueize, _q31);
14857 : 3525 : tree _q32 = gimple_assign_rhs3 (_a1);
14858 : 3525 : _q32 = do_valueize (valueize, _q32);
14859 : 3525 : {
14860 : 3525 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q32, _p0 };
14861 : 3525 : if (gimple_simplify_278 (res_op, seq, valueize, type, captures, NE_EXPR))
14862 : 0 : return true;
14863 : : }
14864 : 3525 : break;
14865 : : }
14866 : : default:;
14867 : : }
14868 : : }
14869 : : break;
14870 : 113935736 : default:;
14871 : : }
14872 : 113935736 : switch (TREE_CODE (_p0))
14873 : : {
14874 : 110966563 : case SSA_NAME:
14875 : 110966563 : if (gimple *_d1 = get_def (valueize, _p0))
14876 : : {
14877 : 35463969 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
14878 : 39045892 : switch (gimple_assign_rhs_code (_a1))
14879 : : {
14880 : 2452624 : case BIT_AND_EXPR:
14881 : 2452624 : {
14882 : 2452624 : tree _q20 = gimple_assign_rhs1 (_a1);
14883 : 2452624 : _q20 = do_valueize (valueize, _q20);
14884 : 2452624 : tree _q21 = gimple_assign_rhs2 (_a1);
14885 : 2452624 : _q21 = do_valueize (valueize, _q21);
14886 : 2452624 : if (tree_swap_operands_p (_q20, _q21))
14887 : 55181 : std::swap (_q20, _q21);
14888 : 2452624 : switch (TREE_CODE (_q20))
14889 : : {
14890 : 2452624 : case SSA_NAME:
14891 : 2452624 : if (gimple *_d2 = get_def (valueize, _q20))
14892 : : {
14893 : 2382200 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14894 : 2752715 : switch (gimple_assign_rhs_code (_a2))
14895 : : {
14896 : 97260 : CASE_CONVERT:
14897 : 97260 : {
14898 : 97260 : tree _q30 = gimple_assign_rhs1 (_a2);
14899 : 97260 : _q30 = do_valueize (valueize, _q30);
14900 : 97260 : if (integer_pow2p (_q21))
14901 : : {
14902 : 22495 : if (integer_zerop (_p1))
14903 : : {
14904 : 22345 : {
14905 : 22345 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q21 };
14906 : 22345 : if (gimple_simplify_279 (res_op, seq, valueize, type, captures, NE_EXPR, LT_EXPR))
14907 : 18 : return true;
14908 : : }
14909 : : }
14910 : : }
14911 : : break;
14912 : : }
14913 : : default:;
14914 : : }
14915 : : }
14916 : : break;
14917 : 2452606 : default:;
14918 : : }
14919 : 2452606 : if (integer_pow2p (_q21))
14920 : : {
14921 : 749678 : if (integer_zerop (_p1))
14922 : : {
14923 : 743905 : {
14924 : 743905 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q20, _q21 };
14925 : 743905 : if (gimple_simplify_280 (res_op, seq, valueize, type, captures, NE_EXPR, LT_EXPR))
14926 : 1176 : return true;
14927 : : }
14928 : : }
14929 : : }
14930 : 113901214 : break;
14931 : : }
14932 : 1787872 : CASE_CONVERT:
14933 : 1787872 : {
14934 : 1787872 : tree _q20 = gimple_assign_rhs1 (_a1);
14935 : 1787872 : _q20 = do_valueize (valueize, _q20);
14936 : 1787872 : switch (TREE_CODE (_q20))
14937 : : {
14938 : 1772652 : case SSA_NAME:
14939 : 1772652 : if (gimple *_d2 = get_def (valueize, _q20))
14940 : : {
14941 : 1738631 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14942 : 2177838 : switch (gimple_assign_rhs_code (_a2))
14943 : : {
14944 : 159 : case ADDR_EXPR:
14945 : 159 : {
14946 : 159 : switch (TREE_CODE (_p1))
14947 : : {
14948 : 159 : case SSA_NAME:
14949 : 159 : if (gimple *_d3 = get_def (valueize, _p1))
14950 : : {
14951 : 159 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
14952 : 303 : switch (gimple_assign_rhs_code (_a3))
14953 : : {
14954 : 15 : CASE_CONVERT:
14955 : 15 : {
14956 : 15 : tree _q40 = gimple_assign_rhs1 (_a3);
14957 : 15 : _q40 = do_valueize (valueize, _q40);
14958 : 15 : switch (TREE_CODE (_q40))
14959 : : {
14960 : 15 : case SSA_NAME:
14961 : 15 : if (gimple *_d4 = get_def (valueize, _q40))
14962 : : {
14963 : 15 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
14964 : 30 : switch (gimple_assign_rhs_code (_a4))
14965 : : {
14966 : 15 : case ADDR_EXPR:
14967 : 15 : {
14968 : 15 : {
14969 : 15 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
14970 : 15 : if (gimple_simplify_281 (res_op, seq, valueize, type, captures, NE_EXPR))
14971 : 0 : return true;
14972 : : }
14973 : 15 : break;
14974 : : }
14975 : : default:;
14976 : : }
14977 : : }
14978 : : break;
14979 : 0 : case ADDR_EXPR:
14980 : 0 : {
14981 : 0 : {
14982 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
14983 : 0 : if (gimple_simplify_281 (res_op, seq, valueize, type, captures, NE_EXPR))
14984 : 0 : return true;
14985 : : }
14986 : 0 : break;
14987 : : }
14988 : : default:;
14989 : : }
14990 : : break;
14991 : : }
14992 : 0 : case ADDR_EXPR:
14993 : 0 : {
14994 : 0 : {
14995 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
14996 : 0 : if (gimple_simplify_281 (res_op, seq, valueize, type, captures, NE_EXPR))
14997 : 0 : return true;
14998 : : }
14999 : 0 : break;
15000 : : }
15001 : : default:;
15002 : : }
15003 : : }
15004 : : break;
15005 : 0 : case ADDR_EXPR:
15006 : 0 : {
15007 : 0 : {
15008 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
15009 : 0 : if (gimple_simplify_281 (res_op, seq, valueize, type, captures, NE_EXPR))
15010 : 0 : return true;
15011 : : }
15012 : 0 : break;
15013 : : }
15014 : : default:;
15015 : : }
15016 : : break;
15017 : : }
15018 : : default:;
15019 : : }
15020 : : }
15021 : : break;
15022 : 14728 : case ADDR_EXPR:
15023 : 14728 : {
15024 : 14728 : switch (TREE_CODE (_p1))
15025 : : {
15026 : 14728 : case SSA_NAME:
15027 : 14728 : if (gimple *_d2 = get_def (valueize, _p1))
15028 : : {
15029 : 14371 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
15030 : 22380 : switch (gimple_assign_rhs_code (_a2))
15031 : : {
15032 : 613 : CASE_CONVERT:
15033 : 613 : {
15034 : 613 : tree _q40 = gimple_assign_rhs1 (_a2);
15035 : 613 : _q40 = do_valueize (valueize, _q40);
15036 : 613 : switch (TREE_CODE (_q40))
15037 : : {
15038 : 434 : case SSA_NAME:
15039 : 434 : if (gimple *_d3 = get_def (valueize, _q40))
15040 : : {
15041 : 382 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
15042 : 752 : switch (gimple_assign_rhs_code (_a3))
15043 : : {
15044 : 0 : case ADDR_EXPR:
15045 : 0 : {
15046 : 0 : {
15047 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
15048 : 0 : if (gimple_simplify_281 (res_op, seq, valueize, type, captures, NE_EXPR))
15049 : 0 : return true;
15050 : : }
15051 : 0 : break;
15052 : : }
15053 : : default:;
15054 : : }
15055 : : }
15056 : : break;
15057 : 179 : case ADDR_EXPR:
15058 : 179 : {
15059 : 179 : {
15060 : 179 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
15061 : 179 : if (gimple_simplify_281 (res_op, seq, valueize, type, captures, NE_EXPR))
15062 : 104 : return true;
15063 : : }
15064 : 75 : break;
15065 : : }
15066 : : default:;
15067 : : }
15068 : : break;
15069 : : }
15070 : 0 : case ADDR_EXPR:
15071 : 0 : {
15072 : 0 : {
15073 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
15074 : 0 : if (gimple_simplify_281 (res_op, seq, valueize, type, captures, NE_EXPR))
15075 : 0 : return true;
15076 : : }
15077 : 0 : break;
15078 : : }
15079 : : default:;
15080 : : }
15081 : : }
15082 : : break;
15083 : 0 : case ADDR_EXPR:
15084 : 0 : {
15085 : 0 : {
15086 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
15087 : 0 : if (gimple_simplify_281 (res_op, seq, valueize, type, captures, NE_EXPR))
15088 : 0 : return true;
15089 : : }
15090 : 0 : break;
15091 : : }
15092 : : default:;
15093 : : }
15094 : : break;
15095 : : }
15096 : : default:;
15097 : : }
15098 : : break;
15099 : : }
15100 : 29414 : case ADDR_EXPR:
15101 : 29414 : {
15102 : 29414 : switch (TREE_CODE (_p1))
15103 : : {
15104 : 21526 : case SSA_NAME:
15105 : 21526 : if (gimple *_d2 = get_def (valueize, _p1))
15106 : : {
15107 : 20517 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
15108 : 26886 : switch (gimple_assign_rhs_code (_a2))
15109 : : {
15110 : 77 : CASE_CONVERT:
15111 : 77 : {
15112 : 77 : tree _q30 = gimple_assign_rhs1 (_a2);
15113 : 77 : _q30 = do_valueize (valueize, _q30);
15114 : 77 : switch (TREE_CODE (_q30))
15115 : : {
15116 : 77 : case SSA_NAME:
15117 : 77 : if (gimple *_d3 = get_def (valueize, _q30))
15118 : : {
15119 : 77 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
15120 : 20 : switch (gimple_assign_rhs_code (_a3))
15121 : : {
15122 : 0 : case ADDR_EXPR:
15123 : 0 : {
15124 : 0 : {
15125 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q30 };
15126 : 0 : if (gimple_simplify_282 (res_op, seq, valueize, type, captures, NE_EXPR))
15127 : 0 : return true;
15128 : : }
15129 : 0 : break;
15130 : : }
15131 : : default:;
15132 : : }
15133 : : }
15134 : : break;
15135 : 0 : case ADDR_EXPR:
15136 : 0 : {
15137 : 0 : {
15138 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q30 };
15139 : 0 : if (gimple_simplify_282 (res_op, seq, valueize, type, captures, NE_EXPR))
15140 : 0 : return true;
15141 : : }
15142 : 0 : break;
15143 : : }
15144 : : default:;
15145 : : }
15146 : : break;
15147 : : }
15148 : 2229 : case ADDR_EXPR:
15149 : 2229 : {
15150 : 2229 : {
15151 : 2229 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
15152 : 2229 : if (gimple_simplify_282 (res_op, seq, valueize, type, captures, NE_EXPR))
15153 : 32 : return true;
15154 : : }
15155 : 2197 : break;
15156 : : }
15157 : : default:;
15158 : : }
15159 : : }
15160 : : break;
15161 : 1000 : case ADDR_EXPR:
15162 : 1000 : {
15163 : 1000 : {
15164 : 1000 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
15165 : 1000 : if (gimple_simplify_282 (res_op, seq, valueize, type, captures, NE_EXPR))
15166 : 74 : return true;
15167 : : }
15168 : 926 : break;
15169 : : }
15170 : : default:;
15171 : : }
15172 : : break;
15173 : : }
15174 : : default:;
15175 : : }
15176 : : }
15177 : : break;
15178 : 595318 : case ADDR_EXPR:
15179 : 595318 : {
15180 : 595318 : switch (TREE_CODE (_p1))
15181 : : {
15182 : 516014 : case SSA_NAME:
15183 : 516014 : if (gimple *_d1 = get_def (valueize, _p1))
15184 : : {
15185 : 160184 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
15186 : 187450 : switch (gimple_assign_rhs_code (_a1))
15187 : : {
15188 : 19384 : CASE_CONVERT:
15189 : 19384 : {
15190 : 19384 : tree _q30 = gimple_assign_rhs1 (_a1);
15191 : 19384 : _q30 = do_valueize (valueize, _q30);
15192 : 19384 : switch (TREE_CODE (_q30))
15193 : : {
15194 : 19384 : case SSA_NAME:
15195 : 19384 : if (gimple *_d2 = get_def (valueize, _q30))
15196 : : {
15197 : 19361 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
15198 : 1282 : switch (gimple_assign_rhs_code (_a2))
15199 : : {
15200 : 0 : case ADDR_EXPR:
15201 : 0 : {
15202 : 0 : {
15203 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q30 };
15204 : 0 : if (gimple_simplify_282 (res_op, seq, valueize, type, captures, NE_EXPR))
15205 : 0 : return true;
15206 : : }
15207 : 0 : break;
15208 : : }
15209 : : default:;
15210 : : }
15211 : : }
15212 : : break;
15213 : 0 : case ADDR_EXPR:
15214 : 0 : {
15215 : 0 : {
15216 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q30 };
15217 : 0 : if (gimple_simplify_282 (res_op, seq, valueize, type, captures, NE_EXPR))
15218 : 0 : return true;
15219 : : }
15220 : 0 : break;
15221 : : }
15222 : : default:;
15223 : : }
15224 : : break;
15225 : : }
15226 : 866 : case ADDR_EXPR:
15227 : 866 : {
15228 : 866 : {
15229 : 866 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
15230 : 866 : if (gimple_simplify_282 (res_op, seq, valueize, type, captures, NE_EXPR))
15231 : 44 : return true;
15232 : : }
15233 : 822 : break;
15234 : : }
15235 : : default:;
15236 : : }
15237 : : }
15238 : : break;
15239 : 37298 : case ADDR_EXPR:
15240 : 37298 : {
15241 : 37298 : {
15242 : 37298 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
15243 : 37298 : if (gimple_simplify_282 (res_op, seq, valueize, type, captures, NE_EXPR))
15244 : 33074 : return true;
15245 : : }
15246 : 4224 : break;
15247 : : }
15248 : : default:;
15249 : : }
15250 : : break;
15251 : : }
15252 : 113901214 : default:;
15253 : : }
15254 : 113901214 : {
15255 : 113901214 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
15256 : 113901214 : if (gimple_simplify_283 (res_op, seq, valueize, type, captures, NE_EXPR))
15257 : 773 : return true;
15258 : : }
15259 : 113900441 : switch (TREE_CODE (_p0))
15260 : : {
15261 : 110965159 : case SSA_NAME:
15262 : 110965159 : if (gimple *_d1 = get_def (valueize, _p0))
15263 : : {
15264 : 35462565 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
15265 : 39044382 : switch (gimple_assign_rhs_code (_a1))
15266 : : {
15267 : 1787768 : CASE_CONVERT:
15268 : 1787768 : {
15269 : 1787768 : tree _q20 = gimple_assign_rhs1 (_a1);
15270 : 1787768 : _q20 = do_valueize (valueize, _q20);
15271 : 1787768 : switch (TREE_CODE (_p1))
15272 : : {
15273 : 1264767 : case INTEGER_CST:
15274 : 1264767 : {
15275 : 1264767 : {
15276 : 1264767 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
15277 : 1264767 : if (gimple_simplify_284 (res_op, seq, valueize, type, captures, NE_EXPR))
15278 : 24238 : return true;
15279 : : }
15280 : 1240529 : break;
15281 : : }
15282 : 1763530 : default:;
15283 : : }
15284 : 1763530 : switch (TREE_CODE (_q20))
15285 : : {
15286 : 1748414 : case SSA_NAME:
15287 : 1748414 : if (gimple *_d2 = get_def (valueize, _q20))
15288 : : {
15289 : 1715732 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
15290 : 2138158 : switch (gimple_assign_rhs_code (_a2))
15291 : : {
15292 : 31135 : case NE_EXPR:
15293 : 31135 : {
15294 : 31135 : tree _q30 = gimple_assign_rhs1 (_a2);
15295 : 31135 : _q30 = do_valueize (valueize, _q30);
15296 : 31135 : tree _q31 = gimple_assign_rhs2 (_a2);
15297 : 31135 : _q31 = do_valueize (valueize, _q31);
15298 : 31135 : if (tree_swap_operands_p (_q30, _q31))
15299 : 1286 : std::swap (_q30, _q31);
15300 : 31135 : switch (TREE_CODE (_q31))
15301 : : {
15302 : 13640 : case INTEGER_CST:
15303 : 13640 : {
15304 : 13640 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
15305 : : {
15306 : 43 : {
15307 : 43 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
15308 : 43 : if (gimple_simplify_285 (res_op, seq, valueize, type, captures, NE_EXPR, NE_EXPR))
15309 : 34 : return true;
15310 : : }
15311 : : }
15312 : : break;
15313 : : }
15314 : : default:;
15315 : : }
15316 : 113876124 : break;
15317 : : }
15318 : 27877 : case EQ_EXPR:
15319 : 27877 : {
15320 : 27877 : tree _q30 = gimple_assign_rhs1 (_a2);
15321 : 27877 : _q30 = do_valueize (valueize, _q30);
15322 : 27877 : tree _q31 = gimple_assign_rhs2 (_a2);
15323 : 27877 : _q31 = do_valueize (valueize, _q31);
15324 : 27877 : if (tree_swap_operands_p (_q30, _q31))
15325 : 10 : std::swap (_q30, _q31);
15326 : 27877 : switch (TREE_CODE (_q31))
15327 : : {
15328 : 22077 : case INTEGER_CST:
15329 : 22077 : {
15330 : 22077 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
15331 : : {
15332 : 52 : {
15333 : 52 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
15334 : 52 : if (gimple_simplify_285 (res_op, seq, valueize, type, captures, EQ_EXPR, NE_EXPR))
15335 : 45 : return true;
15336 : : }
15337 : : }
15338 : : break;
15339 : : }
15340 : : default:;
15341 : : }
15342 : 113876124 : break;
15343 : : }
15344 : : default:;
15345 : : }
15346 : : }
15347 : : break;
15348 : : default:;
15349 : : }
15350 : : break;
15351 : : }
15352 : : default:;
15353 : : }
15354 : : }
15355 : : break;
15356 : 113876124 : default:;
15357 : : }
15358 : 113876124 : switch (TREE_CODE (_p1))
15359 : : {
15360 : 20513261 : case SSA_NAME:
15361 : 20513261 : if (gimple *_d1 = get_def (valueize, _p1))
15362 : : {
15363 : 6212857 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
15364 : 8895230 : switch (gimple_assign_rhs_code (_a1))
15365 : : {
15366 : 329409 : CASE_CONVERT:
15367 : 329409 : {
15368 : 329409 : tree _q30 = gimple_assign_rhs1 (_a1);
15369 : 329409 : _q30 = do_valueize (valueize, _q30);
15370 : 329409 : switch (TREE_CODE (_q30))
15371 : : {
15372 : 320351 : case SSA_NAME:
15373 : 320351 : if (gimple *_d2 = get_def (valueize, _q30))
15374 : : {
15375 : 301376 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
15376 : 317482 : switch (gimple_assign_rhs_code (_a2))
15377 : : {
15378 : 953 : case NE_EXPR:
15379 : 953 : {
15380 : 953 : tree _q40 = gimple_assign_rhs1 (_a2);
15381 : 953 : _q40 = do_valueize (valueize, _q40);
15382 : 953 : tree _q41 = gimple_assign_rhs2 (_a2);
15383 : 953 : _q41 = do_valueize (valueize, _q41);
15384 : 953 : if (tree_swap_operands_p (_q40, _q41))
15385 : 0 : std::swap (_q40, _q41);
15386 : 953 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
15387 : : {
15388 : 0 : switch (TREE_CODE (_q41))
15389 : : {
15390 : 0 : case INTEGER_CST:
15391 : 0 : {
15392 : 0 : {
15393 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
15394 : 0 : if (gimple_simplify_285 (res_op, seq, valueize, type, captures, NE_EXPR, NE_EXPR))
15395 : 0 : return true;
15396 : : }
15397 : 0 : break;
15398 : : }
15399 : : default:;
15400 : : }
15401 : : }
15402 : 113876117 : break;
15403 : : }
15404 : 1828 : case EQ_EXPR:
15405 : 1828 : {
15406 : 1828 : tree _q40 = gimple_assign_rhs1 (_a2);
15407 : 1828 : _q40 = do_valueize (valueize, _q40);
15408 : 1828 : tree _q41 = gimple_assign_rhs2 (_a2);
15409 : 1828 : _q41 = do_valueize (valueize, _q41);
15410 : 1828 : if (tree_swap_operands_p (_q40, _q41))
15411 : 0 : std::swap (_q40, _q41);
15412 : 1828 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
15413 : : {
15414 : 7 : switch (TREE_CODE (_q41))
15415 : : {
15416 : 7 : case INTEGER_CST:
15417 : 7 : {
15418 : 7 : {
15419 : 7 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
15420 : 7 : if (gimple_simplify_285 (res_op, seq, valueize, type, captures, EQ_EXPR, NE_EXPR))
15421 : 7 : return true;
15422 : : }
15423 : 0 : break;
15424 : : }
15425 : : default:;
15426 : : }
15427 : : }
15428 : 113876117 : break;
15429 : : }
15430 : : default:;
15431 : : }
15432 : : }
15433 : : break;
15434 : : default:;
15435 : : }
15436 : : break;
15437 : : }
15438 : : default:;
15439 : : }
15440 : : }
15441 : : break;
15442 : 113876117 : default:;
15443 : : }
15444 : 113876117 : if (integer_zerop (_p1))
15445 : : {
15446 : 63629270 : {
15447 : 63629270 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
15448 : 63629270 : if (TREE_CODE (TREE_TYPE (captures[0])) == BOOLEAN_TYPE
15449 : 63629270 : && types_match (type, TREE_TYPE (captures[0]))
15450 : : )
15451 : : {
15452 : 23764282 : gimple_seq *lseq = seq;
15453 : 23764282 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1852;
15454 : 23764282 : {
15455 : 23764282 : tree tem;
15456 : 23764282 : tem = captures[0];
15457 : 23764282 : res_op->set_value (tem);
15458 : 23764282 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1014, __FILE__, __LINE__, true);
15459 : 23764282 : return true;
15460 : : }
15461 : 0 : next_after_fail1852:;
15462 : : }
15463 : : }
15464 : : }
15465 : 90111835 : switch (TREE_CODE (_p0))
15466 : : {
15467 : 88400757 : case SSA_NAME:
15468 : 88400757 : if (gimple *_d1 = get_def (valueize, _p0))
15469 : : {
15470 : 28290925 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
15471 : 34025056 : switch (gimple_assign_rhs_code (_a1))
15472 : : {
15473 : 1300854 : case BIT_AND_EXPR:
15474 : 1300854 : {
15475 : 1300854 : tree _q20 = gimple_assign_rhs1 (_a1);
15476 : 1300854 : _q20 = do_valueize (valueize, _q20);
15477 : 1300854 : tree _q21 = gimple_assign_rhs2 (_a1);
15478 : 1300854 : _q21 = do_valueize (valueize, _q21);
15479 : 1300854 : if (tree_swap_operands_p (_q20, _q21))
15480 : 15322 : std::swap (_q20, _q21);
15481 : 1300854 : switch (TREE_CODE (_q21))
15482 : : {
15483 : 3855 : case VECTOR_CST:
15484 : 3855 : {
15485 : 3855 : if (integer_zerop (_p1))
15486 : : {
15487 : 3855 : {
15488 : 3855 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
15489 : 3855 : const enum tree_code cmp = NE_EXPR;
15490 : 3855 : const enum tree_code icmp = GT_EXPR;
15491 : 3855 : {
15492 : 3855 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
15493 : 3855 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
15494 : : )
15495 : : {
15496 : 9 : {
15497 : 9 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
15498 : 9 : ? optab_vector : optab_default;
15499 : 9 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
15500 : 9 : if (target_supports_op_p (utype, icmp, optab)
15501 : 9 : || (optimize_vectors_before_lowering_p ()
15502 : 0 : && (!target_supports_op_p (type, cmp, optab)
15503 : 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
15504 : : )
15505 : : {
15506 : 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
15507 : : )
15508 : : {
15509 : 0 : gimple_seq *lseq = seq;
15510 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1853;
15511 : 0 : {
15512 : 0 : res_op->set_op (icmp, type, 2);
15513 : 0 : res_op->ops[0] = captures[1];
15514 : 0 : res_op->ops[1] = csts;
15515 : 0 : res_op->resimplify (lseq, valueize);
15516 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1011, __FILE__, __LINE__, true);
15517 : 0 : return true;
15518 : : }
15519 : 0 : next_after_fail1853:;
15520 : : }
15521 : : else
15522 : : {
15523 : 0 : gimple_seq *lseq = seq;
15524 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1854;
15525 : 0 : {
15526 : 0 : res_op->set_op (icmp, type, 2);
15527 : 0 : {
15528 : 0 : tree _o1[1], _r1;
15529 : 0 : _o1[0] = captures[1];
15530 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, utype, _o1[0]);
15531 : 0 : tem_op.resimplify (lseq, valueize);
15532 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
15533 : 0 : if (!_r1) goto next_after_fail1854;
15534 : 0 : res_op->ops[0] = _r1;
15535 : : }
15536 : 0 : res_op->ops[1] = csts;
15537 : 0 : res_op->resimplify (lseq, valueize);
15538 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1012, __FILE__, __LINE__, true);
15539 : 0 : return true;
15540 : : }
15541 : 3855 : next_after_fail1854:;
15542 : : }
15543 : : }
15544 : : }
15545 : : }
15546 : : }
15547 : : }
15548 : : }
15549 : : break;
15550 : : }
15551 : 1097424 : case INTEGER_CST:
15552 : 1097424 : {
15553 : 1097424 : if (integer_zerop (_p1))
15554 : : {
15555 : 1000555 : {
15556 : 1000555 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
15557 : 1000555 : const enum tree_code cmp = NE_EXPR;
15558 : 1000555 : const enum tree_code icmp = GT_EXPR;
15559 : 1000555 : {
15560 : 1000555 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
15561 : 1000555 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
15562 : : )
15563 : : {
15564 : 1765 : {
15565 : 1765 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
15566 : 1765 : ? optab_vector : optab_default;
15567 : 1765 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
15568 : 1765 : if (target_supports_op_p (utype, icmp, optab)
15569 : 1765 : || (optimize_vectors_before_lowering_p ()
15570 : 1576 : && (!target_supports_op_p (type, cmp, optab)
15571 : 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
15572 : : )
15573 : : {
15574 : 1576 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
15575 : : )
15576 : : {
15577 : 1104 : gimple_seq *lseq = seq;
15578 : 1104 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1855;
15579 : 1104 : {
15580 : 1104 : res_op->set_op (icmp, type, 2);
15581 : 1104 : res_op->ops[0] = captures[1];
15582 : 1104 : res_op->ops[1] = csts;
15583 : 1104 : res_op->resimplify (lseq, valueize);
15584 : 1104 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1011, __FILE__, __LINE__, true);
15585 : 1104 : return true;
15586 : : }
15587 : 0 : next_after_fail1855:;
15588 : : }
15589 : : else
15590 : : {
15591 : 472 : gimple_seq *lseq = seq;
15592 : 472 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1856;
15593 : 472 : {
15594 : 472 : res_op->set_op (icmp, type, 2);
15595 : 472 : {
15596 : 472 : tree _o1[1], _r1;
15597 : 472 : _o1[0] = captures[1];
15598 : 472 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, utype, _o1[0]);
15599 : 472 : tem_op.resimplify (lseq, valueize);
15600 : 472 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
15601 : 472 : if (!_r1) goto next_after_fail1856;
15602 : 456 : res_op->ops[0] = _r1;
15603 : : }
15604 : 456 : res_op->ops[1] = csts;
15605 : 456 : res_op->resimplify (lseq, valueize);
15606 : 456 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1012, __FILE__, __LINE__, true);
15607 : 456 : return true;
15608 : : }
15609 : 998995 : next_after_fail1856:;
15610 : : }
15611 : : }
15612 : : }
15613 : : }
15614 : : }
15615 : : }
15616 : : }
15617 : : break;
15618 : : }
15619 : 1299294 : default:;
15620 : : }
15621 : 1299294 : switch (TREE_CODE (_q20))
15622 : : {
15623 : 0 : case VECTOR_CST:
15624 : 0 : {
15625 : 0 : if (integer_zerop (_p1))
15626 : : {
15627 : 0 : {
15628 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
15629 : 0 : const enum tree_code cmp = NE_EXPR;
15630 : 0 : const enum tree_code icmp = GT_EXPR;
15631 : 0 : {
15632 : 0 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
15633 : 0 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
15634 : : )
15635 : : {
15636 : 0 : {
15637 : 0 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
15638 : 0 : ? optab_vector : optab_default;
15639 : 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
15640 : 0 : if (target_supports_op_p (utype, icmp, optab)
15641 : 0 : || (optimize_vectors_before_lowering_p ()
15642 : 0 : && (!target_supports_op_p (type, cmp, optab)
15643 : 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
15644 : : )
15645 : : {
15646 : 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
15647 : : )
15648 : : {
15649 : 0 : gimple_seq *lseq = seq;
15650 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1857;
15651 : 0 : {
15652 : 0 : res_op->set_op (icmp, type, 2);
15653 : 0 : res_op->ops[0] = captures[1];
15654 : 0 : res_op->ops[1] = csts;
15655 : 0 : res_op->resimplify (lseq, valueize);
15656 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1011, __FILE__, __LINE__, true);
15657 : 0 : return true;
15658 : : }
15659 : 0 : next_after_fail1857:;
15660 : : }
15661 : : else
15662 : : {
15663 : 0 : gimple_seq *lseq = seq;
15664 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1858;
15665 : 0 : {
15666 : 0 : res_op->set_op (icmp, type, 2);
15667 : 0 : {
15668 : 0 : tree _o1[1], _r1;
15669 : 0 : _o1[0] = captures[1];
15670 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, utype, _o1[0]);
15671 : 0 : tem_op.resimplify (lseq, valueize);
15672 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
15673 : 0 : if (!_r1) goto next_after_fail1858;
15674 : 0 : res_op->ops[0] = _r1;
15675 : : }
15676 : 0 : res_op->ops[1] = csts;
15677 : 0 : res_op->resimplify (lseq, valueize);
15678 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1012, __FILE__, __LINE__, true);
15679 : 0 : return true;
15680 : : }
15681 : 0 : next_after_fail1858:;
15682 : : }
15683 : : }
15684 : : }
15685 : : }
15686 : : }
15687 : : }
15688 : : }
15689 : : break;
15690 : : }
15691 : 0 : case INTEGER_CST:
15692 : 0 : {
15693 : 0 : if (integer_zerop (_p1))
15694 : : {
15695 : 0 : {
15696 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
15697 : 0 : const enum tree_code cmp = NE_EXPR;
15698 : 0 : const enum tree_code icmp = GT_EXPR;
15699 : 0 : {
15700 : 0 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
15701 : 0 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
15702 : : )
15703 : : {
15704 : 0 : {
15705 : 0 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
15706 : 0 : ? optab_vector : optab_default;
15707 : 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
15708 : 0 : if (target_supports_op_p (utype, icmp, optab)
15709 : 0 : || (optimize_vectors_before_lowering_p ()
15710 : 0 : && (!target_supports_op_p (type, cmp, optab)
15711 : 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
15712 : : )
15713 : : {
15714 : 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
15715 : : )
15716 : : {
15717 : 0 : gimple_seq *lseq = seq;
15718 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1859;
15719 : 0 : {
15720 : 0 : res_op->set_op (icmp, type, 2);
15721 : 0 : res_op->ops[0] = captures[1];
15722 : 0 : res_op->ops[1] = csts;
15723 : 0 : res_op->resimplify (lseq, valueize);
15724 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1011, __FILE__, __LINE__, true);
15725 : 0 : return true;
15726 : : }
15727 : 0 : next_after_fail1859:;
15728 : : }
15729 : : else
15730 : : {
15731 : 0 : gimple_seq *lseq = seq;
15732 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1860;
15733 : 0 : {
15734 : 0 : res_op->set_op (icmp, type, 2);
15735 : 0 : {
15736 : 0 : tree _o1[1], _r1;
15737 : 0 : _o1[0] = captures[1];
15738 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, utype, _o1[0]);
15739 : 0 : tem_op.resimplify (lseq, valueize);
15740 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
15741 : 0 : if (!_r1) goto next_after_fail1860;
15742 : 0 : res_op->ops[0] = _r1;
15743 : : }
15744 : 0 : res_op->ops[1] = csts;
15745 : 0 : res_op->resimplify (lseq, valueize);
15746 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1012, __FILE__, __LINE__, true);
15747 : 0 : return true;
15748 : : }
15749 : 0 : next_after_fail1860:;
15750 : : }
15751 : : }
15752 : : }
15753 : : }
15754 : : }
15755 : : }
15756 : : }
15757 : : break;
15758 : : }
15759 : : default:;
15760 : : }
15761 : 115998821 : break;
15762 : : }
15763 : 41423 : case RSHIFT_EXPR:
15764 : 41423 : {
15765 : 41423 : tree _q20 = gimple_assign_rhs1 (_a1);
15766 : 41423 : _q20 = do_valueize (valueize, _q20);
15767 : 41423 : tree _q21 = gimple_assign_rhs2 (_a1);
15768 : 41423 : _q21 = do_valueize (valueize, _q21);
15769 : 41423 : switch (TREE_CODE (_q20))
15770 : : {
15771 : 40955 : case SSA_NAME:
15772 : 40955 : if (gimple *_d2 = get_def (valueize, _q20))
15773 : : {
15774 : 39721 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
15775 : 34543 : switch (gimple_assign_rhs_code (_a2))
15776 : : {
15777 : 276 : case MULT_EXPR:
15778 : 276 : {
15779 : 276 : tree _q30 = gimple_assign_rhs1 (_a2);
15780 : 276 : _q30 = do_valueize (valueize, _q30);
15781 : 276 : tree _q31 = gimple_assign_rhs2 (_a2);
15782 : 276 : _q31 = do_valueize (valueize, _q31);
15783 : 276 : if (tree_swap_operands_p (_q30, _q31))
15784 : 2 : std::swap (_q30, _q31);
15785 : 276 : switch (TREE_CODE (_q30))
15786 : : {
15787 : 276 : case SSA_NAME:
15788 : 276 : if (gimple *_d3 = get_def (valueize, _q30))
15789 : : {
15790 : 276 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
15791 : 276 : switch (gimple_assign_rhs_code (_a3))
15792 : : {
15793 : 144 : CASE_CONVERT:
15794 : 144 : {
15795 : 144 : tree _q40 = gimple_assign_rhs1 (_a3);
15796 : 144 : _q40 = do_valueize (valueize, _q40);
15797 : 144 : switch (TREE_CODE (_q31))
15798 : : {
15799 : 28 : case SSA_NAME:
15800 : 28 : if (gimple *_d4 = get_def (valueize, _q31))
15801 : : {
15802 : 28 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
15803 : 28 : switch (gimple_assign_rhs_code (_a4))
15804 : : {
15805 : 28 : CASE_CONVERT:
15806 : 28 : {
15807 : 28 : tree _q60 = gimple_assign_rhs1 (_a4);
15808 : 28 : _q60 = do_valueize (valueize, _q60);
15809 : 28 : switch (TREE_CODE (_q21))
15810 : : {
15811 : 28 : case INTEGER_CST:
15812 : 28 : {
15813 : 28 : if (integer_zerop (_p1))
15814 : : {
15815 : 0 : {
15816 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q30, _q40, _q60, _q21 };
15817 : 0 : if (gimple_simplify_286 (res_op, seq, valueize, type, captures, NE_EXPR))
15818 : 0 : return true;
15819 : : }
15820 : : }
15821 : : break;
15822 : : }
15823 : : default:;
15824 : : }
15825 : : break;
15826 : : }
15827 : : default:;
15828 : : }
15829 : : }
15830 : : break;
15831 : : default:;
15832 : : }
15833 : : break;
15834 : : }
15835 : : default:;
15836 : : }
15837 : : }
15838 : : break;
15839 : : default:;
15840 : : }
15841 : 115998821 : break;
15842 : : }
15843 : : default:;
15844 : : }
15845 : : }
15846 : : break;
15847 : : default:;
15848 : : }
15849 : : break;
15850 : : }
15851 : 1366735 : case PLUS_EXPR:
15852 : 1366735 : {
15853 : 1366735 : tree _q20 = gimple_assign_rhs1 (_a1);
15854 : 1366735 : _q20 = do_valueize (valueize, _q20);
15855 : 1366735 : tree _q21 = gimple_assign_rhs2 (_a1);
15856 : 1366735 : _q21 = do_valueize (valueize, _q21);
15857 : 1366735 : if (tree_swap_operands_p (_q20, _q21))
15858 : 7984 : std::swap (_q20, _q21);
15859 : 1366735 : switch (TREE_CODE (_q21))
15860 : : {
15861 : 1215453 : case INTEGER_CST:
15862 : 1215453 : {
15863 : 1215453 : switch (TREE_CODE (_p1))
15864 : : {
15865 : 865283 : case INTEGER_CST:
15866 : 865283 : {
15867 : 865283 : {
15868 : 865283 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
15869 : 865283 : if (gimple_simplify_287 (res_op, seq, valueize, type, captures, PLUS_EXPR, MINUS_EXPR, NE_EXPR))
15870 : 32493 : return true;
15871 : : }
15872 : 832790 : break;
15873 : : }
15874 : : default:;
15875 : : }
15876 : : break;
15877 : : }
15878 : : default:;
15879 : : }
15880 : 115998821 : break;
15881 : : }
15882 : 179293 : case MINUS_EXPR:
15883 : 179293 : {
15884 : 179293 : tree _q20 = gimple_assign_rhs1 (_a1);
15885 : 179293 : _q20 = do_valueize (valueize, _q20);
15886 : 179293 : tree _q21 = gimple_assign_rhs2 (_a1);
15887 : 179293 : _q21 = do_valueize (valueize, _q21);
15888 : 179293 : switch (TREE_CODE (_q21))
15889 : : {
15890 : 28431 : case INTEGER_CST:
15891 : 28431 : {
15892 : 28431 : switch (TREE_CODE (_p1))
15893 : : {
15894 : 26900 : case INTEGER_CST:
15895 : 26900 : {
15896 : 26900 : {
15897 : 26900 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
15898 : 26900 : if (gimple_simplify_287 (res_op, seq, valueize, type, captures, MINUS_EXPR, PLUS_EXPR, NE_EXPR))
15899 : 192 : return true;
15900 : : }
15901 : 26708 : break;
15902 : : }
15903 : : default:;
15904 : : }
15905 : : break;
15906 : : }
15907 : : default:;
15908 : : }
15909 : : break;
15910 : : }
15911 : : default:;
15912 : : }
15913 : 8811459 : else if (gcall *_c1 = dyn_cast <gcall *> (_d1))
15914 : 5050184 : switch (gimple_call_combined_fn (_c1))
15915 : : {
15916 : 1243 : case CFN_BUILT_IN_CLZ:
15917 : 1243 : if (gimple_call_num_args (_c1) == 1)
15918 : : {
15919 : 1243 : tree _q20 = gimple_call_arg (_c1, 0);
15920 : 1243 : _q20 = do_valueize (valueize, _q20);
15921 : 1243 : switch (TREE_CODE (_p1))
15922 : : {
15923 : 882 : case INTEGER_CST:
15924 : 882 : {
15925 : 882 : {
15926 : 882 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
15927 : 882 : if (gimple_simplify_288 (res_op, seq, valueize, type, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZ))
15928 : 402 : return true;
15929 : : }
15930 : 480 : break;
15931 : : }
15932 : : default:;
15933 : : }
15934 : : }
15935 : : break;
15936 : 282 : case CFN_BUILT_IN_CTZ:
15937 : 282 : if (gimple_call_num_args (_c1) == 1)
15938 : : {
15939 : 282 : tree _q20 = gimple_call_arg (_c1, 0);
15940 : 282 : _q20 = do_valueize (valueize, _q20);
15941 : 282 : switch (TREE_CODE (_p1))
15942 : : {
15943 : 3 : case INTEGER_CST:
15944 : 3 : {
15945 : 3 : {
15946 : 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
15947 : 3 : if (gimple_simplify_290 (res_op, seq, valueize, type, captures, NE_EXPR, CFN_BUILT_IN_CTZ))
15948 : 3 : return true;
15949 : : }
15950 : 0 : break;
15951 : : }
15952 : : default:;
15953 : : }
15954 : : }
15955 : : break;
15956 : 481 : case CFN_BUILT_IN_FFS:
15957 : 481 : if (gimple_call_num_args (_c1) == 1)
15958 : : {
15959 : 481 : tree _q20 = gimple_call_arg (_c1, 0);
15960 : 481 : _q20 = do_valueize (valueize, _q20);
15961 : 481 : switch (TREE_CODE (_p1))
15962 : : {
15963 : 14 : case INTEGER_CST:
15964 : 14 : {
15965 : 14 : {
15966 : 14 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
15967 : 14 : if (gimple_simplify_293 (res_op, seq, valueize, type, captures, NE_EXPR, CFN_BUILT_IN_FFS))
15968 : 14 : return true;
15969 : : }
15970 : 0 : break;
15971 : : }
15972 : : default:;
15973 : : }
15974 : : }
15975 : : break;
15976 : 0 : case CFN_BUILT_IN_FFSIMAX:
15977 : 0 : if (gimple_call_num_args (_c1) == 1)
15978 : : {
15979 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
15980 : 0 : _q20 = do_valueize (valueize, _q20);
15981 : 0 : switch (TREE_CODE (_p1))
15982 : : {
15983 : 0 : case INTEGER_CST:
15984 : 0 : {
15985 : 0 : {
15986 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
15987 : 0 : if (gimple_simplify_293 (res_op, seq, valueize, type, captures, NE_EXPR, CFN_BUILT_IN_FFSIMAX))
15988 : 0 : return true;
15989 : : }
15990 : 0 : break;
15991 : : }
15992 : : default:;
15993 : : }
15994 : : }
15995 : : break;
15996 : 242 : case CFN_BUILT_IN_POPCOUNT:
15997 : 242 : if (gimple_call_num_args (_c1) == 1)
15998 : : {
15999 : 242 : tree _q20 = gimple_call_arg (_c1, 0);
16000 : 242 : _q20 = do_valueize (valueize, _q20);
16001 : 242 : if (integer_zerop (_p1))
16002 : : {
16003 : 3 : {
16004 : 3 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
16005 : 3 : if (gimple_simplify_292 (res_op, seq, valueize, type, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNT))
16006 : 3 : return true;
16007 : : }
16008 : : }
16009 : : }
16010 : : break;
16011 : 539 : case CFN_BUILT_IN_CLZL:
16012 : 539 : if (gimple_call_num_args (_c1) == 1)
16013 : : {
16014 : 539 : tree _q20 = gimple_call_arg (_c1, 0);
16015 : 539 : _q20 = do_valueize (valueize, _q20);
16016 : 539 : switch (TREE_CODE (_p1))
16017 : : {
16018 : 377 : case INTEGER_CST:
16019 : 377 : {
16020 : 377 : {
16021 : 377 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
16022 : 377 : if (gimple_simplify_288 (res_op, seq, valueize, type, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZL))
16023 : 268 : return true;
16024 : : }
16025 : 109 : break;
16026 : : }
16027 : : default:;
16028 : : }
16029 : : }
16030 : : break;
16031 : 173 : case CFN_BUILT_IN_CTZL:
16032 : 173 : if (gimple_call_num_args (_c1) == 1)
16033 : : {
16034 : 173 : tree _q20 = gimple_call_arg (_c1, 0);
16035 : 173 : _q20 = do_valueize (valueize, _q20);
16036 : 173 : switch (TREE_CODE (_p1))
16037 : : {
16038 : 0 : case INTEGER_CST:
16039 : 0 : {
16040 : 0 : {
16041 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
16042 : 0 : if (gimple_simplify_290 (res_op, seq, valueize, type, captures, NE_EXPR, CFN_BUILT_IN_CTZL))
16043 : 0 : return true;
16044 : : }
16045 : 0 : break;
16046 : : }
16047 : : default:;
16048 : : }
16049 : : }
16050 : : break;
16051 : 141 : case CFN_BUILT_IN_FFSL:
16052 : 141 : if (gimple_call_num_args (_c1) == 1)
16053 : : {
16054 : 141 : tree _q20 = gimple_call_arg (_c1, 0);
16055 : 141 : _q20 = do_valueize (valueize, _q20);
16056 : 141 : switch (TREE_CODE (_p1))
16057 : : {
16058 : 0 : case INTEGER_CST:
16059 : 0 : {
16060 : 0 : {
16061 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
16062 : 0 : if (gimple_simplify_293 (res_op, seq, valueize, type, captures, NE_EXPR, CFN_BUILT_IN_FFSL))
16063 : 0 : return true;
16064 : : }
16065 : 0 : break;
16066 : : }
16067 : : default:;
16068 : : }
16069 : : }
16070 : : break;
16071 : 246 : case CFN_BUILT_IN_POPCOUNTLL:
16072 : 246 : if (gimple_call_num_args (_c1) == 1)
16073 : : {
16074 : 246 : tree _q20 = gimple_call_arg (_c1, 0);
16075 : 246 : _q20 = do_valueize (valueize, _q20);
16076 : 246 : if (integer_zerop (_p1))
16077 : : {
16078 : 1 : {
16079 : 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
16080 : 1 : if (gimple_simplify_292 (res_op, seq, valueize, type, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNTLL))
16081 : 1 : return true;
16082 : : }
16083 : : }
16084 : : }
16085 : : break;
16086 : 0 : case CFN_BUILT_IN_CTZIMAX:
16087 : 0 : if (gimple_call_num_args (_c1) == 1)
16088 : : {
16089 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
16090 : 0 : _q20 = do_valueize (valueize, _q20);
16091 : 0 : switch (TREE_CODE (_p1))
16092 : : {
16093 : 0 : case INTEGER_CST:
16094 : 0 : {
16095 : 0 : {
16096 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
16097 : 0 : if (gimple_simplify_290 (res_op, seq, valueize, type, captures, NE_EXPR, CFN_BUILT_IN_CTZIMAX))
16098 : 0 : return true;
16099 : : }
16100 : 0 : break;
16101 : : }
16102 : : default:;
16103 : : }
16104 : : }
16105 : : break;
16106 : 0 : case CFN_POPCOUNT:
16107 : 0 : if (gimple_call_num_args (_c1) == 1)
16108 : : {
16109 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
16110 : 0 : _q20 = do_valueize (valueize, _q20);
16111 : 0 : if (integer_zerop (_p1))
16112 : : {
16113 : 0 : {
16114 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
16115 : 0 : if (gimple_simplify_292 (res_op, seq, valueize, type, captures, NE_EXPR, NE_EXPR, CFN_POPCOUNT))
16116 : 0 : return true;
16117 : : }
16118 : : }
16119 : : }
16120 : : break;
16121 : 0 : case CFN_CLZ:
16122 : 0 : if (gimple_call_num_args (_c1) == 1)
16123 : : {
16124 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
16125 : 0 : _q20 = do_valueize (valueize, _q20);
16126 : 0 : switch (TREE_CODE (_p1))
16127 : : {
16128 : 0 : case INTEGER_CST:
16129 : 0 : {
16130 : 0 : {
16131 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
16132 : 0 : if (gimple_simplify_288 (res_op, seq, valueize, type, captures, NE_EXPR, GE_EXPR, CFN_CLZ))
16133 : 0 : return true;
16134 : : }
16135 : 0 : break;
16136 : : }
16137 : : default:;
16138 : : }
16139 : : }
16140 : 0 : if (gimple_call_num_args (_c1) == 2)
16141 : : {
16142 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
16143 : 0 : _q20 = do_valueize (valueize, _q20);
16144 : 0 : tree _q21 = gimple_call_arg (_c1, 1);
16145 : 0 : _q21 = do_valueize (valueize, _q21);
16146 : 0 : switch (TREE_CODE (_p1))
16147 : : {
16148 : 0 : case INTEGER_CST:
16149 : 0 : {
16150 : 0 : {
16151 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
16152 : 0 : if (gimple_simplify_289 (res_op, seq, valueize, type, captures, NE_EXPR, GE_EXPR))
16153 : 0 : return true;
16154 : : }
16155 : 0 : break;
16156 : : }
16157 : : default:;
16158 : : }
16159 : : }
16160 : : break;
16161 : 10 : case CFN_CTZ:
16162 : 10 : if (gimple_call_num_args (_c1) == 1)
16163 : : {
16164 : 10 : tree _q20 = gimple_call_arg (_c1, 0);
16165 : 10 : _q20 = do_valueize (valueize, _q20);
16166 : 10 : switch (TREE_CODE (_p1))
16167 : : {
16168 : 10 : case INTEGER_CST:
16169 : 10 : {
16170 : 10 : {
16171 : 10 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
16172 : 10 : if (gimple_simplify_290 (res_op, seq, valueize, type, captures, NE_EXPR, CFN_CTZ))
16173 : 2 : return true;
16174 : : }
16175 : 8 : break;
16176 : : }
16177 : : default:;
16178 : : }
16179 : : }
16180 : 8 : if (gimple_call_num_args (_c1) == 2)
16181 : : {
16182 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
16183 : 0 : _q20 = do_valueize (valueize, _q20);
16184 : 0 : tree _q21 = gimple_call_arg (_c1, 1);
16185 : 0 : _q21 = do_valueize (valueize, _q21);
16186 : 0 : switch (TREE_CODE (_p1))
16187 : : {
16188 : 0 : case INTEGER_CST:
16189 : 0 : {
16190 : 0 : {
16191 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
16192 : 0 : if (gimple_simplify_291 (res_op, seq, valueize, type, captures, NE_EXPR))
16193 : 0 : return true;
16194 : : }
16195 : 0 : break;
16196 : : }
16197 : : default:;
16198 : : }
16199 : : }
16200 : : break;
16201 : 0 : case CFN_FFS:
16202 : 0 : if (gimple_call_num_args (_c1) == 1)
16203 : : {
16204 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
16205 : 0 : _q20 = do_valueize (valueize, _q20);
16206 : 0 : switch (TREE_CODE (_p1))
16207 : : {
16208 : 0 : case INTEGER_CST:
16209 : 0 : {
16210 : 0 : {
16211 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
16212 : 0 : if (gimple_simplify_293 (res_op, seq, valueize, type, captures, NE_EXPR, CFN_FFS))
16213 : 0 : return true;
16214 : : }
16215 : 0 : break;
16216 : : }
16217 : : default:;
16218 : : }
16219 : : }
16220 : : break;
16221 : 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
16222 : 0 : if (gimple_call_num_args (_c1) == 1)
16223 : : {
16224 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
16225 : 0 : _q20 = do_valueize (valueize, _q20);
16226 : 0 : if (integer_zerop (_p1))
16227 : : {
16228 : 0 : {
16229 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
16230 : 0 : if (gimple_simplify_292 (res_op, seq, valueize, type, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNTIMAX))
16231 : 0 : return true;
16232 : : }
16233 : : }
16234 : : }
16235 : : break;
16236 : 0 : case CFN_BUILT_IN_CLZIMAX:
16237 : 0 : if (gimple_call_num_args (_c1) == 1)
16238 : : {
16239 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
16240 : 0 : _q20 = do_valueize (valueize, _q20);
16241 : 0 : switch (TREE_CODE (_p1))
16242 : : {
16243 : 0 : case INTEGER_CST:
16244 : 0 : {
16245 : 0 : {
16246 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
16247 : 0 : if (gimple_simplify_288 (res_op, seq, valueize, type, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZIMAX))
16248 : 0 : return true;
16249 : : }
16250 : 0 : break;
16251 : : }
16252 : : default:;
16253 : : }
16254 : : }
16255 : : break;
16256 : 213 : case CFN_BUILT_IN_POPCOUNTL:
16257 : 213 : if (gimple_call_num_args (_c1) == 1)
16258 : : {
16259 : 213 : tree _q20 = gimple_call_arg (_c1, 0);
16260 : 213 : _q20 = do_valueize (valueize, _q20);
16261 : 213 : if (integer_zerop (_p1))
16262 : : {
16263 : 1 : {
16264 : 1 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
16265 : 1 : if (gimple_simplify_292 (res_op, seq, valueize, type, captures, NE_EXPR, NE_EXPR, CFN_BUILT_IN_POPCOUNTL))
16266 : 1 : return true;
16267 : : }
16268 : : }
16269 : : }
16270 : : break;
16271 : 302 : case CFN_BUILT_IN_CLZLL:
16272 : 302 : if (gimple_call_num_args (_c1) == 1)
16273 : : {
16274 : 302 : tree _q20 = gimple_call_arg (_c1, 0);
16275 : 302 : _q20 = do_valueize (valueize, _q20);
16276 : 302 : switch (TREE_CODE (_p1))
16277 : : {
16278 : 82 : case INTEGER_CST:
16279 : 82 : {
16280 : 82 : {
16281 : 82 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
16282 : 82 : if (gimple_simplify_288 (res_op, seq, valueize, type, captures, NE_EXPR, GE_EXPR, CFN_BUILT_IN_CLZLL))
16283 : 0 : return true;
16284 : : }
16285 : 82 : break;
16286 : : }
16287 : : default:;
16288 : : }
16289 : : }
16290 : : break;
16291 : 250 : case CFN_BUILT_IN_CTZLL:
16292 : 250 : if (gimple_call_num_args (_c1) == 1)
16293 : : {
16294 : 250 : tree _q20 = gimple_call_arg (_c1, 0);
16295 : 250 : _q20 = do_valueize (valueize, _q20);
16296 : 250 : switch (TREE_CODE (_p1))
16297 : : {
16298 : 9 : case INTEGER_CST:
16299 : 9 : {
16300 : 9 : {
16301 : 9 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
16302 : 9 : if (gimple_simplify_290 (res_op, seq, valueize, type, captures, NE_EXPR, CFN_BUILT_IN_CTZLL))
16303 : 0 : return true;
16304 : : }
16305 : 9 : break;
16306 : : }
16307 : : default:;
16308 : : }
16309 : : }
16310 : : break;
16311 : 192 : case CFN_BUILT_IN_FFSLL:
16312 : 192 : if (gimple_call_num_args (_c1) == 1)
16313 : : {
16314 : 192 : tree _q20 = gimple_call_arg (_c1, 0);
16315 : 192 : _q20 = do_valueize (valueize, _q20);
16316 : 192 : switch (TREE_CODE (_p1))
16317 : : {
16318 : 0 : case INTEGER_CST:
16319 : 0 : {
16320 : 0 : {
16321 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
16322 : 0 : if (gimple_simplify_293 (res_op, seq, valueize, type, captures, NE_EXPR, CFN_BUILT_IN_FFSLL))
16323 : 0 : return true;
16324 : : }
16325 : 0 : break;
16326 : : }
16327 : : default:;
16328 : : }
16329 : : }
16330 : : break;
16331 : : default:;
16332 : : }
16333 : : }
16334 : : break;
16335 : : default:;
16336 : : }
16337 : : return false;
16338 : : }
16339 : :
16340 : : bool
16341 : 44 : gimple_simplify_CFN_BUILT_IN_FMAXF128 (gimple_match_op *res_op, gimple_seq *seq,
16342 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
16343 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1)
16344 : : {
16345 : 44 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
16346 : 44 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
16347 : : {
16348 : 0 : {
16349 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
16350 : 0 : if (gimple_simplify_492 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FMAXF128))
16351 : 0 : return true;
16352 : : }
16353 : : }
16354 : 44 : switch (TREE_CODE (_p1))
16355 : : {
16356 : 0 : case REAL_CST:
16357 : 0 : {
16358 : 0 : {
16359 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
16360 : 0 : if (gimple_simplify_493 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FMAXF128))
16361 : 0 : return true;
16362 : : }
16363 : 0 : break;
16364 : : }
16365 : 44 : default:;
16366 : : }
16367 : 44 : switch (TREE_CODE (_p0))
16368 : : {
16369 : 0 : case REAL_CST:
16370 : 0 : {
16371 : 0 : {
16372 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _p0 };
16373 : 0 : if (gimple_simplify_493 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FMAXF128))
16374 : 0 : return true;
16375 : : }
16376 : 0 : break;
16377 : : }
16378 : 44 : default:;
16379 : : }
16380 : 44 : {
16381 : 44 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
16382 : 44 : if (gimple_simplify_495 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FMAXF128))
16383 : 0 : return true;
16384 : : }
16385 : 44 : switch (TREE_CODE (_p0))
16386 : : {
16387 : 42 : case SSA_NAME:
16388 : 42 : if (gimple *_d1 = get_def (valueize, _p0))
16389 : : {
16390 : 28 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
16391 : 44 : switch (gimple_assign_rhs_code (_a1))
16392 : : {
16393 : 0 : case NEGATE_EXPR:
16394 : 0 : {
16395 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
16396 : 0 : _q20 = do_valueize (valueize, _q20);
16397 : 0 : switch (TREE_CODE (_p1))
16398 : : {
16399 : 0 : case SSA_NAME:
16400 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
16401 : : {
16402 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
16403 : 0 : switch (gimple_assign_rhs_code (_a2))
16404 : : {
16405 : 0 : case NEGATE_EXPR:
16406 : 0 : {
16407 : 0 : tree _q40 = gimple_assign_rhs1 (_a2);
16408 : 0 : _q40 = do_valueize (valueize, _q40);
16409 : 0 : {
16410 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
16411 : 0 : if (FLOAT_TYPE_P (TREE_TYPE (captures[1]))
16412 : 0 : || (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
16413 : 0 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1])))
16414 : : )
16415 : : {
16416 : 0 : gimple_seq *lseq = seq;
16417 : 0 : if (lseq
16418 : 0 : && (!single_use (captures[0])
16419 : 0 : || !single_use (captures[2])))
16420 : 0 : lseq = NULL;
16421 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2131;
16422 : 0 : {
16423 : 0 : res_op->set_op (NEGATE_EXPR, type, 1);
16424 : 0 : {
16425 : 0 : tree _o1[2], _r1;
16426 : 0 : _o1[0] = captures[1];
16427 : 0 : _o1[1] = captures[3];
16428 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), CFN_BUILT_IN_FMINF128, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
16429 : 0 : tem_op.resimplify (lseq, valueize);
16430 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
16431 : 0 : if (!_r1) goto next_after_fail2131;
16432 : 0 : res_op->ops[0] = _r1;
16433 : : }
16434 : 0 : res_op->resimplify (lseq, valueize);
16435 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1073, __FILE__, __LINE__, true);
16436 : 0 : return true;
16437 : : }
16438 : 0 : next_after_fail2131:;
16439 : : }
16440 : : }
16441 : 0 : break;
16442 : : }
16443 : : default:;
16444 : : }
16445 : : }
16446 : : break;
16447 : : default:;
16448 : : }
16449 : : break;
16450 : : }
16451 : : default:;
16452 : : }
16453 : : }
16454 : : break;
16455 : : default:;
16456 : : }
16457 : : return false;
16458 : : }
16459 : :
16460 : : bool
16461 : 0 : gimple_simplify_CFN_FMAX (gimple_match_op *res_op, gimple_seq *seq,
16462 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
16463 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1)
16464 : : {
16465 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
16466 : 0 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
16467 : : {
16468 : 0 : {
16469 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
16470 : 0 : if (gimple_simplify_492 (res_op, seq, valueize, type, captures, CFN_FMAX))
16471 : 0 : return true;
16472 : : }
16473 : : }
16474 : 0 : switch (TREE_CODE (_p1))
16475 : : {
16476 : 0 : case REAL_CST:
16477 : 0 : {
16478 : 0 : {
16479 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
16480 : 0 : if (gimple_simplify_493 (res_op, seq, valueize, type, captures, CFN_FMAX))
16481 : 0 : return true;
16482 : : }
16483 : 0 : break;
16484 : : }
16485 : 0 : default:;
16486 : : }
16487 : 0 : switch (TREE_CODE (_p0))
16488 : : {
16489 : 0 : case REAL_CST:
16490 : 0 : {
16491 : 0 : {
16492 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _p0 };
16493 : 0 : if (gimple_simplify_493 (res_op, seq, valueize, type, captures, CFN_FMAX))
16494 : 0 : return true;
16495 : : }
16496 : 0 : break;
16497 : : }
16498 : 0 : default:;
16499 : : }
16500 : 0 : {
16501 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
16502 : 0 : if (gimple_simplify_495 (res_op, seq, valueize, type, captures, CFN_FMAX))
16503 : 0 : return true;
16504 : : }
16505 : 0 : switch (TREE_CODE (_p0))
16506 : : {
16507 : 0 : case SSA_NAME:
16508 : 0 : if (gimple *_d1 = get_def (valueize, _p0))
16509 : : {
16510 : 0 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
16511 : 0 : switch (gimple_assign_rhs_code (_a1))
16512 : : {
16513 : 0 : case NEGATE_EXPR:
16514 : 0 : {
16515 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
16516 : 0 : _q20 = do_valueize (valueize, _q20);
16517 : 0 : switch (TREE_CODE (_p1))
16518 : : {
16519 : 0 : case SSA_NAME:
16520 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
16521 : : {
16522 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
16523 : 0 : switch (gimple_assign_rhs_code (_a2))
16524 : : {
16525 : 0 : case NEGATE_EXPR:
16526 : 0 : {
16527 : 0 : tree _q40 = gimple_assign_rhs1 (_a2);
16528 : 0 : _q40 = do_valueize (valueize, _q40);
16529 : 0 : {
16530 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
16531 : 0 : if (FLOAT_TYPE_P (TREE_TYPE (captures[1]))
16532 : 0 : || (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
16533 : 0 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1])))
16534 : : )
16535 : : {
16536 : 0 : gimple_seq *lseq = seq;
16537 : 0 : if (lseq
16538 : 0 : && (!single_use (captures[0])
16539 : 0 : || !single_use (captures[2])))
16540 : 0 : lseq = NULL;
16541 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2135;
16542 : 0 : {
16543 : 0 : res_op->set_op (NEGATE_EXPR, type, 1);
16544 : 0 : {
16545 : 0 : tree _o1[2], _r1;
16546 : 0 : _o1[0] = captures[1];
16547 : 0 : _o1[1] = captures[3];
16548 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), CFN_FMIN, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
16549 : 0 : tem_op.resimplify (lseq, valueize);
16550 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
16551 : 0 : if (!_r1) goto next_after_fail2135;
16552 : 0 : res_op->ops[0] = _r1;
16553 : : }
16554 : 0 : res_op->resimplify (lseq, valueize);
16555 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1073, __FILE__, __LINE__, true);
16556 : 0 : return true;
16557 : : }
16558 : 0 : next_after_fail2135:;
16559 : : }
16560 : : }
16561 : 0 : break;
16562 : : }
16563 : : default:;
16564 : : }
16565 : : }
16566 : : break;
16567 : : default:;
16568 : : }
16569 : : break;
16570 : : }
16571 : : default:;
16572 : : }
16573 : : }
16574 : : break;
16575 : : default:;
16576 : : }
16577 : : return false;
16578 : : }
16579 : :
16580 : : bool
16581 : 131564 : gimple_simplify_ORDERED_EXPR (gimple_match_op *res_op, gimple_seq *seq,
16582 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
16583 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1)
16584 : : {
16585 : 131564 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
16586 : 131564 : switch (TREE_CODE (_p0))
16587 : : {
16588 : 123212 : case SSA_NAME:
16589 : 123212 : if (gimple *_d1 = get_def (valueize, _p0))
16590 : : {
16591 : 46981 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
16592 : 46227 : switch (gimple_assign_rhs_code (_a1))
16593 : : {
16594 : 0 : case VEC_COND_EXPR:
16595 : 0 : {
16596 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
16597 : 0 : _q20 = do_valueize (valueize, _q20);
16598 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
16599 : 0 : _q21 = do_valueize (valueize, _q21);
16600 : 0 : tree _q22 = gimple_assign_rhs3 (_a1);
16601 : 0 : _q22 = do_valueize (valueize, _q22);
16602 : 0 : switch (TREE_CODE (_p1))
16603 : : {
16604 : 0 : case SSA_NAME:
16605 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
16606 : : {
16607 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
16608 : 0 : switch (gimple_assign_rhs_code (_a2))
16609 : : {
16610 : 0 : case VEC_COND_EXPR:
16611 : 0 : {
16612 : 0 : tree _q60 = gimple_assign_rhs1 (_a2);
16613 : 0 : _q60 = do_valueize (valueize, _q60);
16614 : 0 : tree _q61 = gimple_assign_rhs2 (_a2);
16615 : 0 : _q61 = do_valueize (valueize, _q61);
16616 : 0 : tree _q62 = gimple_assign_rhs3 (_a2);
16617 : 0 : _q62 = do_valueize (valueize, _q62);
16618 : 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
16619 : : {
16620 : 0 : {
16621 : 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
16622 : 0 : if (TREE_CODE_CLASS (ORDERED_EXPR) != tcc_comparison
16623 : 0 : || types_match (type, TREE_TYPE (captures[2]))
16624 : 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]), ERROR_MARK)
16625 : : || (optimize_vectors_before_lowering_p ()
16626 : 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]),
16627 : 0 : TREE_TYPE (captures[1]), ERROR_MARK))
16628 : : )
16629 : : {
16630 : 0 : gimple_seq *lseq = seq;
16631 : 0 : if (lseq
16632 : 0 : && (!single_use (captures[0])
16633 : 0 : || !single_use (captures[4])))
16634 : 0 : lseq = NULL;
16635 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2143;
16636 : 0 : {
16637 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
16638 : 0 : res_op->ops[0] = captures[1];
16639 : 0 : {
16640 : 0 : tree _o1[2], _r1;
16641 : 0 : _o1[0] = captures[2];
16642 : 0 : _o1[1] = captures[5];
16643 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ORDERED_EXPR, type, _o1[0], _o1[1]);
16644 : 0 : tem_op.resimplify (NULL, valueize);
16645 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
16646 : 0 : if (!_r1) goto next_after_fail2143;
16647 : 0 : res_op->ops[1] = _r1;
16648 : : }
16649 : 0 : {
16650 : 0 : tree _o1[2], _r1;
16651 : 0 : _o1[0] = captures[3];
16652 : 0 : _o1[1] = captures[6];
16653 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ORDERED_EXPR, type, _o1[0], _o1[1]);
16654 : 0 : tem_op.resimplify (NULL, valueize);
16655 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
16656 : 0 : if (!_r1) goto next_after_fail2143;
16657 : 0 : res_op->ops[2] = _r1;
16658 : : }
16659 : 0 : res_op->resimplify (lseq, valueize);
16660 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 925, __FILE__, __LINE__, true);
16661 : 0 : return true;
16662 : : }
16663 : 0 : next_after_fail2143:;
16664 : : }
16665 : : }
16666 : : }
16667 : : break;
16668 : : }
16669 : : default:;
16670 : : }
16671 : : }
16672 : : break;
16673 : 0 : default:;
16674 : : }
16675 : 0 : {
16676 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
16677 : 0 : if (TREE_CODE_CLASS (ORDERED_EXPR) != tcc_comparison
16678 : 0 : || types_match (type, TREE_TYPE (captures[2]))
16679 : 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]), ERROR_MARK)
16680 : : || (optimize_vectors_before_lowering_p ()
16681 : 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]),
16682 : 0 : TREE_TYPE (captures[1]), ERROR_MARK))
16683 : : )
16684 : : {
16685 : 0 : gimple_seq *lseq = seq;
16686 : 0 : if (lseq
16687 : 0 : && (!single_use (captures[0])))
16688 : 0 : lseq = NULL;
16689 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2144;
16690 : 0 : {
16691 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
16692 : 0 : res_op->ops[0] = captures[1];
16693 : 0 : {
16694 : 0 : tree _o1[2], _r1;
16695 : 0 : _o1[0] = captures[2];
16696 : 0 : _o1[1] = captures[4];
16697 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ORDERED_EXPR, type, _o1[0], _o1[1]);
16698 : 0 : tem_op.resimplify (NULL, valueize);
16699 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
16700 : 0 : if (!_r1) goto next_after_fail2144;
16701 : 0 : res_op->ops[1] = _r1;
16702 : : }
16703 : 0 : {
16704 : 0 : tree _o1[2], _r1;
16705 : 0 : _o1[0] = captures[3];
16706 : 0 : _o1[1] = captures[4];
16707 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ORDERED_EXPR, type, _o1[0], _o1[1]);
16708 : 0 : tem_op.resimplify (NULL, valueize);
16709 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
16710 : 0 : if (!_r1) goto next_after_fail2144;
16711 : 0 : res_op->ops[2] = _r1;
16712 : : }
16713 : 0 : res_op->resimplify (lseq, valueize);
16714 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 926, __FILE__, __LINE__, true);
16715 : 0 : return true;
16716 : : }
16717 : 0 : next_after_fail2144:;
16718 : : }
16719 : : }
16720 : 0 : break;
16721 : : }
16722 : : default:;
16723 : : }
16724 : : }
16725 : : break;
16726 : 131564 : default:;
16727 : : }
16728 : 131564 : switch (TREE_CODE (_p1))
16729 : : {
16730 : 122382 : case SSA_NAME:
16731 : 122382 : if (gimple *_d1 = get_def (valueize, _p1))
16732 : : {
16733 : 46699 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
16734 : 46076 : switch (gimple_assign_rhs_code (_a1))
16735 : : {
16736 : 0 : case VEC_COND_EXPR:
16737 : 0 : {
16738 : 0 : tree _q30 = gimple_assign_rhs1 (_a1);
16739 : 0 : _q30 = do_valueize (valueize, _q30);
16740 : 0 : tree _q31 = gimple_assign_rhs2 (_a1);
16741 : 0 : _q31 = do_valueize (valueize, _q31);
16742 : 0 : tree _q32 = gimple_assign_rhs3 (_a1);
16743 : 0 : _q32 = do_valueize (valueize, _q32);
16744 : 0 : {
16745 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
16746 : 0 : if (TREE_CODE_CLASS (ORDERED_EXPR) != tcc_comparison
16747 : 0 : || types_match (type, TREE_TYPE (captures[3]))
16748 : 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]), ERROR_MARK)
16749 : : || (optimize_vectors_before_lowering_p ()
16750 : 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]),
16751 : 0 : TREE_TYPE (captures[2]), ERROR_MARK))
16752 : : )
16753 : : {
16754 : 0 : gimple_seq *lseq = seq;
16755 : 0 : if (lseq
16756 : 0 : && (!single_use (captures[1])))
16757 : 0 : lseq = NULL;
16758 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2145;
16759 : 0 : {
16760 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
16761 : 0 : res_op->ops[0] = captures[2];
16762 : 0 : {
16763 : 0 : tree _o1[2], _r1;
16764 : 0 : _o1[0] = captures[0];
16765 : 0 : _o1[1] = captures[3];
16766 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ORDERED_EXPR, type, _o1[0], _o1[1]);
16767 : 0 : tem_op.resimplify (NULL, valueize);
16768 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
16769 : 0 : if (!_r1) goto next_after_fail2145;
16770 : 0 : res_op->ops[1] = _r1;
16771 : : }
16772 : 0 : {
16773 : 0 : tree _o1[2], _r1;
16774 : 0 : _o1[0] = captures[0];
16775 : 0 : _o1[1] = captures[4];
16776 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ORDERED_EXPR, type, _o1[0], _o1[1]);
16777 : 0 : tem_op.resimplify (NULL, valueize);
16778 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
16779 : 0 : if (!_r1) goto next_after_fail2145;
16780 : 0 : res_op->ops[2] = _r1;
16781 : : }
16782 : 0 : res_op->resimplify (lseq, valueize);
16783 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 927, __FILE__, __LINE__, true);
16784 : 0 : return true;
16785 : : }
16786 : 0 : next_after_fail2145:;
16787 : : }
16788 : : }
16789 : 0 : break;
16790 : : }
16791 : : default:;
16792 : : }
16793 : : }
16794 : : break;
16795 : 131564 : default:;
16796 : : }
16797 : 131564 : switch (TREE_CODE (_p0))
16798 : : {
16799 : 123212 : case SSA_NAME:
16800 : 123212 : if (gimple *_d1 = get_def (valueize, _p0))
16801 : : {
16802 : 46981 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
16803 : 46227 : switch (gimple_assign_rhs_code (_a1))
16804 : : {
16805 : 0 : case FLOAT_EXPR:
16806 : 0 : {
16807 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
16808 : 0 : _q20 = do_valueize (valueize, _q20);
16809 : 0 : switch (TREE_CODE (_p1))
16810 : : {
16811 : 0 : case SSA_NAME:
16812 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
16813 : : {
16814 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
16815 : 0 : switch (gimple_assign_rhs_code (_a2))
16816 : : {
16817 : 0 : case FLOAT_EXPR:
16818 : 0 : {
16819 : 0 : tree _q40 = gimple_assign_rhs1 (_a2);
16820 : 0 : _q40 = do_valueize (valueize, _q40);
16821 : 0 : {
16822 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
16823 : 0 : if (gimple_simplify_257 (res_op, seq, valueize, type, captures, ORDERED_EXPR, ORDERED_EXPR))
16824 : 0 : return true;
16825 : : }
16826 : 0 : break;
16827 : : }
16828 : : default:;
16829 : : }
16830 : : }
16831 : : break;
16832 : : default:;
16833 : : }
16834 : : break;
16835 : : }
16836 : 246 : case NEGATE_EXPR:
16837 : 246 : {
16838 : 246 : tree _q20 = gimple_assign_rhs1 (_a1);
16839 : 246 : _q20 = do_valueize (valueize, _q20);
16840 : 246 : switch (TREE_CODE (_p1))
16841 : : {
16842 : 246 : case SSA_NAME:
16843 : 246 : if (gimple *_d2 = get_def (valueize, _p1))
16844 : : {
16845 : 246 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
16846 : 246 : switch (gimple_assign_rhs_code (_a2))
16847 : : {
16848 : 246 : case NEGATE_EXPR:
16849 : 246 : {
16850 : 246 : tree _q40 = gimple_assign_rhs1 (_a2);
16851 : 246 : _q40 = do_valueize (valueize, _q40);
16852 : 246 : {
16853 : 246 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
16854 : 246 : if (gimple_simplify_260 (res_op, seq, valueize, type, captures, ORDERED_EXPR, ORDERED_EXPR))
16855 : 246 : return true;
16856 : : }
16857 : 0 : break;
16858 : : }
16859 : : default:;
16860 : : }
16861 : : }
16862 : : break;
16863 : 0 : default:;
16864 : : }
16865 : 0 : if (CONSTANT_CLASS_P (_p1))
16866 : : {
16867 : 0 : {
16868 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
16869 : 0 : if (gimple_simplify_261 (res_op, seq, valueize, type, captures, ORDERED_EXPR, ORDERED_EXPR))
16870 : 0 : return true;
16871 : : }
16872 : : }
16873 : : break;
16874 : : }
16875 : : default:;
16876 : : }
16877 : : }
16878 : : break;
16879 : 131318 : default:;
16880 : : }
16881 : 131318 : switch (TREE_CODE (_p1))
16882 : : {
16883 : 950 : case REAL_CST:
16884 : 950 : {
16885 : 950 : {
16886 : 950 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
16887 : 950 : if (gimple_simplify_594 (res_op, seq, valueize, type, captures, ORDERED_EXPR))
16888 : 0 : return true;
16889 : : }
16890 : 950 : break;
16891 : : }
16892 : 131318 : default:;
16893 : : }
16894 : 131318 : {
16895 : 131318 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
16896 : 131318 : if (tree_expr_nan_p (captures[0]) || tree_expr_nan_p (captures[1])
16897 : : )
16898 : : {
16899 : 0 : gimple_seq *lseq = seq;
16900 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2146;
16901 : 0 : {
16902 : 0 : tree tem;
16903 : 0 : tem = constant_boolean_node (false, type);
16904 : 0 : res_op->set_value (tem);
16905 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1082, __FILE__, __LINE__, true);
16906 : 0 : return true;
16907 : : }
16908 : 0 : next_after_fail2146:;
16909 : : }
16910 : : else
16911 : : {
16912 : 131318 : if (!tree_expr_maybe_nan_p (captures[0]) && !tree_expr_maybe_nan_p (captures[1])
16913 : : )
16914 : : {
16915 : 0 : gimple_seq *lseq = seq;
16916 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2147;
16917 : 0 : {
16918 : 0 : tree tem;
16919 : 0 : tem = constant_boolean_node (true, type);
16920 : 0 : res_op->set_value (tem);
16921 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1083, __FILE__, __LINE__, true);
16922 : 0 : return true;
16923 : : }
16924 : 0 : next_after_fail2147:;
16925 : : }
16926 : : }
16927 : : }
16928 : 131318 : return false;
16929 : : }
16930 : :
16931 : : bool
16932 : 295638 : gimple_simplify_CFN_MUL_OVERFLOW (gimple_match_op *res_op, gimple_seq *seq,
16933 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
16934 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1)
16935 : : {
16936 : 295638 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
16937 : 295638 : switch (TREE_CODE (_p0))
16938 : : {
16939 : 268920 : case SSA_NAME:
16940 : 268920 : if (gimple *_d1 = get_def (valueize, _p0))
16941 : : {
16942 : 188428 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
16943 : 15239 : switch (gimple_assign_rhs_code (_a1))
16944 : : {
16945 : 8957 : CASE_CONVERT:
16946 : 8957 : {
16947 : 8957 : tree _q20 = gimple_assign_rhs1 (_a1);
16948 : 8957 : _q20 = do_valueize (valueize, _q20);
16949 : 8957 : {
16950 : 8957 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
16951 : 8957 : if (gimple_simplify_597 (res_op, seq, valueize, type, captures, CFN_MUL_OVERFLOW))
16952 : 6395 : return true;
16953 : : }
16954 : 2562 : break;
16955 : : }
16956 : : default:;
16957 : : }
16958 : : }
16959 : : break;
16960 : 289243 : default:;
16961 : : }
16962 : 289243 : switch (TREE_CODE (_p1))
16963 : : {
16964 : 77787 : case SSA_NAME:
16965 : 77787 : if (gimple *_d1 = get_def (valueize, _p1))
16966 : : {
16967 : 50966 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
16968 : 4436 : switch (gimple_assign_rhs_code (_a1))
16969 : : {
16970 : 1239 : CASE_CONVERT:
16971 : 1239 : {
16972 : 1239 : tree _q30 = gimple_assign_rhs1 (_a1);
16973 : 1239 : _q30 = do_valueize (valueize, _q30);
16974 : 1239 : {
16975 : 1239 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q30 };
16976 : 1239 : if (gimple_simplify_598 (res_op, seq, valueize, type, captures, CFN_MUL_OVERFLOW))
16977 : 13 : return true;
16978 : : }
16979 : 1226 : break;
16980 : : }
16981 : : default:;
16982 : : }
16983 : : }
16984 : : break;
16985 : : default:;
16986 : : }
16987 : : return false;
16988 : : }
16989 : :
16990 : : bool
16991 : 3117 : gimple_simplify_CFN_BUILT_IN_SCALBN (gimple_match_op *res_op, gimple_seq *seq,
16992 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
16993 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1)
16994 : : {
16995 : 3117 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
16996 : 3117 : if (real_zerop (_p0))
16997 : : {
16998 : 28 : {
16999 : 28 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
17000 : 28 : if (gimple_simplify_608 (res_op, seq, valueize, type, captures))
17001 : 28 : return true;
17002 : : }
17003 : : }
17004 : 3089 : if (integer_zerop (_p1))
17005 : : {
17006 : 15 : {
17007 : 15 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
17008 : 15 : if (gimple_simplify_609 (res_op, seq, valueize, type, captures))
17009 : 15 : return true;
17010 : : }
17011 : : }
17012 : 3074 : switch (TREE_CODE (_p0))
17013 : : {
17014 : 1791 : case REAL_CST:
17015 : 1791 : {
17016 : 1791 : {
17017 : 1791 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
17018 : 1791 : if (!real_isfinite (TREE_REAL_CST_PTR (captures[0]))
17019 : : )
17020 : : {
17021 : 71 : gimple_seq *lseq = seq;
17022 : 71 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2172;
17023 : 71 : {
17024 : 71 : tree tem;
17025 : 71 : tem = captures[0];
17026 : 71 : res_op->set_value (tem);
17027 : 71 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1085, __FILE__, __LINE__, true);
17028 : 71 : return true;
17029 : : }
17030 : 0 : next_after_fail2172:;
17031 : : }
17032 : : }
17033 : 1720 : break;
17034 : : }
17035 : : default:;
17036 : : }
17037 : : return false;
17038 : : }
17039 : :
17040 : : bool
17041 : 0 : gimple_simplify_TRUTH_OR_EXPR (gimple_match_op *res_op, gimple_seq *seq,
17042 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
17043 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1)
17044 : : {
17045 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
17046 : 0 : switch (TREE_CODE (_p0))
17047 : : {
17048 : 0 : case SSA_NAME:
17049 : 0 : if (gimple *_d1 = get_def (valueize, _p0))
17050 : : {
17051 : 0 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
17052 : 0 : switch (gimple_assign_rhs_code (_a1))
17053 : : {
17054 : 0 : case LE_EXPR:
17055 : 0 : {
17056 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
17057 : 0 : _q20 = do_valueize (valueize, _q20);
17058 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
17059 : 0 : _q21 = do_valueize (valueize, _q21);
17060 : 0 : switch (TREE_CODE (_q20))
17061 : : {
17062 : 0 : case SSA_NAME:
17063 : 0 : if (gimple *_d2 = get_def (valueize, _q20))
17064 : : {
17065 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
17066 : 0 : switch (gimple_assign_rhs_code (_a2))
17067 : : {
17068 : 0 : case POINTER_PLUS_EXPR:
17069 : 0 : {
17070 : 0 : tree _q30 = gimple_assign_rhs1 (_a2);
17071 : 0 : _q30 = do_valueize (valueize, _q30);
17072 : 0 : tree _q31 = gimple_assign_rhs2 (_a2);
17073 : 0 : _q31 = do_valueize (valueize, _q31);
17074 : 0 : switch (TREE_CODE (_q31))
17075 : : {
17076 : 0 : case INTEGER_CST:
17077 : 0 : {
17078 : 0 : switch (TREE_CODE (_p1))
17079 : : {
17080 : 0 : case SSA_NAME:
17081 : 0 : if (gimple *_d3 = get_def (valueize, _p1))
17082 : : {
17083 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
17084 : 0 : switch (gimple_assign_rhs_code (_a3))
17085 : : {
17086 : 0 : case LE_EXPR:
17087 : 0 : {
17088 : 0 : tree _q70 = gimple_assign_rhs1 (_a3);
17089 : 0 : _q70 = do_valueize (valueize, _q70);
17090 : 0 : tree _q71 = gimple_assign_rhs2 (_a3);
17091 : 0 : _q71 = do_valueize (valueize, _q71);
17092 : 0 : switch (TREE_CODE (_q70))
17093 : : {
17094 : 0 : case SSA_NAME:
17095 : 0 : if (gimple *_d4 = get_def (valueize, _q70))
17096 : : {
17097 : 0 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
17098 : 0 : switch (gimple_assign_rhs_code (_a4))
17099 : : {
17100 : 0 : case POINTER_PLUS_EXPR:
17101 : 0 : {
17102 : 0 : tree _q80 = gimple_assign_rhs1 (_a4);
17103 : 0 : _q80 = do_valueize (valueize, _q80);
17104 : 0 : tree _q81 = gimple_assign_rhs2 (_a4);
17105 : 0 : _q81 = do_valueize (valueize, _q81);
17106 : 0 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
17107 : : {
17108 : 0 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
17109 : : {
17110 : 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
17111 : : {
17112 : 0 : {
17113 : 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70 };
17114 : 0 : const enum tree_code cmp = LE_EXPR;
17115 : 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
17116 : 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
17117 : 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
17118 : : )
17119 : : {
17120 : 0 : {
17121 : 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
17122 : 0 : offset_int rhs = off * 2;
17123 : 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
17124 : : )
17125 : : {
17126 : 0 : {
17127 : 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
17128 : 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
17129 : 0 : if (cmp == LT_EXPR
17130 : : )
17131 : : {
17132 : : gimple_seq *lseq = seq;
17133 : : if (lseq
17134 : : && (!single_use (captures[0])
17135 : : || !single_use (captures[5])))
17136 : : lseq = NULL;
17137 : : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2193;
17138 : : {
17139 : : res_op->set_op (GT_EXPR, type, 2);
17140 : : {
17141 : : tree _o1[1], _r1;
17142 : : {
17143 : : tree _o2[2], _r2;
17144 : : _o2[0] = swap_p ? captures[6] : captures[1];
17145 : : _o2[1] = swap_p ? captures[2] : captures[4];
17146 : : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
17147 : : tem_op.resimplify (lseq, valueize);
17148 : : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
17149 : : if (!_r2) goto next_after_fail2193;
17150 : : _o1[0] = _r2;
17151 : : }
17152 : : if (sizetype != TREE_TYPE (_o1[0])
17153 : : && !useless_type_conversion_p (sizetype, TREE_TYPE (_o1[0])))
17154 : : {
17155 : : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, sizetype, _o1[0]);
17156 : : tem_op.resimplify (lseq, valueize);
17157 : : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
17158 : : if (!_r1) goto next_after_fail2193;
17159 : : }
17160 : : else
17161 : : _r1 = _o1[0];
17162 : : res_op->ops[0] = _r1;
17163 : : }
17164 : : res_op->ops[1] = rhs_tree;
17165 : : res_op->resimplify (lseq, valueize);
17166 : : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 973, __FILE__, __LINE__, true);
17167 : 0 : return true;
17168 : : }
17169 : : next_after_fail2193:;
17170 : : }
17171 : : else
17172 : : {
17173 : 0 : gimple_seq *lseq = seq;
17174 : 0 : if (lseq
17175 : 0 : && (!single_use (captures[0])
17176 : 0 : || !single_use (captures[5])))
17177 : 0 : lseq = NULL;
17178 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2194;
17179 : 0 : {
17180 : 0 : res_op->set_op (GT_EXPR, type, 2);
17181 : 0 : {
17182 : 0 : tree _o1[1], _r1;
17183 : 0 : {
17184 : 0 : tree _o2[2], _r2;
17185 : 0 : {
17186 : 0 : tree _o3[2], _r3;
17187 : 0 : _o3[0] = swap_p ? captures[4] : captures[2];
17188 : 0 : _o3[1] = wide_int_to_tree (sizetype, off);
17189 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
17190 : 0 : tem_op.resimplify (lseq, valueize);
17191 : 0 : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
17192 : 0 : if (!_r3) goto next_after_fail2194;
17193 : 0 : _o2[0] = _r3;
17194 : : }
17195 : 0 : _o2[1] = swap_p ? captures[2] : captures[4];
17196 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
17197 : 0 : tem_op.resimplify (lseq, valueize);
17198 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
17199 : 0 : if (!_r2) goto next_after_fail2194;
17200 : 0 : _o1[0] = _r2;
17201 : : }
17202 : 0 : if (sizetype != TREE_TYPE (_o1[0])
17203 : 0 : && !useless_type_conversion_p (sizetype, TREE_TYPE (_o1[0])))
17204 : : {
17205 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, sizetype, _o1[0]);
17206 : 0 : tem_op.resimplify (lseq, valueize);
17207 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
17208 : 0 : if (!_r1) goto next_after_fail2194;
17209 : : }
17210 : : else
17211 : : _r1 = _o1[0];
17212 : 0 : res_op->ops[0] = _r1;
17213 : : }
17214 : 0 : res_op->ops[1] = rhs_tree;
17215 : 0 : res_op->resimplify (lseq, valueize);
17216 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 974, __FILE__, __LINE__, true);
17217 : 0 : return true;
17218 : : }
17219 : 0 : next_after_fail2194:;
17220 : : }
17221 : : }
17222 : : }
17223 : : }
17224 : : }
17225 : : }
17226 : : }
17227 : : }
17228 : : }
17229 : : break;
17230 : : }
17231 : : default:;
17232 : : }
17233 : : }
17234 : : break;
17235 : : default:;
17236 : : }
17237 : : break;
17238 : : }
17239 : 0 : case GE_EXPR:
17240 : 0 : {
17241 : 0 : tree _q70 = gimple_assign_rhs1 (_a3);
17242 : 0 : _q70 = do_valueize (valueize, _q70);
17243 : 0 : tree _q71 = gimple_assign_rhs2 (_a3);
17244 : 0 : _q71 = do_valueize (valueize, _q71);
17245 : 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
17246 : : {
17247 : 0 : switch (TREE_CODE (_q71))
17248 : : {
17249 : 0 : case SSA_NAME:
17250 : 0 : if (gimple *_d4 = get_def (valueize, _q71))
17251 : : {
17252 : 0 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
17253 : 0 : switch (gimple_assign_rhs_code (_a4))
17254 : : {
17255 : 0 : case POINTER_PLUS_EXPR:
17256 : 0 : {
17257 : 0 : tree _q90 = gimple_assign_rhs1 (_a4);
17258 : 0 : _q90 = do_valueize (valueize, _q90);
17259 : 0 : tree _q91 = gimple_assign_rhs2 (_a4);
17260 : 0 : _q91 = do_valueize (valueize, _q91);
17261 : 0 : if ((_q90 == _q21 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q21, 0) && types_match (_q90, _q21)))
17262 : : {
17263 : 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
17264 : : {
17265 : 0 : {
17266 : 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q71 };
17267 : 0 : const enum tree_code cmp = LE_EXPR;
17268 : 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
17269 : 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
17270 : 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
17271 : : )
17272 : : {
17273 : 0 : {
17274 : 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
17275 : 0 : offset_int rhs = off * 2;
17276 : 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
17277 : : )
17278 : : {
17279 : 0 : {
17280 : 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
17281 : 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
17282 : 0 : if (cmp == LT_EXPR
17283 : : )
17284 : : {
17285 : : gimple_seq *lseq = seq;
17286 : : if (lseq
17287 : : && (!single_use (captures[0])
17288 : : || !single_use (captures[5])))
17289 : : lseq = NULL;
17290 : : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2195;
17291 : : {
17292 : : res_op->set_op (GT_EXPR, type, 2);
17293 : : {
17294 : : tree _o1[1], _r1;
17295 : : {
17296 : : tree _o2[2], _r2;
17297 : : _o2[0] = swap_p ? captures[6] : captures[1];
17298 : : _o2[1] = swap_p ? captures[2] : captures[4];
17299 : : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
17300 : : tem_op.resimplify (lseq, valueize);
17301 : : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
17302 : : if (!_r2) goto next_after_fail2195;
17303 : : _o1[0] = _r2;
17304 : : }
17305 : : if (sizetype != TREE_TYPE (_o1[0])
17306 : : && !useless_type_conversion_p (sizetype, TREE_TYPE (_o1[0])))
17307 : : {
17308 : : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, sizetype, _o1[0]);
17309 : : tem_op.resimplify (lseq, valueize);
17310 : : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
17311 : : if (!_r1) goto next_after_fail2195;
17312 : : }
17313 : : else
17314 : : _r1 = _o1[0];
17315 : : res_op->ops[0] = _r1;
17316 : : }
17317 : : res_op->ops[1] = rhs_tree;
17318 : : res_op->resimplify (lseq, valueize);
17319 : : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 973, __FILE__, __LINE__, true);
17320 : 0 : return true;
17321 : : }
17322 : : next_after_fail2195:;
17323 : : }
17324 : : else
17325 : : {
17326 : 0 : gimple_seq *lseq = seq;
17327 : 0 : if (lseq
17328 : 0 : && (!single_use (captures[0])
17329 : 0 : || !single_use (captures[5])))
17330 : 0 : lseq = NULL;
17331 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2196;
17332 : 0 : {
17333 : 0 : res_op->set_op (GT_EXPR, type, 2);
17334 : 0 : {
17335 : 0 : tree _o1[1], _r1;
17336 : 0 : {
17337 : 0 : tree _o2[2], _r2;
17338 : 0 : {
17339 : 0 : tree _o3[2], _r3;
17340 : 0 : _o3[0] = swap_p ? captures[4] : captures[2];
17341 : 0 : _o3[1] = wide_int_to_tree (sizetype, off);
17342 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
17343 : 0 : tem_op.resimplify (lseq, valueize);
17344 : 0 : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
17345 : 0 : if (!_r3) goto next_after_fail2196;
17346 : 0 : _o2[0] = _r3;
17347 : : }
17348 : 0 : _o2[1] = swap_p ? captures[2] : captures[4];
17349 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
17350 : 0 : tem_op.resimplify (lseq, valueize);
17351 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
17352 : 0 : if (!_r2) goto next_after_fail2196;
17353 : 0 : _o1[0] = _r2;
17354 : : }
17355 : 0 : if (sizetype != TREE_TYPE (_o1[0])
17356 : 0 : && !useless_type_conversion_p (sizetype, TREE_TYPE (_o1[0])))
17357 : : {
17358 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, sizetype, _o1[0]);
17359 : 0 : tem_op.resimplify (lseq, valueize);
17360 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
17361 : 0 : if (!_r1) goto next_after_fail2196;
17362 : : }
17363 : : else
17364 : : _r1 = _o1[0];
17365 : 0 : res_op->ops[0] = _r1;
17366 : : }
17367 : 0 : res_op->ops[1] = rhs_tree;
17368 : 0 : res_op->resimplify (lseq, valueize);
17369 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 974, __FILE__, __LINE__, true);
17370 : 0 : return true;
17371 : : }
17372 : 0 : next_after_fail2196:;
17373 : : }
17374 : : }
17375 : : }
17376 : : }
17377 : : }
17378 : : }
17379 : : }
17380 : : }
17381 : : break;
17382 : : }
17383 : : default:;
17384 : : }
17385 : : }
17386 : : break;
17387 : : default:;
17388 : : }
17389 : : }
17390 : : break;
17391 : : }
17392 : : default:;
17393 : : }
17394 : : }
17395 : : break;
17396 : : default:;
17397 : : }
17398 : : break;
17399 : : }
17400 : : default:;
17401 : : }
17402 : : break;
17403 : : }
17404 : : default:;
17405 : : }
17406 : : }
17407 : : break;
17408 : : default:;
17409 : : }
17410 : : break;
17411 : : }
17412 : 0 : case LT_EXPR:
17413 : 0 : {
17414 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
17415 : 0 : _q20 = do_valueize (valueize, _q20);
17416 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
17417 : 0 : _q21 = do_valueize (valueize, _q21);
17418 : 0 : switch (TREE_CODE (_q20))
17419 : : {
17420 : 0 : case SSA_NAME:
17421 : 0 : if (gimple *_d2 = get_def (valueize, _q20))
17422 : : {
17423 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
17424 : 0 : switch (gimple_assign_rhs_code (_a2))
17425 : : {
17426 : 0 : case POINTER_PLUS_EXPR:
17427 : 0 : {
17428 : 0 : tree _q30 = gimple_assign_rhs1 (_a2);
17429 : 0 : _q30 = do_valueize (valueize, _q30);
17430 : 0 : tree _q31 = gimple_assign_rhs2 (_a2);
17431 : 0 : _q31 = do_valueize (valueize, _q31);
17432 : 0 : switch (TREE_CODE (_q31))
17433 : : {
17434 : 0 : case INTEGER_CST:
17435 : 0 : {
17436 : 0 : switch (TREE_CODE (_p1))
17437 : : {
17438 : 0 : case SSA_NAME:
17439 : 0 : if (gimple *_d3 = get_def (valueize, _p1))
17440 : : {
17441 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
17442 : 0 : switch (gimple_assign_rhs_code (_a3))
17443 : : {
17444 : 0 : case LT_EXPR:
17445 : 0 : {
17446 : 0 : tree _q70 = gimple_assign_rhs1 (_a3);
17447 : 0 : _q70 = do_valueize (valueize, _q70);
17448 : 0 : tree _q71 = gimple_assign_rhs2 (_a3);
17449 : 0 : _q71 = do_valueize (valueize, _q71);
17450 : 0 : switch (TREE_CODE (_q70))
17451 : : {
17452 : 0 : case SSA_NAME:
17453 : 0 : if (gimple *_d4 = get_def (valueize, _q70))
17454 : : {
17455 : 0 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
17456 : 0 : switch (gimple_assign_rhs_code (_a4))
17457 : : {
17458 : 0 : case POINTER_PLUS_EXPR:
17459 : 0 : {
17460 : 0 : tree _q80 = gimple_assign_rhs1 (_a4);
17461 : 0 : _q80 = do_valueize (valueize, _q80);
17462 : 0 : tree _q81 = gimple_assign_rhs2 (_a4);
17463 : 0 : _q81 = do_valueize (valueize, _q81);
17464 : 0 : if ((_q80 == _q21 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q21, 0) && types_match (_q80, _q21)))
17465 : : {
17466 : 0 : if ((_q81 == _q31 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q31, 0) && types_match (_q81, _q31)))
17467 : : {
17468 : 0 : if ((_q71 == _q30 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q30, 0) && types_match (_q71, _q30)))
17469 : : {
17470 : 0 : {
17471 : 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q70 };
17472 : 0 : const enum tree_code cmp = LT_EXPR;
17473 : 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
17474 : 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
17475 : 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
17476 : : )
17477 : : {
17478 : 0 : {
17479 : 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
17480 : 0 : offset_int rhs = off * 2;
17481 : 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
17482 : : )
17483 : : {
17484 : 0 : {
17485 : 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
17486 : 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
17487 : 0 : if (cmp == LT_EXPR
17488 : : )
17489 : : {
17490 : 0 : gimple_seq *lseq = seq;
17491 : 0 : if (lseq
17492 : 0 : && (!single_use (captures[0])
17493 : 0 : || !single_use (captures[5])))
17494 : 0 : lseq = NULL;
17495 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2197;
17496 : 0 : {
17497 : 0 : res_op->set_op (GT_EXPR, type, 2);
17498 : 0 : {
17499 : 0 : tree _o1[1], _r1;
17500 : 0 : {
17501 : 0 : tree _o2[2], _r2;
17502 : 0 : _o2[0] = swap_p ? captures[6] : captures[1];
17503 : 0 : _o2[1] = swap_p ? captures[2] : captures[4];
17504 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
17505 : 0 : tem_op.resimplify (lseq, valueize);
17506 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
17507 : 0 : if (!_r2) goto next_after_fail2197;
17508 : 0 : _o1[0] = _r2;
17509 : : }
17510 : 0 : if (sizetype != TREE_TYPE (_o1[0])
17511 : 0 : && !useless_type_conversion_p (sizetype, TREE_TYPE (_o1[0])))
17512 : : {
17513 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, sizetype, _o1[0]);
17514 : 0 : tem_op.resimplify (lseq, valueize);
17515 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
17516 : 0 : if (!_r1) goto next_after_fail2197;
17517 : : }
17518 : : else
17519 : : _r1 = _o1[0];
17520 : 0 : res_op->ops[0] = _r1;
17521 : : }
17522 : 0 : res_op->ops[1] = rhs_tree;
17523 : 0 : res_op->resimplify (lseq, valueize);
17524 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 973, __FILE__, __LINE__, true);
17525 : 0 : return true;
17526 : : }
17527 : 0 : next_after_fail2197:;
17528 : : }
17529 : : else
17530 : : {
17531 : : gimple_seq *lseq = seq;
17532 : : if (lseq
17533 : : && (!single_use (captures[0])
17534 : : || !single_use (captures[5])))
17535 : : lseq = NULL;
17536 : : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2198;
17537 : : {
17538 : : res_op->set_op (GT_EXPR, type, 2);
17539 : : {
17540 : : tree _o1[1], _r1;
17541 : : {
17542 : : tree _o2[2], _r2;
17543 : : {
17544 : : tree _o3[2], _r3;
17545 : : _o3[0] = swap_p ? captures[4] : captures[2];
17546 : : _o3[1] = wide_int_to_tree (sizetype, off);
17547 : : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
17548 : : tem_op.resimplify (lseq, valueize);
17549 : : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
17550 : : if (!_r3) goto next_after_fail2198;
17551 : : _o2[0] = _r3;
17552 : : }
17553 : : _o2[1] = swap_p ? captures[2] : captures[4];
17554 : : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
17555 : : tem_op.resimplify (lseq, valueize);
17556 : : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
17557 : : if (!_r2) goto next_after_fail2198;
17558 : : _o1[0] = _r2;
17559 : : }
17560 : : if (sizetype != TREE_TYPE (_o1[0])
17561 : : && !useless_type_conversion_p (sizetype, TREE_TYPE (_o1[0])))
17562 : : {
17563 : : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, sizetype, _o1[0]);
17564 : : tem_op.resimplify (lseq, valueize);
17565 : : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
17566 : : if (!_r1) goto next_after_fail2198;
17567 : : }
17568 : : else
17569 : : _r1 = _o1[0];
17570 : : res_op->ops[0] = _r1;
17571 : : }
17572 : : res_op->ops[1] = rhs_tree;
17573 : : res_op->resimplify (lseq, valueize);
17574 : : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 974, __FILE__, __LINE__, true);
17575 : : return true;
17576 : : }
17577 : : next_after_fail2198:;
17578 : : }
17579 : : }
17580 : : }
17581 : : }
17582 : : }
17583 : : }
17584 : : }
17585 : : }
17586 : : }
17587 : : break;
17588 : : }
17589 : : default:;
17590 : : }
17591 : : }
17592 : : break;
17593 : : default:;
17594 : : }
17595 : : break;
17596 : : }
17597 : 0 : case GT_EXPR:
17598 : 0 : {
17599 : 0 : tree _q70 = gimple_assign_rhs1 (_a3);
17600 : 0 : _q70 = do_valueize (valueize, _q70);
17601 : 0 : tree _q71 = gimple_assign_rhs2 (_a3);
17602 : 0 : _q71 = do_valueize (valueize, _q71);
17603 : 0 : if ((_q70 == _q30 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q30, 0) && types_match (_q70, _q30)))
17604 : : {
17605 : 0 : switch (TREE_CODE (_q71))
17606 : : {
17607 : 0 : case SSA_NAME:
17608 : 0 : if (gimple *_d4 = get_def (valueize, _q71))
17609 : : {
17610 : 0 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
17611 : 0 : switch (gimple_assign_rhs_code (_a4))
17612 : : {
17613 : 0 : case POINTER_PLUS_EXPR:
17614 : 0 : {
17615 : 0 : tree _q90 = gimple_assign_rhs1 (_a4);
17616 : 0 : _q90 = do_valueize (valueize, _q90);
17617 : 0 : tree _q91 = gimple_assign_rhs2 (_a4);
17618 : 0 : _q91 = do_valueize (valueize, _q91);
17619 : 0 : if ((_q90 == _q21 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q21, 0) && types_match (_q90, _q21)))
17620 : : {
17621 : 0 : if ((_q91 == _q31 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q31, 0) && types_match (_q91, _q31)))
17622 : : {
17623 : 0 : {
17624 : 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1, _q71 };
17625 : 0 : const enum tree_code cmp = LT_EXPR;
17626 : 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
17627 : 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
17628 : 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
17629 : : )
17630 : : {
17631 : 0 : {
17632 : 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
17633 : 0 : offset_int rhs = off * 2;
17634 : 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
17635 : : )
17636 : : {
17637 : 0 : {
17638 : 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
17639 : 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
17640 : 0 : if (cmp == LT_EXPR
17641 : : )
17642 : : {
17643 : 0 : gimple_seq *lseq = seq;
17644 : 0 : if (lseq
17645 : 0 : && (!single_use (captures[0])
17646 : 0 : || !single_use (captures[5])))
17647 : 0 : lseq = NULL;
17648 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2199;
17649 : 0 : {
17650 : 0 : res_op->set_op (GT_EXPR, type, 2);
17651 : 0 : {
17652 : 0 : tree _o1[1], _r1;
17653 : 0 : {
17654 : 0 : tree _o2[2], _r2;
17655 : 0 : _o2[0] = swap_p ? captures[6] : captures[1];
17656 : 0 : _o2[1] = swap_p ? captures[2] : captures[4];
17657 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
17658 : 0 : tem_op.resimplify (lseq, valueize);
17659 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
17660 : 0 : if (!_r2) goto next_after_fail2199;
17661 : 0 : _o1[0] = _r2;
17662 : : }
17663 : 0 : if (sizetype != TREE_TYPE (_o1[0])
17664 : 0 : && !useless_type_conversion_p (sizetype, TREE_TYPE (_o1[0])))
17665 : : {
17666 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, sizetype, _o1[0]);
17667 : 0 : tem_op.resimplify (lseq, valueize);
17668 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
17669 : 0 : if (!_r1) goto next_after_fail2199;
17670 : : }
17671 : : else
17672 : : _r1 = _o1[0];
17673 : 0 : res_op->ops[0] = _r1;
17674 : : }
17675 : 0 : res_op->ops[1] = rhs_tree;
17676 : 0 : res_op->resimplify (lseq, valueize);
17677 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 973, __FILE__, __LINE__, true);
17678 : 0 : return true;
17679 : : }
17680 : 0 : next_after_fail2199:;
17681 : : }
17682 : : else
17683 : : {
17684 : : gimple_seq *lseq = seq;
17685 : : if (lseq
17686 : : && (!single_use (captures[0])
17687 : : || !single_use (captures[5])))
17688 : : lseq = NULL;
17689 : : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2200;
17690 : : {
17691 : : res_op->set_op (GT_EXPR, type, 2);
17692 : : {
17693 : : tree _o1[1], _r1;
17694 : : {
17695 : : tree _o2[2], _r2;
17696 : : {
17697 : : tree _o3[2], _r3;
17698 : : _o3[0] = swap_p ? captures[4] : captures[2];
17699 : : _o3[1] = wide_int_to_tree (sizetype, off);
17700 : : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
17701 : : tem_op.resimplify (lseq, valueize);
17702 : : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
17703 : : if (!_r3) goto next_after_fail2200;
17704 : : _o2[0] = _r3;
17705 : : }
17706 : : _o2[1] = swap_p ? captures[2] : captures[4];
17707 : : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
17708 : : tem_op.resimplify (lseq, valueize);
17709 : : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
17710 : : if (!_r2) goto next_after_fail2200;
17711 : : _o1[0] = _r2;
17712 : : }
17713 : : if (sizetype != TREE_TYPE (_o1[0])
17714 : : && !useless_type_conversion_p (sizetype, TREE_TYPE (_o1[0])))
17715 : : {
17716 : : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, sizetype, _o1[0]);
17717 : : tem_op.resimplify (lseq, valueize);
17718 : : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
17719 : : if (!_r1) goto next_after_fail2200;
17720 : : }
17721 : : else
17722 : : _r1 = _o1[0];
17723 : : res_op->ops[0] = _r1;
17724 : : }
17725 : : res_op->ops[1] = rhs_tree;
17726 : : res_op->resimplify (lseq, valueize);
17727 : : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 974, __FILE__, __LINE__, true);
17728 : : return true;
17729 : : }
17730 : : next_after_fail2200:;
17731 : : }
17732 : : }
17733 : : }
17734 : : }
17735 : : }
17736 : : }
17737 : : }
17738 : : }
17739 : : break;
17740 : : }
17741 : : default:;
17742 : : }
17743 : : }
17744 : : break;
17745 : : default:;
17746 : : }
17747 : : }
17748 : : break;
17749 : : }
17750 : : default:;
17751 : : }
17752 : : }
17753 : : break;
17754 : : default:;
17755 : : }
17756 : : break;
17757 : : }
17758 : : default:;
17759 : : }
17760 : : break;
17761 : : }
17762 : : default:;
17763 : : }
17764 : : }
17765 : : break;
17766 : : default:;
17767 : : }
17768 : : break;
17769 : : }
17770 : 0 : case GE_EXPR:
17771 : 0 : {
17772 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
17773 : 0 : _q20 = do_valueize (valueize, _q20);
17774 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
17775 : 0 : _q21 = do_valueize (valueize, _q21);
17776 : 0 : switch (TREE_CODE (_q21))
17777 : : {
17778 : 0 : case SSA_NAME:
17779 : 0 : if (gimple *_d2 = get_def (valueize, _q21))
17780 : : {
17781 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
17782 : 0 : switch (gimple_assign_rhs_code (_a2))
17783 : : {
17784 : 0 : case POINTER_PLUS_EXPR:
17785 : 0 : {
17786 : 0 : tree _q40 = gimple_assign_rhs1 (_a2);
17787 : 0 : _q40 = do_valueize (valueize, _q40);
17788 : 0 : tree _q41 = gimple_assign_rhs2 (_a2);
17789 : 0 : _q41 = do_valueize (valueize, _q41);
17790 : 0 : switch (TREE_CODE (_q41))
17791 : : {
17792 : 0 : case INTEGER_CST:
17793 : 0 : {
17794 : 0 : switch (TREE_CODE (_p1))
17795 : : {
17796 : 0 : case SSA_NAME:
17797 : 0 : if (gimple *_d3 = get_def (valueize, _p1))
17798 : : {
17799 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
17800 : 0 : switch (gimple_assign_rhs_code (_a3))
17801 : : {
17802 : 0 : case LE_EXPR:
17803 : 0 : {
17804 : 0 : tree _q70 = gimple_assign_rhs1 (_a3);
17805 : 0 : _q70 = do_valueize (valueize, _q70);
17806 : 0 : tree _q71 = gimple_assign_rhs2 (_a3);
17807 : 0 : _q71 = do_valueize (valueize, _q71);
17808 : 0 : switch (TREE_CODE (_q70))
17809 : : {
17810 : 0 : case SSA_NAME:
17811 : 0 : if (gimple *_d4 = get_def (valueize, _q70))
17812 : : {
17813 : 0 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
17814 : 0 : switch (gimple_assign_rhs_code (_a4))
17815 : : {
17816 : 0 : case POINTER_PLUS_EXPR:
17817 : 0 : {
17818 : 0 : tree _q80 = gimple_assign_rhs1 (_a4);
17819 : 0 : _q80 = do_valueize (valueize, _q80);
17820 : 0 : tree _q81 = gimple_assign_rhs2 (_a4);
17821 : 0 : _q81 = do_valueize (valueize, _q81);
17822 : 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
17823 : : {
17824 : 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
17825 : : {
17826 : 0 : if ((_q71 == _q40 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q40, 0) && types_match (_q71, _q40)))
17827 : : {
17828 : 0 : {
17829 : 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q70 };
17830 : 0 : const enum tree_code cmp = LE_EXPR;
17831 : 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
17832 : 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
17833 : 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
17834 : : )
17835 : : {
17836 : 0 : {
17837 : 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
17838 : 0 : offset_int rhs = off * 2;
17839 : 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
17840 : : )
17841 : : {
17842 : 0 : {
17843 : 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
17844 : 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
17845 : 0 : if (cmp == LT_EXPR
17846 : : )
17847 : : {
17848 : : gimple_seq *lseq = seq;
17849 : : if (lseq
17850 : : && (!single_use (captures[0])
17851 : : || !single_use (captures[5])))
17852 : : lseq = NULL;
17853 : : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2201;
17854 : : {
17855 : : res_op->set_op (GT_EXPR, type, 2);
17856 : : {
17857 : : tree _o1[1], _r1;
17858 : : {
17859 : : tree _o2[2], _r2;
17860 : : _o2[0] = swap_p ? captures[6] : captures[1];
17861 : : _o2[1] = swap_p ? captures[2] : captures[4];
17862 : : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
17863 : : tem_op.resimplify (lseq, valueize);
17864 : : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
17865 : : if (!_r2) goto next_after_fail2201;
17866 : : _o1[0] = _r2;
17867 : : }
17868 : : if (sizetype != TREE_TYPE (_o1[0])
17869 : : && !useless_type_conversion_p (sizetype, TREE_TYPE (_o1[0])))
17870 : : {
17871 : : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, sizetype, _o1[0]);
17872 : : tem_op.resimplify (lseq, valueize);
17873 : : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
17874 : : if (!_r1) goto next_after_fail2201;
17875 : : }
17876 : : else
17877 : : _r1 = _o1[0];
17878 : : res_op->ops[0] = _r1;
17879 : : }
17880 : : res_op->ops[1] = rhs_tree;
17881 : : res_op->resimplify (lseq, valueize);
17882 : : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 973, __FILE__, __LINE__, true);
17883 : 0 : return true;
17884 : : }
17885 : : next_after_fail2201:;
17886 : : }
17887 : : else
17888 : : {
17889 : 0 : gimple_seq *lseq = seq;
17890 : 0 : if (lseq
17891 : 0 : && (!single_use (captures[0])
17892 : 0 : || !single_use (captures[5])))
17893 : 0 : lseq = NULL;
17894 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2202;
17895 : 0 : {
17896 : 0 : res_op->set_op (GT_EXPR, type, 2);
17897 : 0 : {
17898 : 0 : tree _o1[1], _r1;
17899 : 0 : {
17900 : 0 : tree _o2[2], _r2;
17901 : 0 : {
17902 : 0 : tree _o3[2], _r3;
17903 : 0 : _o3[0] = swap_p ? captures[4] : captures[2];
17904 : 0 : _o3[1] = wide_int_to_tree (sizetype, off);
17905 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
17906 : 0 : tem_op.resimplify (lseq, valueize);
17907 : 0 : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
17908 : 0 : if (!_r3) goto next_after_fail2202;
17909 : 0 : _o2[0] = _r3;
17910 : : }
17911 : 0 : _o2[1] = swap_p ? captures[2] : captures[4];
17912 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
17913 : 0 : tem_op.resimplify (lseq, valueize);
17914 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
17915 : 0 : if (!_r2) goto next_after_fail2202;
17916 : 0 : _o1[0] = _r2;
17917 : : }
17918 : 0 : if (sizetype != TREE_TYPE (_o1[0])
17919 : 0 : && !useless_type_conversion_p (sizetype, TREE_TYPE (_o1[0])))
17920 : : {
17921 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, sizetype, _o1[0]);
17922 : 0 : tem_op.resimplify (lseq, valueize);
17923 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
17924 : 0 : if (!_r1) goto next_after_fail2202;
17925 : : }
17926 : : else
17927 : : _r1 = _o1[0];
17928 : 0 : res_op->ops[0] = _r1;
17929 : : }
17930 : 0 : res_op->ops[1] = rhs_tree;
17931 : 0 : res_op->resimplify (lseq, valueize);
17932 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 974, __FILE__, __LINE__, true);
17933 : 0 : return true;
17934 : : }
17935 : 0 : next_after_fail2202:;
17936 : : }
17937 : : }
17938 : : }
17939 : : }
17940 : : }
17941 : : }
17942 : : }
17943 : : }
17944 : : }
17945 : : break;
17946 : : }
17947 : : default:;
17948 : : }
17949 : : }
17950 : : break;
17951 : : default:;
17952 : : }
17953 : : break;
17954 : : }
17955 : 0 : case GE_EXPR:
17956 : 0 : {
17957 : 0 : tree _q70 = gimple_assign_rhs1 (_a3);
17958 : 0 : _q70 = do_valueize (valueize, _q70);
17959 : 0 : tree _q71 = gimple_assign_rhs2 (_a3);
17960 : 0 : _q71 = do_valueize (valueize, _q71);
17961 : 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
17962 : : {
17963 : 0 : switch (TREE_CODE (_q71))
17964 : : {
17965 : 0 : case SSA_NAME:
17966 : 0 : if (gimple *_d4 = get_def (valueize, _q71))
17967 : : {
17968 : 0 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
17969 : 0 : switch (gimple_assign_rhs_code (_a4))
17970 : : {
17971 : 0 : case POINTER_PLUS_EXPR:
17972 : 0 : {
17973 : 0 : tree _q90 = gimple_assign_rhs1 (_a4);
17974 : 0 : _q90 = do_valueize (valueize, _q90);
17975 : 0 : tree _q91 = gimple_assign_rhs2 (_a4);
17976 : 0 : _q91 = do_valueize (valueize, _q91);
17977 : 0 : if ((_q90 == _q20 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q20, 0) && types_match (_q90, _q20)))
17978 : : {
17979 : 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
17980 : : {
17981 : 0 : {
17982 : 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q71 };
17983 : 0 : const enum tree_code cmp = LE_EXPR;
17984 : 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
17985 : 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
17986 : 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
17987 : : )
17988 : : {
17989 : 0 : {
17990 : 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
17991 : 0 : offset_int rhs = off * 2;
17992 : 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
17993 : : )
17994 : : {
17995 : 0 : {
17996 : 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
17997 : 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
17998 : 0 : if (cmp == LT_EXPR
17999 : : )
18000 : : {
18001 : : gimple_seq *lseq = seq;
18002 : : if (lseq
18003 : : && (!single_use (captures[0])
18004 : : || !single_use (captures[5])))
18005 : : lseq = NULL;
18006 : : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2203;
18007 : : {
18008 : : res_op->set_op (GT_EXPR, type, 2);
18009 : : {
18010 : : tree _o1[1], _r1;
18011 : : {
18012 : : tree _o2[2], _r2;
18013 : : _o2[0] = swap_p ? captures[6] : captures[1];
18014 : : _o2[1] = swap_p ? captures[2] : captures[4];
18015 : : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
18016 : : tem_op.resimplify (lseq, valueize);
18017 : : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
18018 : : if (!_r2) goto next_after_fail2203;
18019 : : _o1[0] = _r2;
18020 : : }
18021 : : if (sizetype != TREE_TYPE (_o1[0])
18022 : : && !useless_type_conversion_p (sizetype, TREE_TYPE (_o1[0])))
18023 : : {
18024 : : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, sizetype, _o1[0]);
18025 : : tem_op.resimplify (lseq, valueize);
18026 : : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
18027 : : if (!_r1) goto next_after_fail2203;
18028 : : }
18029 : : else
18030 : : _r1 = _o1[0];
18031 : : res_op->ops[0] = _r1;
18032 : : }
18033 : : res_op->ops[1] = rhs_tree;
18034 : : res_op->resimplify (lseq, valueize);
18035 : : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 973, __FILE__, __LINE__, true);
18036 : 0 : return true;
18037 : : }
18038 : : next_after_fail2203:;
18039 : : }
18040 : : else
18041 : : {
18042 : 0 : gimple_seq *lseq = seq;
18043 : 0 : if (lseq
18044 : 0 : && (!single_use (captures[0])
18045 : 0 : || !single_use (captures[5])))
18046 : 0 : lseq = NULL;
18047 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2204;
18048 : 0 : {
18049 : 0 : res_op->set_op (GT_EXPR, type, 2);
18050 : 0 : {
18051 : 0 : tree _o1[1], _r1;
18052 : 0 : {
18053 : 0 : tree _o2[2], _r2;
18054 : 0 : {
18055 : 0 : tree _o3[2], _r3;
18056 : 0 : _o3[0] = swap_p ? captures[4] : captures[2];
18057 : 0 : _o3[1] = wide_int_to_tree (sizetype, off);
18058 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
18059 : 0 : tem_op.resimplify (lseq, valueize);
18060 : 0 : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
18061 : 0 : if (!_r3) goto next_after_fail2204;
18062 : 0 : _o2[0] = _r3;
18063 : : }
18064 : 0 : _o2[1] = swap_p ? captures[2] : captures[4];
18065 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
18066 : 0 : tem_op.resimplify (lseq, valueize);
18067 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
18068 : 0 : if (!_r2) goto next_after_fail2204;
18069 : 0 : _o1[0] = _r2;
18070 : : }
18071 : 0 : if (sizetype != TREE_TYPE (_o1[0])
18072 : 0 : && !useless_type_conversion_p (sizetype, TREE_TYPE (_o1[0])))
18073 : : {
18074 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, sizetype, _o1[0]);
18075 : 0 : tem_op.resimplify (lseq, valueize);
18076 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
18077 : 0 : if (!_r1) goto next_after_fail2204;
18078 : : }
18079 : : else
18080 : : _r1 = _o1[0];
18081 : 0 : res_op->ops[0] = _r1;
18082 : : }
18083 : 0 : res_op->ops[1] = rhs_tree;
18084 : 0 : res_op->resimplify (lseq, valueize);
18085 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 974, __FILE__, __LINE__, true);
18086 : 0 : return true;
18087 : : }
18088 : 0 : next_after_fail2204:;
18089 : : }
18090 : : }
18091 : : }
18092 : : }
18093 : : }
18094 : : }
18095 : : }
18096 : : }
18097 : : break;
18098 : : }
18099 : : default:;
18100 : : }
18101 : : }
18102 : : break;
18103 : : default:;
18104 : : }
18105 : : }
18106 : : break;
18107 : : }
18108 : : default:;
18109 : : }
18110 : : }
18111 : : break;
18112 : : default:;
18113 : : }
18114 : : break;
18115 : : }
18116 : : default:;
18117 : : }
18118 : : break;
18119 : : }
18120 : : default:;
18121 : : }
18122 : : }
18123 : : break;
18124 : : default:;
18125 : : }
18126 : : break;
18127 : : }
18128 : 0 : case GT_EXPR:
18129 : 0 : {
18130 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
18131 : 0 : _q20 = do_valueize (valueize, _q20);
18132 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
18133 : 0 : _q21 = do_valueize (valueize, _q21);
18134 : 0 : switch (TREE_CODE (_q21))
18135 : : {
18136 : 0 : case SSA_NAME:
18137 : 0 : if (gimple *_d2 = get_def (valueize, _q21))
18138 : : {
18139 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
18140 : 0 : switch (gimple_assign_rhs_code (_a2))
18141 : : {
18142 : 0 : case POINTER_PLUS_EXPR:
18143 : 0 : {
18144 : 0 : tree _q40 = gimple_assign_rhs1 (_a2);
18145 : 0 : _q40 = do_valueize (valueize, _q40);
18146 : 0 : tree _q41 = gimple_assign_rhs2 (_a2);
18147 : 0 : _q41 = do_valueize (valueize, _q41);
18148 : 0 : switch (TREE_CODE (_q41))
18149 : : {
18150 : 0 : case INTEGER_CST:
18151 : 0 : {
18152 : 0 : switch (TREE_CODE (_p1))
18153 : : {
18154 : 0 : case SSA_NAME:
18155 : 0 : if (gimple *_d3 = get_def (valueize, _p1))
18156 : : {
18157 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
18158 : 0 : switch (gimple_assign_rhs_code (_a3))
18159 : : {
18160 : 0 : case LT_EXPR:
18161 : 0 : {
18162 : 0 : tree _q70 = gimple_assign_rhs1 (_a3);
18163 : 0 : _q70 = do_valueize (valueize, _q70);
18164 : 0 : tree _q71 = gimple_assign_rhs2 (_a3);
18165 : 0 : _q71 = do_valueize (valueize, _q71);
18166 : 0 : switch (TREE_CODE (_q70))
18167 : : {
18168 : 0 : case SSA_NAME:
18169 : 0 : if (gimple *_d4 = get_def (valueize, _q70))
18170 : : {
18171 : 0 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
18172 : 0 : switch (gimple_assign_rhs_code (_a4))
18173 : : {
18174 : 0 : case POINTER_PLUS_EXPR:
18175 : 0 : {
18176 : 0 : tree _q80 = gimple_assign_rhs1 (_a4);
18177 : 0 : _q80 = do_valueize (valueize, _q80);
18178 : 0 : tree _q81 = gimple_assign_rhs2 (_a4);
18179 : 0 : _q81 = do_valueize (valueize, _q81);
18180 : 0 : if ((_q80 == _q20 && ! TREE_SIDE_EFFECTS (_q80)) || (operand_equal_p (_q80, _q20, 0) && types_match (_q80, _q20)))
18181 : : {
18182 : 0 : if ((_q81 == _q41 && ! TREE_SIDE_EFFECTS (_q81)) || (operand_equal_p (_q81, _q41, 0) && types_match (_q81, _q41)))
18183 : : {
18184 : 0 : if ((_q71 == _q40 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q40, 0) && types_match (_q71, _q40)))
18185 : : {
18186 : 0 : {
18187 : 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q70 };
18188 : 0 : const enum tree_code cmp = LT_EXPR;
18189 : 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
18190 : 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
18191 : 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
18192 : : )
18193 : : {
18194 : 0 : {
18195 : 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
18196 : 0 : offset_int rhs = off * 2;
18197 : 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
18198 : : )
18199 : : {
18200 : 0 : {
18201 : 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
18202 : 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
18203 : 0 : if (cmp == LT_EXPR
18204 : : )
18205 : : {
18206 : 0 : gimple_seq *lseq = seq;
18207 : 0 : if (lseq
18208 : 0 : && (!single_use (captures[0])
18209 : 0 : || !single_use (captures[5])))
18210 : 0 : lseq = NULL;
18211 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2205;
18212 : 0 : {
18213 : 0 : res_op->set_op (GT_EXPR, type, 2);
18214 : 0 : {
18215 : 0 : tree _o1[1], _r1;
18216 : 0 : {
18217 : 0 : tree _o2[2], _r2;
18218 : 0 : _o2[0] = swap_p ? captures[6] : captures[1];
18219 : 0 : _o2[1] = swap_p ? captures[2] : captures[4];
18220 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
18221 : 0 : tem_op.resimplify (lseq, valueize);
18222 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
18223 : 0 : if (!_r2) goto next_after_fail2205;
18224 : 0 : _o1[0] = _r2;
18225 : : }
18226 : 0 : if (sizetype != TREE_TYPE (_o1[0])
18227 : 0 : && !useless_type_conversion_p (sizetype, TREE_TYPE (_o1[0])))
18228 : : {
18229 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, sizetype, _o1[0]);
18230 : 0 : tem_op.resimplify (lseq, valueize);
18231 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
18232 : 0 : if (!_r1) goto next_after_fail2205;
18233 : : }
18234 : : else
18235 : : _r1 = _o1[0];
18236 : 0 : res_op->ops[0] = _r1;
18237 : : }
18238 : 0 : res_op->ops[1] = rhs_tree;
18239 : 0 : res_op->resimplify (lseq, valueize);
18240 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 973, __FILE__, __LINE__, true);
18241 : 0 : return true;
18242 : : }
18243 : 0 : next_after_fail2205:;
18244 : : }
18245 : : else
18246 : : {
18247 : : gimple_seq *lseq = seq;
18248 : : if (lseq
18249 : : && (!single_use (captures[0])
18250 : : || !single_use (captures[5])))
18251 : : lseq = NULL;
18252 : : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2206;
18253 : : {
18254 : : res_op->set_op (GT_EXPR, type, 2);
18255 : : {
18256 : : tree _o1[1], _r1;
18257 : : {
18258 : : tree _o2[2], _r2;
18259 : : {
18260 : : tree _o3[2], _r3;
18261 : : _o3[0] = swap_p ? captures[4] : captures[2];
18262 : : _o3[1] = wide_int_to_tree (sizetype, off);
18263 : : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
18264 : : tem_op.resimplify (lseq, valueize);
18265 : : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
18266 : : if (!_r3) goto next_after_fail2206;
18267 : : _o2[0] = _r3;
18268 : : }
18269 : : _o2[1] = swap_p ? captures[2] : captures[4];
18270 : : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
18271 : : tem_op.resimplify (lseq, valueize);
18272 : : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
18273 : : if (!_r2) goto next_after_fail2206;
18274 : : _o1[0] = _r2;
18275 : : }
18276 : : if (sizetype != TREE_TYPE (_o1[0])
18277 : : && !useless_type_conversion_p (sizetype, TREE_TYPE (_o1[0])))
18278 : : {
18279 : : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, sizetype, _o1[0]);
18280 : : tem_op.resimplify (lseq, valueize);
18281 : : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
18282 : : if (!_r1) goto next_after_fail2206;
18283 : : }
18284 : : else
18285 : : _r1 = _o1[0];
18286 : : res_op->ops[0] = _r1;
18287 : : }
18288 : : res_op->ops[1] = rhs_tree;
18289 : : res_op->resimplify (lseq, valueize);
18290 : : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 974, __FILE__, __LINE__, true);
18291 : : return true;
18292 : : }
18293 : : next_after_fail2206:;
18294 : : }
18295 : : }
18296 : : }
18297 : : }
18298 : : }
18299 : : }
18300 : : }
18301 : : }
18302 : : }
18303 : : break;
18304 : : }
18305 : : default:;
18306 : : }
18307 : : }
18308 : : break;
18309 : : default:;
18310 : : }
18311 : : break;
18312 : : }
18313 : 0 : case GT_EXPR:
18314 : 0 : {
18315 : 0 : tree _q70 = gimple_assign_rhs1 (_a3);
18316 : 0 : _q70 = do_valueize (valueize, _q70);
18317 : 0 : tree _q71 = gimple_assign_rhs2 (_a3);
18318 : 0 : _q71 = do_valueize (valueize, _q71);
18319 : 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
18320 : : {
18321 : 0 : switch (TREE_CODE (_q71))
18322 : : {
18323 : 0 : case SSA_NAME:
18324 : 0 : if (gimple *_d4 = get_def (valueize, _q71))
18325 : : {
18326 : 0 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
18327 : 0 : switch (gimple_assign_rhs_code (_a4))
18328 : : {
18329 : 0 : case POINTER_PLUS_EXPR:
18330 : 0 : {
18331 : 0 : tree _q90 = gimple_assign_rhs1 (_a4);
18332 : 0 : _q90 = do_valueize (valueize, _q90);
18333 : 0 : tree _q91 = gimple_assign_rhs2 (_a4);
18334 : 0 : _q91 = do_valueize (valueize, _q91);
18335 : 0 : if ((_q90 == _q20 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q20, 0) && types_match (_q90, _q20)))
18336 : : {
18337 : 0 : if ((_q91 == _q41 && ! TREE_SIDE_EFFECTS (_q91)) || (operand_equal_p (_q91, _q41, 0) && types_match (_q91, _q41)))
18338 : : {
18339 : 0 : {
18340 : 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q21, _q40, _q41, _q20, _p1, _q71 };
18341 : 0 : const enum tree_code cmp = LT_EXPR;
18342 : 0 : if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))
18343 : 0 : && TYPE_OVERFLOW_WRAPS (sizetype)
18344 : 0 : && TYPE_PRECISION (TREE_TYPE (captures[2])) == TYPE_PRECISION (sizetype)
18345 : : )
18346 : : {
18347 : 0 : {
18348 : 0 : offset_int off = wi::to_offset (captures[3]) - (cmp == LE_EXPR ? 1 : 0);
18349 : 0 : offset_int rhs = off * 2;
18350 : 0 : if (wi::min_precision (rhs, UNSIGNED) <= TYPE_PRECISION (sizetype)
18351 : : )
18352 : : {
18353 : 0 : {
18354 : 0 : bool swap_p = tree_swap_operands_p (captures[2], captures[4]);
18355 : 0 : tree rhs_tree = wide_int_to_tree (sizetype, rhs);
18356 : 0 : if (cmp == LT_EXPR
18357 : : )
18358 : : {
18359 : 0 : gimple_seq *lseq = seq;
18360 : 0 : if (lseq
18361 : 0 : && (!single_use (captures[0])
18362 : 0 : || !single_use (captures[5])))
18363 : 0 : lseq = NULL;
18364 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2207;
18365 : 0 : {
18366 : 0 : res_op->set_op (GT_EXPR, type, 2);
18367 : 0 : {
18368 : 0 : tree _o1[1], _r1;
18369 : 0 : {
18370 : 0 : tree _o2[2], _r2;
18371 : 0 : _o2[0] = swap_p ? captures[6] : captures[1];
18372 : 0 : _o2[1] = swap_p ? captures[2] : captures[4];
18373 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
18374 : 0 : tem_op.resimplify (lseq, valueize);
18375 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
18376 : 0 : if (!_r2) goto next_after_fail2207;
18377 : 0 : _o1[0] = _r2;
18378 : : }
18379 : 0 : if (sizetype != TREE_TYPE (_o1[0])
18380 : 0 : && !useless_type_conversion_p (sizetype, TREE_TYPE (_o1[0])))
18381 : : {
18382 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, sizetype, _o1[0]);
18383 : 0 : tem_op.resimplify (lseq, valueize);
18384 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
18385 : 0 : if (!_r1) goto next_after_fail2207;
18386 : : }
18387 : : else
18388 : : _r1 = _o1[0];
18389 : 0 : res_op->ops[0] = _r1;
18390 : : }
18391 : 0 : res_op->ops[1] = rhs_tree;
18392 : 0 : res_op->resimplify (lseq, valueize);
18393 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 973, __FILE__, __LINE__, true);
18394 : 0 : return true;
18395 : : }
18396 : 0 : next_after_fail2207:;
18397 : : }
18398 : : else
18399 : : {
18400 : : gimple_seq *lseq = seq;
18401 : : if (lseq
18402 : : && (!single_use (captures[0])
18403 : : || !single_use (captures[5])))
18404 : : lseq = NULL;
18405 : : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2208;
18406 : : {
18407 : : res_op->set_op (GT_EXPR, type, 2);
18408 : : {
18409 : : tree _o1[1], _r1;
18410 : : {
18411 : : tree _o2[2], _r2;
18412 : : {
18413 : : tree _o3[2], _r3;
18414 : : _o3[0] = swap_p ? captures[4] : captures[2];
18415 : : _o3[1] = wide_int_to_tree (sizetype, off);
18416 : : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
18417 : : tem_op.resimplify (lseq, valueize);
18418 : : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
18419 : : if (!_r3) goto next_after_fail2208;
18420 : : _o2[0] = _r3;
18421 : : }
18422 : : _o2[1] = swap_p ? captures[2] : captures[4];
18423 : : gimple_match_op tem_op (res_op->cond.any_else (), POINTER_DIFF_EXPR, ssizetype, _o2[0], _o2[1]);
18424 : : tem_op.resimplify (lseq, valueize);
18425 : : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
18426 : : if (!_r2) goto next_after_fail2208;
18427 : : _o1[0] = _r2;
18428 : : }
18429 : : if (sizetype != TREE_TYPE (_o1[0])
18430 : : && !useless_type_conversion_p (sizetype, TREE_TYPE (_o1[0])))
18431 : : {
18432 : : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, sizetype, _o1[0]);
18433 : : tem_op.resimplify (lseq, valueize);
18434 : : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
18435 : : if (!_r1) goto next_after_fail2208;
18436 : : }
18437 : : else
18438 : : _r1 = _o1[0];
18439 : : res_op->ops[0] = _r1;
18440 : : }
18441 : : res_op->ops[1] = rhs_tree;
18442 : : res_op->resimplify (lseq, valueize);
18443 : : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 974, __FILE__, __LINE__, true);
18444 : : return true;
18445 : : }
18446 : : next_after_fail2208:;
18447 : : }
18448 : : }
18449 : : }
18450 : : }
18451 : : }
18452 : : }
18453 : : }
18454 : : }
18455 : : break;
18456 : : }
18457 : : default:;
18458 : : }
18459 : : }
18460 : : break;
18461 : : default:;
18462 : : }
18463 : : }
18464 : : break;
18465 : : }
18466 : : default:;
18467 : : }
18468 : : }
18469 : : break;
18470 : : default:;
18471 : : }
18472 : : break;
18473 : : }
18474 : : default:;
18475 : : }
18476 : : break;
18477 : : }
18478 : : default:;
18479 : : }
18480 : : }
18481 : : break;
18482 : : default:;
18483 : : }
18484 : : break;
18485 : : }
18486 : : default:;
18487 : : }
18488 : : }
18489 : : break;
18490 : : default:;
18491 : : }
18492 : : return false;
18493 : : }
18494 : : #pragma GCC diagnostic pop
|
